Claude Opus 5.5 in Foundry: the Opus 5 migration cost math

Claude Opus 5.5 went generally available in Microsoft Foundry on 22 September 2026, the same day Anthropic released it, at $4 per million input tokens and $20 per million output tokens. That is 20% below Claude Opus 5 on both sides of the meter, and the cache read rate falls further still, from $0.50 to $0.20. Anthropic's headline claim is that the model costs 40% less than Opus 5 on typical workloads at default settings. For an Azure team in Sweden that already runs Opus 5 through Foundry, the claim holds for some workloads and reverses for others. Which side you land on depends on two settings most teams never wrote down: whether you disabled thinking on Opus 5, and whether you ever set effort explicitly.

What shipped on 22 September

The API ID is claude-opus-5-5 on the Claude API, Google Cloud and Foundry, and anthropic.claude-opus-5-5 on Bedrock. It keeps the 1M token context window at flat per-token pricing, 128K max output on the synchronous Messages API, and the tokenizer introduced with Opus 4.7, so a prompt that cost N tokens on Opus 5 costs N tokens here. The reliable knowledge cutoff is June 2026. Anthropic commits not to retire it before 22 September 2027.

Anthropic positions it for long-running agentic coding and knowledge work, and says it generates output more than 30% faster than Opus 5. Its own benchmark table reports 66.4% on Terminal-Bench 4.0 and 57.8% on CursorBench 4.0. Treat those as a direction of travel. The number you should trust is the one from your own eval set, run at the effort level you intend to deploy.

In Foundry, Opus 5.5 is available in both hosting versions from day one. Version 2, Hosted on Azure, runs inference end to end on Azure infrastructure and is GA. Version 1, Hosted on Anthropic infrastructure, is also GA. If you pick Default settings when deploying, Foundry gives you the Azure-hosted version. Sonnet 5.5 and Haiku 5.5 are announced for the coming weeks, which matters if you are about to lock a model choice into a procurement document.

Price sheet, September 2026

Opus 5.5 cache reads are billed at 0.05 times base input. Every other Opus model uses 0.1. The practical effect is that an Opus 5.5 cache hit now costs exactly the same as a Sonnet 5 cache hit, $0.20 per million tokens, even though the base input price is double. On Foundry these prices reach your Azure invoice as Claude Consumption Units at a fixed $0.01 each, and CCU spend decrements a Microsoft Azure Consumption Commitment.

Cost math 1: a long agent session

Use the same 60-turn session we modelled for Claude Fable 5.1 in Foundry so the numbers line up. The cached prefix averages 150K tokens per turn, giving 9M cache-read tokens across the session. Each turn writes 3K new tokens to the 5-minute cache (180K in total) and emits 2K output tokens including thinking (120K in total). Initial writes and cache misses are ignored.

At identical token counts, Opus 5.5 cuts the session by 41%, which matches Anthropic's 40% figure. Two caveats keep this from being the whole story.

First, Anthropic's own migration notes say Opus 5.5 tends to think more per turn than Opus 5 at the same effort level, most of all at xhigh and max. Thinking is billed as output. If output grows by 30% on your workload, the session costs $5.82 instead of $5.10, still 33% below Opus 5. Anthropic's counter-claim is that the model finishes tasks in fewer steps and tokens overall, and GitHub reports the same in its Copilot testing. Which effect wins is workload-specific, so measure it.

Second, the gap to Sonnet 5 has narrowed. On the price sheet Opus 5.5 costs twice as much as Sonnet 5. On this cache-heavy session it costs 48% more, because the cache reads that dominate a long loop are now priced identically. If you routed long agent sessions to Sonnet 5 purely on cost, re-run that decision.

Cost math 2: an uncached API with thinking off

The opposite workload is a high-volume extraction or summarisation endpoint. Say 100,000 requests a month, each with 20K input tokens and 1K output tokens, no cache reuse, running on Opus 5 with thinking: {"type": "disabled"} because the task does not need reasoning. That is 2,000 million input tokens and 100 million output tokens.

