Claude Sonnet 5.5: a practical guide to price, effort, benchmarks and migration

Claude Sonnet 5.5 is Anthropic’s mid-tier model in the Claude 5.5 family, released on 28 September 2026 with the model ID claude-sonnet-5-5. It keeps Sonnet 5’s list price of $2 per million input tokens and $10 per million output tokens, halves the cache-read price to $0.10, and, according to Anthropic, typically needs far fewer tokens to do the same work while generating output more than 30 per cent faster than its predecessor.

That makes it the default candidate for most production traffic that is not the hardest, most open-ended work: everyday coding agents, tool-using assistants, document and spreadsheet generation, and chat. It also ships with five API changes that break code written for Sonnet 5, a recalibrated effort scale, and safety classifiers that can decline requests in five categories. Teams that swap the model string and nothing else will hit 400 errors if they disabled thinking or forced tool use.

This guide is for engineers and technical leads deciding whether to move traffic to Sonnet 5.5. It covers the specifications, what Anthropic and independent testers report, how it compares with Opus 5.5, Haiku 5.5 and Sonnet 5, worked cost examples, the parameters that changed, where it runs, how to use it in Claude Code, and a migration checklist. Every figure was checked against Anthropic’s documentation, its system card and the cloud providers’ pages on 21 October 2026.

Claude Sonnet 5.5 at a glance

Anthropic describes Sonnet 5.5 as “the best combination of speed and intelligence” in its models overview, rating its latency as “Fast” against “Moderate” for Opus 5.5 and “Fastest” for Haiku 5.5. The specifications below come from the Sonnet 5.5 model page and the pricing page.

Three lines in that table matter more than they look. The 1M context window is billed at the standard rate across its whole length, which the long-context pricing section confirms for every model from the 4.6 generation except Haiku 5.5. The model page notes that setting temperature, top_p or top_k to a non-default value returns a 400 error, so any sampling parameters carried over from older code must go. And the minimum cacheable prompt is now 512 tokens, down from 1,024 on Sonnet 5, according to the prompt caching limits, which means shorter system prompts now qualify for the cache.

What changed from Sonnet 5

The headline change is efficiency rather than price. Anthropic’s announcement says Sonnet 5.5 costs up to 30 per cent less per task than Sonnet 5 in its testing, generates output more than 30 per cent faster, and is “our fastest Sonnet model to date”. Customer reports quoted on the same page point the same way: Slack says its Slackbot evals improved with about 14 per cent fewer output tokens, and Balyasny Asset Management reports about 121,000 tokens per answer on a 2,441-task finance suite against 497,000 for Sonnet 5. These are vendor-selected testimonials, not independent measurements.

The pricing change is narrow. The What’s new page states that Sonnet 5.5 has the same prices as Sonnet 5 except for cache reads, which fall from $0.20 to $0.10 per million tokens. Cache hits on Sonnet 5.5 and Opus 5.5 are priced at 0.05 times the base input rate, against the 0.1 times that applies to most other models.

The behavioural changes need more attention:

• Effort is recalibrated. A given level does not produce the same amount of thinking as it did on Sonnet 5, and Anthropic tells developers to re-run the effort sweep rather than carry a setting over.
• Text between tool calls moves. Notes longer than a sentence or two that the model writes between tool calls now come back as progress-update thinking blocks, which are empty under the default display setting. An interface that streamed those notes goes quiet with no error.
• Safeguards widen. Sonnet 5.5 is the first Sonnet model to launch with cyber safeguards and fallbacks, because Anthropic judges its cyber capability comparable to Opus 5’s. Declines arrive as stop_reason: "refusal" with one of five categories: cyber, bio, frontier_llm, reasoning_extraction and general_harms.
• New API features. Mid-conversation system messages, mid-conversation tool changes (beta) and per-message effort (beta) are supported on Sonnet 5.5 but not on Sonnet 5.

The system card frames the safety position. Anthropic’s Responsible Scaling Policy evaluations found Sonnet 5.5 “broadly less capable than Opus 5.5 across domains” and that it “does not cross any new RSP thresholds”, according to the executive summary of the Sonnet 5.5 system card. The same summary calls it Anthropic’s most robust Sonnet-class model yet against prompt injection, particularly in coding and browser use, while noting that its thinking “is more illegible than many previous models”.

Benchmarks: what Anthropic reports and what independent tests show

