Claude Opus 5.5 Explained, What Changed Since Opus 5

Analysis by the aitrendblend editorial team  ·  Practical AI tools and prompt engineering  ·  23 September 2026  ·  Reading time about 15 minutes

• Claude Opus 5.5
• Claude Fable 5.1
• Effort parameter
• Adaptive thinking
• Agentic coding
• API migration
• GPT-6 Sol

Why a point five release deserves attention

Anthropic released Opus 5 on 24 July 2026. We covered that launch in our breakdown of Opus 5 and how close it came to Fable 5, and the short version was that Opus 5 gave you most of Fable’s ability at half its token price. Two months later the same pattern repeats one rung higher. Opus 5.5 now reaches for Fable 5.1, the refreshed top model, while cutting Opus prices again.

That is an unusually fast cadence for a flagship tier. It also tells you where Anthropic thinks the money is. Opus has become the workhorse for long running agents, the kind that edit a repository for an hour or assemble a financial model across dozens of files. Those workloads are priced by the token and judged by whether they finish. Both of those levers moved in this release.

The official detail lives on the Anthropic announcement page for Claude Opus 5.5 and in the developer notes on what is new in Opus 5.5. What follows is our reading of both, with the parts that matter to people who actually pay the bill.

The price cut, and the bigger claim behind it

The headline figures are easy. Input falls from $5 to $4 per million tokens. Output falls from $25 to $20. Five minute cache writes cost $5 per million, one hour cache writes cost $8, and cache reads fall to $0.20, which is 60 percent below Opus 5. The Batch API keeps its 50 percent discount, putting batched Opus 5.5 at $2 in and $10 out.

Anthropic’s bolder line is that Opus 5.5 costs 40 percent less to run than Opus 5. A flat 20 percent price cut cannot produce that on its own. The rest has to come from the model using fewer tokens to reach the same result, and Anthropic says it matched Opus 5’s quality in about half the turns, time and output tokens on its internal tests.

Here is a simple way to see how those two effects stack. The cost of one agent task is roughly the sum of each token type multiplied by its price.

Take an illustrative task with 100,000 fresh input tokens and 20,000 output tokens, ignoring caching. On Opus 5 that costs \(0.1 \times 5 + 0.02 \times 25 = \$1.00\). The same token counts on Opus 5.5 cost \(0.1 \times 4 + 0.02 \times 20 = \$0.80\). Now suppose the new model reaches the same answer in half the output, 10,000 tokens. The bill drops to $0.60, which is exactly the 40 percent saving Anthropic advertises.

There is a catch hiding in the developer notes. At the same effort setting, Opus 5.5 produces more thinking tokens than Opus 5, especially at the xhigh and max levels. Anthropic offsets this by moving the default effort from high down to medium. So if you copy your old configuration and pin effort to high, you may pay for more reasoning than you did before. Re running an effort sweep on your own tasks is the only way to know where your sweet spot sits.

Fast mode is also available through the Claude API as a beta, priced at $8 input and $40 output per million tokens for roughly 2.5 times the speed. Separately, Anthropic says standard output is now more than 30 percent faster than Opus 5.

What the benchmarks say, and what they leave out

Anthropic published a comparison table with three columns, Opus 5.5, Fable 5.1 and Opus 5. We have reproduced it below. The effort settings vary by row, which matters when you compare it with anyone else’s numbers.

Where the gains are real and large

The terminal coding result stands out. A jump from 52.3 to 66.4 percent on Terminal-Bench 4.0 is fourteen points over Opus 5 and more than ten over Fable 5.1. Terminal tasks punish models that lose track of state across many commands, so a gain here usually shows up in real agent work rather than only on a leaderboard.

Terminal-Bench-Science is the other eye catching row. Opus 5 scored 29.0 percent. Opus 5.5 scores 58.7 percent, roughly double. That benchmark is at version 0.1, so treat it as an early signal, yet a doubling on multi step scientific research tasks is the kind of change researchers will want to test on their own pipelines. For those of us who run experiments on shared GPUs, a model that can plan and execute analysis scripts with less hand holding is worth a weekend of trials.

