Claude Opus 5 and Claude Opus 4.8 bill the same $5 per million input tokens and $25 per million output, and on identical prompts the default Opus 5 configuration cost 3.1x more. The reason is adaptive thinking: Opus 5 thinks by default, bills the thinking as output, and never shows it to you. One request setting closes the gap to exact parity, and it is a setting the bigger Fable 5 refuses to accept. Opus 5 went GA on 2026-07-24, positioned as Fable-5-level intelligence at half the token price; whether your bill actually halves depends almost entirely on this one choice.
TL;DR
- Default Opus 5 billed 3.1x the same-priced Opus 4.8 on our five-task matrix; 42-95% of its output tokens were hidden thinking.
-
thinking: {"type": "disabled"}brought Opus 5 to exact parity with 4.8 (384 vs 384 output tokens), accuracy held; Fable 5 rejects that parameter. - On agent traffic the tax collapses to +33%, with tool/batch scenarios near parity: adaptive thinking barely fires in tool loops.
- The 1M context is real (needle recalled at 969,950 tokens) and the cache floor is 512 tokens, half of 4.8's 1,024.
How do Opus 5, Opus 4.8, and Fable 5 differ as platforms?
Before the cost deep-dive, the orientation map: three current Claude tiers, two axes of difference, rates and request shape. Side by side (measured items marked, the rest from the model docs):
| Opus 4.8 | Opus 5 | Fable 5 | |
|---|---|---|---|
| List price (in/out per M) | $5 / $25 | $5 / $25 | $10 / $50 |
| Thinking default | off unless requested | adaptive, on (measured) | always on |
thinking: disabled |
accepted, independent of effort | accepted at effort high or below |
rejected with 400 (measured) |
| Effort ladder |
low-max, default high
|
low-max, default high (cost side measured below) |
low-max, default high
|
| Thinking content returned | n/a by default | never (measured) | never |
| Cache floor | 1,024 tokens | 512 tokens (measured) | 512 tokens |
| Context window | 1M | 1M, default and max (969,950-token needle, measured below) | 1M |
| Assistant prefill | rejected | rejected, named 400 (measured) | rejected |
| Fast mode | available (research preview) | available, $10/$50 | not offered |
| Refusal fallbacks | serves as the default fallback target |
fallbacks incl. new "default" mode (beta) |
introduced here (explicit lists) |
| Data retention | standard options | standard options | 30-day retention required |
Three rows deserve a sentence. The thinking: disabled row is the migration trap: on Opus 5 it is coupled to effort, accepted only at high or below per the docs, where 4.8 treated the two settings as independent; version-gate migration scripts. The fast-mode row sets up a comparison that matters later: Opus 5 in a hurry costs exactly Fable 5's rate card, so "fast Opus 5 vs default Fable 5" is a pure speed-vs-capability trade at equal token prices. And the retention row is the quiet compliance win: Fable-class intelligence on Opus 5 comes without Fable 5's 30-day retention mandate.
Two more platform notes that resist table form. Anthropic documents edge cases when thinking is disabled (tool calls occasionally written into visible text, leaked internal tags); we did not hit either across 84 thinking-off calls in the agent suite measured below, but the guidance reinforces the routing rule: keep thinking on for tool-heavy routes, where the tax is small anyway. And mid-conversation tool changes (beta, Opus 5) let you add or remove tools between turns without busting the prompt cache, which protects the cached-prefix economics our prompt caching guide is built on for long agent sessions.
What does Opus 5 cost out of the box vs Opus 4.8?
3.1x more for the same work at the same rate card. We ran the three current Claude tiers through a five-task matrix (n=3 per cell, salted prompts) at their defaults, on the native Messages API, with Fable 5 alongside for scale:
| Task | Opus 5 default | Opus 4.8 | Fable 5 | Accuracy |
|---|---|---|---|---|
| Trivial arithmetic | 12 | 3 | 12 | 3/3 all |
| Factual one-liner | 40 | 6 | 11 | 3/3 all |
| Small code function | 70 | 38 | 44 | — |
| Multi-step word problem | 152 | 102 | 52 | 3/3 all |
| 120-word paragraph | 1,031 | 236 | 264 | — |
| Total out tokens (cost per set) | 1,305 ($0.03427) | 384 ($0.01120) | 383 ($0.02233) |
Same answers, same rates as 4.8, three times the bill. Opus 4.8 does not think unless you ask it to; Opus 5 ships with adaptive thinking on, and the thinking bills at the full $25/M output rate.
The Fable 5 column holds the counterintuitive result: the model with double the rates ($10/$50) billed 35% less than default Opus 5 in absolute dollars, because it answered the same tasks in 383 output tokens to Opus 5's 1,305. All three models run the same documented default effort (high), so the gap is thinking calibration, not configuration. Two mechanisms fit the numbers. First, a more capable model needs less deliberation to be sure of an easy answer: Fable 5 spent 52 tokens on the word problem where Opus 5 spent 152, and 264 on the paragraph where Opus 5 spent 1,031. Second, Opus 5's headline capability is test-time compute scaling, converting extra deliberation into quality on hard problems, and its default calibration buys that insurance on every request, including the ones that need none. On easy traffic you are paying for insurance you do not use; Fable 5 mostly declines to buy it.
Where does the extra spend go?
Into reasoning you cannot read. Comparing billed output tokens against the visible answer text, 42-95% of Opus 5's default output spend was hidden thinking, and it fires even on questions that need none: the answer to 17*23 carried 11 thinking tokens behind a 1-token answer, and the 120-word writing task spent about 806 of its 1,031 output tokens deliberating. The thinking content is never returned in any form, no summary, no trace, which puts Opus 5 at the most closed end of the visibility spectrum we mapped in our token usage anatomy study, alongside Fable 5. You can see the count in the usage itemization; you cannot see what it bought.
What does the thinking switch actually do?
It turns Opus 5 into Opus 4.8's bill. Sending thinking: {"type": "disabled"} drove thinking to zero on every task, and the totals landed at exact parity with 4.8, 384 output tokens to 384, $0.01130 to $0.01120 per set:
| Arm | Output tokens (set) | Cost (set) | vs Opus 4.8 | Accuracy (3 checkable tasks) |
|---|---|---|---|---|
Opus 5 default (= effort high) |
1,305 | $0.03427 | 3.1x | 9/9 |
| Opus 5, effort low | 1,019 | $0.02720 | 2.4x | 9/9 |
| Opus 5, effort medium | 1,167 | $0.03089 | 2.8x | 9/9 |
| Opus 5, explicit effort high | 1,514 | $0.03956 | 3.5x | 9/9 |
| Opus 5, effort xhigh | 1,633 | $0.04262 | 3.8x | 8/8 |
| Opus 5, effort max | 1,569 | $0.04093 | 3.7x | 9/9 |
| Opus 5, thinking disabled | 384 | $0.01130 | 1.0x | 9/9 |
Opus 4.8 default (= effort high, no thinking) |
384 | $0.01120 | 1.0x | 9/9 |
Fable 5 default (= effort high, thinking always on) |
383 | $0.02233 | 2.0x | 9/9 |
A labeling note first: every model here documents the same API default, effort high, and Anthropic states an explicit high is identical to omitting the parameter. Our implicit-default and explicit-high arms still differ by 16%, which is run-to-run variance on the writing task (the noisiest cell in every batch we have run), not a real distinction; read those two rows as one arm measured twice. What separates the three defaults is not the effort level but what thinking does at that level: none on 4.8, frugal and adaptive on Fable 5, aggressive and adaptive on Opus 5.
Two things stand out. First, the effort dial is a quality ladder, not a cost knob: the ladder itself (low through max) is not new, 4.8 accepts the same range, but on tasks this simple every step above low just buys more deliberation at identical accuracy, with xhigh topping out at 3.8x the 4.8 bill. The top tiers exist for test-time compute scaling on genuinely hard problems, which a five-task sanity matrix cannot exercise; what it can show is the cost side, and the cost side says the dial never gets you back to 4.8 parity. Only the off switch does, at 67% below the default. Second, the switch exists at all: Fable 5 rejects thinking: {"type": "disabled"} with a 400, so this is a genuine Opus 5 differentiator, not a family constant. The same thinking object works on both gateway surfaces, /v1/messages and the OpenAI-compatible /v1/chat/completions; on the latter, disabled runs report zero reasoning_tokens in completion_tokens_details:
{"model": "claude-opus-5", "thinking": {"type": "disabled"}}
The honest caveat: our checkable tasks are retrieval- and single-step-shaped, and accuracy held 9/9 with thinking off, including the multi-step word problem. Harder agentic work is exactly what adaptive thinking exists for, so treat the switch as a per-route decision, the same rule we landed on for Kimi K3 and Gemini 3.6 Flash: off for extraction, formatting, and single-step calls; default where your evals say the thinking earns its bill.
Does the 3x tax hold on agent workloads?
No, and the difference is the point. Across our agent scenario suite (tool loops, RAG, tooling, batch, long chat; 50 episodes per arm), default Opus 5 cost only 33% more than Opus 4.8, not 210%, and the tool-shaped scenarios ran near parity (1.01-1.22x). Adaptive thinking is genuinely adaptive there: about 88 thinking tokens per call inside agent loops versus 806 on a bare writing prompt. The outlier is long chat at 1.58x, which is where the off switch still pays (1.22x with thinking disabled). Function calling showed zero thinking tax at all: at the default, a tool-call request came back in 52 output tokens with no thinking attached, the same budget a non-thinking model would spend.
So the practical split is by traffic shape, not by model: bare completions and chat-shaped calls carry the 3x default tax and want the switch; tool-heavy agent traffic mostly does not need it.
Is Opus 5 really half the price of Fable 5?
Only after you flip the switch. Per token, yes: $5/$25 versus Fable 5's $10/$50. In practice, on our bare-task matrix, default Opus 5 billed $0.03427 per set against Fable 5's $0.02233, 53% more in absolute dollars, because Fable 5 answered the same tasks in 383 output tokens to Opus 5's 1,305. With thinking disabled, Opus 5's $0.01130 is almost exactly half of Fable 5's bill, which is the launch promise made real, through a parameter Fable 5 itself does not accept.
Context, cache, and tokenizer: what else did we verify?
The 1M window is real and fails loud. A recall needle at the front of a 969,950-token prompt came back correct in 39 seconds, and a 1,010,221-token prompt returned a clean prompt is too long: … > 1000000 maximum rather than silently truncating.
The cache floor halved. Anthropic documents a 512-token minimum cacheable prefix for Opus 5 (and Fable 5), down from 1,024 on Opus 4.8 and Sonnet 5; our sweep matched it, with prefixes near 511 tokens never caching and 547 caching reliably. Cached reads bill $0.50/M (0.1x), writes 1.25x, 5-minute TTL. Shorter system prompts are now cacheable, which quietly matters for high-QPS routes.
The tokenizer is unchanged across Opus 5, Opus 4.8, Fable 5, and Sonnet 5: identical token counts on our multilingual and code samples, so per-language budgets and prompt-size estimates carry over with no re-baselining.
FAQ
Can you turn thinking off on Claude Opus 5?
Yes, at effort high or below; the docs state that combining it with xhigh or max returns a 400. In our probes it drove thinking tokens to zero and brought cost to parity with Opus 4.8 (384 vs 384 output tokens on our matrix). This is specific to Opus 5: Fable 5 rejects the same parameter at any effort with a 400. The effort dial (low through max) also works but never reaches parity: from -21% at low to +24% at xhigh versus the default in our matrix.
Why is my Opus 5 bill higher than Opus 4.8 at the same list prices?
Because Opus 5 thinks by default and the thinking bills as output at $25/M. On bare prompts, 42-95% of its billed output was hidden reasoning in our measurements; a two-digit multiplication carried 11 thinking tokens behind a 1-token answer. Read reasoning_tokens from the usage itemization to see the share on your own traffic, and disable thinking on routes that do not need it.
Should agent workloads disable thinking on Opus 5?
Usually not. In our agent suite the default cost only +33% versus Opus 4.8, with tool and batch scenarios near parity, because adaptive thinking barely fires inside tool loops. The exception is long chat-shaped sessions (1.58x), where the switch still pays. Measure your own mix; the tax lives in bare completions, not tool calls.
Measured 2026-07-25 through 2026-07-27 on claude-opus-5, claude-opus-4-8, and claude-fable-5 via the Synthorai gateway: five-task matrix and effort/switch ablation from one canonical batch (n=3 per cell, salted prompts, native Messages API), agent numbers from a 150-episode scenario suite, context and cache probes from needle-recall and prefix sweeps, API-shape rows (prefill, switch acceptance) from direct request probes. Accuracy counts use tasks with a single checkable answer. Prices and behavior may change; verify against your own usage records.
Top comments (0)