Most of the numbers in circulation come from Anthropic. The table below reproduces the capability summary in the system card (Table 8.1.A), where every result uses adaptive thinking at max effort, default sampling settings and an average over five trials unless noted. Competitor figures in that table are drawn from other developers’ published cards or leaderboards.

Several conditions change how these should be read.

Terminal-Bench 4.0 was run with safeguards on. The system card says the 70.6 per cent figure used Claude Code in --bare mode at max effort, with 1.2 per cent of requests flagged and answered by the fallback model, and a standard error of plus or minus 2.5 points over 330 trials. Opus 5.5’s 66.4 per cent is reported at xhigh, where it scored highest. The gap between the two is about the size of the combined error bars.

More effort is not always better. Sonnet 5.5 scored lower on FrontierCode at max effort than at xhigh. Anthropic’s footnote explains that Sonnet 5.5 scores lower at Max effort than at Xhigh because at max it more often ran Claude Code’s code-review skill, which split the review across subagents and in two cases caused a timeout or out-of-scope edits that the benchmark penalises.

Some “independent” numbers were run by partners on Anthropic’s behalf. CursorBench scores were measured by Cursor, FrontierCode by Cognition, and GDPval-AA and AA-Briefcase by Artificial Analysis. Anthropic notes that Artificial Analysis ran GDPval-AA and AA-Briefcase on a pre-release deployment that had a structured-outputs bug since fixed. On CursorBench, the system card gives the effort curve: 39.2 per cent at medium, 47.8 at high, 53.1 at xhigh and 55.5 at max.

Lower effort is where the cost story lives. Anthropic’s charts claim that on CursorBench, Sonnet 5.5 at low exceeds Sonnet 5’s best score for less than a tenth of the cost per task, and that on Terminal-Bench 4.0 at medium it “far exceeds” Sonnet 5’s best. These are vendor claims plotted from vendor runs.

The cleanest independent view is Artificial Analysis’s own index. As of 21 October 2026, its Sonnet 5.5 page scores the model at 56 on the Artificial Analysis Intelligence Index at max effort, second of 214 models, behind Opus 5.5 at 58. It measures 135.5 output tokens per second and a cost of $5.46 per index task. The same page ranks it the most verbose model it tracks: 420 million output tokens to complete the index, against 260 million for Opus 5.5, whose cost per task is $5.98 on its own Artificial Analysis page. At max effort, in other words, Sonnet 5.5 spends enough extra tokens to come within about 10 per cent of Opus 5.5’s cost per task despite half the list price. Our October model ranking and coding model ranking put these figures in the wider field.

The practical conclusion: Sonnet 5.5’s advantage over Opus 5.5 is a function of effort. At low, medium and high it is substantially cheaper per task; at max the saving mostly disappears and Opus is the better buy.

Sonnet 5.5 vs Opus 5.5, Haiku 5.5 and Sonnet 5

The four models share a 1M context window and a 128K output limit, so the choice comes down to capability, latency, price and defaults. The table draws on each model’s documentation page and the pricing page as of October 2026.

The Artificial Analysis rows were read from each model’s page on 21 October 2026 and move as the site re-runs its evaluations. Haiku 5.5’s two price bands depend on prompt length, as the pricing page explains: a request whose prompt exceeds 100,000 tokens, including cached tokens, pays the higher rate.

When to choose Sonnet 5.5

Choose Sonnet 5.5 when the work is well scoped. Anthropic positions it as strongest at well-scoped everyday tasks, fixing bugs and producing polished documents, slides and spreadsheets. Coding agents implementing a planned change, support assistants with tools, and report generation fit that description.

Choose Opus 5.5 when judgement is the bottleneck. Anthropic’s own announcement concedes that Opus 5.5 remains clearly stronger at complex, open-ended work requiring sustained judgement. The system card’s capability table agrees on SWE-Bench Pro (89.9 against 81.3 per cent) and Humanity’s Last Exam without tools (64.4 against 56.9 per cent). If you would run Sonnet at max to get the result, run Opus at medium or high instead and compare cost per completed task.

Choose Haiku 5.5 for volume. Classification, routing, extraction and sub-agent work under 100,000 tokens of prompt cost a twentieth of Sonnet’s input price, and Anthropic’s Haiku 5.5 effort guidance says to compare its xhigh and max levels with Sonnet 5.5 before relying on them.

Stay on Sonnet 5 only temporarily. It has the same token prices, double the cache-read price and a lower index score. The one reason to stay is a dependency on behaviour Sonnet 5.5 rejects, such as forced tool_choice or thinking: {type: "disabled"}, while you fix the code.