The business workflow number also moved a lot, from 26.9 to 40.0 percent on AutomationBench. That test comes from Zapier and covers workflows spread across dozens of tools. If your use case looks like glue work between SaaS products, this row is closer to your life than Humanity’s Last Exam.

Where the gap to Fable 5.1 is thin

On computer use, chart reading and Humanity’s Last Exam, Opus 5.5 leads Fable 5.1 by one or two points. Differences that small sit well inside the noise you would expect from a change of prompt or harness. The fair reading is parity, which is still remarkable for a model that costs less than half of Fable 5.1 per token. Fable 5.1 lists at $10 input and $50 output per million tokens.

It performs at the level of Claude Fable 5.1 on most work and costs 40% less to run than Opus 5.Anthropic, Claude Opus 5.5 announcement

Stories rather than scores

Anthropic also offered two anecdotes. One early tester completed a 680,000 line code migration in less than a day, work the company says would have taken an engineering team weeks. In another internal test, asked to cut load times across every page of a web app, Opus 5.5 succeeded 39 times out of 40. Neither comes with enough methodology to reproduce, so read them as illustrations of the target use case rather than evidence.

The list of launch partners gives a clearer hint about who this is for. Anthropic’s page quotes customers including GitHub, Stripe, Ramp, Spotify, Box, Hex, Lovable, Factory, Thomson Reuters Labs, LexisNexis, Deloitte and several trading firms. That is a mix of coding tools, fintech and professional services, the same buyers who were running Opus 5 at scale.

A model that writes more like a person

One of the less technical changes may be the one everyday users notice first. Anthropic says Opus 5.5 uses less jargon, follows writing instructions more closely, and puts the most important information at the start of a reply. An early tester quoted by the company said simply that it writes the way they do.

This is not a small distinction for anyone who has had to rewrite model output before sending it. A model that front loads the answer saves a reader time on every message. It also makes agent progress updates easier to skim, which matters when a person is supervising several long tasks at once. We explored why phrasing differences between models are so visible in our piece on prompts that expose the real gap between two models, and the same test prompts are a good way to judge this claim for yourself.

The API changes that will break code

Here is where it gets interesting for developers. Swapping the model string from claude-opus-5 to claude-opus-5-5 is not always enough. The migration notes list several changes that now return an HTTP 400 error.

Thinking is always on

Adaptive thinking cannot be disabled. A request that sets thinking to disabled, or that uses the older enabled mode with a fixed token budget, will fail. You control depth through the effort parameter instead, with levels low, medium, high, xhigh and max. If you had turned thinking off to save cost on simple classification calls, the replacement is low effort, and you should measure whether that still fits your latency budget.

No more forcing a tool

Setting tool choice to any, or naming one specific tool the model must call, is no longer supported. Only auto and none remain. Anthropic suggests strict tool use or structured outputs where you previously forced a tool to guarantee a JSON shape. Extraction pipelines that relied on a forced tool call are the most likely to break on day one.

Thinking blocks are now tied to the model and the conversation

Opus 5.5 can read thinking blocks produced by Opus 5 and earlier Opus, Sonnet and Haiku models. Only Fable 5.1 and Mythos 5.1 on the Claude API can read the thinking that Opus 5.5 produces. If you switch models in the middle of a conversation, blocks the new model cannot read are dropped silently. For accounts created on or after 31 August 2026, the API also checks that the system prompt, tools and earlier messages have not changed since a thinking block was produced.

That second rule is part of a feature Anthropic calls preserved thinking, introduced with Fable 5.1. It stops API users from editing Claude’s earlier context in an attempt to extract its reasoning, which is a common route for distilling a frontier model into a cheaper copy. Older accounts can opt in, and a beta header lets you drop mismatched blocks instead of erroring.

