Claude Opus 5.5

Overview

Claude Opus 5.5 is a flagship model in the Claude family, tuned for demanding reasoning, coding and multi-step agent work. It is the tier you reach for when a task is hard enough that a faster, cheaper model is likely to stumble: a tangled codebase, a long contract with cross references, a research question that needs many steps, or an agent that must coordinate several helpers over a long run.

In data work, Opus 5.5 is best seen as a senior analyst and planner. It reads a messy problem, breaks it into stages, writes and reviews code, calls tools, and checks its own work. It does not replace models that learn directly from tables, such as the ones covered in /model/research and /model/architecture. Instead it decides when to use them, prepares their inputs, and interprets their outputs. This page is a general explainer. Limits, prices and release details change often, so confirm them in the official documentation.

What it is

Claude Opus 5.5 is a large language model from Anthropic. Like other Claude models it accepts text, and in many setups images and documents, and returns text, structured data or tool requests.

Where it sits in the family

Everyday analogy: a newsroom has reporters who file quick stories, editors who handle most pieces, and a senior investigative editor who takes the long, complicated project that needs weeks of care. Opus plays the investigative editor.

Typical jobs

• Large refactors across many files, including tests and migration notes.
• Reviewing long documents such as contracts, policies, filings and technical specifications.
• Multi-step research that mixes search, reading, computing and writing.
• Orchestrating other agents, deciding who does what and merging results.
• Debugging hard problems where the cause is not obvious.
• Designing systems and weighing trade-offs in writing.

What stays the same across tiers

All tiers share the same basic mechanics: tokens, a context window, tool calling, structured output and safety training. The difference is mostly depth: how reliably the model keeps many constraints in mind, how well it plans over many steps and how often it recovers from its own mistakes.

Where it came from

Anthropic released its first Claude models in 2023. Over the following generations the company split the line into tiers named after poetic forms: Haiku, Sonnet and Opus. The names signal size and effort, from short and quick to long and elaborate.

Several research threads feed into a model like this.

• The transformer architecture, introduced in the 2017 paper "Attention Is All You Need". See transformers.
• Large scale pre-training on diverse text and code, followed by instruction tuning and preference training. See RLHF and DPO.
• Constitutional AI, published by Anthropic in 2022, which uses written principles to guide model self-critique. See Constitutional AI.
• Chain-of-thought and related reasoning methods, which showed that models do better when they work through steps. See tree of thoughts and reflection.
• Tool use and agent design, which grew into products and kits such as Claude Code and the Claude Agent SDK.
• An open protocol for connecting tools and data, the Model Context Protocol.

Training data, parameter counts and exact methods for each release are not fully public. This page therefore avoids numbers it cannot support, and speaks about behavior in general terms.

How it works

Step 1: Tokenization

Input is split into tokens, small pieces of words. A long document becomes many thousands of them. Analogy: a book is cut into index cards, one card per few letters, and the model reads the whole deck.

Step 2: Attention across the context

Stacked transformer layers let every token consult every other token in the window. That is how the model links a clause on page forty with a definition on page two. Large windows allow whole codebases or document sets to be read in one request, though quality can vary with where in the window a fact sits.

Step 3: Next token prediction

The model scores all possible next tokens and picks one. Repeating this builds the reply. Pre-training teaches language and knowledge. Later training teaches it to follow instructions, use tools and behave safely.

Step 4: Deliberate reasoning

For hard tasks, a high capability model benefits from extra thinking. When the platform exposes it, the model can spend a budget of reasoning tokens to plan, test ideas and catch errors before it answers. More budget usually helps on difficult problems and costs more time and tokens.

Step 5: Acting with tools

Given tool definitions, the model emits structured requests such as search, read file, run tests or query a database. Your application runs them and returns results. An agent repeats this loop. See function calling, the ReAct loop and plan and execute.

Step 6: Delegating

For big jobs, the model can act as an orchestrator. It splits the work and hands pieces to sub-agents, often on a lighter tier, then reviews and merges what comes back. See orchestrator workers and multi-agent systems.

Step 7: Checking itself

