Cursor Cut AI Coding Costs 22x by Splitting Planning From Execution

Rebuilding SQLite in Rust from documentation alone cost Cursor’s agent swarm $1,339 in one configuration and $10,565 in another — for functionally equivalent code that passed the same test suite. The difference wasn’t the model’s intelligence. It was who was doing the planning versus who was doing the typing.

The Number

Cursor tested four model configurations on an identical task: GPT-5.5 working alone, Grok 4.5 working alone, and two “swarm” setups where a frontier model (Opus 4.8, then Fable 5) broke the project into subtasks for a cheaper worker model, Composer 2.5, to execute. All four configurations passed 100% of a held-out test suite. The Opus-planned swarm finished for $1,339. GPT-5.5 working solo finished for $10,565 — nearly 8x more, with no corresponding gain in output quality.

How the Math Works

The savings come from where the tokens go, not from using fewer of them. Worker agents — the ones writing and rewriting code — account for 69-90% of total token volume in every configuration tested. What changes is the price per token: Composer 2.5 charges $0.50 per million input tokens and $2.50 per million output tokens, versus GPT-5.5’s substantially higher solo rates. Routing the bulk of the volume (the mechanical execution work) to the cheap model, while reserving the expensive model for the low-volume, high-leverage planning decisions, is what produces the 22x cost swing Cursor found between its cheapest worker fleet ($411) and its most expensive one ($9,373).

The quality difference was structural, not just financial. The Opus-planned swarm produced 4,645 lines of code versus 19,013 for a prior-generation system attempting the same rebuild — a sign that better upfront planning reduces the churn of workers rewriting each other’s mistakes. Merge conflicts stayed under 1,000 in the new architecture versus more than 70,000 in the old one, and the commit rate rose from roughly 1,000 per hour to 1,000 per second.

What This Means for Builders

Teams building on agentic coding tools have been treating “which model should I use” as a single decision. Cursor’s results argue it’s actually two decisions — a planning-model choice and an execution-model choice — and conflating them means overpaying for capability the execution step doesn’t need. A planner has to reason about architecture, tradeoffs, and how pieces fit together; a worker mostly needs to follow well-specified instructions accurately and fast. Cursor has already shipped this planner-worker swarm architecture to enterprise users through Cursor 3, so the pattern is available today, not a research curiosity. Composer 2.5’s own benchmark numbers — matching Opus 4.7 on SWE-Bench at roughly 1/14th the cost — are exactly why it works so well as the worker model here.

It also reframes what “frontier model” spend is actually buying. A team defaulting to GPT-5.5 or a similarly priced model for every step of a coding task — including the high-volume, low-judgment execution steps — is paying frontier rates for work that a fraction of the price will do just as well, provided the plan those workers are executing is good enough. The bottleneck Cursor’s data points to isn’t model capability at the execution layer; it’s whether the planning layer produced instructions precise enough that a cheaper model can follow them without drifting.

Source: The Decoder

Content created with AI assistance and reviewed for accuracy.