Moonshot Built the Engine. Cursor Sold the Car.

On March 19, Cursor shipped its new coding model on top of a Chinese open-weight base. The pricing gap, and what it says about the API business model, is the real story.

March 20, 2026 · Traced in real-time through 6 independent data feeds

The discovery

Cursor shipped Composer 2 without naming the base. A developer found Kimi K2.5 underneath within 24 hours. The discovery turned a launch into a value-capture story.

Cursor launched Composer 2 on March 19, 2026 to its 1M+ daily active users. The blog post credited "continued pre-training of a base model, combined with reinforcement learning" but did not name it. Within 24 hours, a developer intercepted the model ID in Cursor's API responses (kimi-k2p5-rl-0317-s515-fast) and identified the base as Kimi K2.5, an open-weight model from Moonshot AI.

• Mar 19
  Cursor ships Composer 2. Blog credits a generic "base model." No mention of Kimi.
• Mar 19–20
  Model ID discovered. Moonshot's head of pretraining publicly accuses Cursor of license violation.
• Mar 20
  Cursor responds. Co-founder Aman Sanger: "It was a miss to not mention the Kimi base in our blog. We'll fix that."
• Mar 20
  Resolution. Moonshot congratulates Cursor. Fireworks AI commercial agreement confirmed.

Moonshot spent $8.8M training Kimi K2.5 and moved coding benchmarks by an average of 26.7 points. Cursor spent an estimated $26–35M of post-training on top and moved them by 5.8. The capability lives in the base; the revenue accrues to the wrapper.

Is Composer 2 the cheapest?

Composer 2 is cheaper than Claude, but it isn't the cheapest, and the landscape is more crowded than it looks.

Composer 2's standard tier ($0.50/$2.50) is not the default; the "fast" variant at $1.50/$7.50 is. At that price, it's 2× cheaper than Sonnet 4.6 ($3/$15), not the 10× launch headlines suggested (which compared the standard tier to Claude Opus). DeepSeek V3.2 ($0.28/$0.42) is already cheaper than Composer 2 with comparable coding scores.

Composer 2 trades blows with the expensive models on coding benchmarks that resist contamination (Terminal-Bench 2.0, SWE-bench Multilingual, LiveCodeBench v6, Next.js Evals).

Composer 2 beats Claude Opus 4.6 on Terminal-Bench 2.0 (61.7 vs 59.3). It loses on SWE-bench Multilingual (73.7 vs 77.5). The raw K2.5 base, before Cursor's fine-tuning, leads on LiveCodeBench v6 (85.0 vs 82.2).

Cursor also publishes scores on CursorBench, their proprietary internal evaluation suite. It uses real user sessions sourced via "Cursor Blame" (tracing committed code to agent requests), with tasks averaging 352 lines across 8 files, substantially larger than SWE-bench tasks.

Source: cursor.com/blog/cursorbench. CursorBench is proprietary; only Cursor can run it. How CursorBench works →

How much does the harness add?

An agent harness is the scaffolding around the model (file access, tool calls, context retrieval) that turns raw token generation into useful coding work. Most benchmarks score the model and harness together, hiding which is doing the work. If the harness moves scores as much as the model does, Cursor's wrapper is its own value layer, separate from the post-training. Vercel's Next.js Evals (OSS on GitHub) isolates the two:

Source: nextjs.org/evals, github.com/vercel/next-evals-oss

K2.5 scores 19% baseline; Composer 2 scores 76%. That's +57 points from Cursor's RL, far larger than the +0.7 on SWE-bench ML. But with documentation (AGENTS.md), Claude reaches 100% while Composer 2 reaches 95%. The agent harness and context retrieval may matter as much as the model.

From open-weight base to production agent

Cursor didn't just wrap Kimi K2.5. They invested 4× the base model's compute in continued pre-training and RL.

Aman Sanger's tweet disclosed the key details: Cursor evaluated multiple base models on perplexity, chose K2.5, then applied "continued pre-training and high-compute RL (a 4× scale-up)."

