Musk said Grok 4.5 was “Opus-class but faster, more token-efficient, lower cost.” Then SpaceXAI published the benchmark chart, and Grok 4.5 finishes first on none of the four benchmarks in it. On the only one run by a neutral harness, it drops nine points and falls behind Opus.
So the claim is wrong, right?
Not exactly, and that’s what makes this launch more interesting than the usual leapfrog. Grok 4.5 is the first frontier model where the pitch isn’t “we scored higher.” It’s “we spent four times less getting there.” Whether that’s a good trade depends entirely on math nobody in the launch-week coverage bothered to do.
What actually shipped on July 8
Grok 4.5 landed July 8, 2026, out of SpaceXAI — the post-merger entity, which is going to take some getting used to. It’s live in Grok Build, in Cursor across all plans, and through the SpaceXAI console. The EU is waiting until mid-July, as usual.
API pricing is $2 per million input tokens and $6 per million output. Cached input drops to $0.50/M. The context window is 500K tokens, and the model serves at roughly 80 tokens per second.
The detail worth pausing on: Grok 4.5 was trained alongside Cursor. Not “supports Cursor” — trained with it, on real editor traffic. That’s the first time a frontier lab has co-developed a model with an agent harness as a first-class training partner rather than an afterthought integration. It shows up in the results, and not entirely in the way SpaceXAI wants.
Server-side tools bill separately, and they add up faster than people expect. Web search, X search, and code execution run $5 per 1,000 calls each. File attachment search is $10 per 1K. Collections and RAG search sit at $2.50 per 1K. An agent that searches twice per task adds $0.01 to every task — small against Opus, not small against Grok’s own token cost.
The Opus-class claim, tested
Here’s SpaceXAI’s own chart, which is the most damning thing about it:
| Benchmark | Grok 4.5 | Opus 4.8 | GPT-5.5 | Fable 5 |
|---|---|---|---|---|
| DeepSWE 1.0 (provider harness) | 62.0% | 55.75% | 64.31% | 66.1% |
| DeepSWE 1.1 (neutral harness) | 53% | 59% | 67% | 70% |
| Terminal-Bench 2.1 | 83.3% | 78.9% | 83.4% | 84.3% |
| SWE-Bench Pro | 64.7% | 69.2% | 58.6% | 80.4% |
Every score here is vendor-reported by SpaceXAI. No third-party evaluation of Grok 4.5 existed at launch, which is worth holding in mind for the rest of this post.
Fable 5 wins all four. Grok 4.5 beats Opus 4.8 on DeepSWE 1.0 and Terminal-Bench, loses on DeepSWE 1.1 and SWE-Bench Pro. Against GPT-5.5 it’s a near-tie on Terminal-Bench (83.3 vs 83.4, which is noise), a real loss on both DeepSWE variants, and a 6.1-point win on SWE-Bench Pro — the eval that sits closest to a real pull-request workflow.
Now the line that explains the whole table. DeepSWE 1.0 and 1.1 are not a version bump. 1.0 runs on the provider’s own harness, where SpaceXAI writes the scaffolding around the model. 1.1 runs on a neutral mini-swe-agent harness operated by DataCurve. Same model, same task family, different plumbing — and Grok drops 9 points while Opus gains 3.25 and GPT-5.5 gains 2.7.
That is the single most important number in the launch, and it isn’t the token count. When SpaceXAI controls the agent loop, Grok beats Opus by 6.25 points. When someone else controls it, Grok loses by 6. Whatever Grok 4.5 is good at, a meaningful slice of it lives in the scaffolding rather than the weights.
Independent numbers roughly agree with the shape. Artificial Analysis puts Grok 4.5 at 54 on its Intelligence Index — fourth, behind Fable 5, Opus 4.8, and GPT-5.5 — while ranking it first on agentic tool use. Fourth-smartest, best at actually calling tools. That’s a coherent profile, and it’s not “Opus-class.” It’s something else.
The number that decides everything
On SWE-Bench Pro, Grok 4.5 resolves a task using an average of 15,954 output tokens. Opus 4.8 (max reasoning) uses 67,020.
Sit with that for a second. Same benchmark, same tasks. Opus writes 4.2 times more tokens to land 4.5 percentage points higher.
Output tokens are where the money is — $6/M for Grok, $25/M for Opus, and Fable 5 at $50/M. Multiply it out on output alone:
- Grok 4.5: 15,954 × $6/M = $0.096 per task
- Opus 4.8: 67,020 × $25/M = $1.68 per task
That’s 17.5x. Not 2.5x, which is what you’d guess from comparing sticker prices.
Input tokens compress the gap, because agent runs drag a lot of context around. Call it 150K input tokens per task — file reads, tool results, accumulated turns, no caching. That’s $0.30 for Grok, $0.75 for Opus. Totals land at $0.40 and $2.43. Roughly 6x.
But cost per task is the wrong denominator, because neither model finishes every task. Divide by resolve rate and you get the number that actually maps to your invoice:
| Cost/task | Resolve rate | Cost per resolved task | |
|---|---|---|---|
| Grok 4.5 | $0.40 | 64.7% | $0.61 |
| Opus 4.8 | $2.43 | 69.2% | $3.51 |
Grok 4.5 resolves a SWE-Bench Pro task for about 17% of what Opus 4.8 costs, and gives up 4.5 points of resolve rate to do it. Across a 500-task agent run, that’s roughly $198 versus $1,214 — and Opus lands 23 more tasks.
Is 23 extra completions worth $1,016? That’s the whole review, and the answer isn’t universal. If a failed task means a human engineer picks it up, and that human costs $80/hour, then 23 tasks × 40 minutes is about $1,200 of labor. It’s a wash. If a failed task just means you retry with a different prompt, Grok wins by a mile — you can afford five retries per task and still come out ahead.
Fable 5 I can’t price cleanly, because SpaceXAI didn’t publish its token count. If it burns Opus-like volume at $10/$50, you’re looking at somewhere north of $6 per resolved task even with the best-in-class 80.4% rate. Treat that as an estimate, not a figure. The real point is that Fable 5 is not competing in this conversation — it’s the model you reach for when the task is hard enough that price stops being the variable.
Where the token-efficiency story leaks
I’ve watched enough benchmark math survive contact with a real repo to know what to distrust here.
SWE-Bench Pro tasks are scoped. Someone wrote a clean problem statement. Your actual bug report is three Slack messages and a stack trace, and the model spends its first 20K tokens figuring out what you meant. Token efficiency measured on well-specified problems does not obviously transfer to underspecified ones — and the model that “thinks less” is exactly the model you’d expect to guess wrong when the spec is thin.
Which brings back the harness gap, and it cuts deeper than the scoped-task problem. Grok 4.5 was trained alongside Cursor, on real editor traffic. A model co-developed with one agent harness is a model that has learned that harness’s habits — where files get read, how tool results come back, when a loop terminates. That is exactly the kind of skill that evaporates when you swap the scaffolding, and the 9-point drop on the neutral harness is what evaporation looks like on a chart.
The token count may be part of the same story. A model trained to be frugal has learned, somewhere in its objective, to stop. That’s a virtue when the answer is reachable in 16K tokens and a liability when the correct move was to keep going for another 50K. But I want to be careful here: the DeepSWE numbers can’t separate “stops too early” from “stops correctly for the harness it was raised in.” Both explanations predict the same drop. Nobody outside SpaceXAI has the data to tell them apart yet.
Retries also aren’t free in wall-clock. At 80 TPS, a 16K-token task takes roughly 3.3 minutes of generation. Two retries and you’ve spent 10 minutes to save $2. In CI, that matters. In a nightly batch job, it doesn’t.
And the 500K context window is real but load-bearing in a way the pricing page doesn’t show. Cached input at $0.50/M is the only reason a long-context agent loop stays cheap. If your harness doesn’t hit the cache — and plenty don’t, because they mutate the prefix on every turn — that $2/M input price is what you actually pay, on 400K tokens, every turn.
Where I’d actually route work
Grok 4.5 for high-volume iteration. Codemods, dependency bumps, test generation, lint-fix loops, batch refactors across hundreds of files. Anything where the task is well-specified, the failure mode is cheap, and you’re running it a thousand times. This is not a compromise pick here. It’s the correct one, and the cost gap is large enough that it isn’t close.
Grok 4.5 for agencies and cost-sensitive shops. If you’re eating model cost inside a fixed-price engagement, a 6x total-cost reduction on the same workload changes what’s profitable to offer. (Input alone is only 2.5x — the savings live in the output tokens.) That’s a business-model change, not a tooling preference.
Opus 4.8 when the loop has to close. Multi-step reasoning where step 7 depends on a subtle read of step 2. Debugging something that touches three services. The kind of work where the model needs to hold a hypothesis, disconfirm it, and try again. Opus spends 67K tokens per task because it’s willing to be wrong on the way to being right. Whether Grok is unwilling or merely untrained-for-your-harness is the open question, and it resolves the same way either way if your harness isn’t Cursor.
The GPT-5.6 family, with the naming read carefully. OpenAI split 5.6 into three tiers: Sol at $5/$30, Terra at $2.50/$15, Luna at $1/$6. The much-quoted “54% more token-efficient on agentic coding” is Altman’s claim about Sol, not the whole family — and Artificial Analysis has since put Sol at 80 on its Coding Agent Index, ahead of Fable 5, on under half the output tokens. That’s the one efficiency claim here with third-party backing. Terra is the tier that lands between Grok and Opus on price, but it does not inherit Sol’s benchmark, and I’ve seen no separate token-efficiency figure for it. If you’re pricing an agent fleet, price the tier you’ll actually call.
Fable 5 for the hardest 5%. 80.4% on SWE-Bench Pro is a wide margin, and if you’re paying a senior engineer to babysit a failing agent, the model cost was never the expensive part. Anthropic’s own answer to Fable’s price is to have it delegate to Sonnet 5 — which is really an admission that you shouldn’t run the flagship on everything either.
The thing worth watching
Grok 4.5 is the first model that competes on cost per completed task instead of cost per token, and it forced a chart where the pitch survives finishing first on nothing. That framing is contagious. OpenAI is already leading with token efficiency in the 5.6 messaging. Anthropic is teaching Fable 5 to delegate downward to Sonnet 5.
The uncomfortable implication for anyone running a coding agent: if the frontier is now optimizing for tokens-per-task rather than tasks-solved, the benchmark you should care about is neither. It’s tokens-per-your-task, on your repo, with your underspecified tickets — and no lab is going to publish that for you.
Take one bug your team fixed last month. Run it through Grok 4.5 and Opus 4.8 on your own harness — not Cursor’s, unless Cursor is where you live — count the output tokens, and see whether the 4.2x holds when the problem statement isn’t a benchmark and the scaffolding isn’t the vendor’s. If it does, you have a very cheap agent. If it doesn’t, you just learned something about your tickets, and something about whose harness that benchmark was really measuring.
Related: Grok 4.3 vs GPT-5.5 vs Claude Opus 4.7, GPT-5.6 vs Gemini 3.5 Pro vs Claude Mythos 1 routing guide, Claude Fable 5 usage credits and cost per session, Grok Build vs Claude Code vs Codex CLI vs Cursor, best LLM observability and eval tools.