Here is the paradox, captured in a single Together AI screenshot: the model that scores lower on the benchmark is the one you should buy.
On DeepSWE, GPT-5.6 Luna beats DeepSeek V4 Flash head-to-head. Luna is the better coder. Nobody disputes that.
But run Flash twice — two attempts, $0.20 per task — and it solves more tasks than a single pass of Luna at $0.61. It also costs a third as much.
Read that again, because it inverts what a leaderboard tells you to do. The winner of the benchmark is the loser of the budget. And the inversion is the whole story.
The winner of the benchmark is the loser of the budget. And the inversion is the whole story.
Last week this column tracked the Opus 5 price frontier and the 90/10 routing thread — send the cheap model first, escalate only on failure. This week that argument reaches its logical conclusion, and then trips over its own dark side: the same loops that make cheap models economical are the mechanism that turns one task into an invisible six-figure bill.
Start with the collapse itself. DeepSeek V4 Flash delivers roughly 80% of Luna's performance at about one-sixth the cost — the current cost-performance frontier, in Together's phrasing.
That ratio is what breaks the leaderboard's authority. When your cheap model is six times cheaper and only twenty percent worse, "worse" stops being a verdict and becomes an input to an arithmetic problem.
Because capability is now something you can buy in bulk. Two Flash attempts don't just cost less than one Luna run — a Flash-first cascade with test-suite verification solved more tasks than Luna alone at 37% lower cost per task.
The insight is old but suddenly load-bearing: an agent that can iterate cheaply beats one that reasons expensively. The cheap model gets more shots on goal for the same money, and in an agentic loop, shots on goal are what convert.
This is why the competitive axis has quietly moved. The question is no longer "which model tops Vals." It's "what does it cost to solve one task, end to end, including the retries."
Meta's Muse Spark 1.2 is the clearest read on the new axis, because it competes on both dimensions at once. It went from not on the board to Vals top 5 at $0.69 per test — reportedly 3x cheaper than Kimi and more than 10x cheaper than Fable, Opus, and 5.6 Sol.
The finance number is the one to circle. Muse Spark 1.2 became the first model above 60% on Finance Agent v2, at $0.77 per test — against the prior leader, Opus 5, at $5.12 per test, and at twice the speed.
Sit with that spread. The old #1 costs nearly seven times more to run the same eval, and now loses. This is what a commoditizing frontier looks like: the premium model's price is no longer justified by a capability gap, because the gap closed.
Vals framing catches it exactly: the Muse story is "less 'one model won' than 'model quality + orchestration + pricing + serving capacity' now decides adoption." Capability is one variable among four, and three of the four are economics.
The practitioners are already building for this world. One budget stack floating around: Luna as planner and orchestrator, V4 Flash as coder, Luna for code audit, Flash again for fixing review issues — in a loop until satisfied.
That is the cascade institutionalized. Expensive models for planning and judgment, where a single good decision pays for itself; cheap models for the high-volume grunt work of writing and fixing code. The frontier model becomes the fallback, not the default.
Open weights make this even more aggressive, because they give teams room to run loops that would be ruinous on proprietary APIs. When Flash-class inference is a fraction of Sol or Fable pricing, you can afford to be wasteful — retry, verify, retry again — and still come out ahead.
And here is where the story flips.
The very thing that makes cheap models economical — cheap iteration inside a loop — is also the thing that makes agent spend uncontrollable. The economics that reward more attempts also reward more tokens, more tool calls, more context, and those don't stop at a clean boundary.
Together's own thread named it: the "hidden tax of agentic workflows." A single user request triggers dozens of background planning steps and retries, and "those compound token costs will absolutely drain your budget."
The mechanism is compounding, not addition. Planning, tool calls, retries, and long contexts each multiply the token count, and they stack. Cost per token adds up fast once retries and long contexts kick in — and no one is watching in real time.
Look at what "long-horizon" actually means in practice. Muse Code, under stress testing, iteratively optimized GPU kernels over 1,000-plus tool calls, running up to 24 hours on Hopper GPUs.
That is a single task. One kernel-optimization run, a thousand model calls, a full day of continuous inference — powered by persistent async background agents that stay active throughout the session, executing next steps without being asked.
Meta pitches those persistent sub-agents as a feature: less steering, less redundant info-gathering, more autonomy on complex work. And they are a feature. They are also a meter running in a room no one is standing in.
That is the governance gap, and it is where the cost war actually lands. The economics that make Flash-first cascades rational are the same economics that let an agent quietly rack up a five-figure bill on one request — and a six-figure bill across a fleet you discover months later on an invoice.
Note the asymmetry. The savings are legible: $0.20 versus $0.61, right there in the screenshot. The blowups are invisible: dozens of background steps, a thousand tool calls, a 24-hour run, none of it surfaced until finance goes looking.
You cannot govern what you cannot see, and today's stacks are built to maximize iteration, not to bound it. Every incentive in the cascade — try again, spin up another sub-agent, extend the context — pushes token spend up, and nothing in the loop pushes back with a hard ceiling.
Which reframes what a durable moat looks like. If capability has commoditized to the point where a $0.77 finance model beats a $5.12 one, then topping Vals is table stakes, not an advantage — everyone can rent a frontier-adjacent model this quarter.
The scarce thing is a bounded cost-per-outcome. The lab or buyer that can guarantee "this task will solve for under X dollars, verified, with a hard stop" owns something the leaderboard cannot confer.
Notice that even the aggressive price cuts point the same direction. When ARC re-ran Luna after its 80% price cut and found unchanged capability at $0.18 per task, that didn't end the cost war — it lowered the per-token floor, which makes each individual loop cheaper and therefore easier to justify running more of them. Cheaper tokens invite more tokens.
So the price war is only half the story. Falling per-token costs are real and they've genuinely inverted the leaderboard — the cheaper model that loses head-to-head now wins the budget, and cascades have turned that from a trick into an architecture.
But the same math that rewards iteration removes the natural ceiling on spend. The frontier didn't just get cheaper; it got harder to meter, because the winning move is now to run more, longer, in the dark.
The labs that win the next phase won't be the ones with the highest Vals score. They'll be the ones that can hand an enterprise a bounded, auditable cost-per-solved-task — a number you can trust before the run, not discover after it.
And the buyers who win will be the ones who treated spend governance as a first-class feature, right next to accuracy. Everyone else will keep celebrating a $0.20 task and then, one quarter later, find the $1.8M agent bill nobody saw arrive.