Claude Sonnet 5.5 Migration: The Breaks That Return 200 Are the Ones to Test For

Moving from Claude Sonnet 5 to Claude Sonnet 5.5, which shipped on September 28, 2026, takes more than a new model ID. Anthropic's documentation lists five breaking changes, and four of them return an HTTP 400 on the first request that uses them. The rest, including two changes outside the five, can return HTTP 200 with no error.

Two examples show how. The API hands back reasoning with each response, in thinking blocks. When the model cannot read one, the API drops it without a word. And the status text an interface shows between tool calls can stop arriving.

That split decides how to test. A test that watches for errors passes the loud breaks. The quiet ones need a test that asks what should be present and is not: a tool call, a block of reasoning, a status line on screen.

Four of the five breaks announce themselves with a 400

A staging run that exercises each request path finds these four.

The table lists the five from Anthropic's what's-new page, plus two changes from the same pages that the list of five leaves out.

Table: What the first request returns after the swap to Claude Sonnet 5.5

Four rows fail on the first request. The thinking-block row can do either. The last two never fail.

Three terms recur below. Effort, set in output_config.effort, controls how much Sonnet 5.5 thinks, from low to max. Adaptive thinking, the default, lets the model decide how much to think. Up-front thinking is the reasoning the model does before it starts to respond.

Sonnet 5 let a request switch that off with disabled. Sonnet 5.5 rejects disabled and offers between_tools, which skips up-front thinking and keeps the short notes the model writes between tool calls.

The table also names two things explained later. strict: true makes a tool call match its input schema, and input_transformations is a response field that lists the blocks the API removed.

A request that sends thinking: {"type": "disabled"} gets a 400. Anthropic's replacement is between_tools, and the guide's after-example sends these two fields:

{ "thinking": { "type": "between_tools" }, "output_config": { "effort": "high" } }

between_tools accepts no other thinking setting.

Adding display (which controls whether thinking text comes back), budget_tokens (the older fixed thinking budget) or block_binding (the setting that holds prefix_mismatch_behavior, covered below) returns a 400. So does xhigh or max effort. History must also stay append-only: no edits to earlier messages, the system prompt or the tools.

A forced tool call fails with this message, and the same 400 applies to the token counting endpoint:

tool_choice: type "tool" and "any" are not supported for this model.

Computer use and the advisor tool also return a 400, each with its own message.

Anthropic documents the computer-use rejection on the Claude API and Google Cloud, where computer_20251124 is refused. Amazon Bedrock still accepts it, but computer_20250124 is rejected on every platform.

The advisor tool fails when a Sonnet 5.5 executor gets an advisor outside its accepted list. Opus 4.8, Opus 4.7 and Sonnet 5 are examples.

One break errors for some accounts and stays silent for others

Sonnet 5.5 reasons before it answers. The API returns that reasoning as thinking blocks. In a tool loop, your code sends each block back unchanged with the next request. That is how the model keeps its earlier reasoning.

Each block records the model that wrote it. Sonnet 5.5 reads blocks from Sonnet 5, Opus 4.8, Haiku 4.5 and earlier models, but not blocks from Opus 5, Opus 5.5 or any Fable or Mythos model.

When a request carries a block the model cannot read, the API removes it and answers anyway.

The request succeeds.

Anthropic does not bill the dropped blocks.

A conversation that moves from Sonnet 5 onto Sonnet 5.5 keeps its reasoning. One that moves onto Sonnet 5.5 from Opus 5.5 continues without it, and so does one that falls back from Sonnet 5.5 to Sonnet 5. Another account's block is dropped the same way, because blocks work only in the account that produced them or a linked one.

Blocks are also tied to the conversation. Each one is signed over everything before it, which lets the API tell whether anything earlier has changed. Editing an earlier message, the system prompt or the tools invalidates the block.

On accounts created on or after August 31, 2026, replaying a block after such an edit returns a 400.

On older accounts, the API enforces the check only when the request sets prefix_mismatch_behavior, a field that chooses between rejecting and dropping the failing blocks. Without it, the blocks reach the model. Nothing errors. Anthropic's preserved-thinking page spells out the consequence: a run with no errors on your own key does not show whether your code is affected. If people run your tool with their own API keys, those on newer accounts see the 400 before you do.

Without a beta header, the drop is silent. A beta header is an extra HTTP header that opts a request into a preview feature. Send thinking-binding-controls-2026-08-01. Each response then lists what was removed in input_transformations:

{ "type": "thinking_dropped", "path": "messages.3.content.0", "reason": "model_binding_mismatch" }

On an older account, sending the header alone changes nothing the model receives. It only flags failing blocks as thinking_mismatch_allowed, which makes it safe for watching real traffic.

