Cursor: дешёвые модели пишут код по плану frontier-моделей — стоимость упала в 15 раз

Cursor ran an experiment in July 2026: it had a swarm of AI agents rewrite the SQLite database from scratch in Rust, given only the documentation — no source code, no internet access, and no ready-made tests. The new version of the "swarm" (agent swarm), which separates a planner model from executor models, ended up passing 100% of the test suite in every configuration, and the cheapest solution cost 15 times less than a single top-tier agent.

What exactly Cursor tested

Cursor gave the agents one task — recreate SQLite in Rust from scratch, relying only on the official documentation. The finished result was checked against the sqllogictest benchmark with millions of SQL queries; according to Cursor, every configuration of the new system eventually reached 100% test pass rate, while the old "swarm" got stuck in the 11–77% range.

The key idea of the new architecture is to split the roles. The expensive frontier model works as the planner: it breaks down the task and makes architectural decisions. The bulk of the routine code is written by cheap worker models.

• The task: rewrite SQLite in Rust based only on documentation, without source code or internet access
• Planners: GPT-5.5, Grok 4.5, Opus 4.8, Fable 5
• Executor: Composer 2.5 (it was also run as a solo agent for comparison)
• Verification: the sqllogictest benchmark, millions of SQL queries
• New system after 4 hours: 73–85% at the start, all reached 100%; the old one: 11–77%

Why the planner removes the chaos

Splitting the roles frees the swarm from the merge conflicts it used to create for itself. In the configuration with Grok 4.5, the old system generated 68,000 commits and more than 70,000 merge conflicts in two hours — and choked on them. The new swarm kept a pace of around 1,000 commits per second and never exceeded 1,000 simultaneous conflicts.

The difference is also visible in the amount of code at comparable quality. The "Fable 5 plans + Composer writes" pairing came in at 9,908 lines versus 64,305 for the old approach. The "Opus 4.8 + Composer" pair — 4,645 lines versus 19,013. Less code means fewer bugs and cheaper maintenance.

How much was saved

The cost of the runs differed by a factor of 15 for a comparable result: from $1,339 for the "Opus 4.8 + Composer" pairing to $10,565 for a solo GPT-5.5. According to Cursor, worker models consumed 69–90%+ of all tokens, but because of the price difference their contribution to the final bill was far more modest — the expensive part turns out to be mostly the planning.

The frontier model takes on the decomposition and the key decisions, while the cheaper worker models execute the plan efficiently once the ambiguity has been removed — that is the main conclusion the

Cursor team drew from the experiment.

What this means

The economics of AI coding are shifting: paying for a top-tier model makes sense at the planning stage, while the actual implementation can be handed off to cheap executors with almost no loss of quality. For teams this means a multi-fold reduction in the cost of autonomous code generation — provided someone smart cuts up the task correctly.

Frequently asked questions

What is an agent swarm in Cursor?

An agent swarm is a group of many AI agents working on the same task in parallel. In the new version, Cursor split them into a planner (one expensive model) and executors (many cheap ones), which removed the mass merge conflicts.

Which models planned, and which ones wrote the code?

The planners were GPT-5.5, Grok 4.5, Opus 4.8, and Fable 5. The code was written by the Composer 2.5 model — it was also tested solo for comparison.

How much cheaper did the code end up being?

The spread was a factor of 15: from $1,339 for the Opus 4.8 + Composer pairing to $10,565 for a solo GPT-5.5, at comparable result quality.