Cursor deployed its agent swarms on a real task: rebuild SQLite in Rust using only 835 pages of documentation, no source code or internet. The new system splits agents into two roles: planners with frontier models that break down work, and executors with economical models that get it done. Every configuration of the new system hit 100% of the test suite; the previous version plateaued between 11 and 77%.

Why it matters to you: architecture beats individual model, and now there’s a number to prove it. The hybrid setup with Opus 4.8 as planner and Composer 2.5 as executor spent $1,339 against $10,565 for GPT-5.5 alone, with identical final output (source: The Decoder, July 26, 2026). Executors consume between 69 and 90% of tokens in every run: that’s where savings materialize, because you use the expensive model only where judgment matters, not where effort does.

The principle extends beyond code. If you have a long task with repetitive steps, separating who decides from who executes changes the cost-quality equation. It’s the same direction as three papers we covered on July 20: orchestration beats raw power.

In detail

Cursor’s test setup is rigorous. Agents receive the 835-page SQLite manual and must produce a Rust implementation that passes sqllogictest, a suite with millions of SQL queries and known answers. No source code, no visible test suite, no internet. Four configurations tested: GPT-5.5 alone, Grok 4.5 alone, Opus 4.8 as planner with Composer 2.5 as executor, and Fable 5 as planner with Composer 2.5 as executor.

After four hours, the new system configurations scored between 73 and 85%, then all reached 100%. The old system maxed out at 77% and in one case stalled at 11%.

Where the old system failed. The previous version produced 68,000 commits in two hours, roughly 70 times more than the new system. Most was wasted work: over 70,000 accumulated merge conflicts, versus fewer than 1,000 in the new one. The core issue was “split-brain”: two planners built the same idea in different places with different implementations. When planners knew about each other, they blocked each other with competing edits.

How they fixed it. Agents record decisions in shared design documents. Code tied to a decision carries a compiler-verified reference. When conflicts emerge, a neutral agent resolves them. Files that grow too large get flagged for decomposition into smaller modules.

One interesting detail is the field guide, a knowledge folder maintained by agents themselves with a fixed line limit. Each agent receives its contents at startup. Because model weights are frozen, capturing surprising discoveries lets successive agents take shortcuts. It’s external memory, not retraining.

The cost. Totals range from $1,339 for the hybrid Opus configuration to $10,565 for GPT-5.5 alone. Executors consume at least 69% of tokens in every run, usually over 90%. Planners cost more per token but use far fewer. The economics are clear: spend where judgment counts, save where persistence counts.

A reading caveat. Numbers come from Cursor’s implementation on a single task, however ambitious. SQLite has an excellent specification and rigorous test suite: near-ideal conditions for an agent. The same advantage may not hold on tasks with vague requirements or fragmented documentation. And the fact that Cursor had to build proprietary version control to handle 1,000 commits per second shows how tied this architecture is to specific infrastructure, not replicable with a prompt.

If you want to learn how to apply the planner-executor separation principle to your own tasks, the course on orchestrating multiple agents starts here: clear roles instead of duplicate responsibility.