A skeptic can fairly ask whether any of this matters, since the request succeeds and the model still answers. The docs say the model answers without the reasoning in the dropped blocks. No source found for this article measures how much that changes an answer. So nobody can call the drop harmless or harmful.

Reading outputs by eye does not settle it either, because without the header nothing in the response marks the drop.

Checking costs one header and a log line.

Fixing a loud break can plant a quiet one

Forced tool use shows the pattern. Sonnet 5.5 rejects tool_choice of type any or tool. The guide's replacement is auto with strict: true, which makes every call match the tool's input schema.

Strict mode cannot make the call happen.

The model can then answer without calling the tool, so the prompt has to say when the tool applies.

The 400 is gone. So is the guarantee. An extraction step that always returned structured data can now skip it.

One independent write-up suggests the check: send inputs that should call the tool and inputs that should not, and count how often the call is missing. The app then needs a rule for a miss, such as a retry with a firmer instruction or a visible failure.

On Amazon Bedrock the problem is larger. Strict tool use is unavailable for Sonnet 5.5 there. The guide says to send auto without strict and validate the tool input in your own code.

Two more quiet changes sit outside the five

Between tool calls, Sonnet 5.5 writes short notes about what it found and what it will do next, and on Sonnet 5 those notes arrived as text blocks.

Now notes longer than a sentence or two come back as progress-update thinking blocks. The default display setting leaves those blocks empty. An interface that streams the notes goes quiet during tool calls, with no error.

Setting display to "updates" brings the text back. It is a beta feature that needs the header thinking-display-updates-2026-08-18. Under adaptive thinking, "summarized" brings it back too. Switching to between_tools does the same.

The second change concerns effort. The API default is high. Anthropic says the levels are recalibrated. A level no longer produces the same amount of thinking as on Sonnet 5. A setting carried over from the old model can therefore change how much the model thinks without any error.

Anthropic bills thinking tokens as output tokens. The bill can change too.

A pre-upgrade test that looks for what is missing

The checks below need a staging key. Each one names something that should be present. Loud breaks need no help.

A 200 response means the checks start, not that the migration is done.

1. Replay every request path on Sonnet 5.5. Each 400 from the table's loud rows appears at once.
2. Log input_transformations. Send the thinking-binding-controls-2026-08-01 header on real multi-turn sessions. Then switch models mid-conversation, for example from Opus 5.5 to Sonnet 5.5, and read the log. On an older account, also trim an old message: the log flags the failing blocks as thinking_mismatch_allowed. On a newer account the trim returns a 400 instead.
3. Count skipped tool calls. For each path that used forced tool use, send inputs that should and should not call the tool, and record how often the call is missing from the response.
4. Watch the screen. Run one tool-heavy task and check that the status text still appears between calls.
5. Re-run the effort sweep. Compare cost per completed task.
6. Repeat on every platform and account type you serve. Bedrock accepts computer_20251124, but computer_20250124 is rejected everywhere, and older accounts hide the edit check.

A migration that passes means the 400s are gone and the tool calls, the reasoning and the status lines are all still there.

FAQ

Can I just change the model ID to claude-sonnet-5-5?

Yes, if your requests avoid the changes in Anthropic's what's-new page. It lists five breaking changes, plus others such as the text between tool calls that alter the response without failing a request.

Test every request path first.

What replaces thinking disabled on Sonnet 5.5?

Send thinking: {"type": "between_tools"} at low, medium or high effort.

Anthropic's what's-new page says disabled returns a 400. between_tools itself returns a 400 at xhigh or max.

Why does forced tool_choice return a 400?

Claude Sonnet 5.5 does not support tool_choice types any or tool.

The documented replacement is auto with strict tool use, plus a prompt that says when the tool applies.

Why did my interface stop showing progress between tool calls?

Longer notes between tool calls now arrive as thinking blocks. The default display setting leaves them empty.

Set display to "summarized" under adaptive thinking, or use between_tools, to get the text back.

Does Sonnet 5.5 cost less than Sonnet 5?

The per-token prices are the same as Sonnet 5's, at $2 per million input tokens and $10 per million output tokens.

Anthropic reports up to 30% lower cost per task in its own testing. Your result depends on your prompts and your effort level.

Sources

• What's new in Claude Sonnet 5.5, Claude Platform Docs
• Migrating to Claude Sonnet 5.5, Claude Platform Docs
• Preserved thinking, Claude Platform Docs
• Claude Sonnet 5.5, Anthropic, September 28, 2026
• Migrating to Claude Sonnet 5.5? Five Changes That Break Working Code, Harel Asaf, October 2, 2026