Preface¶

In late July 2026, Cursor published the design philosophy and benchmark results of its upgraded Agent Swarm architecture on its official blog. This multi-agent orchestration system has evolved alongside the Cursor 3 Agent Runtime: cutting-edge models are responsible for “task breakdown and planning,” while low-cost Worker models handle “code writing and implementation.” In a closed experiment where the team reimplemented a full database engine in Rust solely using the 835-page SQLite official manual, all configurations of the new architecture ultimately achieved 100% pass rate on sqllogictest. The total cost for the Opus 4.8 planning + Composer 2.5 execution combination was approximately \(1,339**, while a single-model solution using GPT-5.5 throughout the process cost around **\)10,565—a difference of nearly 15x.

These figures come from Cursor’s in-house benchmarks, not production environment tests; but they clearly point to a direction that more teams are now discussing: multi-model collaboration may be more cost-effective than “using the strongest model for everything.” This article summarizes the key architectural points, experimental data, and implementation considerations based on Cursor’s official blog and public reports.

Background: From Browser Swarm to SQLite Reimplementation¶

Cursor first used Agent Swarm for a proof-of-concept “build a browser from scratch” project in early 2026: it worked, but was still far from a deliverable product. The team then shifted focus to understanding and engineering the Swarm system itself, returning to a challenge that stumped the earlier version of Swarm: implementing a complete database engine in Rust using only the 835-page SQLite official manual, with no external resources.

The experimental conditions were deliberately strict:
- No access to SQLite source code, binaries, or test suites;
- No internet connectivity allowed;
- Evaluation used sqllogictest (millions of SQL queries and their标准答案/standard answers) that the Swarm had no prior knowledge of.

The original Swarm performed poorly on this task: the Grok 4.5 single-model configuration was suspended in less than two hours due to coordination failures; after four hours, the pass rates of all old configurations ranged only between 11% and 77%. The new Swarm, under the same time budget, achieved a pass rate of 73% to 85% after four hours, and all new configurations ultimately reached 100%.

Core Architecture: Tree-Based Division of Labor Between Planner and Worker¶

Cursor naturally models large tasks as a task tree: the root node is the overall goal, which is recursively decomposed into executable leaf nodes. Two types of Agents work separately in the Swarm:
1. Planner: Runs state-of-the-art large models, responsible for breaking down goals into subtasks, making architectural and key design decisions, and does not write implementation code.
2. Worker: Runs faster, cheaper models (mostly Composer 2.5 in the benchmarks), executes specific coding work at leaf nodes, and does not perform planning.

This division of labor addresses the context window problem of long-range Agents. A single Agent that tries to both “remember the global goal” and “handle current file details” risks drifting across the task tree—either focusing too much on details and losing sight of the big picture, or fixating on the big picture and failing to execute local work well. The Planner’s context is not cluttered with implementation details, while the Worker dedicates all its context to a single narrow task. Cursor believes this approach scales Swarm capabilities better than simply increasing parallelism.

Cursor also drew a parallel to Ronald Coase’s theory of firm hierarchies: coordination costs grow faster than the workload itself, so systems will naturally form bounded division-of-labor units, rather than having every agent communicate with every other agent.

Orchestration Layer: 1,000 Commits Per Second and Failure Mode Governance¶

When multiple Agents write code concurrently, conventional tools like Git quickly become bottlenecks. The early browser Swarm peaked at around 1,000 commits per hour on Git; the new in-house VCS peaks at approximately 1,000 commits per second. All changes flow through the VCS, where conflicts are first identified, and multiple coordination mechanisms are embedded into this layer.

Cursor documented several failure modes and their countermeasures that are rare in “human-paced” development:

There are also multi-layered Review Lenses (stacked review Agents with different models and input scopes), as well as an Agent-maintained Field Guide—a knowledge document with a line count limit, automatically injected when a new Agent starts, to capture “unexpected discoveries” and shorten the onboarding trajectory for future Agents.

SQLite Benchmark: Accuracy, Code Volume, and Conflict Comparison¶

The official blog compared four model combinations (run with both old and new Harnesses):
1. GPT-5.5 serving as both Planner and Worker
2. Grok 4.5 serving as both Planner and Worker
3. Opus 4.8 Planning + Composer 2.5 Execution
4. Fable 5 Planning + Composer 2.5 Execution

The new Harness outperformed the old one for every combination. Take Grok 4.5 as an example: the old version generated approximately 68,000 commits in two hours (about 70 times that of the new version), but was suspended after accumulating over 70,000 merge conflicts; the new version had fewer than 1,000 conflicts throughout the process. The old Rust project was split into 54 crates (including 3 SQL packages), while the new version stabilized at 9 crates.

