Cursor: рой ИИ-агентов собрал SQLite на 80% за 4 часа — и в разы дешевле старого

Cursor compared the old and new versions of its swarm of AI agents on a single task — build the SQLite DBMS from scratch in Rust, given only its documentation as input — and the new swarm passed 80% of a held-out set of SQL tests in four hours on the Grok 4.5 model, while the old swarm stalled and was stopped before the second hour of work.

What the experiment showed

Cursor's new swarm outperformed the old one in every model configuration, given the same time budget and the same models. The team measured the share of the held-out SQL test set passed — and by this metric the advantage proved consistent, not a one-off.

• The task: build SQLite from scratch in Rust using only the documentation
• Grok 4.5 in the new swarm: 80% of tests in 4 hours
• The old swarm stalled on the same task and was stopped before the second hour
• The flagship of past experiments (early 2026) — a swarm that built a web browser from scratch: a proof of concept, but not a polished product
• Inside Cursor, the swarm has already found and fixed vulnerabilities in open source, raised test coverage, and generated billions of tokens of synthetic training data

Why does a swarm outperform a single agent?

A swarm wins through context efficiency, not parallelism as such — Cursor itself insists on this. Large tasks naturally decompose into a tree: the goal at the root is recursively broken down into elementary units of work. Cursor's swarm is built around two roles: Planner agents on the smartest models split the goal and delegate pieces, while Worker agents on fast, cheap models execute those pieces.

The key is that the planner never writes code, and the worker never plans. So the planner's context isn't clogged with low-level details, and the executor spends its entire context on one narrow task. A single agent, by contrast, has to hold both the overall goal and its current position in the tree in mind — and over time it "drifts." The swarm's design itself is a superset of stricter orchestration schemes: instead of a fixed topology, its shape grows to fit the contours of the task, which is why the approach generalizes to building a browser, solving math problems, and optimizing GPU kernels alike.

"We believe the ability to scale a swarm of agents stems from this context efficiency, rather than from parallelism as such," — the

Cursor team, on the company blog.

How much it costs

The cost of runs varied enormously for nearly identical quality — that's the "new economics of models" from the study's title. Cursor varied the distribution of roles: in some runs, a single model did everything; in others, a frontier model planned while a fast, cheap model executed the work. The resulting quality came out similar, but the bill was fundamentally different. A similar logic was described back in 1937 by economist Ronald Coase: coordination costs grow faster than the work itself, which is why organizations split into levels of bounded units rather than letting everyone talk to everyone.

A separate engineering problem is version control. Git and Cargo rely on coarse-grained locks, which is fine for a single developer but can't withstand hundreds of parallel agents. According to Cursor, last year's browser-building swarm hit a ceiling of around 1,000 commits per hour on Git; the new system can handle on the order of 1,000 commits per second — which is why Cursor built its own version control system.

What this means

Multi-agent systems are moving from the "just spin up more agents" principle to deliberate coordination engineering: correctly splitting roles between an expensive and a cheap model delivers the same quality for a fraction of the cost. The economics of decisions now depend not only on which model you pick, but also on how you distribute the work between them.

Frequently asked questions

What is a swarm of AI agents?

It's a system made up of multiple agents that jointly solve a single large task. At Cursor, the swarm consists of Planner agents (smart models that plan and delegate) and Worker agents (fast, cheap models that execute), and the swarm's shape grows to fit the contours of the task.

Why build SQLite from scratch?

SQLite is a complex, well-documented DBMS, which makes it a convenient test of the limits of agent coordination. Cursor gave the swarm only the documentation and measured the share of SQL tests passed; the new swarm on Grok 4.5 reached 80% in 4 hours.