Model releases usually cost more than the one before them. Claude Opus 5.5 does the opposite. It landed cheaper than Opus 5, runs faster, and Anthropic puts its scores level with (or ahead of) the much pricier Fable 5.1. That combination is rare enough to be worth a hard look rather than a headline.
This is the first model in the 5.5 wave, and it arrives while Anthropic is publicly slowing its own cadence under the pace the frontier policy. So the interesting question is not “is Claude Opus 5.5 the smartest model on the board” but “does it turn the same intelligence into more finished work per dollar?” Every price and benchmark below was checked against Anthropic’s release notes, and the model was run live over the API against Fable 5.1 and Opus 5 on real DevOps tasks.
What is new in Claude Opus 5.5
Claude Opus 5.5 is a cheaper, faster Opus that Anthropic positions at Fable 5.1 performance. The per-token price dropped 20% versus Opus 5, cache reads fell 60%, output generates more than 30% faster, and on Anthropic’s own capability table it sits ahead of both Opus 5 and Fable 5.1 on every row.
The short list of what actually changed:
- Price: $4 per million input tokens and $20 per million output, down from $5 and $25 on Opus 5.
- Speed: more than 30% faster output than Opus 5, which shortens agent loops where the model writes a lot.
- Adaptive thinking: always on, with a default effort of medium. Opus 5 defaulted to high, so the same call now spends fewer reasoning tokens unless you raise the effort.
- Context: 1 million tokens in and up to 128k output (300k in the Batch API), unchanged from Opus 5.
- Knowledge cutoff: June 2026.
- Availability: the Claude API, Amazon Bedrock, Google Vertex AI, and Microsoft Foundry on day one.
Anthropic also flagged that Sonnet 5.5 and Haiku 5.5 follow in the coming weeks, so this is the top of a new family, not a one-off point bump. On safety, the model was tested pre-release by external evaluators including METR and Frontier Design, and Anthropic calls it the strongest performer on its automated behavioral audit to date. On biology it matches or beats the Mythos line, and Anthropic applies cybersecurity safeguards similar to Fable 5.1’s, so it ships under the same tier of protections.
Claude Opus 5.5 pricing
Claude Opus 5.5 costs $4 per million input tokens and $20 per million output tokens. That is 20% below Opus 5 on raw tokens and 60% below Fable 5.1, which still bills at $10 and $50.
| Rate (per 1M tokens) | Opus 5.5 | Opus 5 | Fable 5.1 |
|---|---|---|---|
| Input | $4 | $5 | $10 |
| Output (thinking billed here) | $20 | $25 | $50 |
| Cache write | $5 | $6.25 | $12.50 |
| Cache read | $0.20 | $0.50 | $0.25 |
| Fast mode input / output | $8 / $40 | n/a | n/a |
Anthropic makes two separate claims here, and they are worth keeping apart. The 20% figure is the sticker price on tokens. The larger “about 40% cheaper on typical workloads” figure assumes the model also finishes tasks in fewer tokens because it reasons more efficiently. The first number is guaranteed. The second depends entirely on your prompts, and our own tests below show it holds on some tasks and not others.
Claude Opus 5.5 benchmarks
On Anthropic’s published benchmark table, Claude Opus 5.5 leads Opus 5 and Fable 5.1 across agentic coding, knowledge work, computer use, and reasoning. The headline is agentic coding: Terminal-Bench 4.0 at 66.4%, roughly ten points clear of both Fable 5.1 and GPT-6 Astra.
| Benchmark | Opus 5.5 | Fable 5.1 | Opus 5 | GPT-6 Astra |
|---|---|---|---|---|
| Terminal-Bench 4.0 (agentic coding) | 66.4% | 55.8% | 52.3% | 57.9% |
| FrontierCode v1.1 | 54.4% | 50.3% | 48.0% | 53.3% |
| CursorBench 4.0 | 57.8% | 51.8% | 46.6% | n/a |
| GDPval-AA v2.1 (knowledge work, Elo) | 1846 | 1735 | 1708 | 1542 |
| AutomationBench | 40.0% | 31.4% | 26.9% | 41.4% |
| Humanity’s Last Exam (with tools) | 67.7% | 65.6% | 63.6% | 57.2% |
| Terminal-Bench-Science 0.1 | 58.7% | 52.6% | 29.0% | 64.6% |
| OSWorld 2.0 (computer use) | 81.8% | 80.7% | 74.0% | n/a |
| Chartography (with tools) | 89.0% | 88.4% | 83.4% | n/a |
Two honest caveats. GPT-6 Astra still edges Opus 5.5 on AutomationBench (41.4 vs 40.0) and clears it on Terminal-Bench-Science (64.6 vs 58.7), so “beats every rival everywhere” is not the story. And there is no clean same-harness public comparison against GPT-6 Sol yet, so treat the cross-vendor rows as directional. Independently, Artificial Analysis puts Opus 5.5 at an Intelligence Index of 58 against Fable 5.1’s 53, with output around 93 tokens per second at xhigh effort.
How Claude Opus 5.5 compares to Fable 5.1 and Opus 5
Opus 5.5 is designed to make Fable 5.1 hard to justify for most agentic and coding work. It matches or beats Fable on the published benchmarks while charging 60% less per token, and it is faster. Fable 5.1 keeps a niche at the very hardest frontier problems and where its specific tuning helps, but the default recommendation for coding agents shifts down a tier.
Against Opus 5, the pitch is “same family, less money, more speed.” The one behavior change to plan for is the default effort dropping to medium. If you relied on Opus 5’s high-effort default for hard reasoning, you now set effort explicitly instead of getting it for free.
Anthropic and early testers cite large real-world runs, a 680,000-line migration finished in under a day and a 200,000-line audit in under three hours against Opus 5’s twenty-plus. Those are vendor-selected customer results, not independent benchmarks, so read them as supporting evidence rather than proof. The cleaner test is one you can reproduce, which is what we did next.
Testing Claude Opus 5.5 on real DevOps tasks
We ran Claude Opus 5.5, Fable 5.1, and Opus 5 through the same three DevOps tasks over the API, with an identical terse system prompt that asked for the file contents only. Each answer was graded by the tool that would actually reject it in a pipeline: kubeconform -strict for the Kubernetes manifest, shellcheck for the bash script, and tofu validate plus tofu fmt for the Terraform. Cost is computed from the published per-token rates, thinking tokens included.
| Task (grader) | Opus 5.5 | Fable 5.1 | Opus 5 |
|---|---|---|---|
| K8s Deployment + Service (kubeconform -strict) | Valid, $0.037, 15.3s | Valid, $0.047, 13.2s | Valid, $0.037, 17.4s |
| Bash S3 backup script (shellcheck) | Clean, $0.034, 13.0s | Clean, $0.032, 9.4s | 1 warning, $0.058, 23.8s |
| Terraform VPC + security group (tofu validate) | Valid, $0.019, 7.2s | Refused, $0.003, 1.8s | Valid, $0.022, 8.6s |
Opus 5.5 completed all three tasks with output that passed every linter. The Kubernetes task is the “Fable-level at lower cost” claim in one line: both models produced a valid manifest, but Fable 5.1 charged $0.047 to Opus 5.5’s $0.037 for it, purely because its per-token rate is two and a half times higher. Fable used fewer tokens and still cost more.
Across all three tasks, Opus 5 was the priciest to run ($0.117 versus $0.090 for Opus 5.5), driven by the bash task, where it spent 2,276 output tokens, took 23.8 seconds, and left a helper function it never called. Shellcheck flagged that as SC2329. Small, but it is the kind of dead code a reviewer sends back.
The token-efficiency claim was uneven. Opus 5.5 used fewer output tokens than Opus 5 only on the bash task (1,640 versus 2,276). On the Kubernetes and Terraform tasks it used more (1,810 versus 1,441, and 921 versus 834), and on Terraform it still came out cheaper only because its per-token rate is lower. The 20% price cut is the dependable part. The “fewer tokens per task” saving showed up on one of three workloads here, so budget on the sticker price and treat the rest as upside.
stop_reason “refusal”: the task Opus 5.5 finished and Fable 5.1 would not
On the Terraform task, Fable 5.1 returned an API response with stop_reason set to refusal and zero output tokens. It declined to write a security group that opens ports 22 and 443, and repeated runs under the same system prompt returned the same refusal every time. Opus 5.5 produced valid, fmt-clean Terraform on every attempt.
This is prompt-sensitive rather than a hard policy block. Loosening the system prompt to a conversational framing let Fable 5.1 complete the same request, and its refusals on these infrastructure prompts were not perfectly consistent. The practical point stands: under a strict, tool-style system prompt of the sort agents actually use, the cheaper model finished a routine task that the pricier one balked at. That lines up with Anthropic’s framing that Opus 5.5 completes work where Fable stops, and it is the sort of reliability difference that matters more in an unattended agent loop than a benchmark point.
Breaking API changes when moving from Opus 5
Swapping the model ID to claude-opus-5-5 is not always a drop-in replacement. Four behaviors changed from Opus 5, and code that assumes the old defaults will start returning HTTP 400.
Thinking cannot be disabled. There is no thinking-off mode. Control cost with the effort setting instead, and remember the default is now medium rather than high.
Forced tool use is gone. A tool_choice of any or a named tool now errors. Replace it with auto plus strict tool use or structured outputs:
// Old (Opus 5): forces a tool call
"tool_choice": { "type": "any" }
// New (Opus 5.5): let the model choose, enforce shape with strict tools
"tool_choice": { "type": "auto" }Thinking blocks are bound to the model and the conversation. An earlier model cannot read Opus 5.5 thinking blocks, and the API drops them if you switch models mid-conversation. Do not try to replay reasoning across models.
Computer use moved to a new toolset. On the Claude API and Google Cloud, the old computer_20251124 tool is rejected. Declare computer_toolset_20260801 and update the agent loop to match. Anthropic keeps a full Opus 5.5 migration guide with the specifics.
How to use Claude Opus 5.5
The model ID is claude-opus-5-5. A minimal call over the Claude API looks like this. The key comes from an environment variable, never hardcoded:
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: ${ANTHROPIC_API_KEY}" \
-H "anthropic-version: 2023-06-01" \
-H "content-type: application/json" \
-d '{
"model": "claude-opus-5-5",
"max_tokens": 1024,
"messages": [{"role": "user", "content": "Write a healthcheck probe for an nginx pod."}]
}'The response body reports the model that served the request and a usage block that splits input, output, and thinking tokens (abridged below). That thinking count is what you watch, because it bills at the output rate:
"model": "claude-opus-5-5",
"stop_reason": "end_turn",
"usage": {
"input_tokens": 26,
"output_tokens": 247,
"output_tokens_details": { "thinking_tokens": 184 }
}For interactive coding it is already selectable in the Claude apps and inside Claude Code through the model picker. If you are choosing an agent for infrastructure work, our DevOps coding agent benchmark covers how the harness around the model matters as much as the model itself.
Should you switch from Opus 5 to Opus 5.5
For almost every coding and agent workload, yes. It is cheaper on tokens, faster, and scored better in both Anthropic’s tables and our own graded run, and in testing it completed a task Fable 5.1 refused. The switch costs you a model-ID change plus the four migration fixes above, and the biggest gotcha is the default effort dropping to medium, so set effort explicitly on hard reasoning jobs.
Where to slow down: if you are on Fable 5.1 for genuinely frontier-hard problems, run your own eval before moving, because a couple of benchmarks still favor Fable and GPT-6 Astra. And do not assume the full 40% workload saving, budget on the 20% token cut and let the token efficiency be a bonus. For the wider picture of where this sits against OpenAI’s lineup, the GPT-6 Astra and Opus 5 comparison and the Fable 5.1 breakdown are the two to read next.
