Cursor's latest agent-swarm experiment points to a practical split in AI coding work: use stronger frontier models to decide what should happen, then let faster and cheaper models execute the smaller tasks. In a test built around rebuilding SQLite in Rust, that structure beat Cursor's older swarm across every configuration.
The finding is not simply that more agents can write more code. The bigger lesson is that coordination, context, and review can matter as much as raw model strength when many agents work on the same software project at once.
What Cursor Changed
At Cursor, agent fleets have shifted from research project to core product. With Cursor 3, developers can run fleets of AI agents in parallel, and Anysphere, the company behind Cursor, was recently acquired by Elon Musk's SpaceX for $60 billion.
The new system separates agents into two jobs. Planner agents use powerful frontier models to break a large goal into smaller work. Worker agents use faster, cheaper models to carry out those assignments.
Cursor says this design mainly addresses a context problem. A single agent working through a long project has to remember the broad goal while also handling the immediate details. Over time, that can cause drift. In Cursor's setup, planners do not write code, and workers do not plan.
The result is a task tree that changes as the project develops. Instead of every agent trying to understand everything, each role is narrower and easier to control.
The SQLite Test
Cursor gave the swarm the 835-page SQLite manual and asked it to build a Rust implementation. The agents did not receive source code, test suites, the SQLite binary, or internet access.
The benchmark was sqllogictest, which the swarm did not know existed. It is a test suite with millions of SQL queries and known answers. That made the task a useful measure of whether the agents could turn documentation into working behavior rather than simply optimizing for a visible test.
Cursor tested four configurations:
- GPT-5.5 solo
- Grok 4.5 solo
- Opus 4.8 as planner with Composer 2.5 as worker
- Fable 5 as planner with Composer 2.5 as worker
After four hours, the new runs scored between 73 and 85 percent. The old runs scored between 11 and 77 percent. Every configuration of the new system later reached 100 percent.
That outcome matters because it suggests the system design improved performance beyond any single model choice. The new swarm beat the old one in every configuration, including solo frontier-model runs and hybrid planner-worker runs.
Why Coordination Beat Raw Activity
The older Cursor browser swarm had already shown how quickly agents could produce work. It reached about 1,000 commits per hour on Git with worker agents, a judge agent, and an integrator. But the integrator became a bottleneck while trying to resolve conflicts.
The new swarm reached 1,000 commits per second. Cursor built its own version control system because agents operating at that pace created failure modes that human teams do not normally face.
One major issue was what Cursor called "split-brain design." In that pattern, two planners independently built the same idea in different places and implemented it differently. Contention also became harder when planners knew about each other and blocked one another with competing edits.
Cursor responded by having agents record decisions in shared design documents. Code connected to a decision linked back to that document through a reference checked at compile time. When merge conflicts happened, a neutral agent resolved them.
Workers also flagged bloated files for another agent to split into smaller modules. Cursor let agents patch code outside their assigned areas, allowing the compiler to carry those changes through the system.
The difference showed up clearly in the Grok 4.5 runs. The old swarm produced 68,000 commits in two hours, about 70 times as many as the new one. But that activity created waste. 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 old run split the project into 54 Rust crates with three separate SQL packages. The new run settled on nine crates early.
Review Became a Multi-Angle Process
Cursor also tested several review styles. One reviewer received the worker's full transcript. Another saw only the output. A third saw only the codebase.
No single reviewer perspective caught everything. Cursor found that uncorrelated review angles worked better together because different views exposed different problems.
The system also used a "field guide," a knowledge folder maintained by the agents themselves with a fixed line limit. Each agent received that material at startup. Since model weights are frozen, saving unexpected findings helped later agents avoid rediscovering the same lessons.
This is a practical point for AI coding systems. If many agents are going to work on one task, the system needs a way to preserve useful discoveries without overwhelming every future agent with unlimited history.
The Cost Lesson
The strongest cost signal came from worker models. 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. But planner tokens were more expensive, so token share and cost share did not always match. In the Opus hybrid, the planner produced only a small share of 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 Opus and Composer run, the entire worker fleet cost $411 at comparable quality. Composer 2.5 costs just $0.50 per million input tokens and $2.50 per million output tokens, and Cursor founder Michael Truell said it is based on Kimi K2.5.
Cursor's argument is that only parts of a large coding task need frontier-level intelligence, especially task breakdown and important design decisions. Once ambiguity is reduced, cheaper models can follow the plan.
The hybrid results also show that planner quality still matters. Fable 5 used fewer planning tokens than Opus, but its workers needed far more tokens to finish the job, and the Fable run cost more overall.
Cursor describes swarms as a "probabilistic compiler" that turns intent into executable work step by step. The company says accurately describing that intent was the main constraint in the experiment. That frames the future of AI coding less as a contest between individual models and more as a question of how well systems can divide work, preserve decisions, control conflicts, and spend model intelligence where it has the highest leverage.