K2.5 is a substantial release, not an incremental update: a full re-pretrain with expanded context (tech report).

Moonshot trained K2.5 for ~$8.8M. Cursor then ran "4× the compute" on top, which lands at $26M of incremental spend if the 4× includes the base, or $35M if it's 4× on top of it. Total Composer 2: $35–44M. FLOP-to-dollar derivation in methodology →

For context, Composer 2's $35–44M sits below Llama 3.1 405B (~$53M est.), an order of magnitude below GPT-4.5 (~$340M est.) and Grok-4 (~$388M est.), and above DeepSeek V3 ($5.6M reported). Final-run costs only; see breakdown →.

The base is substitutable in theory, but switching means re-running the $26–35M RL pipeline on a new foundation with no guarantee the recipe transfers. Interchangeability is real but expensive.

With confirmed benchmarks for all three stages (K2, K2.5, and Composer 2), we can measure exactly what each step contributed:

Does Composer 2 pay for itself?

At $2B+ ARR, Cursor's gross margin hinges on the model mix. Users pick (or Auto picks for them); the share running through Composer 2 is the margin lever.

Cursor reportedly surpassed $2B in ARR in early 2026. Users can pick any model inside Cursor (Claude, GPT, Composer 2, Gemini), but Cursor's cost per token varies sharply by choice: Composer 2 runs through Fireworks at a fraction of what Cursor pays Anthropic for Claude. If inference consumes 50% of revenue (a common ratio for AI-native products), that's a ~$1B/year line item whose breakdown by model decides margin.

At fast-tier pricing of $1.50/$7.50 (the default), Composer 2's per-token cost is half of Sonnet 4.6's. The mix scenarios below show how that gap compounds:

We don't know Cursor's actual cost structure. These estimates assume 50% of $2B ARR goes to inference, a common ratio for AI-native products but unverified for Cursor. Fireworks' margin (estimated 30–50% gross) is also embedded in Composer 2's pricing.

Who captures the value?

Moonshot built the model. Cursor built the product. The value-capture gap runs the wrong direction.

Two companies, two roles in the same product:

Sources: Moonshot: 36Kr, KR-Asia, TechCrunch · Cursor: TechCrunch, Stripe, DevGraphiq. Moonshot revenue is approximate. Cursor headcount estimated.

At first glance, this looks like Cursor is winning. But look at who moves the needle on capabilities:

Moonshot is 14–18× more efficient at producing benchmark gains. Some of that is diminishing returns (47→73 is easier than 73→74), but it also reflects the fundamental asymmetry: base model training is the hard, underpaid work.

The durable question is which layer defends its share. Nathan Lambert (Interconnects) frames the squeeze on Cursor's side: "post-training got more popular because there was more low-hanging fruit. A lot of that potential has been realized." If the wrapper is a thinning layer (and Cursor's +5.8-point average gain vs Moonshot's +26.7 suggests it is), the rent defense gets harder over time. The squeeze on Moonshot's side is the inverse: if labs move up the stack and ship their own application surface (Moonshot already has the Kimi consumer app), the wrapper's distribution moat narrows. Whether Cursor remains the best at picking open-weight bases and bolting RL on top, or whether the labs reclaim the user, is the bet investors are pricing. Time will tell.

Who's exposed?

The model layer is becoming a commodity. The question is who captures the value that used to sit there.

The Cursor switch isn't an isolated event. It's the first high-profile instance of a pattern that will repeat: AI-native companies evaluating open-weight bases, applying proprietary fine-tuning, and serving through specialized inference providers, cutting the frontier lab's API out of the loop.

The question for Anthropic and OpenAI isn't whether their models are better. On most benchmarks, they still are. The question is whether "better" justifies 2–5× the price, and for how much longer.

What third parties confirm

Most numbers in this piece come from Cursor, Moonshot, or Fireworks. Here's the subset that independent sources back up.