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

Introduction

If you've been working with Claude's extended thinking feature, you know the power of letting the model "think before it speaks." But manually setting a budget_tokens value for every request can feel like guesswork—too few tokens and the reasoning is shallow; too many and you waste time and money.

Enter adaptive thinking, the smarter evolution of extended thinking. Instead of you deciding how much thinking Claude should do, Claude decides for itself. It evaluates each request's complexity and allocates reasoning effort accordingly. For simple questions, it might skip thinking entirely. For complex multi-step tasks, it can dive deep—and even think between tool calls.

This guide will show you exactly how to use adaptive thinking, which models support it, and how to tune it with the effort parameter for your specific workloads.

What Is Adaptive Thinking?

Adaptive thinking is a new mode for Claude's extended thinking capability. Rather than requiring you to specify a fixed number of thinking tokens (budget_tokens), you set thinking.type to "adaptive" and Claude handles the rest.

Key characteristics:

• Dynamic allocation: Claude decides per-request whether to think and how much.
• Interleaved thinking: Claude can think between tool calls, making it ideal for agentic workflows.
• Effort guidance: You can optionally set an effort level to influence how aggressively Claude thinks.
• No beta header required: Works out of the box with supported models.

Supported Models

Adaptive thinking is available on the following models:

⚠️ Important: On Opus 4.6 and Sonnet 4.6, thinking.type: "enabled" with budget_tokens is deprecated and will be removed in a future model release. Plan to migrate to adaptive thinking.

Older models (Sonnet 4.5, Opus 4.5, etc.) do not support adaptive thinking and still require thinking.type: "enabled" with budget_tokens.

How to Use Adaptive Thinking

Basic Setup

To enable adaptive thinking, set thinking.type to "adaptive" in your API request. Here's a complete 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});
  }
}

Tuning Thinking with the Effort Parameter

Adaptive thinking becomes even more powerful when combined with the effort parameter. This acts as soft guidance for how much thinking Claude should allocate:

Example with Effort Parameter

response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=16000,
    thinking={
        "type": "adaptive",
        "effort": "medium"  # Options: "low", "medium", "high"
    },
    messages=[
        {
            "role": "user",
            "content": "Write a Python function to merge two sorted lists."
        }
    ]
)

When to Use Each Effort Level

• Low effort: Use for simple Q&A, straightforward code generation, or when you need fast responses and can tolerate occasional shallow reasoning.
• Medium effort: Good default for most general-purpose tasks—coding, analysis, content generation.
• High effort: Use for complex reasoning tasks, multi-step agentic workflows, mathematical proofs, or any task where quality is paramount over speed.

Adaptive Thinking in Agentic Workflows

One of the biggest advantages of adaptive thinking is interleaved thinking. In agentic workflows where Claude makes multiple tool calls, adaptive thinking allows Claude to "think" between each call. This is a game-changer for:

• Multi-step research: Claude can reason about search results before deciding the next query.
• Code debugging: Claude can think about error messages before writing a fix.
• Complex decision trees: Claude can evaluate options before choosing a tool.

Here's a conceptual example with tool use:

response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=32000,
    thinking={"type": "adaptive", "effort": "high"},
    tools=[
        {
            "name": "search_web",
            "description": "Search the web for information",
            "input_schema": {
                "type": "object",
                "properties": {
                    "query": {"type": "string"}
                },
                "required": ["query"]
            }
        }
    ],
    messages=[
        {
            "role": "user",
            "content": "Research the latest developments in quantum computing and summarize them."
        }
    ]
)

With adaptive thinking, Claude will reason about the research question, decide on search queries, think about the results, and then formulate a summary—all with dynamic thinking allocation.

Migration Guide: From Fixed Budget to Adaptive

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

Step 1: Identify Your Model

Check which model you're using. If it's Opus 4.7, you must switch to adaptive thinking. If it's Opus 4.6 or Sonnet 4.6, you have time but should plan the migration.

Step 2: Replace the Thinking Block

Before (deprecated):

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

After (recommended):

thinking={
    "type": "adaptive",
    "effort": "high"  # Optional, defaults to "high"
}

Step 3: Test and Adjust

Run your existing workloads with adaptive thinking. For most tasks, you'll see equal or better performance. If you need more control, adjust the effort parameter.

Step 4: Monitor Costs

Adaptive thinking can sometimes use more tokens than a fixed budget for complex tasks, but it can also save tokens on simple ones. Monitor your token usage and adjust effort levels as needed.

Best Practices

• Start with high effort for critical tasks, then dial down if you need speed.
• Use medium effort as your default for most workloads—it balances quality and cost.
• Reserve low effort for high-throughput scenarios where occasional shallow reasoning is acceptable.
• Combine with tool use for maximum benefit—interleaved thinking shines in agentic workflows.
• Monitor token usage across different effort levels to optimize cost.
• Remember max_tokens must be set sufficiently high to accommodate thinking + response tokens.

Limitations and Considerations

• Adaptive thinking is not supported on older models (Sonnet 4.5, Opus 4.5, etc.).
• On Opus 4.7, you cannot disable thinking—it's always available in adaptive mode.
• The effort parameter is soft guidance, not a hard constraint. Claude may still think more or less than you expect.
• For workloads requiring predictable latency, you may still prefer fixed budget_tokens on Opus 4.6 or Sonnet 4.6 (though deprecated).

Key Takeaways

• Adaptive thinking replaces fixed token budgets with dynamic allocation—Claude decides per-request how much to think.
• It's the only mode on Claude Opus 4.7 and the default on Claude Mythos Preview; manual budget_tokens is deprecated on Opus 4.6 and Sonnet 4.6.
• Use the effort parameter (low, medium, high) to guide thinking allocation without hard-coding token limits.
• Interleaved thinking makes adaptive mode ideal for agentic workflows where Claude reasons between tool calls.
• Migrate now if you're using fixed budgets on supported models—the old approach will be removed in future releases.