Figure 1: Sonnet 5.5 is the default for well-scoped work; the decision to move up or down the line is about judgement and volume, not context window.

What Sonnet 5.5 costs: worked examples

List prices only tell part of the story, because thinking tokens are billed as output and caching and batching change the input bill by an order of magnitude. Three scenarios, all at Claude API list prices as of October 2026, show where the money goes. The pricing page confirms that these multipliers stack with the Batch API discount and data residency.

A support assistant with a cached system prompt

Assume one million requests a month, each carrying a 10,000-token system prompt and tool definitions that stay cached, 2,000 tokens of fresh conversation, and 600 output tokens including any thinking at low effort.

• Without caching: 12,000 million input tokens at $2 is $24,000, plus 600 million output tokens at $10 is $6,000. Total: $30,000 a month.
• With caching: 10,000 million cached tokens at $0.10 is $1,000, 2,000 million fresh tokens at $2 is $4,000, and output is still $6,000. Total: $11,000, plus cache writes, which cost 2.5 cents each for a 10,000-token prefix at the 5-minute rate.
• The same on Sonnet 5: cached reads double to $2,000, so $12,000.
• The same on Opus 5.5: $2,000 cached, $8,000 fresh, $12,000 output, so $22,000.
• The same on Haiku 5.5 (prompts under 100,000 tokens): $100 cached, $200 fresh, $300 output, so $600.

Caching removes 63 per cent of the Sonnet 5.5 bill here, and output becomes the largest line. That is why effort matters for chat: at medium and above the model “thinks briefly before almost every reply, even a greeting”, according to the Sonnet 5.5 prompting guide, and every one of those thinking tokens is billed at $10 per million.

An overnight document extraction batch

Assume 200,000 contracts, each 25,000 input tokens, with 1,500 output tokens of structured JSON.

• Synchronous: 5,000 million input tokens at $2 is $10,000, plus 300 million output tokens at $10 is $3,000. Total: $13,000.
• Batch API: input at $1 and output at $5 give $5,000 plus $1,500. Total: $6,500.
• Batch with a cached shared prefix: if 4,000 tokens of each request are an identical instruction block and they hit the cache, those 800 million tokens cost 0.05 times the $1 batch input rate, or $40 instead of $800.

Two platform caveats apply. Anthropic’s Foundry guide lists the Message Batches API among features not supported on Microsoft Foundry, and its Bedrock guide lists Message Batches among the endpoints not supported on Bedrock’s Messages-API endpoint. Google Cloud’s Sonnet 5.5 page lists batch predictions as supported.

A coding agent

For a developer running Claude Code on API billing, our Claude Code pricing guide works through a typical 21.5-million-token day at roughly $8 on Sonnet 5.5 against $16 on Opus 5.5, with caching doing most of the work. The variable to watch is effort. Anthropic’s charts suggest Sonnet 5.5 at medium beats Sonnet 5’s best Terminal-Bench score for under a tenth of the cost per task; Artificial Analysis’s numbers show that at max it costs nearly as much per task as Opus 5.5. A team that sets max as its default for Sonnet will pay close to Opus prices for slightly lower scores.

Modifiers that change the bill

• US-only inference. Setting inference_geo: "us" applies a 1.1x multiplier on all token categories, so the $11,000 support assistant becomes $12,100.
• Regional cloud endpoints. Bedrock regional endpoints and Google Cloud multi-region endpoints carry a 10 per cent premium over global endpoints.
• Tool definitions. Using tools adds a 286-token system prompt for Sonnet 5.5, per the pricing page’s tool-use table, on top of your own tool schemas.
• Refusals. Whether a refusal that arrives before any output is billed depends on its category, and it counts against rate limits either way.

The API parameters that changed

Five breaking changes affect code already running on Sonnet 5, and several affect code from Sonnet 4.6 and earlier. The What’s new page is the authoritative list; what follows is what each one means in practice.

Thinking: between_tools replaces disabled

On Sonnet 5.5, thinking: {"type": "disabled"} returns a 400 invalid_request_error. The replacement is thinking: {"type": "between_tools"}, the lowest thinking setting, which needs no beta header and works on every platform that offers the model. Its rules are strict:

• It is accepted only at low, medium and high effort; at xhigh or max it returns a 400.
• It takes no other field. display, budget_tokens or block_binding alongside it is a 400.
• Effort cannot change mid-conversation while it is in use.
• Short progress updates between tool calls still come back as thinking blocks, which must be passed back unchanged.
• Only Sonnet 5.5 accepts it, so a router or retry that re-sends the same body to another model must strip it.

