Somebody sent you the chart, probably. A swarm of agents wrote SQLite in Rust from nothing but the manual, and the bill came to $1,339. That part is real: Cursor published it on 20 July, four model configurations, every one of them eventually passing 100 percent of a held-out SQL suite it was never told about. The number we'd push back on is the one in all the headlines. Fifteen times cheaper. Cursor's post never says 15x anywhere, and inside its own controlled comparison the spread is 7.9x. To get to fifteen you have to divide by a run that carries Cursor's own footnote: informal, not part of the comparison. Small thing. It's also the difference between a result and a talking point.
The short answer
Cursor pointed an agent swarm at the SQLite manual and got a Rust database back. All four graded model mixes eventually passed 100 percent of sqllogictest, at costs from $1,339 to $10,565. The coordination engineering behind it is the real story. The 15x being quoted everywhere is not, and the public repo is from a run Cursor never graded.
Give it the manual, withhold everything else
The setup is cleaner than most agent demos, and that’s why it’s worth reading.
Cursor took the full 835-page SQLite manual and asked its swarm to implement it in Rust. Then it took away the source code, the test suites, the sqlite3 binary and internet access. Grading ran against sqllogictest, which is SQLite’s own conformance suite and contains millions of queries with known answers. The swarm was never told the suite existed, so it couldn’t optimise against it, and Cursor says it manually reviewed each run afterwards for cheating and shortcuts.
Four configurations, four hours each. GPT-5.5 doing both jobs. Grok 4.5 doing both jobs. Opus 4.8 planning with Composer 2.5 working, and Fable 5 planning with Composer 2.5 working.
At the four-hour cutoff nobody was finished. The new runs sat between 73 and 85 percent, the old harness between 11 and 77, and the Grok 4.5 run on the old harness had to be paused before it reached two hours. Every new configuration went on to pass the whole suite. Read that sentence carefully though, because “went on to” is doing quiet work: the 100 percent lands after the measured window, and no extra time or extra dollars are attached to it.
The 15x needs a bar Cursor greyed out
Here’s the bit we’d flag if you’re about to repeat the number.
Image: Cursor, from the Agent swarms and the new model economics post.
Six bars, two of them starred. The star means “informal run for cost calibration; not part of the controlled comparison”, which is Cursor’s own wording, sitting right there under the chart. The four graded runs are $1,339, $1,928, $2,234 and $10,565. Divide the top by the bottom and you get 7.9x, and that’s the number the post itself uses in prose.
The 15x comes from $20,057 divided by $1,339. That $20,057 is Fable 5 running solo, one of the two calibration runs Cursor explicitly fenced off. So the multiple isn’t invented, it’s just built across a boundary the primary source drew on purpose. Honestly, I’d have expected a vendor to be the one inflating this, and instead the vendor drew the fence and the coverage walked through it.
One more thing the chart says that nobody quoted: Grok 4.5 running solo, at $1,928, came in cheaper than the Fable 5 hybrid at $2,234. So “put a cheap model on the workers” isn’t a free win. Cursor explains why, and it’s counterintuitive. The Fable 5 planner actually billed slightly less than the Opus 4.8 planner despite roughly twice the per-token price, because it planned in fewer tokens. Its workers then burned several times as many tokens carrying out those plans, and the run came out more expensive overall. A terser planner made a more expensive swarm.
The repo everyone is inspecting is a different run
Cursor published the output at github.com/cursor/minisqlite and invited people to dig through it. Good instinct, genuinely. Just check which run you’re reading.
The post says it’s “the codebase from the solo Opus 4.8 run”, and adds, plainly, that the solo runs were graded only informally and that “based on our initial glance it looks great, but we have not done a deeper manual analysis”. We pulled the README ourselves: about 200,000 lines of Rust across 14 crates, 5,650 tests, one external dependency, no unsafe in library code. Impressive on its face.
Now put that against the graded runs. The Opus hybrid that scored 100 percent produced 4,645 lines and settled on nine crates. The Fable hybrid did it in 9,908.
So the artefact you can audit is roughly forty times the size of the artefact that passed the suite, because they came out of different configurations. That doesn’t make minisqlite bad. It does mean “go read the code that scored 100 percent” is not something anyone can currently do.
What actually transfers to your team
Strip out the SQLite theatre and two findings survive.
The first is the spend asymmetry, and it’s the one worth acting on. Workers carried at least 69 percent of the tokens across every run, over 90 percent in most. But in the Opus mix the planner produced a small slice of those tokens for roughly two thirds of the $1,339. Frontier judgment is needed at the decomposition and at a handful of design calls. After that, the ambiguity is gone and a cheaper model just follows the instruction. If you’re running agents at any scale, that’s your knob, and it’s the same logic behind reasoning effort tiers on frontier models.
The second is that most of the engineering here isn’t about models at all. Cursor had to build its own version control because the swarm peaks near 1,000 commits per second and Git tops out around 1,000 an hour. The old harness accumulated more than 70,000 merge conflicts and sprawled to 54 crates including three separate SQL packages, with one file collecting 7,771 conflicts from 1,173 different agents. The new one logged under a thousand conflicts and nine crates. Same models, same task, same clock. That delta is harness work, not intelligence.
The caveat that keeps this honest is the boring one. SQLite is one of the most deployed pieces of software alive, and its code and docs sit in every frontier model’s pretraining data. Withholding the source at run time doesn’t withhold it from the weights. So this measures execution and coordination at scale, which is a real and hard thing, rather than a swarm working from a spec it has never encountered. Cursor doesn’t claim otherwise. Its own framing is that the scarce resource is now the description of intent, and on that point I think it’s right, even if a database with thirty years of public documentation is the friendliest possible test of it.
Worth watching what Grok 4.5 and Opus 5 do to these economics next cycle, since two of the four configurations here are already a generation behind.
Sources
The experiment design, the 835-page figure, the sqllogictest grading, the four-hour pass rates, the merge conflict and crate counts, the line counts, the commits-per-second figures, the $1,339 and $10,565 totals, the $9,373 and $411 worker costs and the planner-versus-worker token split are all quoted from Cursor’s research post Agent swarms and the new model economics, published 20 July 2026 and credited to Wilson Lin, which also hosts the cost chart reproduced above. The $1,928, $2,234, $5,153 and $20,057 totals and the informal-run footnote are read off that chart. The minisqlite figures, about 200,000 lines across 14 crates with 5,650 tests, come from the repository README itself, which we read directly. Circulating summaries at The Decoder and elsewhere are where the 15x framing appears; the multiples in this article are our own arithmetic on Cursor’s published figures.
Frequently asked questions
What did Cursor's agent swarm actually build?
A reimplementation of SQLite in Rust, produced from the 835-page SQLite manual alone. Cursor withheld the source code, the test suites, the sqlite3 binary and internet access for the duration of each run. The output was graded against sqllogictest, a suite from the SQLite project holding millions of queries with known correct answers, and Cursor says the swarm was never told that suite existed.
How much did it cost to rebuild SQLite with agents?
$1,339 for the cheapest of the four controlled runs, which used Claude Opus 4.8 as the planner and Composer 2.5 as the workers. The dearest controlled run was GPT-5.5 doing both jobs at $10,565. Grok 4.5 alone came in at $1,928 and a Fable 5 planner with Composer 2.5 workers at $2,234. Two extra solo runs were done for cost calibration only and were not graded.
Is the swarm really 15 times cheaper?
Not inside the comparison Cursor ran. The four graded configurations span $1,339 to $10,565, which is 7.9x. The 15x figure circulating in coverage is $20,057 divided by $1,339, and the $20,057 is the Fable 5 solo run that Cursor marks with a footnote reading informal run for cost calibration, not part of the controlled comparison. The multiple is arithmetically correct and comparatively misleading.
Can I read the code the swarm produced?
Yes, at github.com/cursor/minisqlite, but read the label first. Cursor states it is the codebase from the solo Opus 4.8 run, one of the informal ones, and adds that it graded those runs only informally and has not done a deeper manual analysis. Its README describes about 200,000 lines of Rust across 14 crates with 5,650 tests, while the graded Opus hybrid run that scored 100 percent produced 4,645 lines across nine crates. Different run, different artefact.
What is the planner and worker split, and why does it matter?
Planner agents run on expensive frontier models and break a goal into tasks. Worker agents run on cheaper, faster models and execute them. Cursor reports workers carried at least 69 percent of the tokens and over 90 percent in most runs, yet in the Opus 4.8 and Composer 2.5 mix the planner produced a small fraction of the tokens for roughly two thirds of the bill. That asymmetry is the transferable idea: pay frontier prices for the decomposition, not for the typing.
Did any run hit 100 percent within the four-hour budget?
No. At the four-hour cutoff the new-harness runs sat between 73 and 85 percent, and every configuration went on to pass 100 percent after that point. Cursor does not state how much extra time or extra spend that tail required, so the headline dollar figures and the headline 100 percent are not pinned to the same moment.
