claude-opus-5-5

Claude Opus 5.5

The generation where the default reasoning effort went down.

Released 22 September 2026 — model card · system card

The Default Effort Dropped

The change that explains everything else about this release, and it runs against the usual direction.

A newer model that deliberates less by default is not what you would expect. More capability usually arrives with more computation, not less.

Anthropic's framing explains it: the model uses fewer tokens per task, and performs at the level of a substantially larger model on most work.

And customers evaluating it report the same pattern in stronger terms. Several describe the lowest effort setting matching or exceeding the previous generation at its highest:

On code review — one team reports 72% of known bugs caught at the lowest effort setting, against 56% for the previous model at high effort, with fewer false alarms and a fraction of the output.

On financial analysis — another reports the lowest effort beating the previous model's high effort on their benchmark, with roughly 60% fewer output tokens.

On general work — a third describes it as the first model they would default to at medium effort, matching the previous generation's high effort while using 20 to 25% fewer output tokens.

Read those together and the default makes sense. medium is not a compromise here; it is where the model does its best work per token, and the settings above it are for cases that genuinely need them.

Thinking Is Always On

Adaptive thinking, and the documentation marks it explicitly: always on.

There is no setting that disables it. Every request reasons; what you control is how much.

Five levels: low, medium, xhigh, high, and max — with medium the default.

Two consequences for your integration.

max_tokens covers reasoning plus answer, always. There is no configuration where the budget goes entirely to the response, and a ceiling sized for the answer alone can truncate the model mid-argument.

And latency varies with the problem rather than only with length. Adaptive thinking means the model decides how much deliberation a request warrants — which is what makes medium a sensible default rather than a fixed cost.

⚠️ Anthropic Publish Numbers That Undercount

The benchmark footnote is worth reading in full, because it does something vendors almost never do.

Claude Opus 5.5 was evaluated with its production safeguards enabled. When they intervened, cybersecurity tasks were completed by Claude Opus 4.8, and biology and frontier LLM development tasks were completed by Claude Opus 5. This likely reduces Claude Opus 5.5's performance on these benchmarks.

They are saying their own published scores are lower than the model's actual capability — because safeguards routed some tasks to older models, and those results were counted anyway.

The same footnote goes further on a third-party benchmark: an evaluation run by an external company was performed without fallback models, so safeguard interventions were counted as failures — which, Anthropic note, produced a lower score than the model would achieve in practice.

And the reproducibility check

Standard errors are published per benchmark — ±2.6 points on one, ±3.5 to 5 on another.

And they reproduce the public leaderboard before reporting against it. The public figure for the previous model is 51.8%; their own harness produces 52.3%, which they describe as within noise.

That is the check that makes a comparison meaningful. A vendor reporting their new model against a competitor's published figure, without first reproducing a known result on the same harness, is comparing two different measurements. This one reproduces first.

Read the effort conditions too. Published results use adaptive thinking at max effort unless noted, and one benchmark is reported at xhigh.

Which means the headline numbers describe the top of the range, not the default. The default is medium — and the customer reports above suggest the gap between them is smaller than it would be on most models.

A Million In, 128,000 Out

The batch figure is the one worth noticing. Three hundred thousand tokens of output in a single response, available through the batch interface — more than double the synchronous ceiling.

What that enables. A complete long document, a full codebase refactor, an extended analysis — generated in one pass rather than assembled from sections, with structure and terminology consistent throughout.

And a million tokens of input holds a codebase, a document archive, or an agent session that runs for hours without compaction.

Vision and Computer Use

Anthropic describe it as their best Opus model for both, and the two are named together for a reason.

Reading: dense documents, charts, screenshots, and diagrams at high fidelity — named as reliable for document extraction, visual analysis, and interpreting complex real-world imagery.

Acting: multi-step tasks spanning multiple applications, requiring planning and judgment.

Those combine into one capability. Computer use is vision plus decision — a model driving an interface must read the screen correctly before it can act on it, and a misread produces a confident wrong click.

Input is text and images. Output is text.

Fewer Steps, Not Just Fewer Tokens

A pattern running through the third-party evaluations, and it is distinct from token efficiency.

Several report the model completing work in substantially fewer steps — one describes solving more terminal tasks than the previous generation in less than half the steps; another reports roughly 40% fewer calls at higher task completion; a third describes tasks finishing in a third to half fewer steps.