The 1,500-token row is an illustrative assumption, not a measurement. It exists to show the break-even: on this workload, if always-on thinking adds more than about 1,250 output tokens per request on average, Opus 5.5 costs more than the Opus 5 setup it replaces. Thinking cannot be switched off on Opus 5.5. The only lever is effort, and at low the model may still think on requests it judges complex. Run a sample of real traffic at low, read usage.output_tokens, and compare before you cut over. If the task truly needs no reasoning, Sonnet 5 with thinking disabled remains the cheaper answer at less than half the cost.

Neither table includes the US Data Zone Standard deployment type, which applies a 1.1x multiplier to every token category. The agent session becomes $5.61 and the uncached workload $11,000 before any thinking overhead.

What breaks when you swap the deployment name

Anthropic lists four breaking changes from Opus 5 plus one silent response-shape change. On Foundry, one of the four does not apply.

• Thinking cannot be disabled. thinking: {"type": "disabled"} and thinking: {"type": "enabled", "budget_tokens": N} both return 400 invalid_request_error. Omit the field or send {"type": "adaptive"}. Microsoft's partner-models table on Learn still describes Opus 5.5 with the Opus 5 rule ("when thinking disabled, effort is capped at high"), and its own Claude models page says such requests are rejected. Build against the stricter behaviour.
• Forced tool use returns 400. tool_choice of type any or tool is rejected, on the token counting endpoint too. Keep auto, add strict: true to the tool definition for schema-valid arguments, or move the schema to structured outputs. If the model must call a tool, say so in the prompt.
• Thinking blocks are bound to the model and conversation. Opus 5.5 can read thinking blocks from Opus 5, so a live conversation can move forward without losing its reasoning. A fallback from Opus 5.5 to Sonnet 5 or Opus 5 silently drops the 5.5 reasoning. For accounts created on or after 31 August 2026, replaying a thinking block after editing the system prompt, tools or an earlier message returns a 400. Keep your harness append-only and change instructions with mid-conversation system messages.
• The computer_20251124 tool is rejected on the Claude API and Google Cloud only. Foundry does not offer the newer computer_toolset_20260801 at all, and Anthropic's Foundry page says the beta computer use tool versions remain available there. If your Foundry integration uses computer use today, leave it alone.

The silent change catches more teams than the 400s do. The short notes the model writes between tool calls now arrive as thinking blocks, and at the default display: "omitted" their text is empty. No request fails. Your agent UI just stops showing progress between steps. Set thinking.display to "summarized", or to "updates" (beta) for the between-call notes, and select content blocks by type rather than by array position.

The default effort dropped from high to medium

A request without effort ran at high on Opus 5. On Opus 5.5 it runs at medium. Nothing errors. Quality on hard tasks may simply drift, and part of the advertised saving comes from this lower default. If your Opus 5 code never set effort, pin high for the first comparison so you are measuring the model change, then sweep downward. For xhigh or max, Anthropic suggests starting max_tokens at 64K because thinking and answer share that limit.

import AnthropicFoundry from "@anthropic-ai/foundry-sdk";
import { DefaultAzureCredential, getBearerTokenProvider } from "@azure/identity";

const client = new AnthropicFoundry({
  resource: "tsp-foundry-swc",
  azureADTokenProvider: getBearerTokenProvider(
    new DefaultAzureCredential(),
    "https://ai.azure.com/.default"
  ),
});

const res = await client.messages.create({
  model: "claude-opus-5-5",                        // deployment name
  max_tokens: 32000,                               // thinking + answer
  thinking: { type: "adaptive", display: "summarized" },
  output_config: { effort: "high" },               // pin it; default is now medium
  system: STABLE_SYSTEM_PROMPT,
  tools: TOOLS.map(t => ({ ...t, strict: true })), // tool_choice stays "auto"
  messages,
});

const text = res.content.filter(b => b.type === "text");   // not res.content[0]
if (res.stop_reason === "refusal") {
  // no server-side fallbacks on Foundry: reroute here
  console.warn(res.stop_details?.category);
}

What Foundry still does not give you

Several features in Anthropic's launch material are not on Foundry. Plan around them before a design depends on them.