A new computer use toolset

On the Claude API and Google Cloud, the older computer use tool version is retired for this model and replaced by a new toolset that supports batched actions. Amazon Bedrock still accepts the old version for now. Text that the model writes between tool calls also now arrives inside thinking blocks, which are empty by default unless you set the display option, so any code that reads replies by position rather than by block type should be checked.

The developer notes also list new beta features that ride along with this release, including tools defined partway through a conversation, compaction on demand for long sessions, per message effort and task budgets. The context window stays at one million tokens, with up to 128,000 output tokens per request and 300,000 through a Batch API beta. If you are wondering whether that window helps your use case, our explainer on when long context windows actually help is still the right starting point.

Safety, routing and the pacing debate

Anthropic judges Opus 5.5 to be comparable to Claude Mythos 5.1 in biology and cybersecurity. Mythos is the tier the company restricts to vetted professionals. So Opus 5.5 ships with safeguards similar to those on Fable 5.1, and most cybersecurity tasks are routed to the older Opus 4.8 instead. Security teams who want the stronger model for defensive work are pointed to an expanded Cyber Verification Program, and life sciences researchers to a separate verification program.

Think about what this actually requires of a product team. A security startup that built on Opus 5 could find some of its requests quietly handled by an older model after upgrading. The API does report refusals with a dedicated stop reason and offers a server side fallback option, but routing decisions of this kind should be tested rather than assumed.

On alignment, Anthropic says Opus 5.5 posted the best scores of any of its models to date on its automated behavioral audit, and that prompt injection resistance matches or beats Opus 5 in every setting tested. External pre release evaluation came from METR and Frontier Design, according to the announcement and TechCrunch’s launch report.

The timing drew comment too. TechCrunch and Yahoo Finance both noted this is Anthropic’s first model since chief executive Dario Amodei argued earlier this month for pacing the frontier, so that alignment research can keep up with capability. Shipping a faster, cheaper, more capable model weeks later is not necessarily a contradiction. Anthropic’s position is that it can advance while tightening safeguards. Readers can judge whether routing, verification programs and anti distillation measures amount to pacing.

Related work and the competitive picture

No model launch happens in isolation, and this one had company within minutes.

Inside the Claude family

The Claude lineup now spans four tiers. Mythos 5.1 sits at the top and is gated behind verification. Fable 5.1 is the general flagship at $10 and $50 per million tokens. Opus 5.5 is the new value leader at $4 and $20. Sonnet and Haiku sit below, and TechCrunch reports that Sonnet 5.5 and Haiku 5.5 are expected in the coming weeks. We compared the earlier generation head to head in Fable 5 versus Mythos 5 versus ChatGPT 5.6 for coding, and many of that article’s conclusions about routing easy tasks to cheaper tiers carry over.

The practical effect of Opus 5.5 is to squeeze Fable 5.1’s role. If Opus matches Fable on most work at under half the price, Fable becomes the model you reach for only when a task actually fails on Opus. That makes a routing layer, where a cheap model tries first and escalates on failure, more valuable than it was a month ago.

OpenAI’s same day response

OpenAI released GPT-6 Sol and GPT-6 Luna minutes after the Anthropic announcement, according to Decrypt’s coverage. Sol costs $2 input and $10 output per million tokens, and Luna costs $0.10 and $0.50. Both sit below the larger GPT-6 Astra. For context on how OpenAI’s tiering evolved, see our explainer on ChatGPT 5.6 and its Sol, Terra and Luna tiers.

OpenAI’s launch materials compared Sol with Opus 5, not Opus 5.5, which makes sense given the timing. The numbers tell a complicated story.

Look at the OSWorld row. OpenAI reports Opus 5 at 60.3 percent. Anthropic reports the same model at 74.0 percent, but under a partial success rule. Those are two different scoring schemes on the same benchmark name, and they are not comparable. Anyone who puts Sol’s 60.5 next to Opus 5.5’s 81.8 and declares a winner is comparing different measurements.

