# Claude Sonnet 5.5 Rejects Forced Tool Calls, and Sonnet 4.5 Users Have Until November 30

**Claude Sonnet 5.5 shipped on September 28, 2026 at an unchanged $2 input and $10 output per million tokens, and it returns 400 on five Sonnet 5 request patterns.** Anthropic's [launch announcement](https://www.anthropic.com/claude-sonnet-5-5) says the model generates output more than 30% faster than Sonnet 5. That page flags two migration items: switching thinking-off code to `between_tools`, and a change to preserved thinking when conversations move between accounts. Forced tool use, computer use and the advisor pairings are only in the developer docs. Two days later, Anthropic scheduled Claude Sonnet 4.5 for retirement on November 30, 2026 and named `claude-sonnet-5-5` as the replacement.

A team on Sonnet 5 can upgrade on its own schedule until at least June 30, 2027. A team on Sonnet 4.5 has a date, and the recommended destination is the model with the longest list of rejected settings.

#### Sonnet 4.5 retires on November 30; Sonnet 5 stays until at least June 30, 2027

The [model deprecations page](https://platform.claude.com/docs/en/about-claude/model-deprecations) lists `claude-sonnet-4-5-20250929` as deprecated on September 30, 2026 and retired on November 30, 2026. Requests to a retired model fail. That is a 61-day window, and 56 days remained on October 5, 2026.

| Model | Status on October 5, 2026 | Retirement | Input / output per million tokens |
|---|---|---|---|
| `claude-sonnet-5-5` | Active | Not sooner than September 28, 2027 | $2 / $10 |
| `claude-sonnet-5` | Active | Not sooner than June 30, 2027 | $2 / $10 |
| `claude-sonnet-4-6` | Active | Not sooner than February 17, 2027 | $3 / $15 |
| `claude-sonnet-4-5-20250929` | Deprecated | November 30, 2026 | $3 / $15 |

Those dates cover the platforms Anthropic operates: the Claude API, Claude Platform on AWS and Microsoft Foundry. Amazon Bedrock and Google Cloud set their own retirement schedules, so a Sonnet 4.5 workload there may run on a different clock.

#### Claude Sonnet 5.5 breaking changes: five return 400, one returns no error

The [What's new in Claude Sonnet 5.5](https://platform.claude.com/docs/en/models/sonnet-5-5/whats-new-sonnet-5-5) document, published with the September 28, 2026 release, counts five breaking changes for code already running on Sonnet 5. A sixth change alters the response shape and fails no request.

| Change | What Sonnet 5 accepted | What Sonnet 5.5 does | Fix |
|---|---|---|---|
| Thinking off | `thinking: {"type": "disabled"}` | 400 `invalid_request_error` | Send `between_tools` at `high` effort or below |
| Forced tool use | `tool_choice` type `any` or `tool` | 400 `invalid_request_error` | `auto` plus `strict: true`, and name the tool in the prompt |
| Thinking-block binding | Replaying thinking blocks after editing history | 400 on accounts created on or after August 31, 2026 | Keep history append-only, or opt in to dropping blocks |
| Computer use | `computer_20251124` | 400 on the Claude API and Google Cloud | `computer_toolset_20260801` |
| Advisor tool | Opus 4.8, Opus 4.7 or Sonnet 5 as advisor | 400 `invalid_request_error` | Opus 5, Opus 5.5, Fable, Mythos or Sonnet 5.5 as advisor |
| Text between tool calls | Returned as `text` blocks | No error; moved into empty `thinking` blocks | Set `display`, or use `between_tools` |

![Overview of six Claude Sonnet 5.5 changes: five return a 400 error and one returns no error](https://s4.tenten.co/learning/content/images/2026/10/linkedin-infographic-1-4.png)

The first two rows touch parameters that ordinary requests carry. The last four only reach code that uses the matching feature.

#### Forced tool calls have no drop-in replacement

Sonnet 5.5 accepts two `tool_choice` values: `auto` and `none`. Types `any` and `tool` return a 400, and the token counting endpoint applies the same check. The error reads:

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

The [migration guide](https://platform.claude.com/docs/en/models/sonnet-5-5/migration-guide) replaces the forced call with `auto`, a strict tool and a prompt instruction:

```python
# Before: Sonnet 5, forcing get_weather
client.messages.create(
    model="claude-sonnet-5",
    max_tokens=1024,
    tools=tools,
    tool_choice={"type": "tool", "name": "get_weather"},
    messages=[{"role": "user", "content": "What's the weather in Paris?"}],
)

# After: Sonnet 5.5, auto plus strict, with the tool named in the prompt
client.messages.create(
    model="claude-sonnet-5-5",
    max_tokens=1024,
    tools=[{**tool, "strict": True} for tool in tools],
    tool_choice={"type": "auto"},
    messages=[
        {
            "role": "user",
            "content": "What's the weather in Paris? Use the get_weather tool.",
        }
    ],
)
```

The two versions promise different things. Forcing guaranteed that the model used the tool. Strict mode guarantees only that the input matches the schema when the model does use it. Under `auto` the model may answer in plain text, so the calling code needs a branch for a response with no `tool_use` block.

Strict mode has limits of its own. Every object in the schema needs `additionalProperties: false`. One API call can carry at most 20 strict tools. MCP, computer use and browser use toolset entries don't accept `strict` at all. Code that forced a tool only to get JSON back can move the schema to structured outputs through `output_config.format`.

This is already breaking shipped software. On October 3, 2026, a user of the open-source project ha-llmvision filed [issue #742](https://github.com/valentinfrlch/ha-llmvision/issues/742), reporting that its Anthropic provider fails on `claude-sonnet-5-5`. The provider sends `thinking: disabled`. For JSON responses it also forces `tool_choice` to a tool named `return_structured_data`. The reporter's workaround was to pin `claude-sonnet-4-6`, and the issue was still open on October 5, 2026.

I think this is the most expensive of the five changes. The other four are fixed by swapping a string or a tool version. This one needs a prompt edit and a new code path for the turn where the model declines to use the tool.

#### Turning thinking off now caps effort at high

Adaptive thinking is on by default in Sonnet 5.5, and the default effort on the Claude API is `high`. The `thinking` field accepts `adaptive` and `between_tools`. A `disabled` value returns a 400 whose message points to `between_tools`, the lowest thinking setting on this model. It works on every platform and needs no beta header.

```python
# Before: Sonnet 5
client.messages.create(
    model="claude-sonnet-5",
    max_tokens=16000,
    thinking={"type": "disabled"},
    output_config={"effort": "xhigh"},
    messages=[{"role": "user", "content": "..."}],
)

# After: Sonnet 5.5
client.messages.create(
    model="claude-sonnet-5-5",
    max_tokens=16000,
    thinking={"type": "between_tools"},
    output_config={"effort": "high"},
    messages=[{"role": "user", "content": "..."}],
)
```

The official sample drops `xhigh` to `high` without comment, because `between_tools` returns a 400 at `xhigh` or `max`. It also rejects any companion field, including `display`, `budget_tokens` and `block_binding`. Effort can't change mid-conversation while it is set.

Anyone who paired `disabled` with top effort to hold costs down now has to pick. Staying at `xhigh` or `max` means adaptive thinking, and thinking tokens bill as output tokens.

#### Editing history returns 400 on accounts created since August 31

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. It can't read blocks from Opus 5, Opus 5.5, or any Fable or Mythos model. Only Opus 5.5 reads Sonnet 5.5 blocks, and only on the Claude API and Google Cloud. The API drops unreadable blocks, the call succeeds, and dropped blocks aren't billed.

The second binding is to the conversation. The API checks whether anything before a Sonnet 5.5 thinking block has changed: the `system` prompt, the `tools`, or an earlier message. Accounts created on or after August 31, 2026, 00:00 UTC get that check by default on the Claude API, Amazon Bedrock and Google Cloud. Replaying a block after such an edit returns a 400 there. Older accounts skip the check unless they opt in.

So the same code passes or fails depending on when the account was opened. A suite that goes green in an older organization can fail in a customer's new one. Of everything on the list, this is the item most likely to slip through testing.

The docs give two fixes. The simpler one is an append-only conversation, with instructions and tools changed through mid-conversation system messages. The other is the `thinking-binding-controls-2026-08-01` beta header with `thinking.block_binding.prefix_mismatch_behavior` set to `"drop_block"`, which drops the affected blocks. `block_binding` works only with adaptive thinking. Under `between_tools`, the choices are append-only history or stripping thinking blocks from the edited turn onward.

Blocks are also tied to the account that produced them. Another account that sends one gets it dropped, and the call still succeeds.

#### Claude Sonnet 5.5 on Bedrock keeps the old computer tool and loses strict mode

Claude Sonnet 5.5 follows different rules on the Claude API, Google Cloud and Amazon Bedrock, so a migration checklist has to be written per platform.

| Item | Claude API | Google Cloud | Amazon Bedrock |
|---|---|---|---|
| Model ID | `claude-sonnet-5-5` | `claude-sonnet-5-5` | `anthropic.claude-sonnet-5-5` |
| Computer use tool | `computer_toolset_20260801` only | `computer_toolset_20260801` only | Still accepts `computer_20251124` |
| Strict tools and structured outputs | Available | No restriction stated in Anthropic's docs; check Google Cloud's page | Not available for Sonnet 5.5 |
| Thinking-block prefix check on new accounts | Enforced by default | Enforced by default | Enforced by default |
| Sonnet 4.5 retirement | November 30, 2026 | Set by the platform | Set by the platform |

![Claude Sonnet 5.5 rules on the Claude API, Google Cloud and Amazon Bedrock, with the 13% cost estimate for Sonnet 4.5 code](https://s4.tenten.co/learning/content/images/2026/10/linkedin-infographic-2-4.png)

On the Claude API and Google Cloud, declaring `computer_20251124` returns a 400. The message begins with `'claude-sonnet-5-5' does not support tool types: computer_20251124`. Moving to the toolset also means removing the `fine-grained-tool-streaming-2025-05-14` beta header. That header returns a 400 next to a toolset entry.

Bedrock gets the awkward half of each rule: the old computer tool stays, forced tool use is rejected as it is everywhere else, and strict tools aren't offered for Sonnet 5.5. The guide's answer for Bedrock is `auto`, a prompt that says when to use the tool, and input validation in your own code. The schema guarantee moves out of the API and into the application.

The advisor tool, a beta feature that lets an executor model consult a second model, narrows too. A Sonnet 5.5 executor accepts seven advisors: Opus 5, Opus 5.5, Fable 5, Fable 5.1, Mythos 5, Mythos 5.1, or Sonnet 5.5 itself. Their advice comes back encrypted in an `advisor_redacted_result` block the client can't read.

#### The silent change empties the text between tool calls

On Sonnet 5 and earlier models, anything the model wrote between two tool calls arrived as `text` blocks. Sonnet 5.5 puts notes longer than a sentence or two into progress-update `thinking` blocks and leaves shorter remarks as `text`. The default `display` is `"omitted"`, so those blocks arrive with empty text.

An interface that streams those notes to users goes quiet between tool calls, with no error. The five changes above return a 400 as soon as the affected request is sent. Thinking-block binding is the conditional one: it fails only on a replay after a history edit, on accounts created on or after August 31, 2026. The text change passes every status-code check, so a test that only checks status codes will not catch it. Add an assertion that the text between tool calls is non-empty, or put it on a manual QA list.

The fix depends on the thinking mode. With adaptive thinking, `display: "summarized"` returns the updates mixed with reasoning summaries. `display: "updates"` returns the updates alone and needs the `thinking-display-updates-2026-08-18` beta header. With `between_tools`, the text comes back with no `display` setting.

#### The Sonnet 4.5 price cut shrinks to about 13%

Moving from Sonnet 5 to Claude Sonnet 5.5 changes neither the price nor the tokenizer. Anthropic claims the new model needs far fewer tokens for the same work and costs up to 30% less per task. That is a vendor figure.

One outside party points the same way. GitHub's [September 28, 2026 changelog entry](https://github.blog/changelog/2026-09-28-claude-sonnet-5-5-in-github-copilot) says Sonnet 5.5 matched Sonnet 5 on coding tasks in its testing "while using significantly fewer steps, tokens, and tool calls." GitHub published no numbers.

From Sonnet 4.5, the arithmetic is different. Anthropic's pricing page lists Sonnet 4.5 at $3 input and $15 output per million tokens, so Sonnet 5.5 is one-third cheaper per token. Sonnet 5.5 also uses the newer tokenizer, which produces about 30% more tokens for the same text.

By our own estimate, assuming exactly 30% more tokens and no thinking, 2/3 of the price times 1.3 times the tokens comes to about 0.87. Identical text costs roughly 13% less, well short of the 33% the price table suggests.

Four other changes move the real number:

- **Thinking.** Sonnet 4.5 ran without thinking by default and Sonnet 5.5 thinks by default. Thinking tokens bill as output tokens, and `max_tokens` covers thinking plus text.
- **Images.** A 2000×1500 image costs about 2.5 times as many tokens.
- **Tool-use system prompt.** The automatic prompt shrinks from 496 tokens on Sonnet 4.5 to 286 in `auto` mode.
- **Caching.** The minimum cacheable prompt falls from 1,024 tokens to 512. Cache reads stay at 10% of the input price, or $0.20 per million tokens. Opus 5.5 cache reads cost 5% and Fable 5.1 cache reads cost 2.5%.

Effort needs a fresh sweep as well. The docs say the levels are recalibrated, so a level doesn't produce the same amount of thinking it did on Sonnet 5. The starting point is `high` for general work. Agentic coding and multistep tool use start at `medium` for well-specified tasks and move to `high` for harder or longer ones. Chat and other latency-sensitive work starts at `medium` or `low`.

#### Claude Sonnet 5.5 migration checklist: start with the usage export

1. Open the Usage page in Claude Console, click Export, and read the CSV by API key and model to find every service still on Sonnet 4.5.
2. Search the codebase for `"disabled"`, `tool_choice`, `computer_20251124`, advisor model IDs and `content[0].text`. A response can begin with `thinking` blocks, so read content blocks by `type`.
3. Coming from Sonnet 4.6 or earlier, add `budget_tokens`, `temperature`, `top_p` and `top_k` to the search.
4. Coming from Sonnet 4.5 or earlier, add assistant prefill and `output_format`.
5. In Claude Code, run `/claude-api migrate this project to claude-sonnet-5-5`. The bundled skill swaps the model ID and parameters, asks for the scope first, and leaves a checklist to verify by hand.
6. Run integration tests in the same kind of account production uses. Flows that edit history need one pass in an account created on or after August 31, 2026.
7. Re-run the effort sweep and re-baseline `max_tokens` and cost.
8. Handle refusals. A declined prompt returns HTTP 200 with `stop_reason: "refusal"` and one of five `stop_details` categories.

Claude Managed Agents users are the exception. The guide says they need nothing beyond the new model name.

#### FAQ

##### What breaks when you migrate from Claude Sonnet 5 to Claude Sonnet 5.5?

Claude Sonnet 5.5 returns a 400 for five things Sonnet 5 accepted: `thinking: disabled`, forced `tool_choice`, thinking blocks replayed after a history edit, `computer_20251124`, and Opus 4.8, Opus 4.7 or Sonnet 5 as an advisor. A sixth change fails nothing and moves text between tool calls into `thinking` blocks. Code from Sonnet 4.6 also loses thinking budgets and sampling parameters, and code from Sonnet 4.5 loses assistant prefill.

##### How do you fix Claude Sonnet 5.5 API errors for thinking and tool use?

Claude Sonnet 5.5 thinking errors clear when `disabled` becomes `between_tools` at `high` effort or below. Tool-use errors clear when `tool_choice` types `any` and `tool` become `auto`, with `strict: true` on the tool and a prompt line naming it. On Amazon Bedrock, strict tools aren't available for Sonnet 5.5, so the migration guide says to send `auto` and validate tool input in application code.

##### Did Claude Sonnet 5.5 API pricing change?

Claude Sonnet 5.5 pricing matches Sonnet 5 at $2 input and $10 output per million tokens, with a 50% Batch API discount. Sonnet 5's $2/$10 rate was introductory through August 31, 2026, and the pricing page now lists it as standard. Against Sonnet 4.6 and 4.5 at $3/$15, the per-token price is one-third lower, while the same text produces about 30% more tokens.

##### Can a Claude Sonnet 4.5 workload move to Sonnet 5 before the retirement date?

Yes, Claude Sonnet 5 is active, with retirement not sooner than June 30, 2027, and it still accepts `thinking: disabled` and forced `tool_choice`. Anthropic's September 30, 2026 notice names `claude-sonnet-5-5` as the recommended replacement. Assistant prefill and non-default sampling parameters return a 400 on Sonnet 5 too, so those edits are due on either path.

##### What does `tool_choice: type "tool" and "any" are not supported for this model` mean on Claude Sonnet 5.5?

Claude Sonnet 5.5 returns that 400 error when a request sets `tool_choice` to type `any` or `tool`. The model accepts `auto` and `none`, and the token counting endpoint applies the same check. Send `tool_choice: {"type": "auto"}`, mark the tool `strict: true`, and say in the prompt when the tool applies. Code that forced a tool only to get JSON back can move the schema to `output_config.format`.

#### Sources

- [Anthropic: Introducing Claude Sonnet 5.5](https://www.anthropic.com/claude-sonnet-5-5)
- [Claude Platform Docs: What's new in Claude Sonnet 5.5](https://platform.claude.com/docs/en/models/sonnet-5-5/whats-new-sonnet-5-5)
- [Claude Platform Docs: Migrating to Claude Sonnet 5.5](https://platform.claude.com/docs/en/models/sonnet-5-5/migration-guide)
- [Claude Platform Docs: Model deprecations](https://platform.claude.com/docs/en/about-claude/model-deprecations)
- [Claude Platform Docs: Pricing](https://platform.claude.com/docs/en/about-claude/pricing)
- [GitHub Changelog: Claude Sonnet 5.5 in GitHub Copilot](https://github.blog/changelog/2026-09-28-claude-sonnet-5-5-in-github-copilot)
- [GitHub: valentinfrlch/ha-llmvision issue #742](https://github.com/valentinfrlch/ha-llmvision/issues/742)

#### Author Insight

Most Sonnet 4.5 teams should go straight to Sonnet 5.5. The migration guide's checklist is grouped by starting model, and Sonnet 4.5 code owes the prefill, thinking-budget and sampling-parameter edits plus a token recount on either destination. After those, Sonnet 5.5 adds only the group every starting model gets: `between_tools`, `tool_choice` and append-only history. Two hops mean two rounds of integration tests and two cost baselines.

One kind of team should stop at Sonnet 5 first. Its pipeline relies on forced `tool_choice` to guarantee a tool call on every turn, and it can't finish a code path for the no-tool-call turn before November 30, 2026. A request that needs more than 20 strict tools belongs in the same group, because input validation then has to be written in-house. Sonnet 5 stays until at least June 30, 2027, which is time to build that validation. On Amazon Bedrock, the platform sets the Sonnet 4.5 retirement date, so the schedule follows Bedrock's notice.