Claude Platform Docs
MessagesThinking

Troubleshooting thinking

Diagnose and fix thinking failures: configuration 400 errors, empty or missing thinking blocks, max_tokens stops, and cache misses.

This page covers failures when configuring thinking or round-tripping thinking blocks (sending returned thinking blocks back in later requests). The first section maps each model to its supported thinking configurations and the ones it rejects. Each later section starts from a symptom you observe, so you can match an error message or unexpected response directly to its cause and fix. To learn how thinking works, see the Thinking overview.

Thinking support, defaults, and rejected configurations by model

Most thinking configuration errors are a mismatch between the thinking.type value in the request and what the model supports. On most models, thinking runs as thinking: {type: "adaptive"}, and many have it on by default. Some earlier models instead use extended thinking, a legacy manual mode configured as thinking: {type: "enabled", budget_tokens: N}.

Extended thinking (thinking.type: "enabled" with budget_tokens) is deprecated on the Claude 4.6 models (requests using it still succeed). Claude 4.7 and later models do not support it and reject requests that use it, returning a 400 error. On Claude 4.5 and earlier models that support thinking, extended thinking is the only available thinking mode. Claude Mythos Preview supports both modes. Where both modes are available, use adaptive thinking instead.

The table lists what each model supports, what it defaults to, and which thinking.type values it rejects with a 400 error; any value not listed as rejected is accepted. Only Claude Sonnet 5.5 accepts "between_tools", and it takes that value in place of "disabled".

ModelThinking typesDefaultRejected with 400
Claude Fable 5.2Adaptive onlyAlways on"enabled", "disabled"
Claude Mythos 5.2Adaptive onlyAlways on"enabled", "disabled"
Claude Fable 5.1Adaptive onlyAlways on"enabled", "disabled"
Claude Mythos 5.1Adaptive onlyAlways on"enabled", "disabled"
Claude Fable 5Adaptive onlyAlways on"enabled", "disabled"
Claude Mythos 5Adaptive onlyAlways on"enabled", "disabled"
Claude Mythos PreviewAdaptive, extendedAlways on"disabled"
Claude Opus 5.5Adaptive onlyAlways on"enabled", "disabled"
Claude Opus 5Adaptive onlyOn"enabled", "disabled"2
Claude Opus 4.8Adaptive onlyOff"enabled"
Claude Opus 4.7Adaptive onlyOff"enabled"
Claude Sonnet 5.5Adaptive, between_tools3On"enabled", "disabled"
Claude Sonnet 5Adaptive onlyOn"enabled"
Claude Haiku 5.5Adaptive onlyOn"enabled", "disabled"2
Claude Opus 4.6Adaptive, extended (deprecated)1OffNone
Claude Sonnet 4.6Adaptive, extended (deprecated)1OffNone
Claude Opus 4.5Extended onlyOff"adaptive"
Claude Haiku 4.5Extended onlyOff"adaptive"
Claude Sonnet 4.5Extended onlyOff"adaptive"

1 enabled and budget_tokens still work on these models but are deprecated; use adaptive thinking instead.
2 Claude Opus 5 and Claude Haiku 5.5 accept "disabled" at effort high or below; combining it with effort xhigh or max returns a 400 error. On Claude Opus 5, this restriction is enforced on each request. On Claude Haiku 5.5, a per-message effort that differs from the level in effect also returns a 400 error.
3 Claude Sonnet 5.5 accepts "between_tools" at effort high or below. Combining it with effort xhigh or max returns a 400 error, and so does a per-message effort that differs from the level in effect.

Models marked Always on cannot turn thinking off. Models marked On default to thinking. Claude Opus 5, Claude Sonnet 5, and Claude Haiku 5.5 accept thinking: {type: "disabled"}. On Claude Sonnet 5.5, send thinking: {type: "between_tools"} to turn off up-front thinking.