AutomationBench is more consistent, since both vendors report Opus 5 at 26.9 percent. On that test Opus 5.5 at 40.0 percent leads Sol at 33.2 percent. Sol, however, costs half as much per token as Opus 5.5, and OpenAI puts Sol’s cost at $0.27 per AutomationBench task. Anthropic did not publish a per task cost for Opus 5.5, so the price to performance question stays open until someone runs both on the same harness.

Open weight pressure

Closed models are not the only competition. Open weight releases such as Kimi K3, which we compared against Fable 5 in Kimi K3 versus Claude Fable 5, keep pushing down the price that closed labs can charge for mid tier capability. The preserved thinking safeguard is partly a response to this pressure, since distillation from a frontier model’s reasoning is one of the cheapest ways to build a strong open model.

Who should switch, and how

If you run long agent loops on Opus 5, the case for moving is strong. You get a lower price, faster output and better benchmark results in exactly the areas agents need. Plan a short migration sprint for the breaking changes and a proper effort sweep, and measure cost per completed task rather than cost per token.

If you mostly send short prompts with short answers, the gain is closer to the flat price cut. That is still worth having, but watch that the always on thinking does not add latency you cannot accept. Low effort is the lever to test.

If you use Fable 5.1 today, run your hardest evaluation set on Opus 5.5 before renewing any commitment. On the published numbers most teams will be able to move a large share of traffic down a tier.

If you work in security, expect routing to Opus 4.8 for many requests unless you are enrolled in the verification program, and test that behavior explicitly.

Subscribers to Claude’s Pro, Max, Team and seat based Enterprise plans also get higher five hour usage limits, according to MacRumors, along with a one time limit reset usable until 22 October.

Limitations of what we know

Every benchmark figure in this article comes from Anthropic or OpenAI. None has been independently reproduced at the time of writing, and several benchmarks here are new versions, such as Terminal-Bench-Science 0.1 and OSWorld 2.0, with little public history to compare against.

The 40 percent cost saving is an average claim tied to Anthropic’s internal workloads. Your own saving depends on your mix of input, cached and output tokens, and on whether the model’s higher thinking per effort level cancels part of the efficiency gain.

Effort settings differ across rows of the benchmark table, from medium to max. A fair comparison with your current setup has to hold effort constant, which the published table does not do.

The anecdotes, the 680,000 line migration and the 39 out of 40 web optimization runs, lack the task definitions and failure analysis that would let anyone check them. They show intent, not proof.

Finally, routing cybersecurity work to an older model and blocking context edits are policy choices that could change after launch. Build tests that detect when behavior shifts, rather than assuming today’s rules will hold.

Migration helper and cost estimator in Python

The template for this series normally ends with a model implementation. Opus 5.5 is a closed commercial model with no published architecture, so we have written something more useful for readers who build on it. The script below audits a request payload for the four breaking changes, rewrites it into a valid Opus 5.5 request, estimates cost on Opus 5 versus Opus 5.5, and runs a smoke test that needs no API key. An optional function shows a real call through the official SDK.

# opus55_migrate.py
# Audit and rewrite Anthropic Messages API payloads for claude-opus-5-5,
# and estimate per task cost against claude-opus-5.
# Prices and rules taken from Anthropic's Opus 5.5 docs, 22 Sep 2026.

from __future__ import annotations
import copy
from dataclasses import dataclass

# ---------------- pricing (USD per million tokens) ----------------
PRICES = {
    "claude-opus-5":   {"in": 5.00, "out": 25.00, "cache_read": 0.50, "cache_write_5m": 6.25},
    "claude-opus-5-5": {"in": 4.00, "out": 20.00, "cache_read": 0.20, "cache_write_5m": 5.00},
}
BATCH_DISCOUNT = 0.5
VALID_EFFORT = {"low", "medium", "high", "xhigh", "max"}


