AI Agent Swarms Hit 1,000 Commits Per Second — Here's What It Costs

Cursor's latest experiment shows that hundreds of AI agents working together can build a database from scratch in four hours. The trick isn't raw compute — it's keeping each agent from going brain-dead on context overload.

Earlier this year, Cursor ran a swarm of AI agents to build a web browser from nothing. It worked, roughly. The real product wasn't the browser — it was the engineering insight about how groups of agents coordinate, collide, and exhaust their own working memory.

Today they published the sequel. A new paper on agent swarms and model economics details how they rebuilt their swarm architecture and tested it against a harder benchmark: implementing SQLite in Rust, from the 835-page manual, with zero source code or internet access.

The Swarm That Broke Git

The flagship browser experiment from earlier this year peaked at roughly 1,000 commits per hour on Git. That sounds like a lot until you do the math — it's about 17 commits per minute. Fine for a weekend hackathon. Not fine for hundreds of agents all writing code at once.

The new swarm peaks at 1,000 commits per second. That's a 60x increase. Git and its ecosystem tools rely on coarse locks for concurrency control — think of it as one developer at a time grabbing the steering wheel. At agent-scale, that's a traffic jam with no traffic light.

So Cursor built a custom version control system from scratch. Every change passes through the VCS, so it's the natural choke point for detecting collisions, tracking design decisions, and resolving conflicts before they cascade.

Two Roles, One Tree

The swarm architecture uses two distinct roles organized around a tree-like task decomposition:

• Planner agents run the smartest, most expensive models. They split goals into subtasks and delegate. They never write implementation code, so their context never fills with low-level detail.
• Worker agents run faster, cheaper models. They execute specific pieces of work. They never plan, so they spend all their context on one narrow task.

The separation of concerns isn't just architectural — it's cognitive. I found the claim that context efficiency, rather than parallelism, is the key advantage of scaling swarms. That's the insight worth repeating. You can throw a hundred agents at a problem, but if every agent is carrying the full context of the problem plus every other agent's work, you're just spending money on the same mistake in parallel.

The SQLite Experiment

Take the 835-page SQLite manual. No source code. No test suites. No internet. Give it to a swarm of agents and ask them to build the database in Rust.

The swarm graded itself against sqllogictest, the SQLite project's own test suite containing millions of queries with known correct answers:

• GPT-5.5 (frontier model for everything): Hit 100% of the suite.
• Grok 4.5 (cost-efficient frontier): Reached 80% in four hours, eventually passed everything.
• Opus 4.8 planning + Composer 2.5 execution: Passed the full suite.
• Fable 5 planning + Composer 2.5 execution: Reached 100% by four hours.

Failure Modes at Scale

Running hundreds of concurrent agents isn't like running a build pipeline. New failure modes emerge that human engineering teams don't encounter:

• Split-brain design — Two planners implement the same concept differently. Fix: planners now make design decisions themselves and ensure no two delegated subtrees answer the same question.
• Contention between planners — Agents fight through back-and-forth changes on the same files. Fix: shared design documents with compile-checked references.
• Merge conflicts — Workers collide constantly. Fix: a neutral third-party agent intervenes, acting like a merge queue.
• Megafiles — Files attract disproportionate attention and bloat. Fix: workers can flag bloated files, blocking new commits while an outside agent decomposes them.
• Ossification — Agents learn not to touch core code even when it needs changing. Fix: intentional breakage is licensed with comments.

The Economics of Mixing Models

Different model combinations produced similar quality output but vastly different costs:

• GPT-5.5 for both planning and execution: $10,565
• Opus 4.8 planning + Composer 2.5 execution: $1,339

That's an eightx difference in cost for roughly the same result. The takeaway is clean: frontier model planning paired with fast model execution is a cost-effective mix.

What I Think

The comparison to economist Ronald Coase's theory of the firm isn't a stretch — it's a direct parallel. The swarm doesn't scale because it has more agents. It scales because each agent has less to hold in its head. The 70,000 merge conflicts in the old run versus under 1,000 in the new run tells the story better than any benchmark chart.

One thing I'll keep an eye on: the custom VCS. Git works fine for one developer, but agent-scale concurrency is a different game. If agent swarms become common — and they will — the version control infrastructure running underneath will need to be purpose-built. Cursor's early work here could be the git(1) moment for AI-assisted development.