Verdict. Claude Opus 5 (API id claude-opus-5, released 24 July 2026) is the model that turns "Claude in your agent stack" from a flagship purchase into a daily utility. It reaches near–Fable 5 intelligence at roughly half the input cost ($5/M vs $10/M), is the new default on Claude Max, and its standout gains — on computer use, end-to-end automation, and novel-reasoning work — are exactly the failures that break real agent pipelines. The honest top-line takeaway for anyone already running agents: swap Opus 4.8 out for Opus 5 as your workhorse, keep Fable 5 reserved for true long-horizon autonomy, and use the effort dial and fast mode as a routing mechanism rather than as on/off switches. Anthropic's launch post calls this the intended use, and every early-access customer quote in it points the same direction.
Last verified: 2026-07-28 · Pricing/limits/versions are volatile — re-check before committing volume.
- Best for: daily coding, business automation, and computer-use work where you pay per task.
- Not a full replacement for: Fable 5 on day-long autonomous runs, or Mythos 5 on offensive security.
- Same token footprint as Opus 4.8; in most stacks you swap the model string and keep everything else.
- Self-verification is built in — your retry/verify loop can be cut substantially, not expanded.
- Fast mode is a per-call choice, not a tier. Use it for the minutes you are watching the loop.
Why Opus 5 matters for an agent stack specifically (not just as a benchmark win)
Opus 5 matters for an existing agent stack specifically because its biggest jumps are on the workloads that break agent pipelines, not on the raw coding bars that move a leaderboard. The published gains line up with real failure modes you have probably already hit: a model that gives up halfway through a web automation, a multi-step business task that stalls on step 4 of 7, or an agent that "succeeds" with broken code because nothing forced it to check.
The numbers that should change your stack, not your press release, are these from Anthropic's launch post:
- Frontier-Bench v0.1 (agentic coding): 43.3% — more than 2× Opus 4.8 (18.7%) by Anthropic's reported numbers, and independent trackers reproduce the same ratio.
- OSWorld 2.0 (computer use): beats Fable 5's best at roughly one-third the cost. This is the single highest-leverage change if your stack clicks, types, or drives a browser.
- Zapier AutomationBench: ~1.5× the next-best model at the same cost per task, and — unusually — even at its lowest effort setting Opus 5 passes more tasks than any other model (Anthropic, Interesting Engineering confirms).
- ARC-AGI-3: ~3× the next-best reported model — a giant gap on a test explicitly designed to resist memorisation.
- ~85% fewer safety-classifier trips than Fable 5 (Anthropic System Card coverage) — far fewer spurious mid-run refusals that silently break a long agent run.
The honest caveat lives in the same set of tables: on SWE-bench Pro (real GitHub issues), Opus 5 scores 79.2% versus Fable 5's 80.0% (codersera's launch guide). Anthropic's own framing is that Opus 5 replaces Opus 4.8, not Fable 5. Treat it that way. For a deeper launch and spec read, see our existing Claude Opus 5 review: near-frontier intelligence at half Fable 5's price.
How should you route Opus 5 against Fable 5 and Sonnet 5 in a real stack?
Route by task horizon and autonomy, not by raw benchmark score. Three tiers is the cleanest mental model:
| Model | Best use in an agent stack | Cost (input / output, per 1M tokens) | When it loses |
|---|---|---|---|
| Opus 5 (default workhorse) | Daily coding, business automation, computer use, multi-tool agent loops that finish in tens of minutes to a few hours | $5 / $25 | Multiday autonomous runs you cannot checkpoint |
| Fable 5 (frontier) | Genuine long-horizon autonomy — runs that span many hours without a human in the loop, where the cost of a stalled run dwarfs the API cost | $10 / $50 (per Anthropic's launch context) | Most budget-constrained daily work — you pay twice for capability you rarely use |
| Sonnet 5 (high-volume) | Bulk, shallow, repetitive steps — classification, summarisation, drafting, formatting | lower still — see Anthropic's pricing page | Anything needing self-verification across a long chain |
The decision rule we use on our own stack: if the task completes inside one context window and one human checkpoint, it goes to Opus 5. If it crosses session boundaries or runs unattended overnight, Fable 5. If it is a single well-defined mechanical step that will be called thousands of times, Sonnet 5. This is the same routing discipline we describe in how to test frontier AI models side by side: pick the model that wins your task mix, not the one that wins the leaderboard.
Two real signals from the launch support this exact split. Cursor reports Opus 5 sits within 0.5% of Fable 5's peak on CursorBench 3.2 at roughly half the cost per task (Anthropic customer quote, Scott Wu / Sualeh Asif). Zapier says Opus 5 "topped Zapier's AutomationBench leaderboard without spending more tokens than prior Claude models" (Wade Foster, CEO, in the same post). Those are operators — not reviewers — saying the workhorse tier now wins the workhorse tier's actual work.
How do Opus 5's effort levels work, and when do you move them?
Effort levels (low / medium / high, plus a new top-tier xhigh per oflight's launch breakdown) are the single most underused lever in an Opus 5 stack. They are not a quality setting — they are a routing decision you make per call, by job type.
| Effort | Reach for it on… | Avoid on… |
|---|---|---|
| Low | Mechanical edits: rename a symbol, add a prop, tidy imports, scaffold a boilerplate test. Throughput over depth. | Anything where a wrong first answer costs you a round trip to recover. |
| Medium (the default) | Feature work, code review, most business-automation tasks. The setting that earns its keep on the 80% of your tasks. | Hard bugs that have already failed a "try again" round. |
| High | Unreproducible race conditions, tricky migrations, architecture decisions, anything you've already sent back twice. | Bulk mechanical work — it just costs more thinking tokens for no quality gain. |
| xhigh (new) | 30+ minute agentic runs where the ceiling of capability matters and you can absorb the wait. A reminder: at xhigh or max, Anthropic returns a 400 if you try to disable thinking — you cannot turn one off the other. |
Interactive loops. The latency is the cost. |
The rule of thumb from Claude Code's operational guide: start at medium, escalate deliberately. Bumping Opus 5 to high once is almost always cheaper and more reliable than re-prompting it five times on medium — because the extra reasoning lives in one round trip, while re-prompting burns five.
When does fast mode actually pay for itself?
Fast mode costs 2× the token price but runs ~2.5× faster (Anthropic's launch post, codersera's guide). The counter-intuitive result: fast mode is cheaper per second of wall-clock time when you are actively in the loop. Standard mode is cheaper per token, so it wins for anything unattended.
| Speed pattern | Input / output (per 1M tokens) | Relative speed | Best for |
|---|---|---|---|
| Standard | $5 / $25 | 1× | Background agents, unattended batches, long refactors, anything where wall-clock doesn't matter |
| Fast mode | $10 / $50 | ~2.5× | Interactive pair-programming, live debugging, tight edit-run-fix loops where you are watching the screen |
The operational rule: standard for the 90% of work that runs in the background; fast mode for the handful of minutes where you are the bottleneck. It is a per-call choice, not a subscription tier — pay for speed only when you are the one waiting on it.
How does Opus 5's self-verification change the orchestrator you build around it?
This is the change with the largest second-order effect, and most stacks are still ignoring it. Anthropic describes Opus 5 as "verifying its work and iterating carefully until it succeeds" rather than producing an answer and moving on (launch post). Two of the demonstrations they ship in the launch — the model writing its own computer-vision pipeline to extract geometry from raw pixels, and the model building its own test harness to validate a market-data feed that had no live source to check against — are not coding tricks. They are the model doing the verification work that an orchestrator normally has to script.
The practical implication for an agent stack:
- Shrink the retry/verify loop. Where you used to wrap a model call in a try → check → retry scaffolding, Opus 5 will often run the check itself before returning. Keep the scaffolding, but budget fewer rounds.
- Pass the failure output directly, don't paraphrase it. Self-verification works when the model reads the actual failing test log, not a summary of it. Stream stdout/stderr in, not a polite description of it.
- Catch root causes, not symptoms. Anthropic's launch describes Opus 5 finding a root cause in a real open-source bug that the community patch had missed while a competing model only fixed the surface symptom — exactly the failure you want at the top of an automation chain, not the bottom of it.
- Lower your classifier-trip recovery cost. The new Automatic Fallbacks beta routes a flagged request to a smaller model instead of erroring out (theroboticsmedia confirms). For a long unattended run, that means an interrupted step self-heals rather than halts — a meaningful change for cost reliability.
This changes the headline advice in our single-agent vs multi-agent decision framework: with a more reliable main agent, the breakeven point moves further out. The case for adding a second agent has to be specialisation or genuine parallelism, not "we need a verifier because the main model sometimes lies to us." When the main model verifies itself, the verifier agent is overhead.
What is the 30-minute migration to put Opus 5 inside an agent OS?
The pragmatic agent OS we've documented before — the local-first layer that schedules agents, shares memory, and routes tools — takes the Opus 5 swap with no architectural changes, only a config change. Here is the migration in rough order, with the gotchas that actually bite:
- Swap the model string. In Claude Code:
/modelper session,claude --model claude-opus-5per launch, or set it as the persistent default in your settings (codersera guide). In a custom orchestrator: one config line, e.g.{"claudeModel": "claude-opus-5"}. Restart, and every Claude surface is on Opus 5. - Audit for
thinking: disabledpaired withxhighormax. Those now return a 400 error from the API — they are the reverse-incompatible change that catches codebases by surprise (oflight). Grep for it before you ship the swap. - Retire Opus 4.1 strings before 5 August 2026. Opus 4.1 retires on that date; Opus 4.8 is now legacy but still callable for now. Update both (oflight's migration notes).
- Drop the verifier step on agentic coding tasks. Where you had an explicit verify-then-retry loop, cut it to a single retry and a single verification round. Watch the failure counts for two weeks before cutting further.
- Set effort defaults per job class, not globally. A pipeline that runs the same
medium-effort call on every task is paying more than it needs to on the easy 60% and getting less than it could on the hard 10%. Tag your tasks and set effort by tag. - Leave Fable 5 configured for the one job it actually does better. Wire a routing rule: if the task has a multi-hour horizon with no human checkpoint, escalate to Fable 5. Otherwise stay on Opus 5. Keep the rule explicit — magic "auto-escalation" costs the wrong thing at the wrong moment.
- Verify your switch doesn't lie to you. A model's training data predates its own launch, so if you ask Opus 5 which model it is, it will often guess an older name. Don't trust that. The real proof is what the CLI resolves —
claude auth statusand the model flag in the process are the only reliable signal (agentos.guide notes this trap).
What does this mean for you?
For builders running their own agent stack: swap the model string today, audit for the thinking: disabled + xhigh/max pair, and cut one round off your verify loop. Measure for two weeks. You will likely find the cheapest improvement you get all year — capability up, cost flat, fewer stalled runs.
For small businesses paying for Claude Pro / Max: most of you are already on Opus 5 without changing a setting (it is the new default on Max and the strongest option on Pro per Anthropic). What you should do is stop leaving effort on the default for every task — set medium for most work, high for the bugs that have already cost you a round, low for mechanical edits. That alone will move your daily token spend without changing the model.
For teams torn between Opus and Fable: if your daily work finishes inside one human checkpoint, Opus 5 is the answer; if your work crosses session boundaries and runs overnight, Fable 5 still earns its premium. The mistake is using Fable 5 to buy "the best" for tasks Opus 5 now does at the same quality for half the cost.
FAQ
Q: Is Claude Opus 5 free on my Claude Pro or Max plan?
A: It is the new default model on Claude Max and the strongest model available on Claude Pro as of the 24 July 2026 launch (Anthropic). If you're on either plan with default settings, you are likely already talking to Opus 5 — verify with claude auth status (Claude Code) or your plan's model selector, since asking the model to name itself is unreliable.
Q: Does Claude Opus 5 cost more than Opus 4.8?
A: No. Standard pricing is unchanged at $5 per million input tokens and $25 per million output tokens (Anthropic; oflight breakdown). Fast mode is the only extra cost — 2× the token price for ~2.5× the speed — and it is a per-call decision, not a tier.
Q: Should I switch from Fable 5 to Opus 5?
A: For most daily coding, business automation, and computer-use work, yes — you get near-Fable 5 quality at half the input cost. Keep Fable 5 only for true long-horizon autonomous runs that span many hours without a human checkpoint, where a stalled run is more expensive than the model. On SWE-bench Pro specifically, Opus 5 (79.2%) still trails Fable 5 (80.0%) by under a point (codersera).
Q: Which effort level should I use by default?
A: Medium for most feature work, code review, and agentic tasks. Low for mechanical bulk edits. High for hard debugging, tricky migrations, or anything that has already failed a "try again" round. Raise effort deliberately and once — it is cheaper than re-prompting five times on medium (Claude Code guide, codersera).
Q: Does Opus 5 work with multi-agent orchestration?
A: Yes, and it makes some multi-agent setups unnecessary. Opus 5's self-verification means the separate "verifier agent" pattern often becomes overhead — if you layered in a second agent only because the first sometimes produced broken code, that case for multi-agent shrinks. Keep multi-agent only for genuine parallelism or specialisation, not as a band-aid for unreliability (we map this trade-off in our single-agent vs multi-agent framework).
Q: Is Opus 5 the most capable Anthropic model on everything?
A: No. Anthropic is explicit that Opus 5 remains behind Mythos 5 on offensive cybersecurity and biology research, and that it does not advance the frontier on risky dual-use capabilities (Anthropic launch post). It is positioned as the most aligned model to date and the best value-per-task for everyday work, not the most capable on the hardest adversarial work.
Q: What breaks when I swap Opus 4.8 out for Opus 5?
A: Three things to check: pairings of thinking: disabled with xhigh or max now return a 400 from the API; Opus 4.1 retires on 5 August 2026 and any hardcoded model strings need updating; and Opus 4.8 is now "legacy" but still callable, so you have a buffer to migrate (oflight migration notes).
Discussion
0 comments