Cursor Demonstrates the Power of Economic Models for Coding

Cursor Demonstrates the Power of Economic Models for Coding

Cursor's squad of agents suggests that less expensive models can handle most coding tasks when advanced models plan the work.

Cursor pitted an enhanced squad of agents against its predecessor by asking both to rebuild SQLite in Rust using only the documentation, without access to the source code or the Internet. Each configuration of the new system achieved 100% on the test suite, while the old squad got bogged down in its own merge conflicts.

At Cursor, fleets of agents have transitioned from research projects to core products. With Cursor 3, developers can run entire fleets of AI agents in parallel. Anysphere, the company behind Cursor, was recently acquired by Elon Musk's SpaceX for $60 billion.

The system divides agents into two roles: planning agents, using powerful advanced models, break down a goal into smaller tasks. Worker agents, using faster and cheaper models, execute these tasks. The result is a task tree that adapts as work progresses.

Cursor claims that this separation of roles primarily addresses a context problem. An isolated agent must traverse the entire tree while keeping both the goal and the current task in mind. This helps explain why agents drift during long tasks. In Cursor's squad, planners do not code, and workers do not plan.

Git Could Not Handle 1,000 Commits Per Second

A previous Cursor browsing squad achieved about 1,000 commits per hour on Git. It used worker agents, a judging agent, and an integrator who resolved conflicts. The integrator ultimately created more bottlenecks than it removed.

The new squad achieved 1,000 commits per second, prompting Cursor to build its own version control system, as agents working at this pace created failure modes that human teams never encounter.

In what Cursor called "split-brain design," two planners unknowingly built the same idea in different locations and implemented it in different ways. Contention was even harder to manage when planners were aware of each other and blocked each other with concurrent changes.

Cursor had agents record their decisions in shared design documents. The code related to a decision was referenced in the document and checked at compile time.

When merge conflicts occurred, a neutral agent intervened and resolved them. Workers flagged cluttered files for an external agent to break them down into smaller modules. Since agents had learned not to touch the main code while working in existing codebases with humans in the loop, Cursor allowed them to intentionally break things. An agent could fix code outside its assigned area, and the compiler would propagate the change throughout the system.

Multiple Review Angles and a Self-Maintained Field Guide

Cursor tested several review approaches. One reviewer received the full transcript from the worker, another saw only the output, and a third saw only the codebase. No single perspective captured everything, but combined uncorrelated perspectives allowed for increased reliability.

Cursor also tested a "field guide," a knowledge repository maintained by the agents themselves with a fixed line limit. Each agent received its content at startup. Since the model weights are fixed, it is beneficial to capture surprising discoveries so that later agents can take shortcuts.

Cursor provided the squad with the 835-page SQLite manual and asked them to build an implementation in Rust. The source code, test suites, SQLite binary, and Internet access were all withheld. The benchmark was sqllogictest, a test suite with millions of SQL queries and known responses. The squad was unaware of its existence.

Four configurations were tested: GPT-5.5 alone, Grok 4.5 alone, Opus 4.8 as planner with Composer 2.5 as worker, and Fable 5 as planner with Composer 2.5 as worker. The new system outperformed the old in every configuration. After four hours, the new runs scored between 73% and 85%, while the old runs scored between 11% and 77%. Each configuration of the new system then achieved 100%.

The Old Squad Created More Work Than It Completed

The runs of Grok 4.5 showed why the old system fell behind. The old squad produced 68,000 commits in two hours, about 70 times more than the new one. Most of this activity was wasted work. The old run accumulated over 70,000 merge conflicts, while the new one stayed below 1,000 throughout the test.

The conflict rate of the old version continued to accelerate instead of stabilizing. The most contested file in the old run recorded 7,771 conflicts from 1,173 agents, compared to 47 in the new run. The same split-brain problem appeared in the package structure. The old run divided the project into 54 Rust crates with three distinct SQL packages. The new run quickly settled on nine crates.

In the Fable 5 configuration, the old squad required 64,305 lines of engine code, while the new one needed only 9,908. In the Opus configuration, the old system produced 19,013 lines and achieved 97%. The new system reached 100% with 4,645 lines.

With similar or better test scores, the new architecture reduced the codebase size by up to 85%.

Cheaper Worker Models Created the Largest Savings

Total costs ranged from $1,339 for the Opus hybrid to $10,565 for GPT-5.5 running alone. Workers accounted for at least 69% of the tokens in each run and generally more than 90%. Planner tokens are more expensive, so the cost distribution was different. In the Opus hybrid, the planner produced only a small share of the tokens but accounted for two-thirds of the total bill.

The cheapest and most expensive configurations differed in cost by a factor of 15 despite comparable results.

The worker model created the largest cost gap. In the GPT-5.5 run, the workers alone cost $9,373. In the run using Opus and Composer, the entire fleet of workers cost $411 at comparable quality. The difference is almost entirely due to pricing. Composer 2.5 is on par with Opus 4.7 and GPT-5.5 but costs only $0.50 per million input tokens and $2.50 per million output tokens. The model is based on Kimi K2.5, according to Michael Truell, founder of Cursor.

Cursor argues that only a few parts of a large task require the intelligence of an advanced model, including task decomposition and key design decisions. Once an advanced planner resolves ambiguity, cheaper models can follow its plan, although hybrid runs have shown that the quality of the planner still matters. The Fable 5 planner used fewer planning tokens than Opus, but its workers needed many more tokens to complete the work. The Fable run ended up costing more overall.

Workers used at least 69% of the tokens in each run but represented only a portion of the cost.

Cursor describes the squads as a kind of probabilistic compiler that translates intent into executable work step by step. The company claims that accurately describing this intent was the main constraint of the experiment. Cursor has released the codebase of the solo Opus run under the name minisqlite on GitHub.

Executions like these are no longer limited to laboratory experiments. A preliminary version of Fable 5 managed most of the rewriting of Bun from Zig to Rust. Sixty-four instances wrote over a million lines of code in 11 days for about $165,000. Production use seems even different. A study published at the end of 2025 revealed that 68% of agents used in production completed no more than ten steps before a human intervened. For 47%, the limit was less than five.