@dataclass
class TaskTokens:
    fresh_in: int
    out: int
    cache_read: int = 0
    cache_write_5m: int = 0


def task_cost(model: str, t: TaskTokens, batch: bool = False) -> float:
    """C = sum(tokens_i * price_i) / 1e6, with optional batch discount on in/out."""
    p = PRICES[model]
    disc = BATCH_DISCOUNT if batch else 1.0
    cost = (
        t.fresh_in * p["in"] * disc
        + t.out * p["out"] * disc
        + t.cache_read * p["cache_read"]
        + t.cache_write_5m * p["cache_write_5m"]
    )
    return cost / 1e6


def compare(t_old: TaskTokens, t_new: TaskTokens | None = None) -> dict:
    """Compare Opus 5 vs Opus 5.5. Pass t_new if 5.5 uses fewer tokens."""
    t_new = t_new or t_old
    old = task_cost("claude-opus-5", t_old)
    new = task_cost("claude-opus-5-5", t_new)
    return {"opus_5": round(old, 4), "opus_5_5": round(new, 4),
            "saving_pct": round(100 * (1 - new / old), 1)}


# ---------------- payload audit and rewrite ----------------
def audit(payload: dict) -> list[str]:
    """Return human readable problems that would cause a 400 on Opus 5.5."""
    issues = []
    th = payload.get("thinking") or {}
    if th.get("type") == "disabled":
        issues.append("thinking.type=disabled is not supported; use adaptive + effort")
    if th.get("type") == "enabled":
        issues.append("thinking.type=enabled with budget_tokens is not supported")
    tc = payload.get("tool_choice") or {}
    if tc.get("type") in ("any", "tool"):
        issues.append(f"tool_choice.type={tc.get('type')} is not supported; use auto + strict tools")
    for tool in payload.get("tools", []):
        if tool.get("type") == "computer_20251124":
            issues.append("computer_20251124 is retired on Claude API / Google Cloud")
    eff = (payload.get("output_config") or {}).get("effort")
    if eff is None:
        issues.append("effort not set; Opus 5.5 defaults to medium (Opus 5 was high)")
    elif eff not in VALID_EFFORT:
        issues.append(f"unknown effort level {eff!r}")
    return issues


def migrate(payload: dict, effort: str = "medium", keep_betas: bool = True) -> dict:
    """Return a new payload valid for claude-opus-5-5."""
    if effort not in VALID_EFFORT:
        raise ValueError(f"effort must be one of {sorted(VALID_EFFORT)}")
    p = copy.deepcopy(payload)
    p["model"] = "claude-opus-5-5"

    # 1. thinking is always adaptive; low effort replaces "disabled"
    old_th = (p.get("thinking") or {}).get("type")
    p["thinking"] = {"type": "adaptive"}
    if old_th == "disabled":
        effort = "low"
    p.setdefault("output_config", {})["effort"] = p.get("output_config", {}).get("effort", effort)

    # 2. forced tool choice -> auto, and mark the formerly forced tool strict
    tc = p.get("tool_choice") or {}
    forced = tc.get("name") if tc.get("type") == "tool" else None
    if tc.get("type") in ("any", "tool"):
        p["tool_choice"] = {"type": "auto"}
        for tool in p.get("tools", []):
            if forced is None or tool.get("name") == forced:
                tool["strict"] = True

    # 3. computer use tool version
    for tool in p.get("tools", []):
        if tool.get("type") == "computer_20251124":
            tool.clear()
            tool["type"] = "computer_toolset_20260801"
    if not keep_betas:
        p.pop("betas", None)
    elif "betas" in p:
        p["betas"] = [b for b in p["betas"] if b != "computer-use-2025-11-24"]
    return p


def text_from_response(content_blocks: list[dict]) -> str:
    """Read text by block type, never by position (between-tool text is now in thinking blocks)."""
    return "".join(b.get("text", "") for b in content_blocks if b.get("type") == "text")


