Cursor's Agent Swarm: Building SQLite in Rust for $1,339

⬅️ Back to Articles

Cursor published a detailed post on Agent swarms and the new model economics that is worth reading end to end. They built SQLite from scratch in Rust, starting from nothing but the 835-page SQLite manual, using a swarm of AI agents. The experiment is a concrete demonstration of the commodity-market math Ben Thompson wrote about last week.

  1. The new swarm is organized as a tree: a frontier model acts as planner, decomposing the goal into pieces, while cheaper models act as workers executing those pieces. The design is deliberately shaped by the problem rather than imposing a fixed topology. This is the same planner-worker distinction Thompson described as a future possibility; Cursor just shipped it.

  2. The context efficiency of this separation is the core insight. A solo agent that walks the whole task tree has to hold every context layer at once and drifts. In the swarm, a planner never sees low-level implementation detail, and a worker never needs to hold the global picture. Cursor suspects this context efficiency matters more than parallelism for scaling.

  3. At 1,000 commits per second, human coordination mechanisms break. Cursor built a custom VCS from scratch, then handled five failure modes that human teams never see: split-brain design (two planners implementing the same thing), planner contention (agents fighting over the same files), merge conflicts (a neutral third-party agent resolves them), megafiles (agents flag bloated files for automatic decomposition), and ossification (agents learn not to touch core code, so Cursor licensed intentional breakage and let the compiler propagate changes).

  4. The stacked review system is the error-correction layer. No single review lens catches everything, but decorrelated lenses (different models, different inputs, different personalities), stack like self-driving car sensor fusion. The compute spent on review is high return because review is much cheaper than the work it audits.

  5. The Field Guide experiment is a stigmergy mechanism: agents write a shared context folder that is injected into every agent at start. Model weights are frozen, so the only way to shorten the next trajectory is by capturing surprise encounters in the guide. This is the closest implementation I have seen of agents building institutional memory for themselves.

  6. The economics are the story. Cursor tested four model mixes: GPT-5.5 (both roles), Grok 4.5 (both), Opus 4.8 planner + Composer 2.5 workers, and Fable 5 planner + Composer 2.5 workers. All passed 100% of the SQL test suite. Costs ranged from $1,339 (Opus hybrid) to $10,565 (GPT-5.5). In the cheapest configuration, the Opus planner produced a small fraction of tokens but two-thirds of the cost, while workers handled the vast majority of tokens for one-third of the cost. In the most expensive, those same workers cost $9,373. This is a big win because they were running GPT-5.5 for a job a cheaper model could do.

  7. The old versus new comparison is staggering. On the same task with the same time budget, the old swarm produced 68,000 commits and 70,000+ merge conflicts in two hours before it had to be paused. The new swarm produced under 1,000 conflicts over its full four hours. The old codebase needed 64,305 lines. The new one did it in 9,908.

The takeaway: This is the Thompson thesis in microcosm. When intelligence becomes a commodity, the winning strategy is not the smartest model but the optimal planner-worker split. The cost difference between the cheapest and most expensive configurations was 8x with identical outcomes. Cursor’s swarm is a working demonstration of what happens when you stop optimizing for capability and start optimizing for cost structure.

Related TMFNK Content

Crepi il lupo!