Anthropic’s guidance is to try adaptive thinking at low effort first, because at low the model skips thinking on most simple requests, and to fall back to between_tools only where a route must stay thinking-off. The prompting guide adds that any instruction telling the model not to think should be removed, because such instructions make it more likely to leak internal XML tags into visible output.

import anthropic

client = anthropic.Anthropic()

# Preferred replacement for a thinking-disabled route: adaptive thinking at low effort
resp = client.messages.create(
    model="claude-sonnet-5-5",
    max_tokens=16000,
    output_config={"effort": "low"},
    messages=[{"role": "user", "content": "Summarise this ticket in two lines: ..."}],
)

# Where the route must stay thinking-off: between_tools, at high effort or below
resp = client.messages.create(
    model="claude-sonnet-5-5",
    max_tokens=16000,
    thinking={"type": "between_tools"},
    output_config={"effort": "high"},
    messages=[{"role": "user", "content": "..."}],
)

# Responses can start with a thinking block: read content by type, not position
text = "".join(b.text for b in resp.content if b.type == "text")

Effort: recalibrated, and the defaults differ by surface

Effort accepts low, medium, high, xhigh and max, set in output_config.effort. The Claude API default is high, while Anthropic’s announcement says the default effort is set to Medium in Claude Code and the Claude apps. Anthropic’s recommended starting points are:

Two side effects are documented. At low and medium, on long agentic tasks, the model is more likely to stop and check in before finishing, and at low it can skip verifying a code change; the prompting guide’s section on verification on coding tasks supplies a system-prompt paragraph to counter that. At xhigh and max the model can start its own review rounds, sometimes with subagents. And because thinking counts toward max_tokens, Anthropic recommends setting max_tokens to 128,000 and streaming for agentic coding.

Changing the top-level effort between requests invalidates the prompt cache. Per-message effort (beta) changes the level partway through a conversation without losing the cache, but it requires adaptive thinking.

Forced tool use is gone

tool_choice set to {"type": "any"} or {"type": "tool", "name": "..."} returns a 400, including on the token-counting endpoint. auto and none still work. The documented replacements are auto plus a prompt that says when the tool applies, with strict: true on the tool for schema-valid arguments, or structured outputs when the forced call existed only to get JSON back. Because auto does not guarantee a call, code should check that one was made.

Thinking blocks are bound to model, conversation and account

Every thinking block records the model that produced it. Sonnet 5.5 reads blocks from Sonnet 5, Opus 4.8, Haiku 4.5 and earlier models, but only Opus 5.5 reads Sonnet 5.5’s blocks, and only on the Claude API and Google Cloud. Any other switch away from Sonnet 5.5 runs the following turns without the earlier reasoning; the request succeeds and the dropped blocks are not billed.

The API also checks that the system prompt, tools and earlier messages have not changed since a block was produced. For accounts created on or after 31 August 2026, a request that replays a block after such an edit returns a 400 by default. Harnesses that rewrite history, prune old tool results or swap tools mid-session need to become append-only, using mid-conversation system messages instead of edits. Finally, Sonnet 5.5’s blocks stay with the account that produced them or a linked account; another account’s blocks are dropped.

Computer use, the advisor tool and refusals

• Computer use. On the Claude API and Google Cloud, only the computer_toolset_20260801 toolset is accepted; computer_20251124 returns a 400. Bedrock still accepts computer_20251124.
• Advisor tool. A Sonnet 5.5 executor rejects Opus 4.8, Opus 4.7, Sonnet 5 and Haiku 5.5 as advisors, and every advisor it accepts returns encrypted advice.
• Refusals. Server-side fallback (fallbacks: "default", beta, Claude API only) retries cyber and frontier_llm declines on Sonnet 5 but does not retry bio, reasoning_extraction or general_harms, according to the migration guide. On other platforms, the SDK’s client-side middleware or your own retry is the option.

Where Sonnet 5.5 runs

Sonnet 5.5 shipped on every major channel on launch day, but the feature surface differs by platform. The table summarises each one as documented in October 2026.

AWS’s launch post says Sonnet 5.5 is available today on Amazon Bedrock through the global cross-region inference profile, and Anthropic’s Bedrock guide notes that Bedrock sets access criteria for each Claude model individually, so check model access in the console before planning a rollout. Google Cloud’s model page lists it as GA from 28 September 2026 with quotas of 2,500 requests and 25 million input tokens per minute on the global endpoint, and notes that between_tools is the lowest thinking setting.

