Mastering Adaptive Thinking: A Guide to Claude's Intelligent Reasoning Engine

Adaptive thinking represents a significant evolution in how Claude approaches complex reasoning tasks. Instead of requiring developers to manually set thinking token budgets, this feature allows Claude to dynamically determine when and how much to use extended thinking based on the complexity of each request. This guide will walk you through everything you need to know to effectively implement and optimize adaptive thinking in your Claude applications.

What is Adaptive Thinking?

Adaptive thinking is the recommended approach for using extended thinking with Claude Opus 4.7, Claude Opus 4.6, and Claude Sonnet 4.6. It's the default mode on Claude Mythos Preview, where it automatically applies whenever thinking is not explicitly disabled.

The key innovation of adaptive thinking is its dynamic nature. Rather than you specifying a fixed token budget (like budget_tokens: 4000), Claude evaluates each request and decides:

• Whether thinking is needed at all
• How much thinking to allocate
• When to think during multi-step processes

This approach often delivers better performance than fixed-budget thinking, particularly for bimodal tasks (where some requests are simple and others complex) and long-horizon agentic workflows.

Supported Models and Compatibility

Adaptive thinking is supported on specific Claude models:

• Claude Mythos Preview (claude-mythos-preview): Adaptive thinking is the default mode; disabling thinking is not supported
• Claude Opus 4.7 (claude-opus-4-7): Adaptive thinking is the only supported thinking mode
• Claude Opus 4.6 (claude-opus-4-6): Supports both adaptive and manual thinking (though manual is deprecated)
• Claude Sonnet 4.6 (claude-sonnet-4-6): Supports both adaptive and manual thinking (though manual is deprecated)

Important Note: On Claude Opus 4.7, thinking: {type: "enabled", budget_tokens: N} is no longer accepted—you must use adaptive thinking. For older models (Sonnet 4.5, Opus 4.5, etc.), you'll need to continue using manual thinking with budget_tokens.

How Adaptive Thinking Works

When you enable adaptive thinking, Claude evaluates each request through a sophisticated decision-making process:

• Complexity Assessment: Claude analyzes the task to determine if extended thinking is beneficial
• Dynamic Allocation: If thinking is warranted, Claude allocates an appropriate amount of thinking tokens
• Interleaved Thinking: Claude can think between tool calls, making it particularly effective for agentic workflows
• Effort-Based Tuning: You can guide Claude's thinking intensity using the effort parameter

At the default high effort level, Claude almost always engages in thinking. At lower effort levels, it may skip thinking for simpler problems, optimizing for speed and cost.

Implementing Adaptive Thinking

Basic Implementation

Here's how to enable adaptive thinking in your API requests:

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

import Anthropic from '@anthropic-ai/sdk';
const anthropic = new Anthropic();
const response = await anthropic.messages.create({
  model: "claude-opus-4-7",
  max_tokens: 16000,
  thinking: { type: "adaptive" },  // Enable adaptive thinking
  messages: [
    {
      role: "user",
      content: "Explain why the sum of two even numbers is always even.",
    }
  ],
});
// Access thinking content if present
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});
  }
}

Using the Effort Parameter

The effort parameter allows you to guide how much thinking Claude does. This is particularly useful when you want to balance performance with cost and latency:

# Different effort levels for different scenarios
High effort - maximum thinking (default)
response_high = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=16000,
    thinking={"type": "adaptive", "effort": "high"},
    messages=[{"role": "user", "content": "Complex task here..."}],
)
Medium effort - balanced approach
response_medium = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=16000,
    thinking={"type": "adaptive", "effort": "medium"},
    messages=[{"role": "user", "content": "Moderately complex task..."}],
)
Low effort - minimal thinking, faster responses
response_low = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=16000,
    thinking={"type": "adaptive", "effort": "low"},
    messages=[{"role": "user", "content": "Simple verification task..."}],
)

When to Use Adaptive Thinking

Ideal Use Cases

• Agentic Workflows: Adaptive thinking shines in multi-step processes where Claude needs to reason between tool calls
• Variable Complexity Tasks: When your application handles both simple and complex requests
• Cost-Optimized Applications: When you want Claude to use thinking only when necessary
• Real-time Applications: Lower effort levels can reduce latency for time-sensitive tasks

