Kimi, Composer, and the Build vs Buy Dilemma

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.

What happened

A $29 billion company built its flagship model on a Chinese open-weight base — then forgot to mention it.

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." It did not name the base model.

Within 24 hours, a developer intercepted the model ID in Cursor's API responses: kimi-k2p5-rl-0317-s515-fast. The base was Kimi K2.5, an open-weight model from Moonshot AI in Beijing.

• 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.

Within 72 hours, a developer discovered the model identity — and the pricing. Composer 2 charges $1.50/$7.50 per million tokens in its default "fast" mode. Claude Sonnet costs $3/$15. The gap was real, but narrower than it first appeared.

The competitive pricing landscape

Composer 2 is cheaper than Claude — but it's not the cheapest option. The full landscape tells a more nuanced story.

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 point, it's 2x cheaper than Sonnet, not 10x. And models like DeepSeek V3.2 ($0.28/$0.42) are already cheaper than Composer 2 with comparable coding scores.

And yet, on coding benchmarks — the ones that actually predict IDE agent performance — Composer 2 trades blows with the expensive models. But first, a guide to which benchmarks actually matter:

CursorBench is arguably the best-designed benchmark on this list — real user sessions, agentic graders, refreshed quarterly, cross-validated against live traffic. The flaw is that only Cursor can run it.

Cursor explicitly chose not to report SWE-bench Verified, citing contamination — a position OpenAI now shares. But their absence from SWE-bench Pro (built by Scale AI specifically to fix Verified's problems) is harder to explain.

A quick guide to what each benchmark measures:

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.

CursorBench sources tasks from real developer sessions via "Cursor Blame," which traces committed code back to the agent request that produced it. Tasks average 352 lines across 8 files — substantially larger than SWE-bench. Grading uses agentic judges and is cross-validated against live traffic metrics. The methodology is arguably best-in-class for measuring "does this model actually help developers in an IDE." The problem is purely verifiability — only Cursor can run it.
Source: cursor.com/blog/cursorbench. CursorBench is not public. A Cursor team member confirmed: "Unfortunately not, as we used our own internal code for the benchmark." Different evaluation harnesses were used per model, so cross-model comparisons are not apples-to-apples. Academic research warns that proprietary benchmarks "shift epistemic authority to the curator."

Next.js Evals: where the agent harness matters

Vercel's Next.js Evals (OSS on GitHub) test framework migration tasks — a practical, real-world workload. The results reveal how much the agent wrapper contributes on top of the raw model:

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.

Three steps 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)."

The jump from K2 to K2.5 is not incremental. K2.5 is a full re-pretrain on 15 trillion mixed visual and text tokens (K2 tech report; K2.5 tech report). Cross-modal transfer from visual training boosted text-only coding benchmarks (MMLU-Pro 84.7 to 86.4). The 128K to 262K context expansion enables whole-codebase understanding.

What does "4× scale-up" mean in dollar terms? The phrasing is ambiguous. Here are both plausible readings:

Frontier model cost estimates are order-of-magnitude approximations based on publicly available architecture details and training compute. DeepSeek V3 is self-reported.

These are final-run costs only. They exclude research experiments, data curation, failed runs, and engineering staff. Moonshot CEO has stated: "It is hard to quantify the training cost because a major part is research and experiments." Sanger notes Cursor has trained about 50 models — total R&D spend is likely multiples higher.

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:

The margin math

At $2B+ ARR, even a partial model switch reshapes Cursor's economics — but the savings are smaller than they first appear.

Cursor reportedly surpassed $2B in ARR in early 2026. If inference costs consume 50% of revenue — a common ratio for AI-native products — that's $1B/year on model serving.

Using the fast pricing ($1.50/$7.50) — what users actually pay by default — the savings are real but more modest than the "standard" tier suggests:

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 specifically. Fireworks' margin (estimated 30-50% gross) is also embedded in Composer 2's pricing.

Why self-hosting doesn't work (yet)

MoE models are cheap to run per token — but expensive to load into memory.

Kimi K2.5 activates only 32 billion of its 1.04 trillion parameters per token. That's extreme sparsity — 48× — which makes each token cheap to compute. But every one of those 1.04 trillion parameters must sit in GPU memory, ready for the router to select.

Imagine a hospital with 384 specialist doctors, but each patient only sees 8. You still need all 384 on staff — their salaries (GPU memory) are fixed — even though each consultation (token) only involves a fraction of them. The per-patient cost is low; the facility cost is high.

On H100s, you need 16–32 GPUs just to fit the model — and throughput is single-digit tokens per second. On next-gen Blackwell B300s, it's viable (1,876 tok/s at 64 users). But Hopper-era self-hosting is a losing proposition.

This is why Cursor went through Fireworks AI rather than self-hosting. Fireworks amortizes the GPU fleet across customers, making the economics work at a price point ($0.90–1.50/M tokens) that neither Cursor nor Moonshot could match alone.

Who captures the value?

Moonshot built the model. Cursor built the product. The gap in value capture is striking.

The Composer 2 story is a case study in open-source value dynamics. Moonshot invested ~$8.8M to pre-train K2.5 and open-sourced it. Cursor invested ~$26-35M in RL on top, and is generating $2B+ in ARR. Compare the two companies side by side:

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 actually moves the needle on capabilities:

Moonshot is 14–18× more efficient at producing benchmark gains. For $8.8M, they moved every benchmark by 23–31 points. Cursor spent $26-35M and moved them by 0.7–10.9 points. This is partly diminishing returns (it's harder to go from 73 to 74 than from 47 to 73), but it also reflects the fundamental asymmetry: base model training is the hard, underpaid work.

This maps directly to Yann LeCun's cake metaphor: pre-training is the bulk of the cake, supervised fine-tuning is the icing, and RL is the cherry on top. Nathan Lambert (Interconnects) adds context: "Post-training got more popular because there was more low-hanging fruit. A lot of that potential has been realized." The diminishing returns are showing up in Cursor's numbers — $4.5-6.0M per benchmark point vs Moonshot's $330K.

This doesn't mean Moonshot is losing. K2.5's open release triggered an overseas revenue explosion — 20 days of post-K2.5 revenue exceeded all of 2025. Open-sourcing is Moonshot's distribution strategy, not charity. And the value capture gap may narrow: if the base model is where the capability lives, then Moonshot controls the thing that matters. Cursor's RL is the cherry on top — and cherries are replaceable.

What this means for investors

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

The Cursor switch is not 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 out the frontier lab's API entirely.

This framework extends beyond coding. Any company with (a) >$10M/year in API inference spend, (b) a proprietary data moat, and (c) access to ML talent could evaluate the same build-over-buy calculus. Legal AI firms fine-tuning on case law, medical AI companies training on clinical notes, financial AI platforms with proprietary trading data — all face the same question Cursor answered: is the frontier API model worth 2-5x the cost of a fine-tuned open-weight alternative?

The question for Anthropic and OpenAI is not 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 we can independently verify

Most of this story relies on claims from interested parties. Here's what third-party data actually shows.