Cursor built a version control system for 1,000 commits per second to make agent swarms work

Cursor Built a Custom Version Control System Because Its Agent Swarms Hit 1,000 Commits Per Second

When Cursor started scaling AI agents to cooperate on large coding tasks, the models were not the bottleneck. The infrastructure was.

In a research post published July 20, Wilson Lin at Cursor laid out what happens when you move from a single AI coding agent to a coordinated swarm of hundreds, and why the engineering problems that surface have no parallel in routine human software development. 1

The most concrete evidence sits in version control. Cursor's earlier browser-building swarm peaked at roughly 1,000 commits per hour on Git. The new system peaks at about 1,000 commits per second. That is a 3,600x jump in throughput, and it required Cursor to abandon Git and Cargo's coarse locking model and build a custom version control system from scratch. 1

Every change in the swarm flows through this custom VCS, which makes it the layer where agent collisions first become visible. Cursor embedded several coordination mechanisms directly inside it. 1

How the swarm is organized

Cursor structures the swarm around a task tree, with a goal at the root that subdivides into progressively smaller pieces. Two agent roles sit on this tree. Planners, powered by the most capable models, decompose goals and delegate. Workers, generally powered by faster and cheaper models, execute the pieces. 1

The advantage is about context, not just speed. A single agent tackling a full task has to hold the overall goal, its current position, and every low-level detail simultaneously. Cursor attributes the tendency of long-running solo agents to drift to this burden: they either lose the bigger picture or fumble the work in front of them. In the swarm, planners never implement, so their context stays clear of detail. Workers never plan, so they can spend all their context on one narrow task. Cursor suspects this context efficiency, more than raw parallelism, is what lets the swarm scale. 1

There is a structural parallel. The economist Ronald Coase argued that coordination costs grow faster than the work itself, which is why firms organize into hierarchical tiers rather than letting everyone communicate with everyone. 1

The cost savings from splitting roles are substantial. Cursor tested different model mixes: one model doing everything versus a frontier model planning while an inexpensive model executed. Quality was comparable across configurations. The price tags were not. 1

To measure progress, Cursor ran the old and new swarms on the same task: building SQLite from scratch in Rust, using only its documentation. With Grok 4.5, the new swarm passed 80% of an unseen SQL test suite in four hours. The old swarm spiraled and was halted before its second hour. 1

Cursor has already applied the architecture internally to find and fix vulnerabilities in open-source software, raise test coverage on its own code, and produce synthetic training data at a scale of billions of tokens. 1

At 1,000 commits per second, the coordination mechanisms that human engineering teams rely on (code review, file ownership, merge queues) stop functioning. 1

Split-brain design occurs when two planners, unaware of each other, build the same feature in incompatible ways across different parts of the codebase. The remedy is in prompting: planners must settle every design decision themselves and guarantee that no two delegated subtrees decide the same question. 1

Planner contention is messier. Two planners who know about each other fight through back-and-forth edits on the same files, and no merge tool can adjudicate a genuine design disagreement. Cursor's answer is shared design docs that code references via compiler-enforced links. When planners unknowingly contradict each other, a reconciler agent merges the docs and the resolution propagates downstream. 1

Worker merge conflicts are more basic. Agents colliding on the same files tend to overwrite the other's change or abandon their own. Cursor dispatches a neutral third-party agent to resolve conflicts for all parties, modeled on how merge queues function in engineering organizations. 1

Megafiles form when a popular file attracts small contributions from many agents, with nobody accountable for its size. The files swell until they become costly to move, diff, and reconcile, and turn into constant collision points. Workers can now flag these files; once flagged, commits are blocked and an outside agent decomposes the file into smaller modules. 1

Ossification is the inverse: agents that learned from working in human codebases become reluctant to modify core code even when it should change. Cursor permits what it calls intentional breakage. An agent can patch outside its assigned scope, leave a comment explaining the rationale, and let the compiler propagate the change. Other agents that hit resulting build errors find the comment, read the reasoning, and adapt their work. 1

For review, Cursor tried giving agents different vantage points: a worker's full transcript, only its output, or nothing but the codebase. Reviewers also ran on different models with different training. No single review approach caught everything, but the approaches stacked, the way overlapping safety systems in autonomous vehicles compensate for individual blind spots. Review costs a fraction of the original work it audits. 1

The takeaway

Every failure mode Cursor identified has a structural fix. Design docs, reconcilers, file decomposition rules, breakage protocols. The model generates the code. The infrastructure determines whether that code survives contact with hundreds of other agents committing at the same time.

For builders, the post is a working blueprint for the agent era. For investors tracking where durable advantages form, it points to the same conclusion: the next competitive moat in AI tooling is not a smarter model. It is the version control system, the design-doc protocol, the merge arbiter, and the rules that keep coordinated agents from collapsing under their own complexity. Cursor just published theirs.