Strong models can review their own output: run tests, compare against a spec, or critique a draft. This works best when there is an objective signal such as a failing test or a validator. See reflection.

Step 8: Guarded by the application

The model is trained to be safe and honest, yet production systems add guardrails, permissions, sandboxes and approval steps. The model is one component in a larger design.

Key concepts and terms

A worked example

Task: a team has a multi-year sales table and wants a forecast pipeline and a report. The data is messy, columns have unclear names, and the question is open ended. This is the kind of work where a high capability model earns its cost.

Step 1: Plan before acting

The orchestrator (Opus) first writes a plan and stores it in a file.

Plan
1. Profile the table: types, missing values, duplicates, date gaps.
2. Propose human readable column names; mark uncertain ones.
3. Build a time-based train/validation split.
4. Baselines: seasonal naive, gradient boosting with lag features.
5. Try a tabular foundation model on a sampled subset.
6. Compare with intervals; check leakage; write report.
Review gates: after 2, after 5.

Step 2: Delegate narrow jobs

Opus hands profiling to a lighter sub-agent and keeps modeling for itself.

# pseudo-code for an orchestration loop
tasks = [
    {"id": "profile", "agent": "worker", "input": "example.internal/sales.parquet"},
    {"id": "names",   "agent": "worker", "depends_on": ["profile"]},
]
results = run_parallel(tasks)
summary = orchestrator.review(results)      # Opus reads, challenges, merges

Using lighter workers for simple steps cuts cost. See Claude Haiku 5.5 and Claude Sonnet 5.5.

Step 3: Build features with tests

Opus writes feature code and a test that guards against leakage.

def make_lags(df, col, lags=(1, 7, 28)):
    out = df.sort_values("date").copy()
    for k in lags:
        out[f"{col}_lag{k}"] = out.groupby("store_id")[col].shift(k)
    return out

def test_no_future_information(df):
    feats = make_lags(df, "units")
    last_train = feats[feats.date <= "2024-06-30"]
    assert last_train["units_lag1"].notna().sum() > 0
    # every lag feature for date t must equal the target at an earlier date

A failing test gives the model an objective signal. It can then repair the code instead of guessing.

Step 4: Compare models fairly

The model sets up a rolling-origin evaluation and compares:

• a seasonal baseline,
• LightGBM with lag features,
• a tabular foundation model such as TabPFN on a sampled subset,
• and, if the data is a pure series, a model from the time series family.

It reports errors with intervals and refuses to claim a winner when intervals overlap.

Step 5: Write the report

The final report includes the data issues found, the assumptions made, the metrics, the limits and a short list of next steps. A human reviewer reads the plan, the code diff and the metrics before anything is published.

What made this work

• The plan and state live in files, not just in the model's head.
• Code and tests, not the model's arithmetic, produce numbers.
• Lighter agents did simple jobs.
• There were review gates for a person.
• Every step was traced. See tracing and long-running tasks.

A second example: reviewing a long contract set

Task: compare twelve supplier agreements and list differences in liability, renewal and data handling clauses.

1. Load each document into the context in turn, or retrieve the relevant sections.
2. Ask for a fixed table per document: clause name, section reference, short quote, plain summary.
3. Ask Opus to merge the tables and highlight clauses that differ from the first document.
4. Have a person verify every highlighted quote against the source.

For each document, return JSON:
{
  "doc": "<file name>",
  "clauses": [
    {"topic": "liability cap", "section": "<ref>", "quote": "<exact text>",
     "summary": "<one sentence>"}
  ],
  "not_found": ["<topics with no matching clause>"]
}
Use the key "not_found" instead of guessing.

The fixed schema makes results comparable, and the not_found field gives the model a safe way to say it found nothing. Quotes tied to section references let a reviewer check claims in seconds.

A third example: debugging a data pipeline

A nightly job produces a table whose row count dropped by a third. Opus can:

• read the job logs and the recent code changes,
• form two or three hypotheses, such as a changed join key or a filter on a renamed column,
• write small queries to test each hypothesis,
• report the confirmed cause with evidence, and propose a fix with a regression test.

