Mastering Adaptive Thinking in Claude: Dynamic Reasoning for Smarter AI Workflows

Claude's extended thinking capability has been a game-changer for complex reasoning tasks. But until recently, you had to manually set a thinking token budget—a fixed number that applied to every request, regardless of its actual complexity. That approach worked, but it was rigid. Simple queries wasted tokens; complex ones might not get enough.

Enter adaptive thinking. This new mode lets Claude dynamically decide when and how much to think, based on the complexity of each individual request. The result? Better performance, lower costs, and simpler code. In this guide, you'll learn exactly how adaptive thinking works, which models support it, and how to integrate it into your API calls.

What Is Adaptive Thinking?

Adaptive thinking is the recommended way to use extended thinking with Claude Opus 4.7, Claude Opus 4.6, Claude Sonnet 4.6, and Claude Mythos Preview. Instead of you specifying a fixed budget_tokens value, Claude evaluates each request and decides:

• Whether to use extended thinking at all
• How much thinking effort to apply

At the default effort level (high), Claude almost always thinks. At lower effort levels, it may skip thinking for simpler problems, saving you tokens and latency.

Adaptive thinking also enables interleaved thinking—Claude can think between tool calls. This makes it especially powerful for agentic workflows where the model needs to reason about intermediate results before taking the next action.

Note: On Claude Opus 4.7, adaptive thinking is the only supported thinking mode. The old thinking: {type: "enabled", budget_tokens: N} syntax is rejected with a 400 error.

Supported Models

If you're using Opus 4.6 or Sonnet 4.6 with a manual budget_tokens configuration, your code still works—but it's deprecated. Plan to migrate to adaptive thinking soon.

How to Use Adaptive Thinking in Your API Calls

Using adaptive thinking is straightforward. Set thinking.type to "adaptive" in your API request. No beta header is required.

Python Example

import anthropic
client = anthropic.Anthropic()
response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=16000,
    thinking={"type": "adaptive"},
    messages=[
        {
            "role": "user",
            "content": "Explain why the sum of two even numbers is always even."
        }
    ]
)
for block in response.content:
    if block.type == "thinking":
        print(f"\nThinking: {block.thinking}")
    elif block.type == "text":
        print(f"\nResponse: {block.text}")

TypeScript Example

import Anthropic from '@anthropic-ai/sdk';
const client = new Anthropic();
const response = await client.messages.create({
  model: 'claude-opus-4-7',
  max_tokens: 16000,
  thinking: { type: 'adaptive' },
  messages: [
    {
      role: 'user',
      content: 'Explain why the sum of two even numbers is always even.'
    }
  ]
});
for (const block of response.content) {
  if (block.type === 'thinking') {
    console.log(\nThinking: ${block.thinking});
  } else if (block.type === 'text') {
    console.log(\nResponse: ${block.text});
  }
}

cURL Example

curl https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-opus-4-7",
    "max_tokens": 16000,
    "thinking": {"type": "adaptive"},
    "messages": [
      {"role": "user", "content": "Explain why the sum of two even numbers is always even."}
    ]
  }'

The Effort Parameter: Fine-Tuning Thinking Intensity

Adaptive thinking comes with an optional effort parameter that lets you control how aggressively Claude applies thinking. The effort parameter accepts values like low, medium, high, or a numeric scale. At the default high level, Claude almost always thinks. At low, it may skip thinking for simple requests.

response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=16000,
    thinking={
        "type": "adaptive",
        "effort": "medium"  # or "low", "high", or a numeric value
    },
    messages=[
        {"role": "user", "content": "What is 2+2?"}
    ]
)

This is especially useful when you have a mix of simple and complex queries. For a chatbot that handles both "What's the weather?" and "Explain quantum entanglement," you can set effort to medium and let Claude decide when deep reasoning is warranted.

Why Adaptive Thinking Is Better

1. Optimal Token Usage

With manual budget_tokens, you either waste tokens on simple queries or risk not allocating enough for complex ones. Adaptive thinking eliminates this trade-off.

2. Interleaved Thinking for Agents

Adaptive thinking automatically enables interleaved thinking. In agentic workflows, Claude can think between tool calls—analyzing results, planning next steps, and reasoning about multi-step tasks. This dramatically improves performance on long-horizon tasks.

3. Simpler Code

No more calculating or guessing the right budget_tokens value. Just set thinking: {type: "adaptive"} and let Claude handle the rest.

4. Better Performance on Bimodal Tasks

If your workload mixes simple and complex requests, adaptive thinking outperforms a fixed budget. Simple requests get fast responses; complex ones get the deep reasoning they need.

Migrating from Manual Budget Tokens

If you're currently using thinking: {type: "enabled", budget_tokens: 8000}, here's how to migrate:

Before (deprecated):

thinking={
    "type": "enabled",
    "budget_tokens": 8000
}

After (recommended):

thinking={
    "type": "adaptive"
}

That's it. One line change, and you're done. If you want to control effort, add the effort parameter:

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

Best Practices

• Start with the default effort (high) for most use cases. Only lower it if you're confident your requests are simple.
• Use adaptive thinking for agentic workflows to take advantage of interleaved thinking between tool calls.
• Monitor your token usage after migrating. You may see cost savings on simple queries and better quality on complex ones.
• Test on Opus 4.7 first if you're building new features, since adaptive thinking is the only supported mode there.
• Don't mix adaptive and manual thinking in the same application. Pick one and stick with it for consistency.

Limitations and Considerations

• Adaptive thinking is not supported on older models (Sonnet 4.5, Opus 4.5, etc.). Those still require thinking: {type: "enabled"} with budget_tokens.
• If your workload requires predictable latency or precise control over thinking costs, manual budget_tokens is still functional on Opus 4.6 and Sonnet 4.6—but it's deprecated and not recommended.
• The effort parameter is still in beta on some models. Check the latest API docs for exact values and behavior.

Key Takeaways

• Adaptive thinking lets Claude dynamically decide when and how much to think, replacing the rigid manual budget_tokens approach.
• It's the only supported mode on Claude Opus 4.7 and the default on Claude Mythos Preview. Manual mode is deprecated on Opus 4.6 and Sonnet 4.6.
• Interleaved thinking is automatically enabled, making adaptive thinking ideal for agentic workflows with multiple tool calls.
• Migration is simple: change thinking: {type: "enabled", budget_tokens: N} to thinking: {type: "adaptive"} and optionally add an effort parameter.
• You'll get better performance and lower costs on bimodal workloads, with simpler code and no more guessing about token budgets.