Adaptive Thinking in Claude: Smarter Reasoning Without Manual Budgets

If you've ever struggled to set the perfect budget_tokens for Claude's extended thinking—too low and the reasoning is shallow, too high and you waste tokens—you're not alone. Anthropic's new adaptive thinking mode solves this by letting Claude decide for itself when and how much to think.

Adaptive thinking is the recommended way to use extended thinking with Claude Opus 4.7, Claude Opus 4.6, and Claude Sonnet 4.6. It's also the default on Claude Mythos Preview. This guide will show you exactly how it works, when to use it, and how to migrate from the old manual approach.

What Is Adaptive Thinking?

Adaptive thinking replaces the manual thinking: {type: "enabled", budget_tokens: N} configuration with a dynamic system. Instead of you guessing how many tokens Claude should allocate to reasoning, Claude evaluates each request's complexity and decides:

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

This is especially powerful for bimodal workloads—where some requests are trivial and others are deeply complex—and for long-horizon agentic workflows where thinking needs to happen between tool calls.

Key Benefits

• No more token budget guesswork – Claude handles allocation automatically
• Interleaved thinking – Claude can think between tool calls, improving agent performance
• Better performance – Especially on mixed-complexity workloads
• Simpler code – One parameter change and you're done

Supported Models

Warning: On Opus 4.6 and Sonnet 4.6, thinking.type: "enabled" and budget_tokens are deprecated and will be removed in a future model release. Plan to migrate to adaptive thinking now.

How to Use Adaptive Thinking

Using adaptive thinking is straightforward. Simply set thinking.type to "adaptive" in your API request.

Basic Example (Python)

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}")

Basic 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: 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});
    }
}

Fine-Tuning with the Effort Parameter

Adaptive thinking also supports an optional effort parameter that acts as soft guidance for how much thinking Claude should do. This is useful when you want to control cost or latency without setting a hard token budget.

Example with Effort

response = client.messages.create(
    model="claude-opus-4-6",
    max_tokens=16000,
    thinking={
        "type": "adaptive",
        "effort": "medium"
    },
    messages=[
        {
            "role": "user",
            "content": "Write a Python script to analyze a CSV file and generate summary statistics."
        }
    ]
)

Adaptive Thinking in Agentic Workflows

One of the most powerful features of adaptive thinking is interleaved thinking—Claude can think between tool calls during multi-step tasks. This is automatically enabled when you use adaptive thinking.

Example: Tool-Using Agent with Adaptive Thinking

import anthropic
client = anthropic.Anthropic()
response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=32000,
    thinking={"type": "adaptive"},
    tools=[
        {
            "name": "search_database",
            "description": "Search a database for customer records",
            "input_schema": {
                "type": "object",
                "properties": {
                    "query": {"type": "string"}
                },
                "required": ["query"]
            }
        },
        {
            "name": "calculate_metrics",
            "description": "Calculate business metrics from data",
            "input_schema": {
                "type": "object",
                "properties": {
                    "data": {"type": "string"}
                },
                "required": ["data"]
            }
        }
    ],
    messages=[
        {
            "role": "user",
            "content": "Find all customers who churned last quarter and calculate the revenue impact."
        }
    ]
)
Claude will think between tool calls automatically
for block in response.content:
    if block.type == "thinking":
        print(f"Thinking: {block.thinking}")
    elif block.type == "tool_use":
        print(f"Tool call: {block.name}")
    elif block.type == "text":
        print(f"Final response: {block.text}")

Migrating from Manual Thinking

If you're currently using thinking.type: "enabled" with budget_tokens, here's your migration path:

Step 1: Update Your Model

Ensure you're using a supported model (Opus 4.6+, Sonnet 4.6+, or Mythos Preview).

Step 2: Change the Thinking Parameter

Before (deprecated):

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

After (recommended):

thinking={
    "type": "adaptive"
}

Step 3: Optionally Add Effort

If you need some control over cost or latency, add the effort parameter:

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

Step 4: Test and Monitor

Run your existing test suite. You may find that adaptive thinking actually improves performance on mixed-complexity tasks while potentially reducing token usage on simpler requests.

When to Use Adaptive Thinking vs. Manual Budgets

Best Practices

• Start with default effort – Use high (or omit effort) for most workloads, then adjust down if costs are too high.
• Use adaptive thinking for agents – The interleaved thinking capability is a game-changer for multi-step tasks.
• Monitor token usage – Even though you're not setting budgets, you should still track usage to understand costs.
• Test on representative data – Adaptive thinking shines on bimodal workloads, so test with your actual request distribution.
• No beta header needed – Unlike some features, adaptive thinking doesn't require any special headers.

Key Takeaways

• Adaptive thinking eliminates manual token budgets – Claude dynamically decides how much reasoning to apply based on request complexity.
• It's the only supported mode on Claude Opus 4.7 – Manual thinking.type: "enabled" is rejected with a 400 error.
• Interleaved thinking is automatic – Claude can reason between tool calls, making it ideal for agentic workflows.
• The effort parameter provides soft control – Use low, medium, or high to guide thinking allocation without hard budgets.
• Migrate now – Manual budgets are deprecated on Opus 4.6 and Sonnet 4.6 and will be removed in future releases.