Why steps matter separately from tokens. On an agent loop, each step is a round trip: a request, a tool call, a result, a decision. Fewer steps means less wall-clock time, fewer opportunities for a loop to go wrong, and less accumulated context.

And the reported behaviour behind it is gathering context once rather than repeatedly, making fewer and more complete edits, and not getting stuck retrying.

One evaluation describes an 18-hour unattended session across six repositories, defining how services communicate and working out how each should apply it — with milestones hit faster than the previous generation and minimal reworking.

It Writes Differently

Named as a change rather than a side effect: it leads with what matters, avoids jargon, and follows your writing rules.

Third-party reports are specific about the effect. Answers described as 40% less verbose without losing accuracy. Code comments described as short and useful rather than long and prose-heavy. Pull requests and user-facing documentation needing almost no editing.

On a long session that compounds. A model that explains what it is about to do before doing it costs output tokens and reader attention on every turn, and neither is recovered.

And "follows your writing rules" is the operative clause for a product. A house style expressed in a system prompt is only useful if it survives forty turns.

Safeguards

The first Opus model to launch with a similar class of safeguards to Anthropic's top tier in cybersecurity, biology, and anti-distillation.

Three things to know about what that means in practice.

Requests in the covered areas may be handled differently. The benchmark footnote describes exactly this: when safeguards intervened during evaluation, the tasks were completed by earlier models.

The anti-distillation measure is aimed at training. Using this model's outputs to train another model is what it exists to prevent, and that is a term of use rather than only a technical measure.

And the safeguards are the reason the published numbers undercount. Anthropic chose to evaluate with them enabled and report the result, rather than measuring an unguarded configuration nobody can call.

Specifications

A fast mode is available with up to 2.5× faster generation, for paths where latency outweighs deliberation.

US-only inference is available where data residency requires it.

Retirement is announced a year ahead. That is a planning commitment rather than a technical specification, and it is worth noting for anything you intend to keep running.

Capabilities

Benchmarks

Published by Anthropic with the conditions described above — production safeguards enabled, adaptive thinking at max effort unless noted, and standard errors given per benchmark.

Read the chart with its footnote. The results describe the top of the effort range; the default sits two levels below it, and the third-party reports above suggest the practical gap is narrow.

Using Claude Opus 5.5 on DEVUP AI

Base URL: https://api.devupai.com/v1 · Model ID: anthropic/claude-opus-5-5

Python

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["DEVUP_API_KEY"],
    base_url="https://api.devupai.com/v1",
)

response = client.chat.completions.create(
    model="anthropic/claude-opus-5-5",
    messages=[
        {"role": "user", "content": "Hello world!"}
    ],
    max_tokens=1024,
)

print(response.choices[0].message.content)

Node.js

import DevupAI from "devupai";

const client = new DevupAI({
  apiKey: process.env.DEVUP_API_KEY,
});

async function main() {
  const response = await client.chat.completions.create({
    model: "anthropic/claude-opus-5-5",
    messages: [{ role: "user", content: "Hello world!" }],
    max_tokens: 1024,
  });

  console.log(response.choices[0].message.content);
}

main();

cURL

curl -X POST "https://api.devupai.com/v1/chat/completions" \
  -H "Authorization: Bearer $DEVUP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "anthropic/claude-opus-5-5",
    "messages": [
      { "role": "user", "content": "Hello world!" }
    ],
    "max_tokens": 1024
  }'

⚠️ How reasoning effort is set varies by platform. Confirm the parameter name and accepted values with a test request before building routing logic around them.

Choosing the Effort Level

The decision this model reframes, and the reframing is the useful part.

Start at medium. It is the documented default, and the third-party evaluations above describe it as sufficient for work that previously needed a higher setting on the previous generation.

Try low before assuming you need more. The most striking customer reports are about the lowest setting: bug detection exceeding the previous model's high effort, financial analysis beating it with 60% fewer output tokens. That is unusual enough to be worth testing on your own work rather than taking on faith.

Reach for xhigh or max deliberately. Anthropic's own benchmarks use them, which tells you they represent real additional capability — and that the published figures are not what medium produces.

Measuring it on your own prompts

def measure(prompt: str, effort: str, max_tokens: int = 32768) -> tuple[str, int]:
    """Return the answer and the completion tokens spent at a given effort level."""
    response = client.chat.completions.create(
        model="anthropic/claude-opus-5-5",
        messages=[{"role": "user", "content": prompt}],
        max_tokens=max_tokens,
        extra_body={"reasoning_effort": effort},
    )

    choice = response.choices[0]

    if choice.finish_reason == "length":
        raise ValueError(f"hit the ceiling at {response.usage.completion_tokens:,} tokens")

    return choice.message.content, response.usage.completion_tokens


