Adaptive Thinking in Claude: Smarter Reasoning Without Manual Budgets

Introduction

Claude's extended thinking capability has been a game-changer for complex reasoning tasks. But manually setting a budget_tokens value for every request can be tedious and inefficient—especially when your workload mixes simple queries with deep reasoning problems. Enter adaptive thinking, the smarter, dynamic approach to extended thinking.

Adaptive thinking lets Claude evaluate each request individually and decide whether—and how much—to use extended thinking. No more guessing token budgets. No more overthinking simple questions. Claude handles the allocation automatically.

This guide covers everything you need to know: supported models, how to enable adaptive thinking, the effort parameter, migration from manual budgets, and practical code examples.

What Is Adaptive Thinking?

Adaptive thinking is a mode where Claude dynamically determines when to engage extended thinking. Instead of you specifying a fixed budget_tokens value, Claude analyzes the complexity of each request and allocates thinking tokens accordingly.

Key benefits:

• Better performance on bimodal tasks – Handles both simple and complex requests optimally.
• Ideal for agentic workflows – Automatically enables interleaved thinking between tool calls.
• No manual tuning – No need to adjust budgets per request or per use case.
• Cost efficiency – Avoids wasting tokens on trivial queries.

Supported Models

Important: Older models (Sonnet 4.5, Opus 4.5, etc.) do not support adaptive thinking. They require thinking: {type: "enabled", budget_tokens: N}.

How Adaptive Thinking Works

In adaptive mode, thinking is optional for the model. Claude evaluates each request's complexity and decides:

• Whether to use extended thinking at all
• How many tokens to allocate for thinking

At the default effort level (high), Claude almost always thinks. At lower effort levels, Claude may skip thinking for very simple problems.

Adaptive thinking also automatically enables interleaved thinking—Claude can think between tool calls, making it especially effective for agentic workflows where the model needs to reason after receiving tool results.

Using the Effort Parameter

The effort parameter gives you soft guidance over how much thinking Claude should do. It's not a hard constraint—Claude may still adjust based on task complexity.

Available Effort Levels

Code Example: Python

import anthropic
client = anthropic.Anthropic()
response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=4096,
    thinking={
        "type": "adaptive",
        "effort": "high"  # Options: max, xhigh, high, medium, low
    },
    messages=[
        {"role": "user", "content": "Explain quantum entanglement in simple terms."}
    ]
)
print(response.content)

Code Example: TypeScript

import Anthropic from '@anthropic-ai/sdk';
const client = new Anthropic();
const response = await client.messages.create({
  model: 'claude-opus-4-7',
  max_tokens: 4096,
  thinking: {
    type: 'adaptive',
    effort: 'high'  // Options: max, xhigh, high, medium, low
  },
  messages: [
    { role: 'user', content: 'Explain quantum entanglement in simple terms.' }
  ]
});
console.log(response.content);

Migrating from Manual Thinking Budgets

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

Step 1: Identify Your Model

• Opus 4.7: You must switch to adaptive thinking. Manual mode is rejected.
• Opus 4.6 / Sonnet 4.6: Manual mode is deprecated but still works. Plan to migrate.
• Older models: Keep using manual mode (adaptive not supported).

Step 2: Replace the Thinking Block

Before (manual budget):

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

After (adaptive):

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

Step 3: Adjust Your Expectations

• Adaptive thinking may use fewer tokens for simple tasks (cost savings).
• For complex tasks, it may use more tokens than your fixed budget—but often with better results.
• No beta header is required for adaptive thinking.

Best Practices

1. Start with high Effort

For most use cases, high provides an excellent balance of reasoning depth and token efficiency. Only increase to max or xhigh when you need exhaustive exploration.

2. Use medium or low for High-Volume, Simple Queries

If your application handles many straightforward requests (e.g., classification, simple extraction), lower effort levels can save tokens without sacrificing quality.

3. Leverage Interleaved Thinking for Agents

Adaptive thinking automatically enables thinking between tool calls. This is perfect for agentic workflows where Claude needs to reason after receiving tool outputs.

# Example: Agentic workflow with adaptive thinking
response = client.messages.create(
    model="claude-opus-4-6",
    max_tokens=8192,
    thinking={"type": "adaptive", "effort": "high"},
    tools=[
        {
            "name": "search_database",
            "description": "Search the internal database",
            "input_schema": {
                "type": "object",
                "properties": {
                    "query": {"type": "string"}
                },
                "required": ["query"]
            }
        }
    ],
    messages=[
        {"role": "user", "content": "Find all customers who purchased in the last 30 days and calculate their average spend."}
    ]
)

4. Monitor Token Usage

Since adaptive thinking is dynamic, monitor your token consumption to understand cost patterns. The usage field in API responses still shows thinking tokens.

5. Test with Your Workload

Run A/B tests comparing adaptive thinking (at various effort levels) against your old manual budget to measure performance and cost differences.

Common Pitfalls

• Using adaptive thinking on unsupported models – Older models will ignore the adaptive type and may error. Always check model compatibility.
• Expecting fixed latency – Adaptive thinking means variable thinking time. If you need predictable latency, consider using manual budgets on Opus 4.6 or Sonnet 4.6 (though deprecated).
• Setting thinking: {type: "disabled"} on Mythos Preview – This is not supported. Mythos Preview always uses adaptive thinking.

Conclusion

Adaptive thinking represents a significant evolution in how Claude handles extended reasoning. By removing the burden of manual token budgeting, it simplifies development while often improving performance—especially for mixed workloads and agentic applications.

Whether you're building a simple Q&A bot or a complex multi-step agent, adaptive thinking with the effort parameter gives you the flexibility to balance reasoning depth, cost, and latency.

Key Takeaways

• Adaptive thinking replaces manual budget_tokens on Claude Opus 4.7, Opus 4.6, Sonnet 4.6, and Mythos Preview. Opus 4.7 requires it.
• Use the effort parameter (max, xhigh, high, medium, low) to guide thinking depth without hard constraints.
• Interleaved thinking is automatic in adaptive mode, making it ideal for agentic workflows with tool calls.
• Migrate now if you're on Opus 4.6 or Sonnet 4.6—manual budgets are deprecated and will be removed in a future release.
• Start with high effort for most use cases, then adjust based on your specific workload needs and token consumption patterns.