Claude Opus 5: Benchmarks, Pricing & Two Breaking Changes

Claude Opus 5 landed on July 24, 2026, and it quietly did the most disruptive thing a model launch can do: it kept the old price. Same $5 / $25 per million tokens as Opus 4.8, and it more than doubles Opus 4.8’s score on Anthropic’s hardest agentic coding benchmark. In the API it’s claude-opus-5.

That combination breaks the mental model most teams have been running on. For the last two months the ladder was simple — default to Sonnet, escalate to Opus, and pay double for Fable 5 when the task was genuinely brutal. Opus 5 collapses the top two rungs: it lands within half a percentage point of Fable 5 on real-world coding evals at roughly half the cost per task. The interesting question is no longer “when do I escalate to Fable?” It’s “is there still a reason to?”

There’s a catch, and it’s the part the launch post doesn’t lead with. Two API behaviors changed, and if you migrate by swapping the model string, one of them will silently truncate your responses and the other will 400 your requests.

TL;DR

• Claude Opus 5 is a drop-in upgrade at Opus 4.8’s exact price — $5 per million input tokens, $25 output, 1M context, 128K max output. No price increase, no new tier.
• It gets near-Fable 5 capability at half Fable’s cost. Within 0.5% of Fable 5 on CursorBench 3.2, past Fable 5’s peak OSWorld 2.0 score at about a third of the budget, and 43.3% on Frontier-Bench v0.1 versus Fable 5’s 33.7%.
• Two breaking changes will bite a string-swap migration. Thinking is now on by default (so a tight max_tokens can truncate mid-answer), and thinking: {"type": "disabled"} returns a 400 at xhigh or max effort.
• Re-sweep your effort levels. low and medium are meaningfully stronger on Opus 5 than on any earlier Opus — they’re now the primary cost lever, not a compromise.
• The play: make Opus 5 your default ceiling, keep Sonnet 5 for high-volume work, and reserve Fable 5 for the narrow band where you’ve measured that Opus 5 falls short.

What Is Claude Opus 5?

Claude Opus 5 is Anthropic’s model for complex agentic coding and enterprise work — a frontier-class model priced at the mid-flagship tier. It has a 1-million-token context window, up to 128K output tokens per request, adaptive thinking that’s on by default, high-resolution vision, and a May 2026 knowledge cutoff. You call it as claude-opus-5 on the Claude API, anthropic.claude-opus-5 on Amazon Bedrock, and claude-opus-5 on Google Cloud and Microsoft Foundry.

The one-sentence version: it’s the model that made “escalate to the premium tier” a much rarer decision. Anthropic positions Fable 5 as the answer when you need the highest available capability, and Opus 5 as the answer for everything else demanding — which, after you look at the benchmarks, turns out to be nearly everything.

Three things define it in practice:

1. It verifies its own work. This is the headline behavioral change over Opus 4.8. It opens pages in a browser at desktop and phone widths, checks its output against reality, and iterates before handing back.

2. It finishes in fewer turns. Across effort levels, Opus 5 averaged roughly 9 percentage points higher accuracy while using about a third fewer turns and tool calls, and 60% less wall-clock time. Fewer turns is not a vanity metric — it’s the token bill.

3. It’s the most aligned Opus Anthropic has shipped. It scored 2.3 on their automated overall-misalignment audit, the lowest of any recent model, with the lowest rates of deceptive behavior and the least susceptibility to being tricked into misuse.

💡 Key insight: The story of Opus 5 is not a capability jump — those happen every few months now. It’s a price-tier jump. Frontier-class results arrived on the shelf below the frontier-class price.

Claude Opus 5 Benchmarks

Anthropic leaned on a newer, harder set of evals for this launch — the older saturated ones stopped separating models. Here’s what the numbers actually say.

Two results deserve a second look.

Frontier-Bench v0.1 is the one that matters for engineering teams. Opus 5 more than doubles Opus 4.8 (43.3% vs 18.7%) and clears Fable 5 (33.7%) — at half Fable’s price. When a mid-tier model beats the premium tier on the premium tier’s home turf, the ladder has changed shape.