# ---------------- optional live call ----------------
def live_call(payload: dict):  # requires: pip install anthropic, ANTHROPIC_API_KEY set
    import anthropic
    client = anthropic.Anthropic()
    body = {k: v for k, v in payload.items() if k != "betas"}
    resp = client.messages.create(**body)
    if resp.stop_reason == "refusal":
        return "[refused; consider a fallback model]"
    return text_from_response([b.model_dump() for b in resp.content])


# ---------------- smoke test (no API key needed) ----------------
if __name__ == "__main__":
    legacy = {
        "model": "claude-opus-5",
        "max_tokens": 4096,
        "thinking": {"type": "disabled"},
        "tool_choice": {"type": "tool", "name": "extract_invoice"},
        "tools": [
            {"name": "extract_invoice", "input_schema": {"type": "object"}},
            {"type": "computer_20251124", "name": "computer"},
        ],
        "betas": ["computer-use-2025-11-24"],
        "messages": [{"role": "user", "content": "Extract totals."}],
    }

    problems = audit({**legacy, "model": "claude-opus-5-5"})
    assert len(problems) == 4, problems
    print("Issues found:")
    for i in problems:
        print("  -", i)

    fixed = migrate(legacy)
    assert audit(fixed) == [], audit(fixed)
    assert fixed["thinking"] == {"type": "adaptive"}
    assert fixed["output_config"]["effort"] == "low"       # was 'disabled'
    assert fixed["tool_choice"] == {"type": "auto"}
    assert fixed["tools"][0]["strict"] is True
    assert fixed["tools"][1] == {"type": "computer_toolset_20260801"}
    assert fixed["betas"] == []
    assert legacy["model"] == "claude-opus-5"                # original untouched
    print("Migrated payload is valid for claude-opus-5-5")

    # The worked example from the article
    same = compare(TaskTokens(fresh_in=100_000, out=20_000))
    half = compare(TaskTokens(100_000, 20_000), TaskTokens(100_000, 10_000))
    assert same == {"opus_5": 1.0, "opus_5_5": 0.8, "saving_pct": 20.0}
    assert half["saving_pct"] == 40.0
    print("Same tokens:", same)
    print("Half output:", half)

    # Reading replies by type, not position
    blocks = [{"type": "thinking", "thinking": ""}, {"type": "text", "text": "Total: $1,240"}]
    assert text_from_response(blocks) == "Total: $1,240"
    print("All smoke tests passed.")

The bigger picture

Opus 5.5 does something that sounds modest and turns out to matter a great deal. It brings top tier performance down to a price where teams can afford to run it all day. The benchmark table shows it matching or beating Fable 5.1 on every listed task, and the pricing puts it at well under half of Fable’s per token cost. For most agent builders that combination moves the default choice.

The conceptual shift is in how Anthropic now thinks about cost. Per token price is only part of it. The company is selling cost per finished task, and it is tuning the model to reach answers in fewer turns and fewer output tokens. That is the right metric for agents, and it is the one every serious buyer should adopt when comparing vendors, including when setting Opus 5.5 against GPT-6 Sol.

The lessons travel beyond Claude. Always on reasoning with an effort dial, anti distillation controls on thinking traces, and model level routing for sensitive domains are all patterns other labs are likely to adopt. Engineers who build a thin abstraction over effort levels, refusals and fallbacks now will find it easier to swap providers later.

The open questions are real. Every number here is self reported. Scoring rules differ between vendors, sometimes on benchmarks with the same name. Higher thinking per effort level could erode the headline saving for some workloads, and routing security tasks to an older model will frustrate some legitimate users. None of that undoes the release, but all of it argues for testing on your own tasks before moving production traffic.

What comes next is already signposted. Sonnet 5.5 and Haiku 5.5 are expected within weeks, OpenAI’s Sol and Luna will get independent evaluations, and the debate over how fast the frontier should move will continue alongside each launch. For now, Opus 5.5 is the model that makes Fable level work an everyday expense rather than a special occasion.