The key habit is to test hypotheses with tools instead of asserting them. A confident but untested explanation is the most common failure in debugging with any language model.

What to log from every run

• The exact prompt, system prompt and tool list, with version labels.
• Each tool call with its arguments and result.
• The final answer and any structured output.
• Token counts, elapsed time and the number of steps.
• Whether a human edited or rejected the result.

These records let you replay failures, compare model versions and measure real cost per completed task. They also give evidence for audits.

Signs that a task needs a higher tier

• A lighter model keeps forgetting a constraint stated early in the prompt.
• The task needs coordinated edits across many files and the edits conflict.
• Answers change sharply when the question is reworded.
• The model abandons the plan midway on long tasks.
• Reviewers find subtle logic errors rather than simple typos.

If you see these signs, try Opus on the failing cases first. If it fixes them, move only those steps up, and keep the rest on lighter tiers.

Working style that gets the best results

Strengths and limitations

Strengths

• High reliability on complex, multi-constraint tasks.
• Strong coding ability, including reading large codebases and making coordinated changes.
• Good at long document analysis and cross referencing.
• Effective as an orchestrator that plans, delegates and merges.
• Better recovery from errors during long runs.
• Writes careful explanations and design documents.

Limitations

• Higher cost and usually higher latency than lighter tiers.
• Still prone to confident mistakes. Checks and tests remain necessary.
• Not needed for simple tasks; using it everywhere wastes money.
• Knowledge has a cutoff date, so recent facts need search tools.
• Can be steered by hostile text in documents. See prompt injection defense.
• Long runs can drift from the goal unless state and goals are restated.
• Not a numeric engine. Exact computation belongs in code.
• Behavior can change between versions, so pin versions and re-run evals.

How it compares with alternatives

Decision hint: if a cheaper tier passes your eval set, use it. If failures cluster on planning, long context or subtle code changes, move those steps to Opus.

Role in tabular foundation models

Tabular foundation models are pre-trained on large numbers of synthetic or real tables. They learn from raw rows and columns, deal with numbers, categories and missing cells, can work without meaningful column names, and make predictions through in-context learning. See /model/research, /model/architecture, /model/benchmarks, TabPFN, TabICL and TabSTAR.

Opus 5.5 is not one of them. It is a language model. The two kinds of model complement each other, and the combination is where a high capability tier is most useful.

The planner around the predictor

A tabular foundation model answers "given these labeled rows, what is the label for these new rows?" It does not choose the target, clean the data, avoid leakage, pick a split or explain the result. Opus can do all of that.

• Frame the business question as classification, regression, ranking or anomaly scoring.
• Choose the target and drop leak columns, for example a field that is only filled after the outcome.
• Decide on a split that matches deployment, usually by time.
• Call the tabular model and a few baselines through tools.
• Interpret the results and write the decision memo.

Analogy: the tabular model is an expert instrument. Opus is the principal investigator who designs the study.

Handling row and column structure

Tables have two axes. Rows are examples, columns are features with their own types and meanings. A language model sees a table as text, which is clumsy for large data. The sound approach is to keep data in files, give Opus tools to inspect it and run code, and let a table-native model do the numeric learning. Opus reads schemas, summaries and small samples, not millions of cells.

Mixed types and missing values

Opus can diagnose missingness: is it random, tied to another column, or tied to the outcome? It can recommend whether to impute, keep a missing indicator or drop. Imputation itself can be done by a table-native model, for example the kind described under imputation networks. Opus then verifies that imputed values keep sensible distributions and relationships.

Columns without names

When headers are missing or cryptic, Opus can propose names from value patterns and context, and mark its confidence. This links to semantic sector heads, where a model infers the domain or sector of a table. Both are best treated as suggestions for human review, not facts.

In-context learning in two senses

A language model learns from examples written into its prompt. A tabular foundation model learns from actual labeled rows given as context. They share the "no gradient step at prediction time" idea but work on different material. For predictions on a table, the table-native approach is generally the better fit. For writing code, explaining, and multi-step reasoning, the language model is. See few-shot learning.

Anomaly detection and monitoring