ARC-AGI 3 is the one that matters for everyone else. 30.2% roughly triples the previous best any model had posted, and sits about four times GPT-5.6 Sol’s 7.8%. ARC-AGI is deliberately built to resist memorization — it tests reasoning on problems the model hasn’t seen a template for. A jump that size on that benchmark is not benchmark-tuning.

The customer quotes line up with the numbers rather than contradicting them, which is rarer than it should be. Devin called it “approaches Fable-level performance at half the cost.” Cursor: “near Fable 5 intelligence at Opus speed and cost.” Lovable called it the “biggest leap in the Opus family since 4.5,” with “far less variance run to run” — and run-to-run variance is the thing that actually decides whether you can put a model in an unattended pipeline.

The Real Cost Math

This is the section that changes what you do on Monday. Opus 5 did not get a price increase. It’s $5 per million input tokens and $25 per million output — the same numbers Opus 4.8, 4.7, 4.6, and 4.5 all carried.

Run the arithmetic on a real workload. Take an agentic run that consumes 500K input tokens (large context, re-sent across turns) and 100K output tokens:

• Opus 5: $2.50 + $2.50 = $5.00
• Fable 5: $5.00 + $5.00 = $10.00
• Sonnet 5: $1.50 + $1.50 = $3.00

But raw per-token price understates the gap, because Opus 5 needs fewer tokens to finish. It hit comparable quality while generating about 26% fewer tokens than Opus 4.8 at max reasoning, with a third fewer tool calls. Applied to the run above, that’s closer to $3.70 of real spend — against $10.00 on Fable 5 for a result within half a percentage point on CursorBench. That’s not a 2x saving. It’s closer to 2.7x.

Two pricing details worth knowing before you budget:

Fast mode is a separate line item. speed: "fast" gives you up to 2.5x output throughput, priced at $10 / $50 — double the base rate, and Claude API only (not Bedrock, Google Cloud, or Foundry). It also draws on its own rate-limit pool.

Opus 5 has its own rate-limit bucket. Opus 4.8, 4.7, 4.6, and 4.5 share one combined Opus limit. Opus 5 does not draw from it. Shifting traffic over neither frees headroom on the old bucket nor inherits it — check your tier’s Opus 5 limits before you move volume, or you’ll rate-limit yourself on launch day.

The Two Breaking Changes

Here’s the part that costs people an afternoon. Everything from the Opus 4.7 API surface still holds — budget_tokens is gone, sampling parameters (temperature, top_p, top_k) are rejected, and last-assistant-turn prefills 400. If you’re already on 4.8, those are clean. Two things are genuinely new.

1. Thinking is on by default — and it eats your max_tokens

On Opus 4.8 and 4.7, omitting the thinking parameter meant no thinking. On Opus 5, omitting it runs adaptive thinking. The wire value didn’t change; the default did.

This is a silent cost and truncation change, not just a behavior one. max_tokens is a hard cap on thinking plus response text. A route that ran thinking-off on Opus 4.8 and sized max_tokens tightly around its expected answer can now truncate mid-response — with no error, just a shorter reply and stop_reason: "max_tokens".

from anthropic import Anthropic

client = Anthropic()

# On Opus 4.8 this ran with NO thinking. On Opus 5 it thinks —
# and thinking tokens come out of the same 2000-token budget.
response = client.messages.create(
    model="claude-opus-5",
    max_tokens=2000,          # ← now shared between thinking and the answer
    messages=[{"role": "user", "content": "..."}],
)

The fix is one of two lines: raise max_tokens to leave room, or opt out explicitly with thinking: {"type": "disabled"} — subject to the next change.

2. Disabling thinking 400s at xhigh and max effort

You can only disable thinking at effort high or lower. Pair thinking: {"type": "disabled"} with xhigh or max and the request returns a 400.

# 400 on Claude Opus 5 — disabled thinking above "high" effort
client.messages.create(
    model="claude-opus-5",
    max_tokens=4096,
    thinking={"type": "disabled"},
    output_config={"effort": "xhigh"},   # ← invalid combination
    messages=[{"role": "user", "content": "..."}],
)

The trap is that this is validated per request, not per conversation. A later call that bumps effort to xhigh while thinking is still disabled gets rejected even though every earlier call in the same session succeeded. Audit every call site, not just the first one.