Foundry needs a closer look. Anthropic’s Foundry guide states that Sonnet 5.5 supports only Global Standard deployments, while Microsoft’s model catalogue entry also mentions US Data Zone. Deployments hosted on Azure lack code execution, newer web search and web fetch versions, Agent Skills, programmatic tool calling and the Files API, per the guide’s list of features not supported when hosted on Azure. Confirm the deployment type in the Foundry portal before committing.

On the Claude API, Sonnet 5.5 has its own rate-limit pool: the rate limits page says Sonnet 5.5 and Sonnet 5 each have a separate rate limit, outside the combined Sonnet 4.x bucket. The published defaults are 1,000 requests, 2 million input tokens and 400,000 output tokens per minute on the Start tier, rising to 10,000 requests, 10 million and 2 million on Scale. Moving volume from Sonnet 5 means checking the new pool’s headroom, not assuming it inherits the old one. Key management and workspace limits are covered in our guides to Claude API keys and Claude platform administration.

Running Sonnet 5.5 across providers

Teams that buy Claude through more than one channel often want the same model reachable on the Claude API, Bedrock and Google Cloud so that a regional outage or a 429 on one does not stop traffic. That routing usually lives in a gateway rather than in each application, as our piece on gateways for Bedrock, Vertex and Azure failover explains. Bifrost, Maxim AI’s open-source Go gateway, is one example: requests carry an ordered list of provider/model fallbacks, and the documentation says each fallback gets its own full retry budget and re-runs governance and logging plugins. Virtual keys carry per-team budgets and rate limits, and Claude Code can point at the gateway through ANTHROPIC_BASE_URL with Sonnet pinned to a provider-prefixed ID, as the Claude Code integration page shows for Bedrock. Advanced controls such as SSO, RBAC and audit logs come with the enterprise tier.

Two Sonnet 5.5 specifics apply to any cross-provider setup. Server-side fallback exists only on the Claude API, so refusal handling elsewhere is the gateway’s or the client’s job. And thinking blocks are bound to the account that produced them, so a mid-conversation failover to a provider account that is not linked to the original one continues without the earlier reasoning. The request succeeds, but long agentic sessions may behave differently after the switch.

Using Sonnet 5.5 in Claude Code

Sonnet 5.5 requires Claude Code v2.1.284 or later, according to the model configuration page. From that version the sonnet alias resolves to Sonnet 5.5 on the Anthropic API. It is not the default model: Claude Code’s default setting resolves to Opus 5.5 on Pro, Max, Team, Enterprise and the Anthropic API, and on Bedrock, Google Cloud and Claude Platform on AWS. On Microsoft Foundry, default resolves to Sonnet 4.5.

The provider matters more than people expect. The same alias table says sonnet resolves to Sonnet 4.6 on Claude Platform on AWS and to Sonnet 4.5 on Bedrock, Google Cloud and Foundry. A team on Bedrock that types /model sonnet gets a model two generations old. Pin it explicitly:

# Anthropic API: the alias is enough
claude --model sonnet

# Amazon Bedrock (Invoke API, global cross-region profile)
export CLAUDE_CODE_USE_BEDROCK=1
export ANTHROPIC_DEFAULT_SONNET_MODEL='global.anthropic.claude-sonnet-5-5'

# Google Cloud or Microsoft Foundry
export ANTHROPIC_DEFAULT_SONNET_MODEL='claude-sonnet-5-5'

Claude Code’s documentation tells administrators to pin model versions before rolling out to users on third-party providers, because the built-in default can lag the newest release or point at a model not enabled in the account.

Effort in Claude Code defaults to medium for Sonnet 5.5, Opus 5.5 and Haiku 5.5, and high on most other models. The effort guidance describes medium as fitting “day-to-day engineering work with a clear scope” and high for work where verification matters, such as fixing a bug in an existing codebase. Change it with /effort, the --effort flag, the CLAUDE_CODE_EFFORT_LEVEL variable or per-model modelSettings; max applies to the current session only unless set through the environment variable.

The most useful pattern is to pair the models. The opusplan setting uses Opus in plan mode and switches to Sonnet for execution. That matches the division Anthropic describes in its announcement and that one quoted tester puts plainly: Opus sets the architecture, Sonnet implements it. For subagents and skills, the model and effort frontmatter fields let a team run reading-heavy or routine subtasks on Sonnet 5.5 at low or medium while the main session stays on Opus.

