A Rust SQLite in 4 Hours, 80% of Tests Passed: Cursor Turns AI Coding Into a Company
Source: Cursor official blog / sqllogictest / cursor/minisqlite Date: 2026-07-21
- Cursor official post: https://cursor.com/blog/agent-swarm-model-economics
- SQLite sqllogictest: https://www.sqlite.org/sqllogictest/doc/trunk/about.wiki
- Public repository: https://github.com/cursor/minisqlite
Cursor handed a swarm of coding agents the 835-page SQLite manual and asked them to rewrite the database from scratch in Rust. No source code, no SQLite binaries, no internet. Four hours later, the Grok 4.5 variant passed 80% of SQL logic tests; the old swarm architecture spiraled into runaway loops within two hours and had to be manually stopped.
This is not just "running several Claude Code instances at once." Cursor redesigned the organizational structure: the strongest model serves as the planner, only splitting tasks, defining boundaries, and resolving conflicts; faster, cheaper models act as executors, each focused on one narrow problem. Planners don't write implementations; executors don't change the overall design. Context is separated by role—like a company, not a group chat where everyone edits the same code simultaneously.
Coordination Cost Is the Real Differentiator
Cursor ran four configurations in parallel: GPT-5.5 full-stack, Grok 4.5 full-stack, Opus 4.8 planning with Composer 2.5 executing, and Fable 5 planning with Composer 2.5 executing. At the four-hour mark, the new architecture's test pass rates ranged from 73% to 85%; all four groups eventually reached 100%.
The old architecture failed in very concrete ways. The old Grok 4.5 version produced 68,000 commits and over 70,000 merge conflicts in two hours, splitting into 54 crates including three mutually incompatible SQL packages. The new architecture settled early on 9 crates, with fewer than 1,000 cumulative conflicts over four hours.
Cursor stopped fighting Git and built a purpose-built version control system from scratch. Early browser experiments peaked at around 1,000 commits per hour on Git; the new system's design peak is around 1,000 commits per second. Throughput isn't the point—the point is that conflict adjudication, design document references, and merge queues are built into the collaboration infrastructure.
The failure modes are candidly documented: planners making conflicting designs, executors fighting over hot files, code ossifying into untouchable cores. Cursor's fixes include shared design docs, compile-time references, third-party merge agents, and "allowing justified breaking of legacy interfaces." This part is more valuable than the 80% score. It shows the main challenge in multi-agent engineering isn't whether models can write code—it's whether the organization spirals out of control.
A Model's Cost Depends on Its Position
Four-hour run costs ranged from $1,339 to $10,565. The most expensive GPT-5.5 full-stack setup spent $9,373 on executors alone; when Opus 4.8 planned and Composer 2.5 executed, the entire executor fleet cost just $411.
Executors consumed at least 69% of tokens, over 90% in most combinations. But planners, while token-light, are expensive per token—planners still accounted for roughly two-thirds of costs in the Opus hybrid group. The billing data yields a practical conclusion: frontier models don't need to blanket the whole pipeline; they just need to hold the high-ambiguity, high-impact decision points.
The public cursor/minisqlite repository is no longer just a four-hour demo. The README shows it has grown to ~200,000 lines of Rust across 14 crates with 5,650 tests, capable of bidirectional reads and writes of SQLite format 3 files, with support for WAL, transactions, triggers, window functions, and foreign keys. The boundaries are equally clear: no C API, no prepared statements, no cross-process concurrency, and no cost-based optimization using sqlite_stat1. It is not yet a SQLite replacement.
Three Things to Watch
First, 80% is a company self-assessment—the questions, runtime environment, and human review were all controlled by Cursor. The code is public; independent reproduction is the next step.
Second, once agent swarms make "writing code" cheap, specifications become the new scarce resource. The 835-page manual was rigorous enough for the swarm to compile text layer by layer into a system; vague requirements will only be amplified in parallel.
Third, Cursor has pushed competition from the model layer to the organizational layer. Comparing Claude Code, Codex, and Cursor by SWE-bench alone will get increasingly boring. Whoever can keep dozens of agents from fighting, remain auditable, and roll back cleanly is truly approaching the automated software company.
One-line takeaway: the most important number in this experiment isn't 80%—it's compressing 70,000 conflicts down to under 1,000. The next step for AI coding isn't finding a smarter programmer model; it's building a governance system that lets a group of models operate without collapsing.