Claude Opus 5.0 Complete Guide: Model Specifications, API Notes, and Claude Code Operations

Hello!

On July 24, 2026, Anthropic released Claude Opus 5.

That is a generational change just two months after Opus 4.8 (released May 28). The pace here keeps accelerating.

Now, this blog has followed the Opus line through the Claude Opus 4.7 Complete Guide、Claude Opus 4.8 Complete Guide — but this Opus 5 is fundamentally different in structure from those two updates within 4.x.

What is different? First of all, Opus 5 is not the top-of-the-line model。

Anthropic's lineup already has, at the top, the June 9, 2026 release Claude Fable 5, and Opus 5 was slotted in below it and above Sonnet 5 — an upper-middle position.

The era when the name Opus meant "top tier" ended with the arrival of Fable 5.

On top of that, Anthropic positions Opus 5 as "a model that approaches Fable 5's frontier-class intelligence at half the price" — and has even published benchmark scores where it beats Fable 5.

Pricing is unchanged from Opus 4.8: $5 input / $25 output.

In other words, this is a character no previous Opus has had: not the top model, but the practical workhorse.

And remember: Fable 5 went through the turmoil of being suspended on June 12 by order of the U.S. government and returning on July 1 (we covered the full story in The Fable 5 / Mythos 5 Suspension: What Happened).

The "safety classifiers" at the center of that incident have, in fact, been added to Opus 5 as well。

Something Opus 4.8 did not have is now on board — a change you absolutely need to know about when migrating (covered in detail in Chapter 7).

This is a long piece, so there is no need to read it start to finish. Skim the chapters that interest you. Sources are collected at the end.

The intended readers: engineers considering a migration from Opus 4.8, tech leads deciding between Fable 5 and Opus 5, lead engineers running Claude Code across a team, and anyone optimizing API costs.

Table of Contents

Part 1 What Claude Opus 5 Is

• 1. Where Opus 5 sits in the Claude 5 family
• 2. Claude Opus 5 core specifications
• 3. What "beating Fable 5" actually means in the benchmarks
• 4. Two breaking API changes around thinking
• 5. Migration checklist (from the official guide)
• 6. New and related features

Part 2 Notes for API Use

• 7. Safety classifiers that 4.8 did not have
• 8. Choosing effort levels
• 9. Task budgets (beta): giving agents a sense of budget
• 10. Prompting to get the most out of Opus 5

Part 3 Opus 5 in Claude Code

• 11. Prerequisites for using Opus 5 in Claude Code
• 12. Watch the carry-over behavior of Claude Code's effort setting
• 13. What changed in Fast mode
• 14. What happens when you get flagged: the automatic model fallback
• 15. The 1M context and opusplan
• 16. A rhythm for day-to-day operation

The updates from 4.8, at a glance

From Opus 4.8, which we covered last time, the main changes in Opus 5 are the following.

Details come in each chapter; first, the overall picture.

Not incremental — a "step-change"

The official documentation itself describes the gain over 4.8 as "a step-change, not incremental." The biggest gains are in deep reasoning, long-horizon agentic tasks, and test-time compute scaling (Chapter 3).

thinking is ON by default

On 4.8, requests without the thinking field ran without thinking; on Opus 5, the same requests run with thinking.max_tokens settings need revisiting (Chapter 4).

Disabling thinking is possible only at effort `high` or below (breaking change)

thinking: {type: "disabled"} combined with effort xhigh/max returns a 400 error (Chapter 4).

The recommended starting effort has changed

The API default remains high, unchanged. What changed is the recommended starting point: from 4.7/4.8's "start coding with xhigh" to Opus 5's "start with high and step up to xhigh only for demanding work" — with active use of low/medium now spelled out explicitly (Chapter 8).

No Web Fetch server tool

The Web Fetch tool available on Opus 4.8 is not available on Opus 5 (it is separate from web search). API integrations using it need an alternative design (Chapter 5).

Safety classifiers on board

Model-specific cyber and biology classifiers absent from 4.8 are present on Opus 5. Interventions are said to be about 85% less frequent than Fable 5's, but for 4.8 migrants this is a new constraint (Chapter 7).

Knowledge cutoff of May 2026

Newer than Fable 5 and Sonnet 5 (both January 2026) — the freshest knowledge in the current lineup (Chapter 2).

New and related features

Mid-conversation tool changes (beta), the fallbacks parameter's "default" mode (beta), Task budgets (beta), and the minimum cacheable length dropping to 512 tokens, among others (Chapter 6, Chapter 7, Chapter 9).

Pricing unchanged

$5 input / $25 output, as before. Fast mode is also $10/$50, the same as Opus 4.8 (Chapter 2).

No Priority Tier

Priority Tier, usable with Opus 4.8, is not supported on Opus 5. Organizations with commitments should watch their capacity planning (Chapter 5).

One more note: code written for Opus 4.8 will not necessarily run with just a model ID swap。