• No fast mode. The $8/$40 fast mode for Opus 5.5 is Claude API only.
• No Message Batches API. The 50% batch price of $2/$10 is not available on Foundry. Offline jobs pay the synchronous rate.
• No server-side fallback. Opus 5.5 adds a biology classifier to the cyber one and can decline requests under a new reasoning_extraction category. A refusal returns HTTP 200 with stop_reason: "refusal", and on Foundry your client code has to retry on another deployment.
• Azure-hosted gaps. Deployments hosted on Azure reject code execution, the Files API, Agent Skills and programmatic tool calling with a 400, and support only the older web_search_20250305 and web_fetch_20250910 tool versions. Those features need the Anthropic-hosted version.
• No Anthropic rate-limit headers. Track 429s and throughput in Azure Monitor instead.

The beta features Microsoft lists for Opus 5.5 are per-turn effort, mid-conversation system messages and task_budget. Anthropic's new compact-on-demand beta has its own platform availability table, so check it before building a long-session design on it. For the base deployment walkthrough, see Claude on Azure is GA.

GitHub Copilot got it the same day

GitHub made Opus 5.5 available in Copilot on 22 September for Pro+, Max, Business and Enterprise plans, across VS Code, Visual Studio, JetBrains IDEs, the Copilot CLI, the coding agent and github.com. It is billed at provider list pricing under usage-based billing, and Business and Enterprise administrators control access through the model policy in Copilot settings. If your organisation reviews each new model before developers use it, check that policy this week rather than after the gradual rollout reaches your tenant.

The Swedish and EU angle

Sweden Central is a deployment location, not a processing boundary. Opus 5.5 is listed for Global Standard in Sweden Central, both versions. The Data Zone Standard table lists Claude only for US regions, and the Europe tab reads "Not available". A Global Standard deployment created in Sweden Central may process prompts in any Azure region. We covered what the EU Data Zone costs for OpenAI models in our Swedish cost math on the EU Data Zone premium. For Claude that option does not exist yet at any price.

Azure-hosted is a better DPIA story than Anthropic-hosted. Anthropic's Foundry documentation states that for Azure-hosted deployments, prompts and completions remain within Azure, and only usage metadata and content flagged by Anthropic's safety systems egress to Anthropic. Anthropic is still the data processor under its own Data Processing Addendum in both versions, and Microsoft classifies Claude as a Non-Microsoft Product. The Anthropic-hosted version, by contrast, "might be processed outside Azure." If you need code execution or the Files API and therefore pick version 1, write that transfer into your records of processing.

No mandatory 30-day retention. Anthropic designates Fable 5.1, Fable 5, Mythos 5.1 and Mythos 5 as Covered Models that require 30-day retention of prompts and outputs. Opus 5.5 is not on that list. For regulated Swedish workloads where Fable 5.1 was blocked on retention, Opus 5.5 is the strongest Claude model you can run without that obligation.

CSP subscriptions are excluded. Microsoft lists Cloud Solution Provider subscriptions as unsupported for Claude models in Foundry. Many Swedish mid-market companies buy Azure through a CSP partner. If that is you, Claude in Foundry needs a separate pay-as-you-go, EA or MCA subscription, which changes who holds the invoice and whether spend counts toward any commitment.

Decision guide

• Long agent sessions on Opus 5 with thinking on? Migrate. Expect roughly 30 to 40% lower session cost at similar token counts. Pin effort, fix tool_choice, and set thinking.display before you ship.
• High-volume endpoints on Opus 5 with thinking disabled? Measure first. Sample real traffic at effort: "low" and compare output tokens. If thinking adds more than about 1,250 tokens per request on a 20K-in, 1K-out workload, stay put or move to Sonnet 5.
• Choosing between Sonnet 5 and Opus 5.5 for agents? Re-run the comparison. On cache-heavy loops the premium is now closer to 1.5x than 2x.
• On Fable 5.1 and blocked by retention? Test Opus 5.5 on the same eval set. It is not a Covered Model and costs 51% less on our session model.
• Need EU-only processing? Not on Foundry, for any Claude model. Document Global Standard processing or use another platform's EU endpoint.
• Buying Azure via CSP? Arrange a supported subscription type before the pilot starts, not after.

Whichever row you are in, design the refusal fallback across deployments before cutover, since Foundry will not do it for you. For the failover pattern itself, see our multi-provider failover plan.