for effort in ("low", "medium", "high", "xhigh", "max"):
    answer, tokens = measure(your_prompt, effort)
    print(f"{effort:>7}  {tokens:>7,} tokens  correct={check(answer)}")

Run it across twenty of your real prompts, not one. The claim worth testing is that lower settings suffice more often than they used to — and that is a distribution over your workload rather than a property of any single task.

Compare tokens at equal correctness. If low and max both produce a correct answer, the difference between them is cost and latency, and on a model tuned for token efficiency that difference is the product.

An Agent Session

The workload the step-count reports describe.

import json
import time

TOOLS = [
    {
        "type": "function",
        "function": {
            "name": "read_file",
            "description": "Read a file relative to the repository root.",
            "parameters": {
                "type": "object",
                "properties": {"path": {"type": "string"}},
                "required": ["path"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "edit_file",
            "description": "Replace an exact string in a file. The old string must appear exactly once.",
            "parameters": {
                "type": "object",
                "properties": {
                    "path": {"type": "string"},
                    "old_str": {"type": "string"},
                    "new_str": {"type": "string"},
                },
                "required": ["path", "old_str", "new_str"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "run_tests",
            "description": "Run the test suite and return pass/fail counts with failure output.",
            "parameters": {"type": "object", "properties": {}},
        },
    },
]


def read_file(path: str) -> dict:
    """Replace with your real, sandboxed file access."""
    raise NotImplementedError


def edit_file(path: str, old_str: str, new_str: str) -> dict:
    """Replace with your real, sandboxed editor."""
    raise NotImplementedError


def run_tests() -> dict:
    """Replace with your real, sandboxed test runner."""
    raise NotImplementedError


HANDLERS = {"read_file": read_file, "edit_file": edit_file, "run_tests": run_tests}

session = [
    {
        "role": "system",
        "content": (
            "You are working inside a git repository. Find the root cause before changing anything. "
            "Run the tests after each edit. Explain each change in plain language so it can be "
            "reviewed quickly."
        ),
    },
    {"role": "user", "content": "The DZD invoice test fails on totals ending in .005. Find the cause and fix it."},
]

CEILING = 100
start = time.monotonic()

for step in range(CEILING):
    response = client.chat.completions.create(
        model="anthropic/claude-opus-5-5",
        messages=session,
        tools=TOOLS,
        max_tokens=32768,
    )

    message = response.choices[0].message
    session.append(message)

    if not message.tool_calls:
        print(message.content)
        break

    for call in message.tool_calls:
        handler = HANDLERS.get(call.function.name)
        if handler is None:
            outcome = {"error": "unknown tool", "name": call.function.name}
        else:
            try:
                outcome = handler(**json.loads(call.function.arguments or "{}"))
            except Exception as exc:
                outcome = {"error": type(exc).__name__, "detail": str(exc)}

        session.append({"role": "tool", "tool_call_id": call.id, "content": json.dumps(outcome)})

    if step % 25 == 0:
        used = response.usage.prompt_tokens
        print(f"step {step:>3} · {(time.monotonic() - start) / 60:>5.1f} min · {used:>9,} tokens ({used / 1_048_576:.1%})")
else:
    print(f"Reached the {CEILING}-step ceiling.")

print(f"finished in {step + 1} steps, {(time.monotonic() - start) / 60:.1f} min")

Count steps as well as tokens. The reported efficiency gains are largely about round trips, and step count is the measurement that captures them — a model finishing in twelve steps rather than thirty has changed something token counts alone will understate.

"Find the root cause before changing anything" matches what the model was described as doing. Making it explicit costs one line and makes the behaviour checkable.

Documents and Screenshots

Where "best Opus model for vision" applies.

import base64
from pathlib import Path

encoded = base64.b64encode(Path("filing.png").read_bytes()).decode("utf-8")

response = client.chat.completions.create(
    model="anthropic/claude-opus-5-5",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{encoded}"}},
                {
                    "type": "text",
                    "text": (
                        "Extract every figure from this filing with its label, unit, and period. "
                        "Separate values printed in the document from values you derived by reading "
                        "a chart. Mark anything illegible as unreadable rather than estimating it."
                    ),
                },
            ],
        }
    ],
    max_tokens=16384,
)

Separating printed values from chart-read values is the instruction that matters on dense financial documents. A number in a table is transcription; a number read off an axis is estimation, and a pipeline that treats them identically inherits the uncertainty without recording it.

Send documents at full resolution. Downscaling before upload discards detail the encoder would otherwise use.

Long-Form Generation

128,000 tokens synchronously, and up to 300,000 through the batch interface.

response = client.chat.completions.create(
    model="anthropic/claude-opus-5-5",
    messages=[
        {
            "role": "system",
            "content": (
                "Produce the complete document requested. Use headings. Do not stop early, do not "
                "summarise sections you have not written, and do not add meta-commentary."
            ),
        },
        {"role": "user", "content": f"{source_material}\n\nWrite the full specification."},
    ],
    max_tokens=100_000,
)

choice = response.choices[0]

if choice.finish_reason == "length":
    raise ValueError(f"reached {response.usage.completion_tokens:,} tokens without finishing")

A complete document in one response keeps structure, terminology, and cross-references consistent in a way section-by-section generation struggles to.

And remember the budget is shared with reasoning. Thinking is always on; a hundred thousand tokens covers deliberation and document together, not document alone.

"Do not stop early" earns its place, and the revised communication style helps — a model tuned toward fewer preambles spends more of a large budget on the content itself.

Watching the Budget

Thinking is always on, which makes this check more necessary than on most models.

def ask(prompt: str, *, effort: str = "medium", want: int = 8192) -> str:
    """Send a request with a budget that accounts for mandatory reasoning."""
    response = client.chat.completions.create(
        model="anthropic/claude-opus-5-5",
        messages=[{"role": "user", "content": prompt}],
        max_tokens=want,
        extra_body={"reasoning_effort": effort},
    )

    choice = response.choices[0]

    if choice.finish_reason == "length":
        raise ValueError(
            f"truncated at {response.usage.completion_tokens:,} tokens — "
            f"raise max_tokens or lower the effort from '{effort}'"
        )

    return choice.message.content

The error message names both remedies, because on a model with mandatory reasoning they are genuinely alternatives. A truncated response at max effort may complete at medium within the same budget — and given how narrow the reported gap is, that is frequently the better fix.

Where It Fits

Agentic coding, named as the strongest Opus model for it — long-running work in large codebases, with root-cause investigation before changes.

Multi-tool agents, orchestrating complex tasks, coordinating subagents, and using memory across sessions.

Enterprise workflows producing spreadsheets, slides, and documents intended to be used rather than edited.

Financial and legal analysis, reading dense filings and carrying context across a full deal or reporting cycle.

Document extraction and visual analysis, at the family's highest stated vision fidelity.

Computer use, spanning multiple applications with planning and judgment.

Long-context work at a million tokens, and long-form generation at 128,000 — or 300,000 in batch.

Less suited to latency-critical paths without fast mode; to work requiring no reasoning pass at all, which this model does not offer; and to anything needing image, audio, or video output.

Practical Notes

Start at medium — it is the default for a reason, and the reason is measured.

Test low before assuming you need more. The reports about the lowest setting are the surprising part of this release.

Size max_tokens for reasoning plus answer. Thinking cannot be switched off.

Count agent steps as well as tokens; the efficiency gains are largely in round trips.

Read benchmark figures against their effort conditions — published results use the top of the range.

Separate transcribed values from chart-read values on document work.

Send images at full resolution.

Consider the batch interface when you need more than 128,000 tokens of output.

Confirm how reasoning effort is set on your path before building routing.

Limitations

Thinking cannot be disabled. Every request reasons, at a minimum cost no parameter removes.

Published benchmarks use max effort, two levels above the default — the headline figures do not describe default behaviour.

And they undercount. Anthropic evaluated with production safeguards enabled and note this likely lowers the scores in the covered areas.

Safeguards may route or refuse in cybersecurity, biology, and frontier model development.

Anti-distillation applies. Using this model's output to train another model is what those measures exist to prevent.

Knowledge ends June 2026. Recent by current standards, and a fixed point — ground anything time-sensitive.

Text and images in, text out. No audio, no video, no image generation.

Closed weights. API access only, with no architecture published and no self-hosted option.

Released 22 September 2026. Independent evaluation is still ahead of it, and the customer reports here come from early-access testing rather than from public measurement.

Third-party efficiency figures are from vendors evaluating on their own workloads — directionally consistent across many of them, and not a substitute for measuring yours.