The Harness Is the Alpha
Cursor rebuilt SQLite with an agent swarm for 15x less money and identical quality. The lesson has nothing to do with coding.
Two runs. Same task. Same quality bar. One cost $10,565. The other cost $1,339.
That gap is the most important number in Cursor’s new post on agent swarms and model economics, and it deserves your attention even if you never write a line of code.
Here’s the setup. Cursor pointed a swarm of agents at a genuinely brutal task: implement SQLite from scratch in Rust, working from the 835-page specification, with no access to the original source code. Grading was unforgiving. The output ran against sqllogictest, a suite that throws millions of queries at the result. This is not a demo task. It’s months of work for a strong human team.
The first configuration used GPT-5.5 for everything, planning and execution. Total cost: $10,565.
The second split the work into two tiers. Planners, running on a frontier model (Opus 4.8), decompose the goal into a task tree and own every design decision. They never write code. Workers, running on a much cheaper model (Composer 2.5), execute explicit subtasks. They never plan. Total cost: $1,339, with identical quality. The worker layer alone dropped from $9,373 to $411, a 95 percent reduction on the layer consuming 69 to 90 percent of the tokens.
Before we dive in -- thank you to our paid subscribers! Make sure to take full advantage of all the value you get.
Check out our AI Education section, and this is where things get real. Step-by-step guides, how-to breakdowns, and hands-on training to help you build agents, build systems, and use tools like Claude Code, ChatGPT, and Perplexity at a level most people don’t even know exists. This isn’t surface-level stuff -- it’s the training that actually moves your AI capabilities forward.
Paid subscribers get access to interactive tools and guides that free subscribers don’t see.
Office hours and live events where you can bring your real questions, get them answered by people who’ve actually built this stuff, and get hands-on keyboard time with experts in the room.
Come build with us.
Cursor’s own summary is the line worth taping to your monitor: “Few moments in a large task genuinely require frontier intelligence, such as the original decomposition, the design decisions, and certain trade-offs. Once a frontier planner has collapsed the ambiguity into a detailed, explicit instruction, less expensive models simply have to follow it.”
Read that twice, because it generalizes well past software.
You already know this model, actually. It’s how every professional services firm on earth works. Partners don’t draft every document. They set strategy, structure the matter, and delegate to associates who bill at a third of the rate. The pyramid is the profit model, and it’s survived a century because it matches where judgment actually lives. But the pyramid only works because of everything around it: the precedent library, the review process, the training system. A partner and a pile of associates with no system is not a firm. It’s expensive chaos.
Cursor’s data on the chaos is spectacular. Their earlier harness, running a Grok swarm on the same problem, produced 68,000 commits and more than 70,000 merge conflicts, ending at 64,305 lines of code. The rebuilt harness: roughly 970 commits, under 1,000 conflicts, and 9,908 lines of code at 100 percent accuracy. Same class of models. Six times less code for a perfect score. The difference was never the model. It was the coordination system wrapped around it.
Look at what that system actually contains. A neutral referee agent that resolves merge conflicts, because the two agents in the conflict both think they’re right. Decorrelated review lenses: multiple reviewer agents on different models, each given different inputs (one sees the full transcript, one sees only the output, one sees only the codebase), stacked so they catch different error classes. A self-authored Field Guide, a living document the agents write for themselves that gets injected into every new agent at startup, coordination through a shared environment the way ant colonies coordinate (biologists call it stigmergy). And a custom version control system built from scratch because Git couldn’t keep up with 1,000 commits per second.
None of that is model capability. All of it is harness.
Now the part I actually care about: what this means for the applied layer.
Multi-model routing is becoming THE core design pattern of serious agent systems. Frontier model plans and orchestrates. Workhorse models execute. But there’s a catch, and it’s exactly where differentiation lives: you can only capture that 15x if you know the domain deeply enough to know which moments genuinely need frontier intelligence. Cursor knows coding. That’s why they knew the decomposition and the design trade-offs were the frontier moments, and everything else was execution.
In a revenue organization, that’s a specific list, and you should be able to write it down. The moments that need frontier-grade judgment: how you segment the market, the pricing structure for the new product line, the account strategy for the eight-figure renewal, the design of the qualification logic itself. The moments that don’t: enriching 4,000 accounts on a Monday morning, drafting the follow-up after Tuesday’s discovery call, summarizing the call notes, checking whether last night’s signups match the ICP definition someone already wrote. The second list is most of the volume. Cursor’s numbers say it can run at a few percent of the cost, if, and only if, something upstream has already collapsed the ambiguity into explicit instructions.
That “if” is the whole business.
I’ve seen this from the inside. Care Agent, the multi-agent product I helped build at Experity, has handled more than 12 million conversations. At that volume, model economics stop being a rounding error and start showing up in the margin line. Nobody runs every one of those conversations on a frontier model. The system decides, per moment, how much intelligence each step deserves. Get the routing wrong in one direction and quality breaks customer trust. Get it wrong in the other and the unit economics never close.
Which is why the 15x number is not an efficiency story. Cost is the gate on the addressable market for agents. Every workload that penciled out at $1,339 but not at $10,565 just became a market. Now multiply that across coding, finance, legal, healthcare, life sciences. The companies that master planner-worker routing in their domain will sell automation into workloads their customers literally could not afford last year. That’s how markets actually expand: not when the technology gets better, but when the price crosses the line where the next tier of buyers says yes.
So here’s where I land, and it’s the same place I keep landing. The labs will keep making models better and cheaper, and every competitor you have will get the same models you do, on the same day you do. Rent the model. The routing logic, the referee, the review lenses, the field guide your system writes for itself, the accumulated knowledge of which moments in your domain need frontier judgment: that’s owned. That compounds. In my Revenue Nervous System framing (the six-layer architecture I use for AI-native GTM), this is the Orchestration layer earning its keep, deciding what runs where and at what cost. The harness is the alpha.
One exercise before you close this tab. Pick one workflow you’re paying for right now, human hours or API bills, doesn’t matter. List every step. Mark the two or three moments that genuinely require your best thinking. Then ask what it would take to turn every other step into an explicit instruction a cheaper model could follow. I’ve done versions of this exercise with GTM teams and the ratio surprises people every time: the frontier moments are rarer than anyone expects, and the harness to exploit that fact doesn’t exist yet in most companies.
Whoever builds it first in your category sets the cost curve everyone else has to chase.
-- J