Differences in code volume were also significant (all engine code lines):
- Fable 5 Combination: Old version 64,305 lines vs new version 9,908 lines (both ultimately passed 100%)
- Opus Combination: Old version 19,013 lines at 97% accuracy vs new version 4,645 lines at 100% accuracy—code volume reduced by approximately 85%, with higher accuracy

The codebase produced solely by Opus is open-sourced at github.com/cursor/minisqlite, and readers can review its quality independently.

Model Economics: Workers Consume Tokens, Planners Impact the Bill¶

All four configurations achieved similar final quality, but total costs ranged from \(1,339** (Opus + Composer 2.5) to **\)10,565 (GPT-5.5 single-model)—a difference of roughly 15x.

In terms of token breakdown, Workers accounted for at least 69% of tokens across all runs, and over 90% in most cases—the execution phase was the largest token consumer. However, the dollar cost distribution differed: state-of-the-art models used by Planners have much higher per-token pricing. Take the Opus + Composer 2.5 combination as an example: Opus planning used only a small number of tokens, but accounted for approximately two-thirds of total cost; Composer Workers processed the vast majority of tokens, but only accounted for about one-third of the total cost.

A more direct comparison comes from the GPT-5.5 single-model run: Worker-only costs alone were approximately $9,373; when switching to Opus planning + Composer 2.5 execution, the entire Worker fleet cost only about $411 for equivalent quality. This demonstrates that “using expensive models for planning and cheap models for execution” offers massive cost-saving potential in Cursor’s closed experiments.

Composer 2.5 is the mainstay of the Worker side: based on the open-source Moonshot Kimi K2.5 checkpoint, further pre-trained and RL-tuned by Cursor. Standard pricing is $0.50/M input tokens, $2.50/M output tokens (with a Fast tier at \(3/\)15, used by default for interactions). Cursor claims its intelligence level matches Opus 4.7 and GPT-5.5, a claim that has not been independently verified by third-party public benchmarks.

Note: While Fable 5 planning consumed fewer planning tokens than Opus, its total Worker tokens were multiple times higher than the Opus combination, making the full run more expensive overall—this shows that Planner quality directly impacts Worker efficiency, and one cannot focus solely on planning unit costs.

Relationship to Cursor 3¶

Cursor 3 was released on April 2, 2026, with its core being an Agent-first unified workspace: Agents Window, parallel local/cloud/SSH Agents, multi-repository layout, and more. The Planner/Worker orchestration of Agent Swarm is an architectural upgrade built on this runtime, not a separately sold model product; media reports describing TPS have framed it as part of Cursor 3’s multi-Agent capabilities.

For end users, the interface layer already supports parallel management of Agent fleets; Swarm’s paper-grade improvements (in-house VCS, Field Guide, Review stack) are mainly reflected in Cursor’s internal long-running tasks and Cloud Agent scenarios.

Insights and Limitations for Engineering Teams¶

Worthwhile takeaways:
- Task Routing: Use strong models for decomposition, architecture, and key trade-off decisions; assign clear subtasks to low-cost models like Composer 2.5—aligning with the industry trend of “using the minimum viable model for the task.”
- Spec as Prompt: Swarm elevates the engineering abstraction level from “files/features” to “specifications”; feeding in 835 pages of manual and outputting a full database, the scarce resource is the quality of intent description.
- Orchestration and VCS Are Equally Important: 70,000 conflicts vs fewer than 1,000 conflicts shows that the bottleneck for multi-Agent systems often lies in orchestration and merging, rather than the intelligence of individual models.

Important cautions:
- The benchmarks are synthetic, closed-book, and self-evaluated by Cursor, and the company has commercial incentives to showcase product advantages.
- Cursor’s blog also cited research: approximately 68% of production AI Agents stall within 10 steps—today’s cost savings mostly apply to controlled experiments, and cannot be directly equated to daily business codebases.
- Claims about Composer 2.5 matching state-of-the-art model performance, and details of partial models like Fable 5, are subject to Cursor’s disclosures and await community replication.

Summary¶

Cursor’s new Agent Swarm uses tree-based Planner/Worker division of labor, an in-house high-throughput VCS, and multi-layered reviews to improve accuracy, code volume, and merge conflicts in the SQLite-to-Rust benchmark. In terms of model combinations, the Opus 4.8 + Composer 2.5 solution reduced total costs by approximately 15x compared to the GPT-5.5 single-model方案, with Worker-only costs dropping from approximately \(9,373** to around **\)411.

This sends a clear signal to teams evaluating AI coding Agent procurement and architecture: multi-model orchestration may be just as important as “switching to a stronger model.” Worthwhile next areas to watch include the replicability of similar Planner/Worker strategies in real legacy codebases, under compliance and audit requirements—and whether open-source artifacts like minisqlite can withstand independent community scrutiny.