Mastering Adaptive Thinking: A Guide to Claude's Intelligent 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 about implementing and optimizing 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
• Determine automatically whether thinking is needed
• Allocate appropriate reasoning resources based on the specific request
• Enable interleaved thinking between tool calls for agentic workflows

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 Migration Path

Current Support

• Claude Mythos Preview: Adaptive thinking is the default mode; disabling thinking is not supported
• Claude Opus 4.7: Adaptive thinking is the only supported thinking mode
• Claude Opus 4.6: Supports adaptive thinking (manual thinking deprecated)
• Claude Sonnet 4.6: Supports adaptive thinking (manual thinking deprecated)

Important Migration Notes

If you're currently using thinking: {type: "enabled", budget_tokens: N} with Opus 4.6 or Sonnet 4.6, you should migrate to adaptive thinking. The manual thinking approach is deprecated and will be removed in future model releases.

For older models (Sonnet 4.5, Opus 4.5, etc.), you must continue using thinking.type: "enabled" with budget_tokens as adaptive thinking is not supported.

Implementing Adaptive Thinking

Basic Implementation

Here's how to implement 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.",
    }
  ],
});
// Access thinking and response content
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 Effort Parameters

While adaptive thinking automatically determines thinking needs, you can guide Claude's approach using the effort parameter. This is particularly useful when you have specific latency or cost considerations.

Available Effort Levels

• high (default): Claude almost always thinks, maximizing reasoning quality
• medium: Balanced approach, may skip thinking for simpler problems
• low: Conservative thinking, minimizes latency and cost for straightforward tasks

Implementing Effort Control

# Using adaptive thinking with medium effort
response = client.messages.create(
    model="claude-opus-4-6",
    max_tokens=16000,
    thinking={
        "type": "adaptive",
        "effort": "medium"  # Control thinking intensity
    },
    messages=[
        {
            "role": "user",
            "content": "Analyze this quarterly financial report and identify three key trends.",
        }
    ],
)

// Using adaptive thinking with low effort
const response = await anthropic.messages.create({
  model: "claude-sonnet-4-6",
  max_tokens: 16000,
  thinking: { 
    type: "adaptive",
    effort: "low"  // Control thinking intensity
  },
  messages: [
    {
      role: "user",
      content: "Provide a brief summary of this news article.",
    }
  ],
});

Best Practices for Adaptive Thinking

1. Match Effort to Task Complexity

• Use high effort for complex reasoning, analysis, and multi-step problems
• Use medium effort for moderate complexity tasks where some thinking is beneficial
• Use low effort for simple queries, translations, or straightforward extractions

2. Leverage Interleaved Thinking for Agentic Workflows

Adaptive thinking automatically enables interleaved thinking between tool calls. This makes it particularly effective for:

# Example of adaptive thinking in a tool-using workflow
response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=16000,
    thinking={"type": "adaptive"},
    tools=[
        {
            "name": "calculator",
            "description": "Perform mathematical calculations",
            "input_schema": {
                "type": "object",
                "properties": {
                    "expression": {"type": "string"}
                },
                "required": ["expression"]
            }
        }
    ],
    messages=[
        {
            "role": "user",
            "content": "Calculate the compound interest on $10,000 at 5% annual rate over 10 years, then analyze how changing the rate to 6% affects the final amount.",
        }
    ],
)

3. Monitor Performance and Adjust

Track how different effort levels affect:

• Response quality for your specific use case
• Latency patterns
• Cost implications (thinking tokens are billed differently)

4. Handle Thinking Content Appropriately

Remember that thinking content is returned in the response and can be:

• Logged for debugging and understanding Claude's reasoning process
• Hidden from end-users in production applications
• Used to improve prompt engineering based on how Claude approaches problems

Migration from Manual Thinking

If you're migrating from manual thinking (budget_tokens), here's your transition path:

# OLD APPROACH (Deprecated)
response = client.messages.create(
    model="claude-opus-4-6",
    thinking={"type": "enabled", "budget_tokens": 4000},  # Deprecated
    # ... other parameters
)
NEW APPROACH (Recommended)
response = client.messages.create(
    model="claude-opus-4-6",
    thinking={"type": "adaptive", "effort": "high"},  # Recommended
    # ... other parameters
)

When to Use Adaptive Thinking vs. Other Approaches

Use Adaptive Thinking When:

• Working with Opus 4.7, Opus 4.6, or Sonnet 4.6
• Task complexity varies significantly
• You want optimal performance without manual tuning
• Building agentic workflows with tool calls

Use Manual Thinking (Only for Older Models) When:

• Using Sonnet 4.5, Opus 4.5, or earlier models
• You require precise, predictable token budgeting
• Working with legacy systems that haven't been updated

Use No Thinking When:

• Tasks are extremely simple and fast
• You're using models that don't support extended thinking
• Minimizing latency is the absolute priority

Zero Data Retention (ZDR) Consideration

Adaptive thinking is eligible for Zero Data Retention (ZDR). When your organization has a ZDR arrangement, data sent through adaptive thinking is not stored after the API response is returned, enhancing privacy and compliance.

Common Implementation Patterns

Pattern 1: Research and Analysis

# Complex analysis with high effort
response = client.messages.create(
    model="claude-opus-4-7",
    thinking={"type": "adaptive", "effort": "high"},
    messages=[
        {
            "role": "user",
            "content": "Compare and contrast three different machine learning approaches for image classification, considering accuracy, training time, and resource requirements.",
        }
    ],
)

Pattern 2: Content Generation with Quality Control

# Creative writing with medium effort
response = client.messages.create(
    model="claude-sonnet-4-6",
    thinking={"type": "adaptive", "effort": "medium"},
    messages=[
        {
            "role": "user",
            "content": "Write a product description for a new smartwatch that emphasizes health tracking features while maintaining an elegant tone.",
        }
    ],
)

Pattern 3: Rapid Information Processing

# Quick data extraction with low effort
response = client.messages.create(
    model="claude-sonnet-4-6",
    thinking={"type": "adaptive", "effort": "low"},
    messages=[
        {
            "role": "user",
            "content": "Extract all dates and amounts from this invoice text.",
        }
    ],
)

Troubleshooting and Tips

Issue: Thinking Not Triggering

• Ensure you're using a supported model
• Check that thinking.type is set to "adaptive"
• For Opus 4.7, remember that thinking is off unless explicitly enabled

Issue: Excessive Latency

• Try lowering the effort parameter
• Consider whether thinking is necessary for your specific task
• Monitor thinking token usage in your responses

Issue: Insufficient Reasoning

• Increase the effort parameter to "high"
• Review if your prompt clearly communicates complexity
• Consider breaking complex tasks into smaller steps

Key Takeaways

• Adaptive thinking replaces manual token budgeting with intelligent, dynamic reasoning allocation
• Supported on Opus 4.7, Opus 4.6, and Sonnet 4.6 with Opus 4.7 requiring adaptive thinking exclusively
• Effort parameters (high, medium, low) allow fine-tuning of thinking intensity
• Automatically enables interleaved thinking for superior agentic workflow performance
• Migration from manual thinking is essential as the old approach is deprecated and will be removed

By implementing adaptive thinking with appropriate effort levels, you can achieve optimal performance across varying task complexities while simplifying your codebase and leveraging Claude's most advanced reasoning capabilities.