With two behavior changes — the thinking default and the restriction on disabling thinking — we recommend running through the migration checklist (Chapter 5) once.

Part 1: What Claude Opus 5 Is

1. Where Opus 5 sits in the Claude 5 family

First, a recap of how Anthropic's lineup changed over the roughly two months from June 2026.

In that period, Anthropic shipped four models in rapid succession.

• June 9 Claude Fable 5 / Claude Mythos 5 released (the newly created top "Mythos class." Benchmark deep-dive)
• June 12 Both models suspended worldwide under a U.S. Commerce Department export-control directive (full story)
• June 26 Mythos 5 partially restored, limited to vetted U.S. organizations
• June 30 Export restrictions lifted. Same day, Claude Sonnet 5 released (introductory pricing $2/$10 through August 31, 2026; $3/$15 thereafter)
• July 1 Fable 5 fully restored on claude.ai, Claude Code, and elsewhere
• July 24 Claude Opus 5 released. Same day, Opus 4.7's Fast mode discontinued

As a result, the current lineup is a four-tier structure, from the top: Fable 5 ($10/$50), Opus 5 ($5/$25), Sonnet 5 ($3/$15), and Haiku 4.5 ($1/$5).

Opus 5's official positioning is "for complex agentic coding and enterprise work."

Anthropic made it the new default model for Claude Max and the top model available on the Pro plan.

The arrangement Anthropic itself recommends: Opus 5 as the daily mainstay, Fable 5 only for truly frontier work.

