Cursor pitted an upgraded agent swarm against its predecessor by asking both to rebuild SQLite in Rust using only the documentation, with no source code or internet access. Every configuration of the new system reached 100 percent on the test suite, while the old swarm bogged down in its own merge conflicts.

At Cursor, agent fleets have moved from research project to core product. 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: planner agents using powerful frontier models recursively break a goal into smaller tasks. Worker agents using faster, cheaper models carry out those tasks. The result is a task tree that adapts as the work progresses.

Cursor says this role split primarily solves a context problem. A lone agent has to traverse the entire tree while keeping both the goal and the current task in mind. That helps explain why agents drift during long jobs. In Cursor's swarm, planners don't write code, and workers don't plan.

Git could not handle 1,000 commits per second

An earlier Cursor browser swarm reached about 1,000 commits per hour on Git. It used worker agents, a judge agent, and an integrator that resolved conflicts. The integrator ended up creating more bottlenecks than it removed.

The new swarm reached 1,000 commits per second, so Cursor built its own version control system because agents working at that rate created failure modes that human teams never encounter.

In what Cursor called "split-brain design," two planners would unknowingly build the same idea in different places and implement it in different ways. Contention was even harder to manage when planners knew about one another and blocked each other with competing edits.

Cursor had agents record decisions in shared design documents. Code tied to a decision linked back to the document through a reference checked at compile time.

When merge conflicts occurred, a neutral agent stepped in and resolved them. Workers flagged bloated files for an outside agent to split into smaller modules. Because agents had learned not to touch core code while working in existing codebases with humans in the loop, Cursor let them break things on purpose. An agent could patch code outside its assigned area, and the compiler would carry the change through the system.

Multiple review angles and a self-maintained field guide

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

Cursor also tested a "field guide," a knowledge folder maintained by the agents themselves with a fixed line limit. Every agent received its contents at startup. Since model weights are frozen, it pays to capture surprising findings so later agents can take shortcuts.

Cursor gave the swarm the 835-page SQLite manual and told it to build a Rust implementation. Source code, test suites, the SQLite binary, and internet access were all withheld. The benchmark was sqllogictest, a test suite with millions of SQL queries and known answers. The swarm didn't know it existed.

Four configurations were tested. GPT-5.5 solo, Grok 4.5 solo, 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 beat the old one in every configuration. After four hours, the new runs scored between 73 and 85 percent, while the old runs scored between 11 and 77 percent. Every configuration of the new system later reached 100 percent.

The old swarm created more work than it completed

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

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 broke the project into 54 Rust crates with three separate SQL packages. The new run settled on nine crates early.

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

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 percent of the tokens in every run and usually more than 90 percent. Planner tokens cost more, so the cost split looked 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 worker model created the largest cost gap. In the GPT-5.5 run, workers alone cost $9,373. In the run using Opus and Composer, the entire worker fleet cost $411 at comparable quality. The difference comes down almost entirely to pricing. Composer 2.5 benchmarks at the level of Opus 4.7 and GPT-5.5 but costs just $0.50 per million input tokens and $2.50 per million output tokens. The model is based on Kimi K2.5, according to Cursor founder Michael Truell.

Cursor argues that only a few parts of a large task need the intelligence of a frontier model, including task breakdown and key design decisions. Once a frontier planner resolves the ambiguity, cheaper models can follow its plan, though the hybrid runs showed that planner quality still mattered. The Fable 5 planner used fewer planning tokens than Opus, but its workers needed far more tokens to finish the job. The Fable run cost more overall.

Cursor describes swarms as a kind of probabilistic compiler that translates intent into executable work one step at a time. The company says accurately describing that intent was the main constraint in the experiment. Cursor published the codebase from the Opus solo run as minisqlite on GitHub.

Runs like these are no longer limited to lab experiments. A prerelease version of Fable 5 handled most of Bun's rewrite from Zig to Rust. Sixty-four instances wrote more than a million lines of code in 11 days for about $165,000. Production use still looks different. A study published in late 2025 found that 68 percent of agents used in production completed no more than ten steps before a human intervened. For 47 percent, the limit was fewer than five.

AI News Without the Hype – Curated by Humans

Read on for the full picture.
Subscribe for hype-free coverage.

• Access to all THE DECODER articles.
• Read without distractions – no Google ads.
• Access to comments and community discussions.
• Weekly AI newsletter.
• 6 times a year: “AI Radar” – deep dives on key AI topics.
• Up to 25 % off on KI Pro online events.
• Access to our full ten-year archive.
• Get the latest AI news from The Decoder.