When to Consider Alternatives

• Predictable Latency Requirements: If you need consistent response times, test different effort levels thoroughly
• Legacy Systems: If you're using older Claude models that don't support adaptive thinking
• Specialized Workloads: Some highly specific tasks might benefit from manual tuning (though this is rare)

Migration from Manual Thinking

If you're currently using manual thinking with budget_tokens, here's how to migrate:

# OLD APPROACH (deprecated on supported models)
response_old = client.messages.create(
    model="claude-opus-4-6",
    max_tokens=16000,
    thinking={"type": "enabled", "budget_tokens": 4000},  # Deprecated
    messages=[{"role": "user", "content": "Your prompt here..."}],
)
NEW APPROACH with adaptive thinking
response_new = client.messages.create(
    model="claude-opus-4-7",  # Consider upgrading to 4.7
    max_tokens=16000,
    thinking={"type": "adaptive", "effort": "high"},  # Modern approach
    messages=[{"role": "user", "content": "Your prompt here..."}],
)

Important: thinking.type: "enabled" and budget_tokens are deprecated on Opus 4.6 and Sonnet 4.6 and will be removed in future model releases. Plan your migration accordingly.

Best Practices and Tips

1. Start with High Effort

Begin with effort: "high" to see how Claude performs on your tasks. This gives you a baseline for maximum thinking capability.

2. Test Different Effort Levels

Experiment with different effort levels to find the right balance for your specific use case:

• High: Maximum reasoning power, best for complex problem-solving
• Medium: Balanced approach for mixed workloads
• Low: Optimized for speed and cost on simpler tasks

3. Monitor Thinking Usage

Even though you're not setting token budgets, it's still valuable to monitor how much thinking Claude is using:

response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=16000,
    thinking={"type": "adaptive", "effort": "high"},
    messages=[{"role": "user", "content": "Your prompt here..."}],
)
Check if thinking was used and how much
if hasattr(response, 'usage') and response.usage:
    print(f"Input tokens: {response.usage.input_tokens}")
    print(f"Output tokens: {response.usage.output_tokens}")
    # Note: Thinking tokens are included in output tokens

4. Combine with Other Features

Adaptive thinking works particularly well when combined with:

• Tool Use: For agentic workflows where thinking between tool calls is valuable
• Structured Outputs: When you need Claude to reason about complex data structures
• Long Context Windows: For documents that require deep analysis

5. Handle Thinking Content Appropriately

Remember that thinking content is included in the response and counts toward output tokens. Ensure your application properly handles or filters thinking blocks as needed.

Common Questions

Q: Can I disable adaptive thinking?

A: On Claude Opus 4.7, thinking is off by default unless you explicitly enable it. On Mythos Preview, adaptive thinking cannot be disabled. On other supported models, you can use thinking: {type: "disabled"}.

Q: How does adaptive thinking affect costs?

A: Thinking tokens are included in output tokens for billing purposes. Adaptive thinking can be more cost-effective than fixed budgets because Claude only uses thinking when it's beneficial.

Q: Can I set a maximum thinking budget?

A: No, adaptive thinking doesn't support maximum budgets. The model dynamically determines the appropriate amount. If you need strict budget control, you may need to use older models with manual thinking (though this is not recommended).

Q: Is adaptive thinking available in the Console?

A: Yes, adaptive thinking is available through both the API and the Claude Platform Console.

Key Takeaways

• Adaptive thinking is the modern approach to extended reasoning in Claude, replacing manual token budgets with intelligent, dynamic allocation
• It's particularly effective for agentic workflows and tasks with variable complexity, thanks to interleaved thinking capabilities
• Use the effort parameter (high, medium, low) to balance reasoning power with speed and cost for your specific use case
• Migrate from manual thinking on supported models, as budget_tokens is deprecated and will be removed in future releases
• Start with high effort for complex tasks and experiment with lower levels for optimization, always monitoring performance and costs

Adaptive thinking represents a significant step forward in making Claude's reasoning capabilities more accessible and efficient. By letting the model determine when and how much to think, you can focus on building your applications while Claude optimizes its own reasoning process.