From stumbling single agents to synchronized digital fleets, the leap to “swarm engineering” is turning natural language specs into production-ready codebases—and fundamentally altering the cost of computation.
- A New Tier of Task Complexity: By dividing work into a tree-like structure of “planners” and “workers,” agent swarms overcome the memory and context limitations that previously caused single AI agents to drift and fail on long-running tasks.
- Infrastructure for the Inhuman Tempo: Managing swarms required building a custom version control system capable of handling 1,000 commits per second, alongside novel, automated mechanisms to resolve merge conflicts, prevent “megafiles,” and enforce design consensus.
- The Power of Hybrid Economics: Blending frontier models (for planning) with fast, inexpensive models (for execution) yields identical code quality to using frontier models universally, but slashes execution costs by staggering margins.
Earlier this year, the frontier of AI agent capabilities was tested through a flagship experiment: unleashing a swarm to build a web browser from scratch. It was a purely empirical exercise—a blank canvas where models hill-climbed toward a functioning, if unpolished, proof of concept.
Since that early victory, the engineering objective shifted from merely observing the swarm to deliberately engineering it. To measure this progress, the focus turned to a notoriously rigid challenge the old swarm failed to conquer: building a SQLite database engine from scratch, written in Rust, using nothing but its 835-page manual.
The results are not just an upgrade in software generation; they represent a fundamental shift in how we orchestrate artificial intelligence.
Trees, Leaves, and the Economics of Context
Descriptions of massive projects naturally resemble a tree: a root goal that recursively subdivides into basic units of work. The new agent swarm mirrors this exact topology through two distinct roles:
- Planner Agents: Powered by the smartest frontier models, these agents break down goals and delegate them.
- Worker Agents: Powered by faster, less expensive models, these agents execute the granular tasks.
Rather than forcing a rigid structure onto a problem, the swarm organically grows to map the problem’s contours.
What the Tree Does for Memory
When a single AI agent tackles a massive codebase, it suffers from context collapse. It must hold the grand vision, its current position, and the minute details of the leaf it’s working on simultaneously. Consequently, single agents drift—they either get lost in the weeds or sacrifice detail to maintain the big picture.
In the swarm, a planner never writes code, keeping its context free of low-level clutter. Conversely, a worker never plans, allowing it to dedicate its entire context window to one hyper-specific task. This context efficiency—reminiscent of economist Ronald Coase’s theory that organizations form bounded tiers to manage escalating coordination costs—is the true engine of the swarm’s scalability.
Managing the Chaos: 1,000 Commits Per Second
Tools like Git were built for humans. For a swarm of hundreds of concurrent agents, human tools bottleneck immediately. The old browser swarm peaked at roughly 1,000 commits per hour. The new SQLite swarm peaks at 1,000 commits per second.
To survive this throughput, a custom Version Control System (VCS) was built from scratch. Because every system change passes through this VCS, it serves as the frontline for detecting and resolving high-speed collisions.
Failure Modes at the Inhuman Tempo
Human teams rely on standups and code reviews. At swarm velocity, those paradigms fail. Here is how the new architecture solves swarm-specific breakdowns:
| Failure Mode | The Problem | The Swarm’s Solution |
|---|---|---|
| Split-Brain Design | Two unaware planners implement the same concept differently in separate parts of the codebase. | Prompting constraints. Planners must finalize design decisions upfront and ensure no delegated subtrees debate the same question. |
| Planner Contention | Two planners disagree on reality and endlessly overwrite each other’s files. | Shared design docs. Code carries compile-checked references to a central design doc. A reconciler merges conflicting docs, propagating the resolution downstream. |
| Merge Conflicts | Agents collide on files. Lacking the context to merge manually, they overwrite or abandon changes. | The Neutral Arbiter. A specialized third-party agent intervenes, impartially absorbing both contexts and resolving the conflict efficiently. |
| Megafiles | Popular files become bloated as agents continually add small bits of code, choking the system. | Flag and Decompose. Workers flag bloated files. Commits are temporarily blocked while an outside agent breaks the megafile into smaller modules. |
| Ossification | Agents become too timid to modify foundational code, even when architectural shifts require it. | Intentional Breakage. Agents are licensed to break core code, leaving an explanatory comment. The compiler fails downstream, forcing affected agents to read the comment and update their respective pieces. |
Stacked Review Lenses
Because errors compound rapidly in a multi-agent system, the swarm utilizes decorrelated “review lenses.” By assigning review agents different constraints (e.g., viewing only the output, or only the transcript) and using models with varying personalities, the system achieves self-driving levels of reliability. Review compute is exceptionally high-return because auditing is significantly cheaper than generating.
Stigmergy: Letting Agents Shape Their World
In nature, organisms like ants coordinate without direct communication by altering their environment—a process called stigmergy.
The swarm utilizes this concept through the Field Guide, a shared folder entirely owned and curated by the agents. The index.md of this guide is automatically injected into every agent at startup. Operating on a strict line budget, agents institutionalize their “surprise encounters” and learnings. Because model weights are frozen, this shared, self-authored context allows agents to shorten the trajectory for their successors, essentially leaving breadcrumbs of institutional knowledge.
The SQLite Experiment & Model Economics
Equipped with this robust architecture, the swarm was tasked with implementing the 835-page SQLite manual in Rust—without internet access, source code, or tests. Progress was rigorously graded against sqllogictest, a test suite of millions of queries.
The swarm outperformed the old architecture universally. While the old Grok 4.5 run spiraled and had to be paused within two hours, every new configuration eventually passed 100% of the suite.
The Financial Breakthrough of Hybrid Swarms
The most startling revelation was not just the capability, but the economics. We tested four configurations across the capability/cost spectrum:
- GPT-5.5 (Planner & Worker): Strong frontier model throughout. Total cost: $10,565.
- Grok 4.5 (Planner & Worker): Cost-efficient frontier model for baseline comparison.
- Opus 4.8 (Planner) + Composer 2.5 (Worker): Frontier judgment paired with efficient execution. Total cost: $1,339.
- Fable 5 (Planner) + Composer 2.5 (Worker): Testing a next-tier planner in a hybrid setup.
Every mix produced similar high-quality output, but the costs varied wildly. Token data revealed that workers handle 69% to 90%+ of the workload. When a frontier model collapses ambiguity into a tight spec, a cheaper model can easily execute it.
In the GPT-5.5 run, the worker fleet alone cost $9,373. In the Opus 4.8 / Composer 2.5 hybrid run, the exact same worker workload cost just $411.
Specs as Prompts
Historically, every leap in AI software generation has raised the level of abstraction: from auto-completing single lines, to generating blocks, to drafting entire files. With swarms, the unit of work is now the specification.
The swarm operates remarkably like a compiler. Just as a compiler translates source code down to machine code through intermediate steps, the swarm translates high-level intent into executable work by parsing goals into task trees. The critical difference is that while a traditional compiler preserves meaning deterministically, the swarm operates probabilistically.
As we look toward the future of software engineering, the scarcity will no longer be the ability to write code. The scarcity will be the ability to clearly, structurally, and effectively describe intent.
