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

Adaptive Thinking represents a significant evolution in how Claude approaches complex reasoning tasks. Unlike the previous extended thinking approach that required manual token budgeting, Adaptive Thinking allows Claude to dynamically determine when and how much to think based on the complexity of each request. This guide will walk you through everything you need to know to implement and optimize Adaptive Thinking in your Claude applications.

What is Adaptive Thinking?

Adaptive Thinking is the recommended approach for extended reasoning with Claude Opus 4.7, Claude Opus 4.6, and Claude Sonnet 4.6 models. It's also the default mode for Claude Mythos Preview. Instead of manually setting a fixed thinking token budget, Adaptive Thinking enables Claude to:

• Dynamically evaluate task complexity
• Automatically determine when extended thinking is necessary
• Optimize thinking duration based on the specific problem
• Enable interleaved thinking between tool calls for agentic workflows

This approach often delivers better performance than fixed-budget thinking, particularly for bimodal tasks and long-horizon agentic workflows.

Supported Models and Compatibility

Current Support

• Claude Mythos Preview (claude-mythos-preview): Adaptive Thinking is the default mode
• 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 legacy thinking
• Claude Sonnet 4.6 (claude-sonnet-4-6): Supports both Adaptive and legacy thinking

Important Migration Notes

• Opus 4.7 requires Adaptive Thinking: Manual thinking ({type: "enabled", budget_tokens: N}) is rejected with a 400 error
• Legacy thinking is deprecated: On Opus 4.6 and Sonnet 4.6, thinking.type: "enabled" and budget_tokens are deprecated and will be removed in future releases
• Older models: Sonnet 4.5, Opus 4.5, and earlier require legacy thinking with budget_tokens

How Adaptive Thinking Works

Adaptive Thinking operates on a simple but powerful principle: let Claude decide. The model evaluates each request and determines:

• Whether to think at all: Simpler problems may skip extended thinking entirely
• How much to think: Complex problems receive more reasoning time
• When to think between steps: Particularly useful for multi-step workflows

This automatic optimization means you don't need to guess appropriate token budgets for different types of tasks.

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 and response content
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."
    }
  ]
});
// Process the response
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});
  }
}

Working with the Effort Parameter

The effort parameter allows you to guide Claude's thinking intensity while maintaining adaptive behavior:

# Different effort levels for different scenarios
High effort (default) - Claude almost always thinks
response_high = client.messages.create(
    model="claude-opus-4-7",
    thinking={"type": "adaptive", "effort": "high"},
    # ... other parameters
)
Medium effort - Balanced approach
response_medium = client.messages.create(
    model="claude-opus-4-7",
    thinking={"type": "adaptive", "effort": "medium"},
    # ... other parameters
)
Low effort - Claude thinks less, faster responses
response_low = client.messages.create(
    model="claude-opus-4-7",
    thinking={"type": "adaptive", "effort": "low"},
    # ... other parameters
)

Effort Levels Explained

High Effort (Default)

• Behavior: Claude almost always uses extended thinking
• Use Case: Critical reasoning tasks, complex problem-solving, high-stakes decisions
• Trade-off: Highest quality, potentially slower responses

Medium Effort

• Behavior: Balanced approach, thinks for moderately complex tasks
• Use Case: General-purpose applications, mixed complexity workloads
• Trade-off: Good balance of quality and speed

Low Effort

• Behavior: Minimal thinking, skips for simple problems
• Use Case: Simple Q&A, straightforward tasks, latency-sensitive applications
• Trade-off: Fastest responses, may sacrifice depth for simple tasks

Adaptive Thinking in Agentic Workflows

One of Adaptive Thinking's most powerful features is automatic interleaved thinking between tool calls. This makes it particularly effective for agentic workflows:

# Example of Adaptive Thinking in a multi-step workflow
response = client.messages.create(
    model="claude-opus-4-7",
    thinking={"type": "adaptive", "effort": "high"},
    tools=[
        {
            "name": "web_search",
            "description": "Search the web for current information"
        },
        {
            "name": "calculator",
            "description": "Perform mathematical calculations"
        }
    ],
    messages=[
        {
            "role": "user",
            "content": "Research the latest climate change data and calculate the projected temperature increase by 2050 based on current trends."
        }
    ]
)
Claude will automatically think between:
1. Understanding the query
2. Planning the research approach
3. After web search results
4. Before and after calculations
5. Synthesizing the final answer

Migration from Legacy Thinking

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

Before (Legacy)

# Deprecated approach
thinking={"type": "enabled", "budget_tokens": 4000}

After (Adaptive)

# Recommended approach
thinking={"type": "adaptive", "effort": "high"}  # or "medium", "low"

Migration Strategy

• Test with Adaptive Thinking using your existing workloads
• Compare results between legacy and adaptive approaches
• Adjust effort levels based on your quality/latency requirements
• Update all Opus 4.7 applications to use Adaptive Thinking exclusively
• Plan migration for Opus 4.6 and Sonnet 4.6 applications

Best Practices and Optimization

When to Use Different Effort Levels

• Use High Effort for:

- Complex reasoning tasks - Mathematical proofs and derivations - Code generation with intricate requirements - Strategic planning and analysis

• Use Medium Effort for:

- General content generation - Data analysis and interpretation - Multi-step problem solving - Most business applications

• Use Low Effort for:

- Simple Q&A - Text summarization - Basic formatting tasks - High-throughput applications

Monitoring and Evaluation

# Track thinking usage in your applications
def analyze_thinking_usage(response):
    thinking_blocks = [b for b in response.content if b.type == "thinking"]
    text_blocks = [b for b in response.content if b.type == "text"]
    
    print(f"Thinking blocks: {len(thinking_blocks)}")
    print(f"Text blocks: {len(text_blocks)}")
    
    if thinking_blocks:
        # Estimate thinking tokens (approximate)
        thinking_text = " ".join([b.thinking for b in thinking_blocks])
        estimated_tokens = len(thinking_text) // 4  # Rough approximation
        print(f"Estimated thinking tokens: {estimated_tokens}")

Common Use Cases

1. Complex Problem Solving

Adaptive Thinking excels at mathematical proofs, logical reasoning, and multi-step analysis where the required thinking depth varies by problem complexity.

2. Agentic Applications

For workflows involving multiple tool calls, Adaptive Thinking automatically inserts reasoning between steps, improving decision quality.

3. Content Generation

From simple summaries to complex technical documentation, Adaptive Thinking adjusts reasoning depth based on content complexity.

4. Code Generation and Review

Adaptive Thinking helps Claude understand complex requirements and generate appropriate solutions with varying levels of analysis.

Limitations and Considerations

• Predictable Latency: Adaptive Thinking may introduce variable latency. For applications requiring consistent response times, consider using lower effort levels.

• Cost Management: While generally efficient, the dynamic nature means thinking costs may vary. Monitor usage patterns for cost-sensitive applications.

• Model Compatibility: Ensure you're using supported models (Opus 4.7, Opus 4.6, Sonnet 4.6, or Mythos Preview).

• Migration Timing: Plan migration from legacy thinking before it's removed from future model releases.

Key Takeaways

• Adaptive Thinking replaces manual token budgeting with intelligent, dynamic reasoning that adjusts based on task complexity
• Opus 4.7 requires Adaptive Thinking and no longer supports the legacy budget_tokens approach
• Use the effort parameter (high, medium, low) to balance reasoning depth with response speed
• Automatic interleaved thinking makes Adaptive Thinking particularly effective for agentic workflows with multiple tool calls
• Plan migration now from legacy thinking approaches, as they're deprecated on Opus 4.6 and Sonnet 4.6

Adaptive Thinking represents a significant step forward in making Claude's reasoning capabilities more accessible and efficient. By letting Claude determine the appropriate amount of thinking for each task, developers can focus on building applications rather than optimizing token budgets.