Migration checklist

The migration guide organises changes by starting model. The list below covers code coming from Sonnet 5, with the additional steps for older models after it.

Figure 2: Most of the work is in steps two to four; the model ID change is the easy part.

1. Change the model string to claude-sonnet-5-5 (anthropic.claude-sonnet-5-5 on Bedrock). There is no date suffix.
2. Replace thinking: {type: "disabled"}. Try adaptive thinking at low effort and measure time to first token; where the route must stay thinking-off, send between_tools at high or below, and strip it from anything re-sent to another model.
3. Replace forced tool_choice with auto plus strict: true and a prompt instruction, or structured outputs. Check that the call happened.
4. Read content by block type and pass thinking blocks back unchanged. Responses can begin with an empty thinking block.
5. Make conversation history append-only. Use mid-conversation system messages for instruction changes and avoid editing or pruning earlier turns.
6. Move computer use to computer_toolset_20260801 on the Claude API and Google Cloud.
7. Check advisor pairings if you use the advisor tool.
8. Handle stop_reason: "refusal" before reading content, and configure server-side fallback on the Claude API or a client-side retry elsewhere.
9. Restore progress updates if your interface showed text between tool calls: set display: "updates" (beta) or "summarized" with adaptive thinking.
10. Re-run the effort sweep and set effort explicitly per route.
11. Re-check rate limits for the separate Sonnet 5.5 pool before shifting volume.

From Sonnet 4.6 or earlier, also replace budget_tokens with an effort level, remove non-default temperature, top_p and top_k, expect thinking on requests with no thinking field, and recount tokens. From Sonnet 4.5 or earlier, replace assistant prefills, parse tool input with a JSON parser, and move output_format to output_config.format. From Haiku 4.5, re-baseline cost at the higher per-token price.

Prompt changes worth testing

Anthropic says existing Sonnet 5 prompts should perform well without changes, but its prompting guide flags a few patterns. Remove language that discourages tool use, such as “minimize tool calls”, because the model follows it literally and can answer from training knowledge when a connected search would be better. Deliver mid-task user input as a user turn rather than inside a tool result, which the model can read as prompt injection. Add the guide’s “keep working until everything the user asked for is done” paragraph if low-effort agents stop to check in too often, and its scope paragraph if the model adds tests and docs nobody requested. And give it crop, zoom or code tools for dense charts: the guide reports these help chart reading at every effort level, more than raising effort does.

Limits of the evidence

Three caveats should temper any migration plan.

First, almost every headline benchmark is vendor-reported or run by a launch partner, and several were run with Anthropic’s own harness, Claude Code in --bare mode. The Terminal-Bench gap over Opus 5.5 sits inside the reported error bars. Independent aggregates such as Artificial Analysis rank Sonnet 5.5 second, behind Opus, not ahead of it.

Second, the cost advantage is conditional. Anthropic’s “up to 30 per cent less per task” claim and its tenth-of-the-cost charts are measured at lower effort settings. At max, Artificial Analysis records Sonnet 5.5 as the most verbose model it tracks, and its cost per task approaches Opus 5.5’s.

Third, the new safety classifiers and preserved thinking have real operational cost. Some benign requests will decline under general_harms, the system card notes regressions in some multi-turn harmlessness areas, and harnesses that edit history will need rework before new accounts can use them at all. None of this is a reason to avoid the model, but each is a reason to stage the rollout behind evals rather than flip the model string.

What to do

• Move well-scoped traffic now. Coding agents on planned changes, tool-using assistants and document generation should go to Sonnet 5.5 at medium or high, after the migration checklist.
• Do not default to max. Measure medium, high and xhigh on your own tasks; if only max is good enough, compare Opus 5.5 at medium on cost per completed task.
• Turn on caching and batch where they fit. The halved cache-read price makes cached prefixes the largest saving on Sonnet 5.5, and batch halves everything else for offline work.
• Pin the model on cloud providers. On Bedrock, Google Cloud and Foundry, Claude Code’s sonnet alias does not point at Sonnet 5.5 unless you set it.
• Budget for refusals and history rules. Handle stop_reason: "refusal", decide on fallback per platform, and make harnesses append-only before new accounts hit the 400.

Sonnet 5.5 is the strongest argument yet that the mid-tier model, not the flagship, should carry most production traffic. The condition is that teams treat effort as a per-route setting they measure, because at the top of the dial the price advantage is gone.