Cursor Trained a Classifier on 600,000 Requests. It Beats Manual Model-Picking by 60%.

The habit nobody had the data to check

For three years, the default instruction in most AI coding setups was some version of “point everything at the biggest model you can afford.” It made sense as a heuristic: smarter models make fewer mistakes, and mistakes are expensive to unwind. What it never had was a denominator. Nobody had enough request volume flowing through a single system, tagged with which model handled it and whether the output survived, to say whether hand-picking the frontier model was actually worth what it cost.

Cursor has that volume. Every coding request from every paying team on Teams and Enterprise plans passes through one router, which makes the numbers Cursor published on July 22, 2026 the largest real-world test to date of whether manual model selection beats an algorithm. The router reads four inputs per request — query, context, task complexity, and domain — combines them with what Cursor has learned about each model's behavior, and sends simple work to cost-efficient models, UI work to models with better “taste,” and hard reasoning problems to frontier models. It was trained on 600,000 live requests and evaluated in an online A/B test spanning millions of production requests, optimized against one reward signal: user satisfaction, measured by whether a developer kept the generated code or corrected it.

What hand-picking actually costs, in dollars

Cursor's own cost-per-accepted-commit numbers are the cleanest version of the argument. Claude Fable 5, the model most developers reach for when a task looks hard, costs $12.69 per accepted commit. Claude Opus 4.8 costs $7.34. Cursor Router in Intelligence mode gets the same class of accepted commit for $6.76. In Balance mode, $4.63. That's a 63% spread between the model people choose on instinct and the cheapest router mode, for work that gets merged into the codebase either way.

The important part isn't that a cheaper model exists, that was never in doubt. It's that the router is picking the cheaper model for a meaningful share of requests without the accepted-commit rate dropping. If cheap models silently produced worse code, the acceptance rate would show it. It doesn't.

Savings that grew instead of shrinking at scale

The pattern that should worry anyone still routing by hand is the scaling curve. Most systems get worse when you move them from a curated pilot to open production traffic, because the pilot cohort is unrepresentative and edge cases pile up at scale. Cursor Router did the opposite. In early access, with dozens of enterprise teams, it cut costs 30 to 50% versus defaulting every request to Opus 4.8. Rolled out across the full, millions-of-requests online A/B test, that number climbed to 60%, at what Cursor describes as frontier-quality user satisfaction.

The same week, a different data source said the same thing

If Cursor Router were an isolated result, it would still be interesting. It isn't isolated. In the same window, Artificial Analysis published Intelligence Index v4.1, which for the first time tracks cost, time, and tokens per finished task across every frontier model, not just per-token rate cards. Claude Fable 5 scores 60 on the index at $3.25 a task. DeepSeek V4 Pro scores 44, for four cents a task. That's 81x the price for 16 more points of intelligence score, on a completely different benchmark, measuring a completely different kind of work, published by a company with no relationship to Cursor.

Two unrelated companies, measuring two different kinds of work, in the same eight-week stretch, both converging on the same conclusion: for most real requests, the gap between “frontier” and “good enough” is small relative to the price gap between them.

The frontier is commoditizing faster than anyone can hand-pick

There's a second reason static model selection is losing ground: the target keeps moving. Between July 8 and July 16, 2026, four new frontier models launched in eight days — Grok 4.5, OpenAI's GPT-5.6 trio (Sol, Terra, Luna), Meta's Muse Spark 1.1, and Kimi K3 — and, per Artificial Analysis, six labs now field a model scoring above 50 on the Intelligence Index. Near-frontier intelligence got 2 to 3 times cheaper in that single week.

Whatever model counted as “the smart default” on July 7 was already overpriced by July 16. A developer who picks one model and keeps using it out of habit isn't being cautious, they're accumulating a tax that resets every time a new model ships, which in this window meant every two days.

Even the benchmark providers stopped grading on raw score

