If the hardest coding stays on a frontier tier — and it should — the pick for that tier is Grok 4.5 for the large body of agentic work its resolve rate can close, Opus 4.8 for the hard tail where a missed bug is expensive, and Sol for agentic orchestration or an OpenAI-native stack. That ordering is set by cost per solved task, not price per token, and cost per solved task inverts the sticker prices: the model with the cheapest-looking output rate is not automatically the cheapest way to close a bug, and the most expensive one sometimes is.
Here is the whole field on one screen, then the number that should actually decide it.
The three, side by side#
| Sol (GPT-5.6) | Opus 4.8 | Grok 4.5 | |
|---|---|---|---|
| Input / 1M | $5.00 | $5.00 | $2.00 |
| Output / 1M | $30.00 | $25.00 | $6.00 |
| SWE-bench Verified | not published | 88.6% | not published |
| SWE-bench Pro | ~64.6%* | 69.2% | 64.7% |
| Terminal-Bench 2.1 | 88.8% | — | 83.3% |
| Output tokens / task | not published | ~67,020 | ~15,954 |
| Context | ~1M | 1M | 500K |
By raw solve rate, Opus 4.8 leads: 88.6% on SWE-bench Verified and 69.2% on the harder SWE-bench Pro, the top active score. By sticker price, Grok is the obvious cheap pick at $6 output. If you stop reading here you'll route by one of those two columns and get the decision wrong, because neither column is the bill.
Cost per solved task is the only honest ranking#
Cost per solved task = (output tokens the model emits to finish) ÷ (success rate) × (output price). A terser, more accurate model at a higher per-token price can close a bug for less than a cheap, verbose one that keeps re-opening it.
Two things the pricing page hides. First, models spend wildly different token budgets on the same problem. On SWE-bench Pro, Grok 4.5 finishes a task in about 15,954 output tokens on average; Opus 4.8 in max mode spends about 67,020 — roughly 4.2x more. Grok was co-trained on real Cursor agent telemetry to be terse, and that discipline compounds across a long agent run. Second, a task you fail still costs tokens; you just have to retry, so every attempt divides by the success rate before it becomes a solved-task cost.
Put both into the formula and the rankings move.
A worked example, round numbers#
Take one SWE-bench-Pro-shaped bug and run it three ways. Cost per attempt is output tokens × output rate; cost per solved is that divided by the resolve rate.
- Grok 4.5 — ~16,000 tokens × $6/1M = $0.096 per attempt. At a 65% solve rate: $0.096 ÷ 0.65 = ~$0.15 per solved task.
- Opus 4.8 — ~67,000 tokens × $25/1M = $1.68 per attempt. At a 69% solve rate: $1.68 ÷ 0.69 = ~$2.43 per solved task.
- Sol — its token budget on this benchmark isn't published, so this one you must measure. Plug an illustrative 40,000 tokens × $30/1M = $1.20, at 65%: ~$1.85 per solved task.
Grok closes the bug for about one-sixteenth of Opus's cost — the 4.2x token gap times the 4.2x price gap, roughly 17x, lightly offset by the resolve-rate difference. Sol lands in between and is dragged up by the priciest output token in the field.
But read the second half of the sentence. That ~$0.15 only exists on tasks Grok can actually solve. On the 4.5 points of SWE-bench Pro that Opus resolves and Grok doesn't, Grok's cheap attempts buy nothing — you retry, escalate, or ship a wrong patch, and the "cheap" model becomes infinitely expensive per solved task because the denominator is zero. That is exactly the tail where Opus's extra resolution is worth its output rate.
The tie-breakers past cost-per-solved#
When your measured cost-per-solved numbers land close, these decide it:
- Context window. Opus 4.8 and Sol both hold ~1M tokens (Opus at a flat rate, no long-context surcharge); Grok caps at 500K. For whole-monorepo reasoning, that gap matters.
- Cache discounts. Grok cuts cached input to $0.50 (75% off) and Sol to $0.50; Opus applies prompt-cache discounts. All three touch only the input side — in an agent loop, output dominates the bill, so cache helps less than it looks.
- Ecosystem and distribution. Sol ships through Codex and GitHub Copilot with a clean Luna/Terra/Sol ladder in one SDK; Grok is native in Cursor on every plan; Opus runs across the Claude API, Bedrock, Vertex, and Foundry.
- Agentic vs raw coding. Sol's strength is terminal and agentic orchestration (88.8% Terminal-Bench 2.1), not single-shot bug-fix. Opus is the raw-accuracy and code-review specialist. Grok is the terse in-loop worker.
The decision#
Don't buy the tier by its output rate, and don't buy it by its top-line benchmark. Measure output-tokens-per-solved-task on your own eval — a ten-minute experiment — multiply by each output rate, divide by each resolve rate, and let that number route you. As a starting map:
- High-volume agentic loops and in-editor coding, where most tasks are within reach → Grok 4.5. Its terseness and $6 output make it the cheapest per solved task by a wide margin, and Cursor-native distribution seals it for in-editor work.
- The hard tail — bugs where a miss is expensive (production, security, irreversible migrations) → Opus 4.8. You pay far more per task, but the highest solve rate and a flat 1M context are what you're buying, and they're worth it exactly here.
- Agentic orchestration, terminal-driven work, or an OpenAI-native stack → Sol. Strong agentic scores and the deepest ecosystem; just know its $30 output is the priciest token in the field.
The winning move isn't one tier for everything. It's routing by task class, because "cheapest frontier tier" stopped being a property of the price sheet and became a property of how hard the task in front of it actually is — the resolution is the unit, and the unit is priced per bug closed, not per token spent.
Once you've picked the tiers, the mechanics of running two models side by side without a bad night are their own problem — we wrote the ~60-line fallback + cost-cap + A/B router that lets you measure output-tokens-per-solved-task on your own traffic before you commit.