Opus can set up an anomaly detection pipeline, choose among methods such as isolation forest and table-native scorers, then turn flagged rows into readable cases for a reviewer. For monitoring, it can compare new data batches to reference data, summarize drift and recommend retraining. The decision to act on an anomaly stays with a person.

Continual learning and long-running work

Table models may be refit as data arrives. A long-running agent needs its own memory for this: notes on what was tried, what data version was used and what metrics resulted. See agent memory and long-running tasks. Opus is well suited to maintain such a log, because it can follow a plan over many steps and update it.

Causal questions

Many business questions are causal, such as "what would happen if we changed price?" A predictive table model does not answer that alone. Opus can recognize this, explain the difference and set up a design that uses causal inference methods, with a tabular model as one component.

Evaluation and auditing

Opus can write evaluation harnesses, run them and summarize results. For regulated areas, it can draft documentation of data sources, assumptions and limits. A human signs off. See evals and regression boards.

Practical guidance and best practices

Use it where it matters

• Keep Opus for planning, review, hard coding and final synthesis.
• Use lighter tiers for bulk extraction, routing and simple edits.
• Test whether a lighter tier is enough before defaulting to the top.

Give it good context

• State the goal, constraints and definition of done.
• Provide the schema, a data dictionary and a few sample rows.
• Provide existing code conventions and test commands.
• Keep a short project notes file that the agent can read at the start of each session.

Structure long tasks

• Ask for a plan, then approve it.
• Break work into stages with checkpoints.
• Save intermediate results to files.
• Restate the goal after long tool outputs.
• Set budgets for steps, tokens and time.

Keep numbers honest

• Compute with code and tests.
• Compare every number in a report with the tool output.
• Show intervals and sample sizes.
• Avoid claims about causes unless the design supports them.

Control risk

• Give read-only access by default.
• Run code in a sandbox.
• Require approval for writes, deletes, payments and external messages.
• Log all tool calls and keep the trace.
• Treat retrieved text as untrusted.

Designing a multi-agent setup with Opus as lead

• Give the lead a clear charter: goal, constraints, budget and what counts as done.
• Give each worker a narrow brief, the minimum tools it needs and a defined output format.
• Let workers run in parallel when their tasks are independent.
• Make workers return short, structured summaries rather than full transcripts.
• Have the lead verify claims that matter, rather than trusting summaries blindly.
• Keep a shared notes file as the single source of truth for decisions made.
• Add a stop rule so the run ends when the goal is met or the budget is spent.

Handling data privacy

• Minimize what leaves your environment. Prefer schemas and aggregates to raw rows.
• Mask or drop personal fields before sending anything to a hosted model.
• Check retention and training terms in the provider's documentation.
• Keep an audit log of what was sent and why.
• Involve legal and security teams for regulated data.

Control cost and delay

• Cache stable prefixes such as system prompts and schemas.
• Batch jobs that are not urgent.
• Use sub-agents on lighter tiers.
• Cap thinking budgets for simple steps.
• See cost and latency budgets.

Evaluate and iterate

• Build a task set from real examples, including hard cases.
• Track pass rate, cost and time per task.
• Re-run it on every model, prompt or tool change.
• Review failures by reading traces, not only scores.

A review checklist before shipping an Opus based workflow

• Is there an eval set with hard cases, and does the workflow pass it?
• Are tool permissions the minimum needed?
• Is there a human approval step for irreversible actions?
• Are budgets set for tokens, steps and time?
• Is there a trace for every run, and does someone read a sample weekly?
• Are prompts, tool definitions and model versions stored in version control?
• Is there a fallback when the model or a tool is unavailable?
• Is there a plan for retraining or refreshing table models as data drifts?

Common mistakes

• Using the top tier for every call without measuring.
• Letting the model do arithmetic instead of running code.
• Pasting a full large table into the prompt.
• Skipping a plan on a long task, then getting lost mid-run.
• Giving broad write access with no approval step.
• Treating a fluent report as verified. Check the numbers.
• Letting leakage in: a feature that contains the answer, or a random split on time-ordered data.
• Believing that a good predictive model proves a cause.
• Forgetting that the context is finite, and not saving state to files.
• Ignoring prompt injection from documents, web pages and tool results.
• Not pinning versions, then seeing behavior shift after an update.
• Using an LLM judge without calibrating it against human review.
• Reading only final answers and never the trace of intermediate steps.
• Over-trusting self-review without an objective test.