Earlier Claude 4 models (Claude Opus 4.1, Claude Sonnet 4, and Claude Opus 4) support extended thinking only. See Model deprecations for their availability. Claude Fable 5.2, Claude Mythos 5.2, Claude Fable 5.1, Claude Mythos 5.1, Claude Fable 5, and Claude Mythos 5 are not available under zero data retention unless expressly authorized by Anthropic.

A 400 error says "thinking.type.enabled" is not supported

The request fails with a 400 error whose message reads:

"thinking.type.enabled" is not supported for this model. Use "thinking.type.adaptive" and "output_config.effort" to control thinking behavior.

This occurs because the model you requested doesn’t support extended thinking (see the per-model configuration table).

Switch the request to thinking: {type: "adaptive"} and steer thinking depth with effort instead of budget_tokens. Migrating to adaptive thinking walks through the conversion.

A 400 error after sending thinking: {type: "disabled"}

The request fails with a 400 error. On Claude Fable 5.2, Claude Mythos 5.2, Claude Fable 5.1, Claude Mythos 5.1, Claude Fable 5, Claude Mythos 5, and Claude Opus 5.5, the message reads:

"thinking.type.disabled" is not supported for this model. Use "thinking.type.adaptive" and "output_config.effort" to control thinking behavior.

On Claude Mythos Preview, the only one of these models that accepts extended thinking, the message reads:

"thinking.type.disabled" is not supported for this model. Thinking defaults to adaptive mode when not specified; use "thinking.type.enabled" with "budget_tokens" for extended thinking.

This occurs because thinking is always on for all of these models (see the per-model configuration table).

Omit the thinking parameter; these models think without any configuration. If your goal was to keep thinking text out of responses, use display: "omitted" instead of disabling thinking; see Controlling thinking display.

A 400 error on "disabled" can also occur on Claude Opus 5 and Claude Haiku 5.5, which accept thinking: {type: "disabled"} only at effort high or below: combining it with effort xhigh or max is rejected. Lower the effort level, or set thinking to {"type": "adaptive"}.

On Claude Sonnet 5.5, thinking: {type: "disabled"} returns a 400 error at every effort level. The message reads:

To turn thinking off on this model, send "thinking": {"type": "between_tools"} instead of {"type": "disabled"}. The model does not think before responding. The short updates it writes between tool calls come back as thinking blocks.

To turn off up-front thinking on Claude Sonnet 5.5, send thinking: {type: "between_tools"} instead, at effort high or below.

A 400 error says "thinking.type.between_tools" is not supported

The request fails with a 400 error whose message reads:

"thinking.type.between_tools" is not supported for this model.

This occurs because only Claude Sonnet 5.5 accepts thinking: {type: "between_tools"} (see the per-model configuration table).

Send between_tools only to Claude Sonnet 5.5. On other models, omit thinking or use a thinking.type value the table doesn’t list as rejected.

A 400 error says an effort level is not supported when thinking is disabled

On Claude Sonnet 5.5, a request with thinking: {type: "between_tools"} at effort xhigh or max fails with a 400 error whose message reads:

output_config.effort 'xhigh' is not supported when thinking is disabled on this model. Use effort 'high' or below, or enable thinking.

This occurs because Claude Sonnet 5.5 accepts between_tools only at effort high or below. The error message says thinking is disabled because between_tools has no up-front thinking, even though the request didn’t send "disabled". The message names the level the request sent.

Lower the effort to high or below. To run at xhigh or max, use adaptive thinking: omit the thinking field or send thinking: {"type": "adaptive"}. That’s what the message means by “enable thinking.” Claude Sonnet 5.5 rejects "enabled" with a 400 error.

Claude Haiku 5.5 returns the same message when a request sends thinking: {type: "disabled"} at effort xhigh or max. It accepts "disabled" only at high or below. Lower the effort, or set thinking to {"type": "adaptive"}.

A 400 error says effort cannot change when thinking is disabled

On Claude Sonnet 5.5, a request with thinking: {type: "between_tools"} whose per-message effort changes the level fails with a 400 error whose message reads:

messages.N: output_config.effort 'low' differs from the 'high' in effect before it; effort cannot change when thinking is disabled on this model. Use effort 'high', or enable thinking.

The error message says thinking is disabled because between_tools has no up-front thinking. With between_tools, effort can’t change mid-conversation: a per-message output_config.effort that differs from the level in effect returns a 400 error. messages.N is the position of the message that set the new level.

Remove that per-message effort, or set it to the level in effect. To vary effort for each turn, use adaptive thinking: omit the thinking field or send thinking: {"type": "adaptive"}. That’s what the message means by “enable thinking.”

Claude Haiku 5.5 returns the same message when a request with thinking: {type: "disabled"} sets a per-message effort that differs from the level in effect. Remove that per-message effort, or set thinking to {"type": "adaptive"} to vary effort for each turn.

A 400 error says adaptive thinking is not supported

The request fails with a 400 error whose message reads:

adaptive thinking is not supported on this model

This occurs because the model supports only extended thinking (see the per-model configuration table).

Use thinking: {type: "enabled", budget_tokens: N} instead; see Extended thinking for the configuration.

A 400 error says thinking blocks cannot be modified

A request that returns tool results fails with a 400 invalid_request_error whose message contains:

`thinking` or `redacted_thinking` blocks in the latest assistant message cannot be modified

In multi-turn and tool-use conversations, you send previous assistant messages back to the API, including their thinking and redacted_thinking blocks. The API verifies their signatures.

This error can mean that thinking blocks in the request don’t match what the API returned. The mismatch can be in any assistant turn, although the error message says “latest.”

Echo the assistant turn back verbatim, thinking blocks included. See Preserving thinking blocks for the rules, and the worked round trip in Thinking in tool and multi-turn workflows for correct code in every SDK.

A 400 error says a thinking block signature is invalid

A request that replays earlier thinking blocks to Claude Fable 5.2, Claude Mythos 5.2, Claude Fable 5.1, Claude Mythos 5.1, Claude Opus 5.5, Claude Sonnet 5.5, or Claude Haiku 5.5 can fail with a 400 invalid_request_error whose message reads:

messages.{i}.content.{j}: Invalid `signature` in `thinking` block. The block is bound to a different conversation. Remove the block, or set `thinking.block_binding.prefix_mismatch_behavior` to "drop_block".

If the request didn’t send the thinking-binding-controls-2026-08-01 beta header, the error message adds That setting requires the `thinking-binding-controls-2026-08-01` value in the `anthropic-beta` header.

The error message can end with a sentence naming what changed: the system prompt, the tools list, the first message or block that differs, content that is missing or new, or an earlier thinking block that is missing or out of order. That sentence is for people and logs. Its wording can change, so don’t match on it in code.

If the error message stops after Invalid `signature` in `thinking` block, the signature itself didn’t verify: it was truncated, altered, or sent back empty, and prefix_mismatch_behavior doesn’t apply.

A replayed thinking block passes the prefix check only while the system prompt, tools, and messages that preceded it are unchanged. See What must stay the same, and why. The error means something earlier in the conversation changed between requests. Causes include the following:

  • An edited, reordered, or removed turn
  • A per-turn reminder that was injected and later removed
  • A rebuilt system prompt or tools array
  • Client-side compaction that kept recent turns and their thinking verbatim

Server-side compaction at a token threshold and context editing never trigger this error. With on-demand compaction, thinking in the turns you keep after the summary triggers it when one of the conditions for kept thinking doesn’t hold. For requests that don’t set thinking.block_binding.prefix_mismatch_behavior, see Which models run the prefix check.

Retrying the same request body doesn’t clear the error. Neither does fixing your code if the stored history holds the edit. To continue the conversation, do one of the following:

  • Send the thinking-binding-controls-2026-08-01 beta header and set thinking.block_binding.prefix_mismatch_behavior to "drop_block" on the retry and every later request. The request then succeeds without the invalidated reasoning. On Claude Sonnet 5.5 and Claude Haiku 5.5, block_binding works only with thinking: {"type": "adaptive"}. With any other thinking setting on those models, you can’t send block_binding, so use the next option.
  • Strip the block the error names and every later thinking and redacted_thinking block, leaving each turn’s other blocks in place. Retry, and leave the stripped blocks out of later requests.