(Source: Anthropic's official model list. Prices and cutoffs as of July 27, 2026.)

Easily overlooked but important is the knowledge cutoff.

Opus 5's reliable knowledge cutoff is May 2026,
four months newer than Fable 5 and Sonnet 5's January 2026 — the newest in the current lineup.

When working with newer libraries and APIs, it may hold fresher knowledge than its "superior," Fable 5.

A newer cutoff does not guarantee accuracy on any specific detail, though. As noted below, Opus 5 lacks the Web Fetch server tool (Chapter 5), so supplement fresh information via the web search tool or your own retrieval, and keep cross-checking against official documentation.

For a comparison of LLM vendors' pricing, see our LLM API price roundup; on Fable 5's cost problem, see Fable 5: Costs and Outlook as well.

User complaints that Fable 5 "burns tokens aggressively" have been widely reported; per Fortune, Opus 5 leading with token efficiency is in part an answer to that complaint.

OpenAI's GPT-5.6, released July 9, also markets economical token consumption — the axis of competition is shifting from "intelligence" to "the balance of intelligence and cost."

2. Claude Opus 5 core specifications

Much carries over from 4.8, but two points signal a generational shift: "1M is the default and the maximum, with no smaller-context variant at all," and "thinking is ON by default."

Note that claude-opus-5 is a fixed snapshot, not an evergreen pointer (the dateless-ID scheme in place since the Claude 4.6 generation).

3. What "beating Fable 5" actually means in the benchmarks

Anthropic's launch announcement claims Opus 5 beats Fable 5 on several benchmarks.

In this blog's usual style, we will go through them while distinguishing who measured each number.

Frontier-Bench v0.1 (run internally by Anthropic)

In the System Card's evaluation summary table, Opus 5 tops the compared models at 43.3%, well above Fable 5's 33.7% and Opus 4.8's 18.7% — more than double 4.8. Cost per task is also said to be lower.

The official launch chart also shows multiple values by effort level, so 43.3% is not necessarily Opus 5's per-effort peak.

ARC-AGI 3 (verified external evaluation by ARC Prize)

Opus 5 scored, at high effort, 30.16% (rounded to 30.2% at publication) — about 3.9 times the 7.8% of the runner-up, GPT-5.6 Sol (Anthropic's announcement modestly calls it "3×").

Opus 4.8 was at 1.5% — essentially zero. Note that because the evaluation window was short, Opus 5's max has not been evaluated on ARC-AGI 3.

CursorBench 3.2 (external evaluation by Cursor)

max effort: Opus 5 at 70.0%, Fable 5 at 70.5% — a 0.5-point gap. Average cost per task is $8.23 for Opus 5 versus $17.32 for Fable 5, more than double.

Cursor itself notes, however, that small score differences may not be statistically significant.

OSWorld 2.0 (computer use; Anthropic evaluation, listed in the System Card)

70.57% (mean first-attempt success over 5 runs), up sharply from Opus 4.8's 55.7%. It is said to beat Fable 5's best result at roughly one-third the cost.

Zapier AutomationBench (results from an external evaluation provider)

A pass rate about 1.5× the runner-up model's (at comparable cost per task).

Life sciences (Anthropic's own evaluations)

+10.2 points over Opus 4.8 on organic chemistry tasks and +7.7 on protein prediction. Anthropic is pitching Opus 5 as "the most capable generally available model for scientific research."

Two caveats.

First, the numbers fall into three kinds of attribution: (a) evaluations Anthropic ran itself (Frontier-Bench, OSWorld, life sciences), (b) external evaluations run and published by benchmark providers (ARC Prize, Cursor, Zapier), and (c) press coverage of those.

(b) is not self-reporting, but neither is it independent replication by a third-party community.

Second, "beating Fable 5" does not apply across all benchmarks.

Anthropic itself continues to recommend Fable 5 for the hardest long-horizon autonomous tasks, and states plainly that in cybersecurity exploit capability Opus 5 "does not reach Mythos 5."

How it fares in blind voting (Arena-style) and in our LLM rankings will be settled once independent evaluations are in.

TechCrunch highlights the trait Anthropic emphasized: Opus 5 "verifies its own work and iterates carefully until it succeeds."

No premature victory declarations; verify, then fix. This is the change that symbolizes Opus 5's character — two sides of the same coin as the prompting changes described later (removing re-verification instructions that duplicate its self-verification; Chapter 5 and Chapter 10).

4. Two breaking API changes around thinking

Opus 4.7 to 4.8 was a "swap the model ID and go" migration.

This time there are two breaking changes in API parameters. On top of that, on the feature side, there are the effective incompatibilities noted above — no Web Fetch and no Priority Tier (covered in Chapter 5's checklist).

Change 1: thinking is now ON by default

On Opus 4.8, requests without the thinking field ran without thinking.

On Opus 5, the same requests run with thinking (adaptive thinking: the model decides, turn by turn, whether and how deeply to think).

Nothing changed on the wire — explicitly sending thinking: {type: "adaptive"} behaves the same.

The practical caution concerns max_tokens.

max_tokens is a hard limit on the combined total of thinking and visible text. Move a workload that ran thinking-free on 4.8 over as-is, and the added thinking tokens can truncate the visible text mid-response (stop_reason: "max_tokens").

Revisit anywhere you set a smallish max_tokens on the assumption of no thinking.

Change 2: disabling thinking now works only at effort `high` or below

If you want the old behavior, you can pass thinking: {type: "disabled"}, but Opus 5 accepts it only when the effort level is high or below.

thinking: {type: "disabled"} combined with effort xhigh/max returns a 400 error.

This combination was accepted on 4.8, so audit your requests for it before migrating.

The check runs on every single request, so "the first half of the conversation was fine, then a 400 the moment we raised effort mid-conversation" can happen.

# Passes on 4.8 but returns a 400 error on Opus 5
client.messages.create(
    model="claude-opus-5",
    max_tokens=16000,
    thinking={"type": "disabled"},
    output_config={"effort": "xhigh"},   # disabled cannot be combined with xhigh
    messages=[{"role": "user", "content": "..."}],
)

# Fix A: drop the thinking field (back to the default, thinking on)
client.messages.create(
    model="claude-opus-5",
    max_tokens=16000,
    output_config={"effort": "xhigh"},   # thinking is ON by default
    messages=[{"role": "user", "content": "..."}],
)

# Fix B: keep thinking disabled and lower effort to high or below
client.messages.create(
    model="claude-opus-5",
    max_tokens=16000,
    thinking={"type": "disabled"},
    output_config={"effort": "high"},    # high / medium / low are acceptable
    messages=[{"role": "user", "content": "..."}],
)

The official documentation also spells out side effects of disabling thinking.

Without thinking, Opus 5 can occasionally write a tool call as body text instead of a tool_use block. The call is never executed, and in agent loops the leaked text remains in the conversation history and affects subsequent turns.

<thinking> and similar internal XML tags can also end up mixed into visible output.

The official recommendation: keep thinking enabled and control cost with lower effort.

For most tasks, "thinking on at low effort" is said to beat "thinking off" at comparable cost. Prompt-level mitigations for integrations that truly must disable it are covered in Chapter 10.

5. Migration checklist (from the official guide)

The official migration guide's checklist, reordered for practical workflow.

1. Update the model name from claude-opus-4-8 to claude-opus-5 in your code
2. Audit requests that use the Web Fetch server tool. It is unavailable on Opus 5, so design alternatives: the web search tool, client-side fetching, or routing just those requests to another model
3. thinking-less workloads: audit anything you ran without the field (it runs with thinking on Opus 5). Either revisit max_tokens, or keep the old behavior with thinking: {type: "disabled"} plus effort high or below
4. thinking: {type: "disabled"} with effort xhigh/max: fix requests combining them (they will return 400)
5. Re-evaluate effort from a blank slate. Do not carry settings over from the old model; re-run an effort sweep on your own evals.low/medium are worth trying aggressively as cost/latency controls, and max is worth trying on capability-first tasks.xhigh/max runs should start with max_tokens at 64k or higher
6. Check prompts near the cache boundary (cacheable from 512 tokens; 4.8 required 1,024)
7. stop_reason: "refusal" handling should be reviewed; consider adopting fallbacks: "default" (beta) (Chapter 7)
8. Organizations with Priority Tier commitments should plan capacity separately. Priority Tier is unsupported on Opus 5 and remains available on Opus 4.8
9. For agentic workloads, consider Task budgets (beta) and mid-conversation tool changes (beta) (Chapter 9 and Chapter 6)
10. Re-tune prompts for length and verbosity. Opus 5 tends toward longer visible responses and longer deliverable documents, and lowering effort does not shorten them (Chapter 10)
11. Remove re-verification instructions written for older models ("add a final verification step," "double-check," "verify with a subagent," etc.). Opus 5 self-verifies unprompted, so leaving them in wastes tokens on redundant verification. Do not remove project-specific acceptance criteria such as running designated tests, lint, and type checks (Chapter 10)
12. Re-baseline cost and latency on your own workloads

Of these, items 5, 10, and 11 are of the "won't break, but becomes suboptimal" kind — skipping them causes no errors.

That said, item 11 (removing redundant re-verification instructions) is one of the few the official guide flatly describes as "token savings with no quality loss," so it deserves higher priority.

6. New and related features

A roundup of the new and related features available with Opus 5.

This includes not only features added alongside Opus 5 but also existing features that now support it. Details in the relevant chapters.

Mid-conversation tool changes is an unglamorous change, but one that matters to agent developers.

Previously, changing the tool list invalidated the cached prefix, so the standard practice was to hand over every tool at the start of the session.

With the beta header mid-conversation-tool-changes-2026-07-01, you can progressively expose or retire tools as the task advances while keeping cache hits for earlier turns.

It is easiest understood as the sequel to the mid-conversation system messages introduced in 4.8.

Part 2: Notes for API Use

7. Safety classifiers that 4.8 did not have

First, pin down the key fact.

Model-specific safety classifiers of the same family as Fable 5's (cybersecurity and biology) are now on Opus 5 as well.

And Opus 4.8 does not carry these classifiers。

The only models the official documentation describes as classifier-equipped are Fable 5 and Opus 5. The very fact that flagged requests are routed to Opus 4.8 corroborates that 4.8 lacks the same classifiers.

To be fair, the 4.8 era also saw false positives from the platform-side Usage Policy safeguards.Our June article covered exactly that — a different layer from the model-specific classifiers.

So for users migrating from 4.8, this is a newly added constraint.

The accurate reading is not "it got safer" but "a classifier has been attached — though it intervenes far less often than Fable 5's."

That said, in the context of having just lived through work stopping during the Fable 5 suspension, the differences from Fable 5 carry practical meaning too. Four points.

(1) Alignment itself is the best in the line's history

In Anthropic's automated behavioral audit, Opus 5's misaligned-behavior score is 2.3 (lower is better).

That is the best among recent models including Opus 4.8, Sonnet 5, and Fable 5; Anthropic calls it "the most aligned Opus, and the hardest to steer toward misuse" (bear in mind this is self-evaluation).

(2) Classifier interventions about 85% fewer than Fable 5's (not zero)

Because of its high cybersecurity capability, Fable 5 runs strong safety classifiers at all times, and there were complaints that this obstructed even legitimate security work.

For Opus 5, Anthropic says it deliberately capped raw exploit capability below Mythos 5 and reduced classifier intervention frequency to "about 85% less than Fable 5."

Put the other way around: model-classifier interventions that never happened on 4.8 will happen at some frequency on Opus 5.

The line is drawn so that vulnerability discovery against source code is allowed, while vulnerability scanning against binaries and exploit generation are blocked.

For Project Glasswing — the special defensive-security framework under which Mythos 5 is offered — see our Glasswing explainer.

Companies and researchers already in the Cyber Verification Program (CVP) get immediate access to Opus 5 with relaxed restrictions.

(3) Automatic fallback on flags (API side)

When the classifier flags a request, there is now an option to route it automatically to another model instead of ending in an error.

fallbacks parameter's new "default" mode (fallbacks: "default") automatically selects the Anthropic-recommended fallback model per refusal category. Opus 5's cyber refusals, for example, flow to Opus 4.8.

The existing explicit model-list form remains available, and the "default" mode requires the server-side-fallback-2026-07-01 beta header.

(4) Data retention differences (confirmed in official documentation)

Anthropic's official "API and data retention" documentation names Fable 5 and Mythos 5 as "Covered Models" subject to mandatory 30-day data retention; those two cannot be used under ZDR (zero data retention). They do not appear in Claude Code's model picker in ZDR environments either.

Opus 5 is not among the Covered Models, and the launch announcement imposes no model-specific data-retention requirement on generally accessible Opus 5.

Organizations with ZDR agreements on the Claude API can therefore use Opus 5 within the scope of ZDR-eligible features.

Note that ZDR is an organization-level agreement; consumer plans like Pro/Max are not themselves covered. Features such as the Batch API and code execution sit outside ZDR, so check your contract terms and per-feature ZDR eligibility for actual coverage.

In sum, this is a change whose assessment depends on where you stand.

Seen from 4.8, adding the classifiers is purely an added constraint. Workloads touching security or biology may see processing that passed on 4.8 get stopped (staying on 4.8 is an option; Chapter 16).

Seen from Fable 5, though, interventions are about 85% fewer, there is no model-specific 30-day retention requirement, and cyber refusals get automatic fallback — clearly easier to live with.

Caveats remain: the automatic fallback is opt-in on the API, and Opus 5's biology category has no fallback destination (Chapter 14). Nor does any of this guarantee against future regulatory action.

8. Choosing effort levels

Since Opus 4.7, effort has remained the single most important lever for getting the most out of Opus.

With Opus 5, the wording of the official guide's recommendation changed.

To clear up a common misreading first: the API default has stayed high ever since 4.7. What changed is the description of the recommended starting point.

The 4.7/4.8 official guides said plainly: "Start with xhigh for coding and agentic use cases."

The Opus 5 guide instead reads: "Start with high, the default, and adjust based on evals; step up to xhigh for demanding coding and agentic work."

In table form.

The background to the change is the improved efficiency of Opus 5's lower effort levels.

The official guide says "low and medium deliver strong quality at a small fraction of the tokens and latency of the upper settings," and goes as far as "use low/medium liberally as the primary control over cost and response time."

Carry the 4.8-era habit of "default to xhigh" over unconditionally, and you can end up doubling tokens for a barely measurable quality gain.

The official recommendation is unambiguous: do not carry effort settings over from the old model; re-run sweeps on your own evals.

At the top end, meanwhile, max is more worth trying than in the 4.8 era, because Opus 5 converts additional effort into results (test-time compute scaling) better than any previous Opus.

The CursorBench run that came within 0.5 points of Fable 5's peak was also at max effort.

xhigh/max runs need headroom for thinking and tool calls, so start max_tokens at 64k or higher and tune from there.

Two effort-specific cautions.

effort does not control visible response length

Lowering effort on Opus 5 reduces thinking, but does not reliably shorten user-facing responses. If you want shorter responses, say so in the prompt (Chapter 10).

do not change effort mid-conversation

effort affects the rendered prompt, so changing the value between requests invalidates the prompt cache for the preceding prefix. In long cache-dependent sessions, fix the value you chose at the start.

Also, the restriction that thinking: {type: "disabled"} can only be combined with high or below (Chapter 4) affects effort selection too.

The configuration "thinking off but effort up" simply cannot be built on Opus 5.

9. Task budgets (beta): giving agents a sense of budget

Among the beta features usable with Opus 5, the most interesting one for agent-infrastructure developers is Task budgets.

The beta header is task-budgets-2026-03-13. Supported on Opus 5 / Fable 5 / Mythos 5 / Opus 4.8 / 4.7; Sonnet 5 is not supported. It is not an Opus 5-exclusive new feature but an existing beta gaining Opus 5 support.

output_config.task_budget given a {type: "tokens", total: N} conveys to the model a token budget for the entire agentic loop — thinking, tool calls, tool results, and output included.

Watching a server-injected countdown, the model prioritizes work against the remaining budget and lands gracefully before it runs out — summarizing findings, reporting progress, and so on.

with client.beta.messages.stream(
    model="claude-opus-5",
    max_tokens=128000,
    output_config={
        "effort": "high",
        "task_budget": {"type": "tokens", "total": 64000},
    },
    messages=[{"role": "user", "content": "Review the codebase and propose a refactor plan."}],
    betas=["task-budgets-2026-03-13"],
) as stream:
    response = stream.get_final_message()

Let's keep the concepts straight.

Where effort controls the depth of reasoning at each step, task_budget controls the amount of work across the whole loop.

Effort for depth, task budget for volume, and the per-request hard cap of max_tokens — a three-layer structure.

Four operational cautions.

The budget is advisory, not enforced

In the middle of work where interruption would be more destructive, it can overrun. Hard caps still go through max_tokens.

The minimum is 20,000 tokens

Anything below returns a 400 error.

Budgets that are too small trigger refusal-like behavior

Hand a 20k-token budget to an hours-scale task and the model may decline the task outright, over-trim scope, or wrap up early.

If you see mysterious refusals or early exits after setting a budget, raise the budget before suspecting any other parameter.

Only the model sees the countdown

There is no remaining-budget field in API responses.

Decrementing remaining client-side every turn breaks the cache, and the double counting makes the budget appear to shrink faster than reality — a cause of premature wrap-ups.

The basic pattern: set total once on the first request and leave the rest to the server.remaining is used only when compaction (context compression) rewrites the history and you need to carry over the tokens already consumed.

The official recommendation on setting budgets: do not guess.

First run representative tasks without task_budget, measure the distribution of loop-wide usage.output_tokens and tool-result tokens, then start around p99 and tune.

Note that Task budgets are not available in Claude Code / Cowork. This is a feature for agent platforms calling the Messages API directly (Claude Code's workflow feature has its own similar budget mechanism).

10. Prompting to get the most out of Opus 5

Opus 5 runs well as-is even on prompts written for 4.8.

But the official prompting guide names five behaviors that "tend to need adjustment." All are cases where the model now does things on its own, making legacy instructions excessive.

(1) Responses and deliverables got longer

Both conversational responses and reports or Markdown documents written to disk tend to run longer than 4.8's.

As noted, lowering effort does not shorten them; state it in the prompt.

Keep responses focused, brief, and concise. Keep disclaimers and caveats short, and spend most of the response on the main answer. When asked to explain something, give a high-level summary unless an in-depth explanation is specifically requested.

In long system prompts, layering a short reminder near the end (something like <tone_preference>Keep outputs reasonably concise.</tone_preference>) is said to work.

For document length, add a calibration instruction: cover the substance, and do not pad with filler sections, redundant summaries, or boilerplate.

(2) More progress narration

During agentic work it actively announces what it is about to do, and output per message runs longer.

Specifying frequency and format explicitly works well; the official example is this.

Before your first tool call, say in one sentence what you're about to do. While working, give a brief update only when you find something important or change direction. When you finish, lead with the outcome: your first sentence should answer "what happened" or "what did you find," with supporting detail after it for readers who want it.

Conversely, if you want more narration or a different style, showing positive examples of the desired form beats prohibitions.

(3) It self-verifies and self-corrects on its own

This is Opus 5's biggest character change.

The official recommendation is to delete re-verification instructions that duplicate the model's self-verification — "add a final verification step," "double-check," "verify with a subagent," and the like.

They overlap with the model's own verification behavior, producing over-verification: added cost with no quality gain.

But the only safe deletions are these duplicated instructions.

Project-specific acceptance criteria — "run the designated test suite after changes," "pass lint and type checks" — are completion conditions, not duplicated self-checks. Keep them.

It has also become more willing to voice corrections to its own earlier statements. For user-facing products, the guide shows a narrowing instruction: correct only errors that change the user's code, conclusions, or decisions concisely, and fix inconsequential misstatements silently.

(4) It tends to widen task scope

It may add steps you did not ask for, or reshape the task based on its own judgment of how things "really ought to be."

For narrow tasks, bound the scope explicitly.

Deliver what was asked, at the scope intended. Make routine judgment calls yourself, and check in only when different readings of the request would lead to materially different work. If the request seems mistaken or a better approach exists, say so in a sentence and continue with the task as asked rather than quietly narrowing, widening, or transforming it.

(5) More delegation to subagents

On multi-agent platforms, it spawns subagents more aggressively than 4.8.

A strength for genuinely independent, large work; for small tasks it multiplies cost and time. Recommended: explicit delegation criteria, or a deterministic cap on spawn count.

The official guide includes example lines like "do not delegate work that finishes in a few tool calls" and "do not use subagents to verify your own work."

Amusingly, the 4.8 prompting guide said the exact opposite, with examples nudging toward more subagents.

Default behavior swings like a pendulum between generations, so harness-side steering prompts need review every generation.

Two more strengths deserve mention.

Code review

Opus 5 is described as "finding real bugs at a high rate per pass, with the additional findings mostly non-spurious."

And accuracy holds even at low effort, enabling a two-stage setup: a fast pass at review time, a more thorough pass later.

As in the 4.8 era, an instruction like "report high-severity only" is obeyed literally and reduces reporting — so the standard practice remains: have it report everything at the discovery stage, and filter in a separate pass.

Vision (image understanding)

Understanding of charts, documents, and figures — and visual reproduction of UI and front-end work — has improved.

We recommend re-validating image workarounds added for older models.

Giving it tools to iteratively analyze, crop, and inspect images is said to be more cost-effective than piling on thinking.

Part 3: Opus 5 in Claude Code

11. Prerequisites for using Opus 5 in Claude Code

If you have never used Claude Code, start with our Claude Code primer (CLI and web).

Here we cover the operational prerequisites.

Version

Opus 5 requires Claude Code v2.1.219 or later (Sonnet 5: v2.1.197+; Opus 4.8: v2.1.154+).claude update to update.

Alias resolution

opusAlias resolution has advanced considerably since the 4.8 era.

Not only on the Anthropic API but also on Claude Platform on AWS, Amazon Bedrock, and Google Cloud's Agent Platform, opus resolves to Opus 5 (in the 4.8 era this varied by provider).

The exception is Microsoft Foundry, where opus remains Opus 4.6. On Foundry, use the full model name or ANTHROPIC_DEFAULT_OPUS_MODEL.

The `best` alias

An alias that resolves to Fable 5 if your organization has access, and otherwise to the latest Opus: best is available.fableDirect alias specification also works.

default (when no model is specified) resolves as follows.

Note that the Pro plan's default is now Sonnet 5.

Fable 5 is never the default for any account type (/model fable or similar explicit selection is required).

To pin a version, the standard practice is unchanged: use the full model name (claude-opus-5) or the environment variable (ANTHROPIC_DEFAULT_OPUS_MODEL) instead of an alias.

12. Watch the carry-over behavior of Claude Code's effort setting

The ways to control effort in Claude Code (/effort, --effort, CLAUDE_CODE_EFFORT_LEVEL, the settings-file effortLevel, and skill/subagent frontmatter) are the same as in the 4.8 era.

The thing to watch on Opus 5 is the carry-over behavior of the effort setting.

On Fable 5, Opus 4.8, and 4.7, the first use of a model force-applied the model default even if you had set a level on another model earlier (behavior we flagged in the 4.8 guide).

Opus 5 has no such hold: a previously set level carries over as-is.

So someone who lived at xhigh on 4.8 will, after switching to Opus 5, keep running at xhigh without noticing.

Chapter 8 explains that the official recommendation on Opus 5 is to start at high and adjust as needed — so right after switching, check the current value with /effort and re-choose deliberately.

You can also see the current effort in the session header's "with xxx effort" display.

Everything else is as before.

max is session-only (cannot be saved to settings files); ultracode is a Claude Code-side setting meaning "xhigh plus dynamic-workflow orchestration," not a model effort level; and for a one-off deep think you write ultrathink in the prompt — for these, see the 4.8 guide's Chapter 9 and Chapter 11.

Dynamic Workflows themselves work as detailed in the 4.8 guide; no mechanism changes in Opus 5.

13. What changed in Fast mode

/fast-toggled Fast mode (same model, same quality, up to 2.5× faster) covers Opus 5 by default from v2.1.219.

Pricing is $10 input / $50 output for both Opus 5 and Opus 4.8, keeping the level set by the 4.8-era price cut (flat across the whole 1M window).

The cautions carry over from the 4.8 era, with one new development.

• Opus 4.7's Fast mode was removed on July 24, 2026 (Opus 5 launch day). Moreover, Claude Code still treats 4.7 as Fast mode-eligible, so a 4.7 session with Fast mode left ON gets its requests rejected by the API (an error, not a fallback to standard speed). If you used Fast mode on 4.7, switch to Opus 5 or 4.8
• On subscription plans (Pro/Max/Team/Enterprise), it is usage-credits only. It is not part of the plan's normal allowance; Fast mode rates apply from the first token
• Turning it ON mid-conversation charges the uncached input rate once for the entire conversation context at that point, so if you use it, use it from session start
• Unavailable on Bedrock / Google Cloud / Foundry / Claude Platform on AWS. The VS Code extension does not support it (CLI only)

14. What happens when you get flagged: the automatic model fallback

Chapter 7 described the API-side fallbacks; separately from that, Claude Code has gained its own category-based automatic fallback (v2.1.219+).

Fable 5 and Opus 5 run with cybersecurity/biology safety classifiers, and when a request is flagged, the behavior is as follows.

As the table shows, Opus 4.8 serves as the fallback precisely because it lacks the classifiers.

After a fallback the session continues on that model, so to go back, use /model.

Three behaviors worth knowing operationally.

It can fire on the very first request of a session

The first request carries workspace context such as CLAUDE.md and git status.

In repositories with security or biology content, the classifier can react even when you asked for nothing unusual.

For isolation, claude --safe-mode (start with CLAUDE.md, skills, MCP, and hooks disabled) is useful.

If you don't want automatic switching, it is configurable

/config lets you turn off "switch models when a message is flagged."

When flagged, the session pauses and offers a choice: switch to the fallback model, or edit the prompt and retry on the current model.

In penetration testing, CTFs, and biology-adjacent codebases, frequent firing is "working as intended"

It does not mean your account has been flagged.

For organizations that need Fable-class capability in these domains, Anthropic's trusted access programs (CVP and others) are the indicated route.

Claude Code has also had confusing bugs around refusals in the past. Our guide to the "usage policy violation" message is collected in this article.

15. The 1M context and opusplan

Handling of the 1M context carries over the 4.8-era framework, and with "1M as default and maximum" on Opus 5 it got even simpler.

• On the Anthropic API, Opus 5 (and Opus 4.7+, Sonnet 5, Fable 5) always runs with the 1M window
• On Max / Team / Enterprise plans, Opus upgrades to 1M automatically with no extra configuration (included in the subscription; no premium billing beyond 200k)
• To disable it entirely, use CLAUDE_CODE_DISABLE_1M_CONTEXT=1

opusplan (an alias that switches automatically: plan mode on opus, execution on the sonnet alias) now means, on the Anthropic API, that Opus 5 plans and Sonnet 5 executes.

The actual combination follows the per-provider alias resolution explained in Chapter 11. Note that it becomes Opus 5 + Sonnet 4.6 on Claude Platform on AWS, Opus 5 + Sonnet 4.5 on Bedrock and Google Cloud Agent Platform, and Opus 4.6 + Sonnet 4.5 on Foundry.

Sonnet 5 bills itself as "the most agentic Sonnet," with execution capability approaching Opus class — and it is at introductory pricing of $2/$10 through August 31.

"Let Opus 5 think the design through, stream code generation to Sonnet 5" is an attractive setup cost-wise.

When the execution side is Sonnet 5 on the Anthropic API, Sonnet 5 always runs the 1M window, and auto-compaction kicks in around 967k tokens by default (per the Claude Code model-config docs; CLAUDE_CODE_AUTO_COMPACT_WINDOW changes the threshold).

16. A rhythm for day-to-day operation

Chapter 10's prompting changes apply directly to daily Claude Code operation.

Three operational patterns.

(1) Sort the verification instructions in CLAUDE.md

Split the verification-related instructions in your project's CLAUDE.md and skills into two kinds.

One: mandatory acceptance criteria (running the designated test suite, lint, type checks, the Definition of Done). Two: instructions that merely duplicate the model's self-checking ("double-check before completing," "verify once more at the end").

On Opus 5, only the latter should be deleted. The former are the project's completion conditions; keep them.

Opus 5 checks its own changes unprompted, so keeping the latter wastes tokens on over-verification.

The inversion also happens: it is precisely the situations where you don't want verification (fast draft-stage iteration, for example) that now require explicit instruction.

(2) Front-loading information into the first prompt is still paramount

The trait "hand over the complete task spec up front, then let it run" has strengthened further since 4.8.

Writing out intent, completion criteria, allowed scope, and constraints at the start remains as effective as ever.

Interim progress reporting, meanwhile, moved in the direction of more — so if you want a quiet run, put Chapter 10's narration-suppression prompt into CLAUDE.md.

(3) Redesign your model assignments

With Opus 5's arrival, the realistic division of labor inside Claude Code looks like this.

"Just use Fable 5 for everything" now pays off less often, both on cost (Fable 5: Costs and Outlook) and on classifier intervention frequency.

Reserving Fable 5 for the hardest problems and making Opus 5 the everyday ceiling is, we think, the right balance for now.

What we don't know yet / unconfirmed items

In the interest of honesty, here is what we have not been able to confirm at this point.

• The individual points in Frontier-Bench's by-effort chart (press readings put xhigh at about 44%) are shown only as an image; we could not confirm them in text form. The 43.3% in this article is the value listed in the System Card's evaluation summary table
• Independent evaluations are not yet in. We could not confirm Opus 5's position in Arena-style blind voting or on Artificial Analysis and the like as of writing (three days after release). We plan to check the answers in our August LLM rankings series
• Timelines for Opus 5 support in Priority Tier and Web Fetch have not been announced
• Fast mode, Task budgets, mid-conversation tool changes, and fallbacks are all beta / research preview, and specs and pricing may change

Summary

In one sentence: "Opus 5 is not the top model, yet it has become the practical workhorse." That is the essence of this release.

The practical takeaways condense to these five.

1. Migration is not "just swap the ID"

thinking is now ON by default, and disabling thinking is limited to effort high or below (a 400 error otherwise). Counting the Web Fetch and Priority Tier gaps as well, you need to revisit max_tokens and audit the affected requests.

2. Do not carry effort over — re-measure

The default is still high. The official starting point moved from "coding at xhigh" to "start at high, step up to xhigh only for demanding work," while the practical range of low/medium has widened. In Claude Code, note also that Opus 5 alone inherits your previous effort setting.

3. Delete duplicated re-verification instructions

Opus 5 self-verifies on its own. "Double-check" style instructions become a source of token waste through over-verification. Keep required tests, lint, and other acceptance criteria.

4. Understand the safety classifiers, then choose

Opus 5 carries model-specific classifiers (cyber, biology) that 4.8 lacks. For 4.8 migrants this is an added constraint, and staying on 4.8 remains an option for security workloads. Compared with Fable 5, interventions are 85% fewer, there is no 30-day retention requirement, and fallback exists — an easier landing spot for those moving off Fable 5.

5. Redesign the division of labor

Sonnet 5 for the everyday, Opus 5 as the mainstay (Max's default), Fable 5 for the hardest problems. The newest knowledge cutoff (May 2026) is Opus 5's quiet, exclusive advantage.

That Anthropic assembled this lineup just six weeks after the Fable 5 suspension is startling speed.

Once independent evaluations are in, we will revisit them in our regular rankings article.

See you next time!

Sources

The information in this article is based on official documentation, official announcements, and press coverage as of July 27, 2026.

Beta features and research previews may change; check each source for the latest.