Cursor tested an upgraded agent swarm against its earlier system by asking both to rebuild SQLite in Rust using only documentation, with no access to source code or the internet. Every configuration of the new system eventually reached 100 percent on the test suite, while the older swarm was slowed by extensive merge conflicts and duplicated work.

At Cursor, agent fleets have shifted from a research project into a core product. With Cursor 3, developers can run fleets of AI agents in parallel. Anysphere, the company behind Cursor, was recently acquired by Elon Musk's SpaceX for $60 billion.

The system separates agents into two roles. Planner agents, powered by frontier models, recursively break a goal into smaller tasks. Worker agents, using faster and cheaper models, complete those tasks. The process creates a task tree that can change as work progresses.

Cursor says the division mainly addresses a context-management problem. A single agent has to move through the full task tree while retaining both the overall objective and the immediate task, which can help explain why agents drift during long-running jobs. In Cursor's swarm design, planners do not write code, and workers do not plan.

Git could not keep up with 1,000 commits per second

An earlier Cursor browser swarm reached about 1,000 commits per hour on Git. That system used worker agents, a judge agent, and an integrator responsible for resolving conflicts. The integrator ultimately became more of a bottleneck than a solution.

The new swarm reached 1,000 commits per second. Cursor therefore built its own version control system, saying that agents operating at that speed produced failure modes that human engineering teams do not normally encounter. The result makes the experiment less about raw code generation alone and more about whether software-development infrastructure can coordinate thousands of automated edits without collapsing into duplicated work.

One issue was what Cursor called "split-brain design." In that pattern, two planners would unknowingly build the same concept in different areas of the codebase and implement it in different ways. Contention became even harder to manage when planners were aware of one another and blocked each other with competing edits.

To reduce those problems, Cursor had agents document decisions in shared design documents. Code associated with a decision linked back to the relevant document through a reference checked at compile time.

When merge conflicts occurred, a neutral agent intervened to resolve them. Workers also flagged oversized files so that an outside agent could split them into smaller modules. Because agents had learned to avoid touching core code while working in existing human-supervised codebases, Cursor deliberately allowed them to break things. An agent could patch code outside its assigned area, and the compiler would carry the change through the system.

Cursor tested multiple reviewers and an agent-maintained field guide

Cursor evaluated several review methods. One reviewer received the worker's complete transcript, another saw only the worker's output, and a third saw only the codebase. No single viewpoint caught every issue, but Cursor found that combining uncorrelated perspectives improved reliability.

The company also tested a "field guide," a knowledge folder maintained by the agents themselves under a fixed line limit. Every agent received the folder contents at startup. Since model weights are fixed after training, Cursor said it was useful to capture surprising findings so later agents could take shortcuts.

For the benchmark, Cursor gave the swarm the 835-page SQLite manual and instructed it to build a Rust implementation. The agents did not receive the SQLite source code, test suites, the SQLite binary, or internet access. The benchmark was sqllogictest, a test suite containing millions of SQL queries with known answers. The swarm did not know the benchmark existed. That setup made the task a test of specification-following and system integration rather than source-code translation or benchmark-specific tuning.

Cursor tested four configurations: 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 outperformed the old system in every configuration. After four hours, the new runs scored between 73 and 85 percent, compared with 11 to 77 percent for the old runs. Every configuration of the new system later reached 100 percent.

The old swarm generated more work than it completed

The Grok 4.5 runs showed why the earlier system lagged. The old swarm produced 68,000 commits in two hours, about 70 times as many as the new system. Cursor said most of that activity was wasted. The old run accumulated more than 70,000 merge conflicts, while the new run remained below 1,000 for the entire test.

The most contested file in the old run recorded 7,771 conflicts involving 1,173 agents. The comparable figure in the new run was 47 conflicts. The same split-brain problem also appeared in the package layout. The old run divided the project into 54 Rust crates and created three separate SQL packages, while the new run settled early on nine crates.

In the Fable 5 configuration, the old swarm required 64,305 lines of engine code, compared with 9,908 lines for the new system. 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. For Cursor, fewer lines and fewer conflicts were part of the same result: the improved swarm did less redundant implementation work while reaching higher test performance.

Cheaper worker models produced the biggest cost difference

Total costs ranged from $1,339 for the Opus hybrid configuration to $10,565 for GPT-5.5 running alone. Workers accounted for at least 69 percent of tokens in every run and usually more than 90 percent. Because planner tokens were more expensive, the cost distribution was different from the token distribution. In the Opus hybrid run, the planner produced only a small share of tokens but accounted for two thirds of the total bill.

The choice of worker model produced 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. Cursor attributed the difference almost entirely to pricing. Composer 2.5 benchmarks at the level of Opus 4.7 and GPT-5.5, but costs $0.50 per million input tokens and $2.50 per million output tokens. According to Cursor founder Michael Truell, the model is based on Kimi K2.5.

Cursor argues that only certain parts of a large task require frontier-model intelligence, including task decomposition and key design decisions. Once a frontier planner resolves ambiguity, cheaper models can follow the plan. However, the hybrid runs also showed that planner quality still mattered. The Fable 5 planner used fewer planning tokens than Opus, but its workers required far more tokens to finish the job, making the Fable run more expensive overall.

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

The article said runs of this type are no longer limited to laboratory 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 at a cost of about $165,000. Production use remains 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 steps. That contrast leaves the key practical question around how much of Cursor's controlled, high-parallelism workflow can transfer into production settings where humans still interrupt most agent runs quickly.