Then fix the cause so that new conversations don’t hit the error. Keep the history append-only: pass earlier turns back exactly as sent and received, add instructions with a mid-conversation system message instead of editing system or tools, and let server-side context editing or compaction do any trimming.

A block from a model the target model can’t read never produces this error: the API drops it and, under the beta header, reports it in input_transformations.

The thinking field is empty in the response

The response contains thinking blocks, but their thinking field is an empty string and only the signature field is populated.

This occurs because display defaults to "omitted" on some models (see Controlling thinking display), which returns thinking blocks without their text.

Set display: "summarized" in your thinking configuration to receive the summarized thinking text. See Controlling thinking display for each model’s default. If you only want the short status lines some models write between tool calls, and not the reasoning, set display: "updates", which is in beta, instead. See Progress updates between tool calls.

A block whose thinking field is empty is still complete: the signature holds the reasoning. Send it back with the turn like any other. See Send assistant turns back exactly.

No thinking block appears on some turns

Some responses contain no thinking block at all, even though thinking is configured.

This is normal in adaptive mode: Claude skips thinking on requests it determines are simple enough to answer directly.

If you want thinking more often or more deeply, raise effort or steer with prompting; see Steering how often Claude thinks.

A forced tool_choice ({"type": "any"} or a named tool) also returns no thinking block: the response starts with the tool call. To let the model think before it calls a tool, use tool_choice: {"type": "auto"} and say in the prompt when to use the tool.

Tool calls or XML tags appear in the text output

A response occasionally writes a tool call into its text instead of emitting a tool_use block, or includes <thinking> or other internal XML tags in its visible text. A leaked tool call never runs, and in agentic loops the leaked text stays in the conversation history, so later turns are affected as well.

This occurs on Claude Opus 5 when thinking is disabled, most commonly on tool-heavy workloads such as search. System-prompt rules instructing the model not to think or not to reason increase the tag leakage.

Re-enable thinking (the default) and use lower effort levels to control token cost instead. If your integration must keep thinking disabled, apply the prompting mitigations in Running with thinking disabled.

The response stops with stop_reason: "max_tokens"

The response ends with stop_reason: "max_tokens", often with a truncated or missing text block.

This occurs because thinking tokens count toward max_tokens, so a long thinking pass can consume the budget before the text response completes.

Raise max_tokens to leave room for both thinking and text, or lower effort so Claude spends less on thinking; see Cost control and Thinking and the context window.

Cache hits drop after changing thinking settings

cache_read_input_tokens falls to zero on requests that previously hit the cache.

This occurs because the thinking configuration and the effort level (or its default) are part of the cached prompt prefix, so changing any of them starts a new prefix. Switching thinking modes and changing budget_tokens invalidate message cache breakpoints, and changing the effort value can. They can invalidate tool and system-prompt breakpoints too, depending on where the model renders the configuration.

Keep the thinking configuration and effort level constant across requests that share a conversation; setting a parameter explicitly to its default is equivalent to omitting it and does not invalidate. See Thinking and prompt caching.

Setting effort does not change thinking

You change effort but thinking frequency or depth stays the same.

This occurs because effort is the primary thinking lever only in adaptive mode. On extended-thinking-only models, thinking depth is set by budget_tokens instead.

Adjust budget_tokens on those models, or check which mode your model runs in; see Thinking and effort. On Claude Opus 4.5, the one extended-thinking-only model that supports effort, effort composes with the budget; see Budget rules and tuning.

Next steps

The overview: what thinking is, how to configure it, and how it interacts with tools, caching, and streaming.

The full error reference, including the thinking configuration 400s with their exact server messages.

Convert budget_tokens requests to adaptive thinking with effort.

Was this page helpful?