Claude thinking modes and breaking changes between models

1.Adaptive and extended thinking, model by model

Thinking lets Claude work through a problem before it answers. It restates the question, tries approaches, checks intermediate results and drops paths that don't hold up. That is why thinking helps most on math, coding, analysis and long agentic tasks. It also costs money: thinking tokens are billed as output tokens even when you never see the text, and they count toward max_tokens.

There are two ways to configure thinking. Adaptive thinking (type: "adaptive") lets Claude decide when to think and how deeply, and you steer it with effort. Extended thinking (type: "enabled" with budget_tokens) sets a token budget yourself. The budget must be at least 1,024 tokens and less than max_tokens, and it is a target, not a hard cap. max_tokens is still the hard limit on total output.

Effort is the request parameter output_config.effort, which controls how many tokens Claude spends on a response, thinking included. It has five levels, from least to most spending: low, medium, high, xhigh and max. Not every model accepts every level, and the default differs by model.

Support splits by model generation. On Opus 5.5, Sonnet 5.5 and Fable 5.1, adaptive thinking is on with no configuration, and manual budgets are rejected. On Opus 4.8 and 4.7, thinking stays off until you send "adaptive". Claude Haiku 4.5 goes the other way: it rejects "adaptive" and only supports extended thinking with budget_tokens. So if a workload needs an exact thinking budget at the lowest price per token, Haiku 4.5 is the model.

Sources1234

2.Choosing what thinking output comes back

Thinking arrives in thinking content blocks before the text. Even when it is visible, it is a summary of Claude's reasoning, never the raw chain of thought. The display field controls what is returned, and it works with both adaptive and extended thinking. It takes three values:

- "summarized" returns a readable summary. It is the default on Claude Opus 4.6, Sonnet 4.6, Haiku 4.5 and earlier models. - "omitted" returns the block with an empty thinking field and an encrypted signature. It is the default on Opus 5.5, Sonnet 5.5, Fable 5.1, Opus 5, Opus 4.8 and Opus 4.7. - "updates" (beta) also leaves thinking empty but returns the short progress notes some models write between tool calls.

{
  "content": [
    {
      "type": "thinking",
      "thinking": "",
      "signature": "EosnCkYICxIMMb3LzNrMu..."
    },
    {
      "type": "text",
      "text": "The answer is 12,231."
    }
  ]
}

"omitted" speeds up delivery but does not lower cost. When streaming, the server skips the thinking text and sends only the signature, so the final answer starts sooner. You still pay for every thinking token. If your interface shows reasoning to users, "omitted" looks like a long pause before anything appears, so set "summarized" to bring back visible progress. Whichever value you choose, pass thinking blocks back unchanged in multi-turn conversations.

Sources14

3.Request settings newer models reject

Moving a working integration to Claude Opus 5.5 or Sonnet 5.5 can turn previously valid requests into 400 errors. These failures are loud, which makes them the easy kind to fix. On these models the following are rejected:

- thinking: {"type": "enabled", "budget_tokens": N}. Control thinking depth with effort instead. - thinking: {"type": "disabled"}. Opus 5.5 cannot turn thinking off at all. Sonnet 5.5 uses "between_tools" as its lowest setting. - Non-default temperature, top_p or top_k. - A prefilled assistant turn at the end of the messages. - tool_choice of type any or tool. On Sonnet 5.5 this applies even on the token counting endpoint. - The computer_20251124 tool for Opus 5.5 on the Claude API and Google Cloud. Use the computer_toolset_20260801 toolset there.

between_tools suppresses up-front thinking but keeps thinking between tool calls: the model skips deliberation before it starts, and the short progress updates it writes while tools run still come back as thinking blocks. Choose it when a request should start answering immediately and you don't need deep reasoning first. Without tools, the response contains only text.

between_tools has its own limit. It works at low, medium and high effort and returns a 400 at xhigh or max. If you need those levels, use adaptive thinking. Code ported from Sonnet 5 that paired disabled with xhigh therefore needs two changes, not one.

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

Forced tool calls need a different approach on these models. Send tool_choice: {"type": "auto"}, mark the tool strict: true so its input matches the schema, and tell the model in the prompt when to call the tool. With auto, the model can now answer without calling the tool at all.

client.messages.create(
    model="claude-sonnet-5-5",
    max_tokens=1024,
    # strict tool use: every call matches the tool's input_schema
    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.",
        }
    ],
)

Sources451

4.Behaviour changes that break code without an error

The worst migration bugs return 200. The most common one comes from thinking that switches on by itself. A request that ran without thinking on an older model now thinks, so the response can start with a thinking block. Code that reads content[0].text, or a stream handler that treats the first block as text, breaks. Pick out blocks by their type field instead.

The same change also affects budgets. max_tokens is still a hard limit on thinking plus text together, so a limit sized for answer-only output can now cut responses off. Thinking is billed as output, so cost per request goes up too. At xhigh or max, start max_tokens at 64k. Defaults shift as well. Opus 5.5 defaults to medium effort where Opus 5 defaulted to high, so set effort explicitly and re-run your effort sweep instead of carrying over an old setting. Code that parsed thinking text gets empty strings, because display now defaults to "omitted".

Switching models partway through a conversation drops thinking without warning. Claude Sonnet 5.5 can't read thinking blocks from Opus 5, Opus 5.5, Fable or Mythos models. The API removes those blocks and still returns 200, and the removed blocks aren't billed. A router that falls back from Opus 5.5 to another model should expect that model to run without Opus 5.5's earlier reasoning.

Sources45

Exam traps

Each one states something that sounds right. Open it to see what is actually true.

1. 1.Setting display to "omitted" reduces thinking cost.Why is that wrong?

   Omitted only skips returning the thinking text, which improves time to first text token. The full thinking tokens are still billed.

   Covered in Choosing what thinking output comes back

2. 2.On Claude Sonnet 5.5, between_tools works at any effort level, just like adaptive thinking.Why is that wrong?

   between_tools is only accepted at low, medium and high effort. At xhigh or max it returns a 400.

   Covered in Request settings newer models reject

3. 3.If a model switch mid-conversation drops prior thinking, the API returns an error.Why is that wrong?

   Blocks the new model can't read are removed without warning, the request returns 200, and the removed blocks aren't billed.

   Covered in Behaviour changes that break code without an error