Effort: Re-Sweep It, Don’t Reuse It

Opus 5 supports all five effort levels — low, medium, high, xhigh, max — with high as the API default. The guidance genuinely changed from 4.8, and copying your old settings over is the most common way to leave money on the table.

The line from Anthropic’s own effort docs is unusually direct: low and medium are stronger on Opus 5 than on earlier Opus models, and you should “use them liberally as your primary control for token cost and response time wherever your evals show quality holds.” That is the opposite of the reflex most teams built up over the 4.x series, where dropping below high meant visibly worse output.

One trap: effort controls thinking volume, not visible response length. If Opus 5’s answers are too long, lowering effort won’t reliably fix it — you have to prompt for brevity. A short conciseness instruction cut user-facing response length by about 20% in testing; changing effort didn’t.

What Else Is New

The refusal path deserves a code snippet, because it’s the one that crashes production:

response = client.beta.messages.create(
    model="claude-opus-5",
    max_tokens=16000,
    betas=["server-side-fallback-2026-07-01"],
    fallbacks="default",     # routes by refusal category, no model list to maintain
    messages=[{"role": "user", "content": "..."}],
)

if response.stop_reason == "refusal":
    handle_refusal()
else:
    print(response.content[0].text)

A refused request is a successful HTTP 200, not an exception. Code that reads response.content[0] unconditionally breaks on it. Check stop_reason first.

Opus 5 vs Fable 5 vs Sonnet 5

And Sonnet 5 hasn’t been displaced — it’s just been re-scoped. It remains the right default for high-volume backends, chat, RAG, and anything latency-sensitive, where $3 / $15 and fast turnaround beat a capability ceiling you never touch. Just remember its tokenizer inflates counts by roughly 30%, which eats into the apparent saving versus Opus 5.

The heuristic I’d use in July 2026: Sonnet 5 for volume, Opus 5 as the ceiling for everything hard, Fable 5 only where a measured gap justifies double. That’s a simpler ladder than we had last month, and it’s cheaper at the top.

The Honest Ledger

The Migration Checklist

That seventh item is the counterintuitive one and it’s worth repeating: delete your verification scaffolding. Instructions like “include a final verification step” or “double-check your answer” were good practice on earlier models. On Opus 5 they cause over-verification, and removing them reduces it with no capability regression. It’s a delete, not a rewrite — which inverts a prompting rule most teams have internalized. If you maintain a shared prompt library or a house CLAUDE.md, that’s the line to carve out.

FAQ

The Bottom Line

Claude Opus 5 is the rare launch where the interesting number is the one that didn’t change. Same $5 / $25 as the model it replaces, near-Fable capability, fewer turns to get there, and a knowledge cutoff four months fresher than the flagship. If you’re running Opus 4.8 today, this is a migration where the ceiling goes up and the bill goes down — those don’t come along often.

Just don’t swap the string and walk away. Thinking is on by default now, which means the max_tokens you tuned last quarter is quietly a truncation risk, and disabled thinking plus xhigh effort is a 400 waiting for whichever call site raises effort first. Fifteen minutes of auditing buys you the whole upgrade.

Then do the thing most teams skip: re-sweep your effort levels. The single biggest cost lever in this release isn’t the price tag — it’s that low and medium finally hold quality on hard work. Measure it on your own evals rather than trusting your Opus 4.8 instincts, and the same workload can get better and cheaper at the same time.

Next: if you’re deciding where Opus 5 fits alongside your tooling, read the Claude Code vs Cursor production breakdown, and the Sonnet 5 tokenizer gotcha before you assume Sonnet is always the cheaper option.

Sources

• Introducing Claude Opus 5 — Anthropic’s launch announcement (benchmarks, alignment audit, customer results)
• Models overview — Anthropic docs: pricing, context window, knowledge cutoff, platform IDs
• Effort — Anthropic docs: effort levels and the Opus 5 recommendations
• Model migration guide — Anthropic docs: the Opus 4.8 → Opus 5 breaking changes
• Anthropic launches Claude Opus 5 — VentureBeat’s launch coverage

Written for umesh-malik.com — no-fluff technical writing on AI, Web Dev, and Engineering.