Extended Thinking vs Adaptive Thinking Explained

If you have hit extended thinking and adaptive thinking back to back in Claude’s docs and wondered whether they are the same thing, you are not alone.

Short answer: they are not, and you are almost certainly using adaptive thinking already without realizing it 🧠

What Is “Thinking” in Claude?

Before answering, Claude can use a scratchpad to reason through the problem on its own. It works step by step, rules out possibilities, does the math, then delivers the final answer.

You know it as the “thinking” part you see in chat. On the API side the response arrives in two pieces: the model’s internal reasoning, and the text shown to the user.

What changed between model generations is how that behavior gets triggered. That is exactly where the two terms part ways.

What Is Extended Thinking?

Extended thinking is manual mode. You write the token budget for thinking on every request:

{
  "thinking": {
    "type": "enabled",
    "budget_tokens": 10000
  }
}

The model reasons up to the budget you gave, then writes its answer. The budget is a target rather than a hard cap: if the task is easy, Claude may stop well before using it up.

Simple tasks used small budgets, complex ones 16,000 and above. A higher budget means more thorough reasoning, at the cost of a longer wait.

What Is Adaptive Thinking?

In adaptive thinking there is no thinking budget at all. The model evaluates each request and decides:

{
  "thinking": { "type": "adaptive" },
  "output_config": { "effort": "medium" }
}

A simple question gets a direct answer with no thinking. A multistep math problem or a tricky debugging task triggers deep reasoning.

The decision happens per request, so the same conversation can have turns with thinking and turns without.

It Also Thinks Between Tool Calls

This is adaptive mode’s most practical win: Claude can now think between tool calls. It reflects on each tool result before deciding what to do next.

This is called interleaved thinking and it works automatically, no extra setting required. The difference shows up in long-running agent tasks: the right amount of reasoning at each step is something a fixed budget can never give you.

The Difference Between Them

Was Extended Thinking Removed?

This is the part that confuses everyone, so let me be blunt: on newer models, yes.

So if you moved to Opus 4.7 or later, old code sending budget_tokens returns an error.

Effort Levels: How Much Should It Think?

In adaptive mode the depth control is the effort parameter. There are five levels:

Which one for which job?

Migrating Old Code

The change is small. Turn this:

{
  "thinking": {
    "type": "enabled",
    "budget_tokens": 10000
  }
}

into this:

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

Three things: delete budget_tokens, set the type to adaptive, and control depth with effort.

How Does It Show Up on Your Bill?

Thinking is not free. Every token Claude generates while thinking is billed as an output token.

There is a trap here, and most people estimating cost fall into it:

Two things bound the cost:

• max_tokens: a hard cap on total output. Thinking and the answer count toward it together.
• effort: soft guidance on how much of that output goes to thinking.

Because thinking eats from the same budget, set max_tokens high enough to leave room for the answer too. A value that was fine without thinking is often too small once the model starts reasoning. If your answers get cut off, either raise max_tokens or lower the effort.

To sketch out the cost of your own workload, try our LLM cost calculator and token counter.

Common Mistakes

1. Putting effort in the wrong place. It lives under output_config, not inside the thinking object. The most commonly missed detail when migrating.

2. Sizing max_tokens as if thinking did not exist. It eats from the same budget, leave room for the answer.

3. Estimating the bill from the summary on screen. You pay for the full process.

4. Changing effort between turns. On the API side it breaks your prompt cache and quietly raises cost. Pick one level per conversation and keep it.

5. Moving to a new model and still sending budget_tokens. On Opus 4.7 and later that returns an error.

Frequently Asked Questions

What is the difference between extended thinking and adaptive thinking? In extended thinking you set the token budget for reasoning and the model thinks on every request. In adaptive thinking there is no budget: the model evaluates each request and decides for itself whether to think and how deeply. You guide the depth with the effort parameter.

Was extended thinking removed? On newer models, yes. It still works on the Claude 4.6 models but is not recommended. Claude Opus 4.7 and later do not support it and requests using the old method return an error. On Claude 4.5 and earlier, extended thinking is the only option.

What does the Claude effort parameter do? It sets how often and how deeply the model thinks. There are five levels: low, medium, high (the default), xhigh and max. Lower levels skip thinking on simple jobs and speed things up, higher levels always reason and go deep.

What is interleaved thinking? It is Claude thinking between tool calls. It reflects on each tool result before deciding what to do next. In adaptive thinking it works automatically and needs no extra setting.

How does thinking show up on the bill? Tokens Claude generates while thinking are billed as output tokens. The key point: Claude shows you a summary of its thinking, but you are billed for the full process, not the summary. That makes estimating cost from the on-screen text misleading.

How do I limit thinking cost? You cannot set a thinking budget in adaptive mode. Two controls exist: max_tokens is a hard cap on total output with thinking and the answer counted together, and effort is soft guidance on how much of that output goes to thinking.

How do I migrate old code to adaptive thinking? Delete the budget_tokens field, set the thinking type to adaptive, and control depth with the effort parameter inside output_config. The syntax change is small but behavior shifts: the model may now skip thinking entirely on easy inputs, so test your outputs after migrating.

Summary

Anthropic took thinking control away from you and gave it to the model. Instead of a fixed token budget you now express an intent, and the model decides per request.

What to do:

• On a newer model, delete budget_tokens and switch to adaptive
• Put effort under output_config
• Pick one effort level per conversation and keep it
• Size max_tokens to leave room for thinking as well as the answer
• Do not estimate cost from the summary on screen

For the models themselves see Claude Opus 5 and Claude Sonnet 5, and for the Claude Code side see the customization guide 👀