Claude Opus 5: The Price Didn't Move, and That's the Story
On July 24, 2026, Anthropic shipped Claude Opus 5. The pitch is short: close to the frontier intelligence of Fable 5, at half the price.
The number that matters is the one that didn't change. Opus 5 costs $5 per million input tokens and $25 per million output tokens, exactly what Opus 4.8 cost. Same sticker, much better model.
That is not the interesting part either.
The interesting part is that Anthropic shipped a dial. You now choose how hard the model thinks on a given task, from low effort up to max, and the cost follows your choice instead of your model selection. Combine that with a model that verifies its own work before handing it back, and the way you budget AI work changes more than the way you prompt it.
What Anthropic actually shipped
The concrete list, before the opinions:
Claude Opus 5, available on all platforms from day one, model string claude-opus-5
Pricing unchanged from Opus 4.8 at $5 per million input tokens and $25 per million output tokens
An effort setting customers control, spanning low through high, xhigh, and max
Fast mode at roughly 2.5 times default speed, priced at twice the base rate
New default model on Claude Max, strongest model available on Claude Pro
State of the art on coding and knowledge work evaluations including Frontier-Bench and GDPval-AA
Still behind Mythos 5 on cybersecurity and on long-horizon biology research
Anthropic's most aligned model to date on its automated behavioral audit
No data retention requirement for general access, consistent with previous Opus models
Two beta platform updates alongside it: mid-conversation tool changes that no longer invalidate the prompt cache, and automatic fallbacks on the API
This is the fourth model release in under two months, after Mythos 5, Fable 5, and Sonnet 5. Keep that pace in mind. It shapes how you should be building.
The pricing story is not the price
Cost per million tokens is a vendor metric. Cost per completed task is your metric. Those two numbers have been drifting apart for a while, and Opus 5 is where the gap gets hard to ignore.
Three figures from Anthropic's own benchmarks make the point:
On Frontier-Bench v0.1, Opus 5 more than doubles Opus 4.8's performance at a lower cost per task
On CursorBench 3.2 at max effort, it lands within half a percent of Fable 5's peak score at half the cost per task
On OSWorld 2.0, a computer use benchmark, it beats Fable 5's best result at just over a third of the cost
Read that middle line again. A model at $5 and $25 per million tokens getting within a rounding error of the frontier model on a real coding benchmark, for half the money per finished task.
If you are still comparing models on token price alone, you are measuring the wrong thing. A cheaper model that needs four attempts and a human review pass is more expensive than an Opus-class model that gets it right the first time.
Why cost per task keeps beating cost per token
Token pricing assumes the work is roughly fixed and the model is the variable. In agentic workflows the opposite is true. The model decides how many turns, how many tool calls, how much retry, how much of your engineer's afternoon.
One financial modeling team reported Opus 5 averaging nine percentage points higher accuracy than Opus 4.8 across effort levels, with a third fewer turns and tool calls, and sixty percent less wall clock time. A trading benchmark had it hitting its best Opus score using roughly a seventh of the reasoning tokens and under half the latency of Opus 4.8.
Better answers, fewer tokens. That combination is unusual and it is the actual product claim here.
The effort dial is the real change
Effort settings are not new to the Claude lineup, but Opus 5 is the release where they stop being a footnote and start being how you architect.
Here is the shift. Previously your cost and capability knob was model selection. Cheap task, use Haiku. Medium task, use Sonnet. Hard task, use Opus. That meant maintaining prompts, evals, and fallbacks across three or four models, each with its own quirks.
Now one model spans a lot of that range. Same behavior, same prompt handling, same tool use patterns, with a reasoning budget you set per call.
Two details make this more than a convenience feature:
Anthropic reports that even at its lowest effort setting, Opus 5 passes more business automation tasks on Zapier's AutomationBench than any other model
A legal AI team found it held roughly equivalent quality at reduced reasoning levels while generating twenty-six percent fewer tokens than Opus 4.8 at max reasoning
So the floor is high. That is what makes the dial usable in production rather than just in demos. You are not choosing between good and broken. You are choosing between good and slightly better, and paying accordingly.
What this kills
A lot of model-routing infrastructure. If you built a classifier that sorts incoming requests into cheap-model and expensive-model buckets, a chunk of that logic collapses into a single parameter.
That is a real reduction in complexity for anyone running agents in production. Fewer prompt variants to maintain. Fewer eval suites. Fewer places where a fallback silently changes behavior and nobody notices for two weeks.
Reliability is the feature that actually matters
The benchmark charts are the marketing. The behavior change is the product.
Anthropic's framing is that Opus 5 is much stronger at verifying its own work and iterating until it succeeds. Three examples from the launch material show what that means in practice.
The first is the one worth remembering. On a Frontier-Bench task, the model was given a drawing of a machine part and asked to write code rebuilding it as a 3D FreeCAD model. The catch was deliberate: it had no way to actually view the drawing. Opus 5 wrote its own computer vision pipeline to extract the geometry from raw pixels, then reconstructed the part. It did this repeatedly. No competing model in the same setup solved it in five attempts.
The second is smaller and more familiar to anyone who has shipped software. Handed a real bug in a popular open source package manager, Opus 5 found the root cause and fixed an edge case the community patch had missed. A competing model patched the visible symptom and declared victory.
The third: an engineer at a trading firm used it to build a market data feed for a new exchange in one session. No live feed existed to validate against, so the model built its own test harness to confirm it was parsing the exchange data correctly. Previous models could not finish the task at all, even with detailed plans handed to them.
Why self-verification changes agent economics
Long-running agents fail for one boring reason. Error compounds.
Step three makes a small wrong assumption. Steps four through twelve build on it. By step twenty you have a confident, coherent, completely wrong result, and the only way to catch it is a human reading the whole trace.
That failure mode is why most teams cap agents at short horizons and insert review gates. The gates are the expensive part, not the tokens.
A model that checks its own assumptions against reality, notices when it is off, and corrects mid-run shortens the babysitting. One monitoring team described an agent that flagged a possible anomaly, re-checked its own assumption against production, found the signal was benign, wrote the correction into its own memory, and retired its monitoring queries without being asked.
You do not have to find that exciting to find it useful. Every review gate you can remove is margin.
Judgment is the word people keep using
Across the early access reports, the same theme repeats and it is not accuracy. It is judgment.
A frontend benchmark had it opening its own pages in a browser at desktop and phone widths, catching a product hidden below the mobile fold and an off-screen checkout button, and fixing both before handing the work back. A PR handoff test had it verifying branches and checking the template instead of rushing to publish.
The one I find most telling: during a rearchitecting session, the model pushed back on a design an engineer proposed, and did not fold when the engineer insisted. It explained what was good in the idea, narrowed its objection to one specific design question, and proposed a compromise.
That is not a benchmark score. That is the difference between a tool you supervise and a collaborator you delegate to.
Anthropic backs this with alignment numbers rather than vibes. On its automated behavioral audit, Opus 5 scored 2.3 on overall misaligned behavior, the lowest of the recent models. It adheres to Claude's Constitution better than Opus 4.8, Sonnet 5, or Fable 5, shows the lowest rates of deceptive behavior, and is described as the least susceptible to being tricked into misuse.
For anyone giving a model write access to a repository or a production system, that last part is not a nice-to-have.
Where it sits in the lineup, briefly
Light version, since the point of this piece is not a spec comparison:
Mythos 5 remains ahead on offensive cybersecurity and on long-running autonomous biology research. It is not generally available.
Fable 5 is still the frontier model you can buy, but it carries heavier classifier restrictions and a 30-day data retention policy. Opus 5 has no retention requirement for general access.
Opus 5 is now the everyday default. New default on Max, strongest option on Pro, and Anthropic's most capable generally available model for scientific research.
Sonnet 5 is still the volume play when you need Opus-adjacent quality at lower cost across high-throughput workloads.
One number worth knowing if classifier friction has bitten you before: Anthropic expects Opus 5's cyber classifiers to intervene around eighty-five percent less often than Fable 5's. Flagged requests in Claude.ai, Claude Code, and Claude Cowork fall back to Opus 4.8 by default, and fallbacks can be enabled on the API too. Biology requests blocked on Fable 5 now route to Opus 5 rather than Opus 4.8.
How to actually use it
This is the part most launch coverage skips. Here is what I would change in a working setup.
Match effort to workload, not to importance
The instinct is to crank effort on anything that feels important. Wrong instinct. Match it to task shape.
Low to medium effort:
Classification, extraction, tagging, routing
Summarization and rewriting
Routine single-file edits with clear instructions
High-volume background jobs where throughput beats depth
High effort:
Feature work across a few files
Multi-step tool use with a defined goal
Content and analysis where the reasoning is the output
Extra high to max effort:
Architecture decisions and refactors that cross module boundaries
Debugging where the symptom and the cause are far apart
Novel problems with no obvious template
Research work where a wrong intermediate step wastes hours
The failure mode to avoid is defaulting everything to max. You pay for reasoning you did not need, and on well-specified tasks the returns flatten fast. The floor being high is the whole reason the dial is useful. Start lower than feels comfortable and move up only where your evals say it earns the tokens.
Fast mode, and when 2x is worth it
Fast mode runs around 2.5 times default speed at twice the base price, available on the Claude Platform and through usage credits in Claude Code.
Worth it:
Anything a human is sitting and waiting for
Interactive pair-programming loops where latency breaks flow
Client demos and live sessions
User-facing features where response time is part of the product
Not worth it:
Background agents and scheduled jobs
Batch processing
Anything where the result lands in a queue for review
Speed is a user experience purchase, not a capability purchase. Buy it where a person feels it.
Migration notes from Opus 4.8
Same price and a drop-in model string make this the easiest Opus migration in a while, but a few things in your setup are now mistuned.
Revisit your turn limits and timeouts. If Opus 5 finishes in a third fewer turns, caps you set to stop 4.8 from spiralling are now just arbitrary ceilings. Some will still be correct. Check rather than assume.
Strip your babysitting scaffolding. Most production prompts written for earlier models are full of instructions like "double check your work before responding" and "verify each step". Opus 5 does more of that natively. Leftover scaffolding wastes tokens and occasionally fights the model's own process. Test with it removed.
Restructure agents that swap tools. Mid-conversation tool changes no longer invalidate the prompt cache. If you were starting fresh conversations purely to change the available tool set, that workaround is now costing you cache hits for nothing.
Turn on automatic fallbacks if you were getting blocked. With fallbacks enabled, requests flagged by safety classifiers route to another model rather than failing. That converts a hard error path into a soft one, which matters if you are shipping to end users who do not care why the request failed. Know which model you are falling back to and whether the quality difference is acceptable for that request type.
Log the effort level with every run. If you are not recording which setting produced which result, you cannot optimize the dial. Effort level belongs in your traces next to token counts and latency.
Switch your cost dashboard to cost per task. Token spend alone will now mislead you, because the whole point of this release is that the relationship between tokens and outcomes moved.
Build your own eval before you trust anyone's benchmarks
Including these ones. Anthropic published them, they are self-reported, and the Frontier-Bench footnote itself notes that Opus 4.8 served as the fallback on safety classifier refusals for both Opus 5 and Fable 5.
A usable eval is smaller than people think. Twenty to thirty tasks pulled from work you have actually done, with a pass or fail you can judge without debate. Run them across two or three effort levels. Record pass rate, turns, tokens, and wall clock.
That gives you your own cost-per-task curve for your own workloads, which is the only number that should drive your defaults. It takes an afternoon and it outlives every model release.
What this means depending on what you run
For agencies: the effort dial is a margin lever, not just a config. If you price AI-assisted work per outcome, you now control input cost per deliverable without changing the deliverable. The teams that will make money here are the ones who measure their own cost per task and tune, not the ones who set everything to max and eat the difference.
For solo founders and small SaaS teams: this is the release where background agents get less scary. The blocker was never capability, it was supervision cost. A model that catches its own mistakes and pushes back on bad instructions needs less of your attention per unit of work, and attention is the scarcest thing a solo operation has.
For businesses evaluating AI spend: the toggle is a procurement-friendly story. Predictable model price, controllable per-task cost, no data retention requirement on general access. The catch is that effort level becomes a configuration decision someone owns, and a wrong default multiplied across a company gets expensive quietly.
The caveats worth naming
Fast mode is not free speed. It is a 2x price multiplier and should be treated as one.
Consumer plan limits still bite. A better default model on Max does not fix session and weekly usage ceilings, and community reaction to this launch reflected that.
Some specialist benchmarks still favor other models, including in Anthropic's own published tables. Frontier state of the art is not the same as best at your specific thing.
Cyber restrictions remain real. Opus 5 can find vulnerabilities in source code, but binary-based vulnerability scanning, penetration testing, and exploit generation are blocked. The Cyber Verification Program exists for enterprises and researchers with legitimate need, and members get access to a less restricted version.
Model churn is now the baseline condition. Four releases in under two months. Anything you hardcode to one model name is technical debt with a short fuse. Build for swappability and keep your evals portable.
Takeaways
Opus 5 costs what Opus 4.8 cost. The improvement arrives as capability per dollar, not as a price cut.
Cost per completed task is the metric. Token price is a distraction, especially in agentic work.
The effort dial replaces a lot of model-routing logic. One model, one prompt style, a reasoning budget you set per call.
The high floor is what makes the dial practical. Low effort is still competitive, so tuning down is a real option.
Self-verification is the reliability story. Fewer compounding errors means fewer human review gates, and review gates are the expensive part.
Judgment shows up repeatedly in early reports: pushing back, checking assumptions, refusing to declare victory early.
Migrate the config, not just the model string. Turn limits, prompt scaffolding, cache strategy, and cost dashboards all need a second look.
Run your own thirty-task eval. It beats every published benchmark for your specific decisions.
FAQ
How much does Claude Opus 5 cost?
Five dollars per million input tokens and twenty-five dollars per million output tokens, identical to Opus 4.8. Fast mode is available at twice the base rate.
Is Opus 5 better than Fable 5?
Not across the board. Fable 5 remains the more capable frontier model, and Mythos 5 leads on cybersecurity and long-horizon biology research. What Opus 5 does is get close enough on coding and knowledge work benchmarks at roughly half the cost per task, without Fable's 30-day data retention policy and with classifiers that intervene far less often.
What is the effort setting and how do I choose one?
It controls how much reasoning the model spends on a task, from low through max. Use low or medium for classification, extraction, summarization, and routine edits. Use high for feature work and defined multi-step tool use. Reserve xhigh and max for architecture, hard debugging, and novel problems. Then verify against your own tasks, because the right default is workload-specific.
Is Fast mode worth twice the price?
Only when a human is waiting. Interactive coding sessions, live demos, and user-facing features benefit. Background agents, batch jobs, and anything headed for a review queue do not.
Do I need to change my prompts when migrating from Opus 4.8?
The model string swaps cleanly, but a few things are worth revisiting. Remove instructions telling the model to verify its own work, since it does more of that natively. Recheck turn limits and timeouts, because it tends to finish in fewer turns. And start logging effort level alongside tokens so you can tune.
What can Opus 5 not do on cybersecurity tasks?
It can find vulnerabilities in source code. It blocks binary-based vulnerability scanning, penetration testing, and exploit generation. Enterprises and researchers in the Cyber Verification Program have access to a version with fewer restrictions.
Does Anthropic retain my data with Opus 5?
Consistent with previous Opus models, Opus 5 has no data retention requirement for general access. That is one of the practical differences from Fable 5 and Mythos 5, which carry a 30-day retention policy.
What are automatic fallbacks and should I enable them?
A new API beta that routes requests flagged by safety classifiers to another model instead of blocking them. In Claude.ai, Claude Code, and Claude Cowork, flagged requests fall back to Opus 4.8 by default. Enable it if a hard refusal would break your user experience, and confirm the fallback model's quality is acceptable for the request types that get flagged.
Should I switch immediately?
For most coding and knowledge work, the same price for a materially better model makes this an easy yes. Build a thirty-task eval from your real workload first, run it at two or three effort levels, and set your defaults from your own numbers rather than anyone's launch charts.