Frequently asked questions

What is Claude Opus 5.5 designed for?

It is designed for demanding work such as complex software engineering, analysis of long documents and orchestration of multi-step agents. It is the high capability tier, chosen when quality on hard tasks matters more than the lowest cost or latency.

When should I choose Opus instead of Sonnet?

Choose Opus when a task is complex, spans many constraints or steps, or when a balanced model fails your evaluation in ways that look like lack of depth. If Sonnet already passes your tests, it is usually the better choice for cost and speed.

Is Opus 5.5 the most capable Claude model?

No. Claude Fable 5.1 is described as a top tier model for the hardest reasoning and agentic work. Opus 5.5 is a flagship that sits just below that, aimed at complex but common professional tasks.

Can Opus 5.5 build and run a machine learning pipeline on a table?

Yes, it can plan the pipeline, write the code, run it through tools, check for leakage and explain the results. The numeric learning is done by the libraries or models it calls, such as gradient boosting or a tabular foundation model, not by the language model itself.

How does it relate to tabular foundation models?

It is a language model and not a tabular foundation model. It acts as planner, coder and explainer around table-native models, which learn directly from rows and columns. Used together, each does what it is best at.

Can it work for hours on a long task?

It can take part in long-running agent workflows when the system around it provides state, checkpoints and budgets. Reliability depends heavily on that design: saved notes, plans in files, tests, and periodic human review.

Does it remember earlier conversations?

Not by default. Each request carries its own context. Memory has to be built by your application, for example through notes files or a database that you read back into the prompt.

How do I reduce cost when using Opus?

Use it only for steps that need it, delegate simple work to lighter models, cache repeated prefixes, batch non-urgent jobs, and cap output and reasoning budgets. Measure cost per completed task rather than per call.

Is it safe to give it access to a production database?

Only with strong controls. Use read-only credentials, restrict tables, run generated code in a sandbox, log everything and require human approval for any change. Treat all text coming from data and documents as untrusted.

Where do I check current features and limits?

Use the official provider documentation. Context sizes, features, availability and prices change over time, and this page avoids quoting figures that may become outdated.

Glossary

• Agent: a loop in which a model plans, calls tools and observes results.
• Agentic coding: using a model to write, run and fix code with tool access.
• Checkpoint: a saved state that lets work resume.
• Context window: the amount of text a model can consider at once.
• Eval: a repeatable test set for measuring quality.
• Extended thinking: extra reasoning tokens before the answer.
• Flagship: the high capability tier of a model family.
• Guardrail: a rule or check that constrains behavior.
• Human in the loop: a person reviewing or approving steps.
• Leakage: information in training features that would not be available at prediction time.
• Long-horizon task: work with many steps over a long time.
• Orchestrator: a model that plans and delegates.
• Prompt injection: text that tries to override the model's instructions.
• Rolling-origin evaluation: testing a forecast repeatedly at successive cutoff dates.
• Sandbox: an isolated place to run untrusted code.
• Sub-agent: a helper with a narrow task and its own context.
• Tool call: a structured request to run an external function.
• Trace: the recorded steps of an agent run.

Summary

Claude Opus 5.5 is a high capability Claude model for complex coding, long document analysis and multi-step agent work. It earns its cost on tasks that need planning, many constraints held at once, and recovery from errors. Around tabular data it acts as planner, coder, reviewer and explainer, while table-native models such as TabPFN and TabICL do the direct learning from rows and columns. Keep calculations in code, state in files, risky actions behind approvals and quality under evals. Choose among Claude Haiku 5.5, Claude Sonnet 5.5, Opus and Claude Fable 5.1 by measurement, not habit. For the table-native side, see /model/research and /model/benchmarks.

Related

It belongs to Frontier models in my stack, under LLMs, retrieval, and evaluation. Others in the same group: