Claude Adaptive Thinking vs Extended Thinking: What Changed

The way Claude "thinks" has changed shape dramatically over the past year. The old extended thinking worked by having a human specify how many tokens the model could spend reasoning. The current generation replaces it with adaptive thinking — the model itself decides whether to think and how deeply. And with Claude Opus 5, thinking is now on by default, so even the old assumption that "no configuration means no thinking" belongs to the past.

This article walks through what actually separates extended thinking from adaptive thinking, how behavior differs model by model, and the traps that catch people migrating code — 400 errors, truncated output, and bills that quietly go up. Everything is grounded in Anthropic's official documentation.

1. What thinking is

Thinking is the stage where Claude works through the problem in its own words before it starts writing the final answer. It restates the question, tries several approaches, checks intermediate results, and abandons paths that don't hold up — and that process is generated as thinking content blocks ahead of the response. The payoff is biggest on tasks where the quality of the intermediate work decides the quality of the answer: math, coding, analysis, and long-running agentic work.

It isn't free, though. As Anthropic's "Thinking" documentation states plainly, the tokens Claude spends reasoning are billed as output tokens and count toward max_tokens — and the billing is the same even in configurations where the thinking text is never returned to you (see section 6). Designing your thinking setup is as much a cost and latency question as a quality question.

2. The extended thinking era — you set budget_tokens

The first incarnation was extended thinking. You attach thinking: {"type": "enabled", "budget_tokens": N} to the request, and Claude reasons against that budget before answering. A human specifies how much to think, on every request. Per the official documentation, the rules are:

• Minimum 1,024 tokens. The API rejects smaller values
• Must be less than max_tokens — thinking counts toward it, so room has to be left for the answer
• The budget is a target, not a strict cap. Actual usage varies by task, and Claude often finishes thinking well before the budget runs out
• For thinking budgets above 32,000, Anthropic recommends batch processing to avoid timeouts

The problem with this design is straightforward: the right budget differs per task, and a human can't guess it in advance. Simple questions can burn the budget you allotted; hard problems can starve on it. And changing the budget value invalidates your prompt cache — the documentation demonstrates this with a measured example.

3. The shift to adaptive thinking — the model decides

That is what adaptive thinking, introduced in 2026, replaces. The configuration is a single line: thinking: {"type": "adaptive"}. Whether to think, and how deeply, is Claude's own decision based on how hard the request looks. Easy inputs get an instant answer with thinking skipped; hard problems get deep reasoning.

The migration followed the schedule laid out in Anthropic's "Extended thinking" documentation: budget_tokens was deprecated on Claude Opus 4.6 / Sonnet 4.6 (it still works there), and models from Claude Opus 4.7 onward reject it with a 400 error. Point old code at a new model and it stops with this:

# Old: extended thinking (400 error on Opus 4.7 and later)
"thinking": {"type": "enabled", "budget_tokens": 10000}
→ 400: "thinking.type.enabled" is not supported ...

# New: adaptive thinking (depth is set via effort)
"thinking": {"type": "adaptive"},
"output_config": {"effort": "high"}

The rewrite itself is small — delete budget_tokens, switch to adaptive, and hand depth control to effort. But as the documentation warns, this is a behavioral change, not just a syntax change. With a fixed budget, Claude thought on every request; with adaptive thinking, at lower effort settings it may skip thinking entirely on easy inputs.

4. How each model handles thinking, at a glance

The tricky part is that "is it on by default?" and "can it be turned off?" differ per model. Here is the official documentation condensed into one table.

Source: Anthropic, "Thinking" and "Extended thinking" (as of August 2026)

Two things matter in practice. First, the default flipped to "thinking on" with the Opus 5 generation — if you were running a job cheaply on Opus 4.8 with thinking off and you change only the model ID, output tokens grow by the thinking share, and answers get cut off at max_tokens or the bill goes up (covered in detail in our guide to Opus 5's breaking changes). Second, only the legacy models keep using budget_tokens — as long as you stay on Sonnet 4.5 or earlier there is nothing to migrate; rewrite when you move to a newer model.

5. Depth is now tuned with effort

With the "budget" gone, thinking depth is adjusted through output_config: {"effort": ...} — five levels, low / medium / high / xhigh / max, with high as the API default. Effort shapes more than thinking depth: it also affects how consolidated tool calls are and how much preamble you get, i.e. overall token spend.

What the five levels mean, the Claude Code slider, and how settings persist are covered in our guide to the effort setting. One caching note from the documentation: in adaptive mode, the effort value is rendered into the prompt, so changing it invalidates the prompt cache — the same shape as "changing the budget busts the cache" in the extended-thinking era. Don't flip it back and forth mid-conversation.

6. You pay for thinking even when you can't see it

How thinking looks from the outside is controlled by the display field. It takes two values:

• "summarized" — the thinking block carries a readable summary of the reasoning. Default on Claude Opus 4.6 / Sonnet 4.6 and earlier
• "omitted" — the thinking block comes back with an empty string inside. Default on Fable 5 / Mythos 5 / Opus 5 / Sonnet 5 / Opus 4.8 / 4.7

Two traps live here. First, the newer the model, the more the default leans toward "don't show it" — move an app that streamed the reasoning to users onto a new model, and the experience turns into a long silence followed by a sudden answer. If you want it visible, say so explicitly: thinking: {"type": "adaptive", "display": "summarized"}. Second, display changes visibility only — billing is identical. The documentation is explicit: with omitted you are still charged for the full thinking tokens; what you save is latency, not cost. And in no configuration do you get the raw chain of thought — what summarized shows is a summary.

One more thing that matters in practice: handling of thinking blocks. In multi-turn conversations and tool use, pass the previous response's thinking blocks back completely unmodified. Editing them triggers a 400 — the "invalid signature in thinking block" error Claude Code users run into comes from exactly this mechanism.

7. The traps of turning thinking off

"We care about speed, let's turn thinking off" is a legitimate call — but on Opus 5 it comes with conditions. Per the official documentation:

Even when the request goes through, there are side effects. Anthropic documents that with thinking disabled, Opus 5 can write tool calls out as body text (the tool never runs while the turn still looks successful) and can leak internal XML tags into the output. If you are building agents, keeping thinking on and lowering effort is the safe path — and it cuts cost in roughly the same direction anyway.

8. Thinking between tool calls — interleaved thinking

Thinking isn't only "once, before the answer." With interleaved thinking, Claude also reasons between tool calls, weighing each tool result before deciding the next move — revising the plan after reading search results, choosing the next command after reading the output of the last one. It is the machinery behind good agentic behavior.

There is a generational difference here too. In the old extended-thinking world this required the beta header interleaved-thinking-2025-05-14; with adaptive thinking it is automatic and the header is unnecessary (the documentation states that "adaptive thinking interleaves automatically" and says you can drop the header after migrating). Moving to adaptive thinking simplifies your code by one more setting.

9. When you need speed: fast mode

If you want the quality of thinking but less waiting, the option is fast mode. Per the Claude Code documentation on fast mode, this is not a downgrade to a different model: it runs the same Claude Opus in a speed-first configuration. Output is up to about 2.5x faster and the price doubles ($10 in / $50 out per million tokens on both Opus 5 and Opus 4.8). It is available on Opus 5 and Opus 4.8 only; fast mode for Opus 4.7 was removed on July 24, 2026.

Thinking, effort, and fast mode play different roles: thinking = the mechanism for whether to reason, effort = how deeply to reason, fast mode = how fast the same reasoning is delivered. Before you reach for "it's slow, kill thinking," remember you hold two other cards: lower the effort, or turn on fast mode.

Summary

• Extended thinking (budget_tokens) is the old way. Deprecated on Opus 4.6 / Sonnet 4.6, a 400 error from Opus 4.7 onward — and still the only thinking mode on legacy models (Sonnet 4.5 / Haiku 4.5, etc.)
• Adaptive thinking is the current way. The model decides whether and how much to think; depth is tuned with effort (five levels, default high)
• Opus 5 / Sonnet 5 / Fable 5 have thinking on by default. Fable 5 can't turn it off; Opus 5 can only at effort high or below
• You pay for thinking even when it's invisible. The new-generation default is display: "omitted" (empty thinking blocks). Measure with usage.output_tokens_details.thinking_tokens
• Turning thinking off has side effects (tool calls as text, tag leakage). Lowering effort is safer than disabling
• Interleaved thinking is automatic with adaptive — the beta header is no longer needed
• Need speed? Fast mode (about 2.5x, 2x price, Opus 5/4.8; toggle with /fast in Claude Code)

FAQ

Note: the specifications and figures in this article are based on Anthropic's documentation "Thinking", "Extended thinking", and the Claude Code documentation "Fast mode" (all as of August 2026). Specifications change; check the official docs for the current wording before you build on them.