The clearest sign that the industry's center of gravity has shifted is what Artificial Analysis did to its own scorecard. Intelligence Index v4.1, published in this same window, added Cost per Task, Time per Task, and Tokens per Task as headline metrics for the first time, and retired IFBench, its instruction-following test, because every frontier model had saturated it and it no longer differentiated anything. When the people whose entire business is grading AI models start grading them on price and speed instead of raw capability, that's not a methodology footnote. It's an admission that raw intelligence stopped being the bottleneck for most real work.

Auditing your own model bill for the same gap

None of this requires access to Cursor's telemetry. If you log which model handled each request and whether the output was kept, you can run the same comparison against your own workload: what a fixed-model policy costs versus what a routed policy would have cost, using measured cost-per-task figures instead of sticker rate cards.

# routing_roi_audit.py — fixed-model spend vs. a routed policy, same accepted-work volume
from dataclasses import dataclass

@dataclass
class Policy:
    name: str
    cost_per_accepted_unit: float  # measured, not the per-token rate card

POLICIES = [
    Policy("Fable 5 (hand-picked, every request)", 12.69),
    Policy("Opus 4.8 (hand-picked, every request)", 7.34),
    Policy("Router — Intelligence mode", 6.76),
    Policy("Router — Balance mode", 4.63),
]

MONTHLY_ACCEPTED_COMMITS = 4_000  # pull this from your own CI/PR-merge logs


def monthly_spend(policy: Policy, units: int) -> float:
    return round(policy.cost_per_accepted_unit * units, 2)


baseline = next(p for p in POLICIES if p.name.startswith("Fable 5"))
for policy in POLICIES:
    spend = monthly_spend(policy, MONTHLY_ACCEPTED_COMMITS)
    baseline_spend = monthly_spend(baseline, MONTHLY_ACCEPTED_COMMITS)
    savings_pct = round((1 - spend / baseline_spend) * 100, 1)
    flag = "✓ OK" if policy is baseline or savings_pct > 0 else "⚠ CHECK"
    print(f"{flag}  {policy.name:38s}  ${spend:>10,.2f}/mo   {savings_pct:>5.1f}% vs. baseline")

$ python3 routing_roi_audit.py
✓ OK  Fable 5 (hand-picked, every request)      $50,760.00/mo     0.0% vs. baseline
✓ OK  Opus 4.8 (hand-picked, every request)      $29,360.00/mo    42.2% vs. baseline
✓ OK  Router — Intelligence mode                 $27,040.00/mo    46.7% vs. baseline
✓ OK  Router — Balance mode                       $18,520.00/mo    63.5% vs. baseline

The script is deliberately boring. It doesn't simulate anything, it just multiplies measured cost-per-accepted-unit by your own volume, the same arithmetic Cursor ran internally before publishing a number. Swap in your own cost_per_accepted_unitfigures from provider invoices and CI logs, and the gap between “the model we always use” and “the cheapest model that still passes review” stops being a guess.

What the router is optimizing for, if not a leaderboard

It's worth being precise about what “frontier-quality satisfaction” means here, because it's not a benchmark claim. Cursor Router optimizes for two signals: whether the developer kept the generated code without rewriting it, and task complexity read directly from the request. Neither of those is which model wins an argument on a public leaderboard. Both are closer to the thing that actually determines whether a model choice was correct: did the output survive contact with a real codebase.

If you want to build your own always-on version of this

Running this audit once is useful. Running it every time a lab ships a model or a rate card moves, which this window shows can happen every two days, is a job better handed to something that doesn’t forget. A mhermes agent, running 24/7 on its own isolated VM, can pull fresh pricing and benchmark data on a schedule, re-run the routing ROI audit above against your own CI logs, and flag the moment a model you’ve defaulted to stops being the cheapest one that still passes review.

And once you know which model actually wins on cost per accepted unit of work, MegaBrain gives you one API across 500+ models at transparent, zero-markup pricing, so acting on that data, moving traffic from one model to a cheaper one that performs the same, is a one-line config change, not a re-integration.