A Practical Guide to Extended Thinking in Claude AI: Boost Reasoning for Complex Tasks

Extended Thinking is one of Claude's most powerful capabilities for tackling complex, multi-step problems. When activated, Claude generates internal reasoning content—essentially showing its "work"—before delivering a polished final answer. This not only improves accuracy on difficult tasks but also provides transparency into Claude's problem-solving process.

In this guide, you'll learn how Extended Thinking works, when to use it, and how to implement it effectively through the Claude API with practical code examples.

What is Extended Thinking?

Extended Thinking gives Claude enhanced reasoning capabilities for complex tasks while providing varying levels of transparency into its step-by-step thought process. When enabled, Claude creates special "thinking" content blocks where it outputs internal reasoning, then incorporates insights from this reasoning before crafting its final response.

Think of it as Claude "thinking out loud" before answering—similar to how humans might work through a complex math problem on scratch paper before writing the final solution.

Key Benefits:

• Improved accuracy on complex, multi-step problems
• Transparent reasoning that you can inspect and validate
• Better handling of tasks requiring deep analysis or creative problem-solving
• Reduced hallucinations through more structured reasoning

Model Support and Evolution

Important Update: The implementation of Extended Thinking has evolved with newer Claude models:

For Claude Opus 4.7+ Models:

• Manual Extended Thinking (thinking: {"type": "enabled", "budget_tokens": N}) is no longer supported and returns a 400 error
• Use Adaptive Thinking (thinking: {"type": "adaptive"}) with the effort parameter instead

For Claude Opus 4.6 & Claude Sonnet 4.6:

• Adaptive Thinking is recommended
• Manual configuration is deprecated but still functional
• Will be removed in a future model release

For Claude Mythos Preview:

• Adaptive thinking is the default
• Manual configuration is accepted
• thinking: {"type": "disabled"} is not supported

How Extended Thinking Works: API Response Format

When Extended Thinking is enabled, the API response includes thinking content blocks followed by text content blocks:

{
  "content": [
    {
      "type": "thinking",
      "thinking": "Let me analyze this step by step...",
      "signature": "WaUjzkypQ2mUEVM36O2TxuC06KN8xyfbJwyem2dw3URve/op91XWHOEBLLqIOMfFG/UvLEczmEsUjavL...."
    },
    {
      "type": "text",
      "text": "Based on my analysis..."
    }
  ]
}

The signature field provides cryptographic verification of the thinking content, ensuring it hasn't been tampered with.

Implementing Extended Thinking: Code Examples

1. Adaptive Thinking (Recommended for Opus 4.7+)

Adaptive Thinking automatically determines the appropriate amount of reasoning based on task complexity and your specified effort level.

Python Example:

import anthropic
client = anthropic.Anthropic(
    api_key="your-api-key-here"
)
message = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=1000,
    thinking={
        "type": "adaptive",
        "budget_tokens": 1024  # Maximum thinking tokens
    },
    messages=[
        {
            "role": "user",
            "content": "Analyze this complex business problem: Our SaaS company has seen a 15% decrease in user engagement over the last quarter despite a 20% increase in marketing spend. What could be causing this discrepancy and what strategic changes should we consider?"
        }
    ]
)
Process the response
for block in message.content:
    if block.type == "thinking":
        print("\n--- THINKING CONTENT ---")
        print(block.thinking)
    elif block.type == "text":
        print("\n--- FINAL ANSWER ---")
        print(block.text)

TypeScript/JavaScript Example:

import Anthropic from '@anthropic-ai/sdk';
const anthropic = new Anthropic({
  apiKey: 'your-api-key-here',
});
async function useAdaptiveThinking() {
  const message = await anthropic.messages.create({
    model: 'claude-3-5-sonnet-20241022',
    max_tokens: 1000,
    thinking: {
      type: 'adaptive',
      budget_tokens: 1024
    },
    messages: [
      {
        role: 'user',
        content: 'Explain quantum entanglement in simple terms, then create an analogy that a high school student would understand.'
      }
    ]
  });
// Extract thinking and final answer
  message.content.forEach(block => {
    if (block.type === 'thinking') {
      console.log('\n--- THINKING PROCESS ---');
      console.log(block.thinking);
    } else if (block.type === 'text') {
      console.log('\n--- FINAL EXPLANATION ---');
      console.log(block.text);
    }
  });
}

2. Manual Extended Thinking (Legacy Models)

For models that still support manual configuration (deprecated for newer models):

# For Claude Opus 4.6 or Sonnet 4.6 (deprecated approach)
message = client.messages.create(
    model="claude-3-opus-20240229",
    max_tokens=1000,
    thinking={
        "type": "enabled",
        "budget_tokens": 500  # Fixed token budget for thinking
    },
    messages=[
        {
            "role": "user",
            "content": "Solve this complex calculus problem step by step..."
        }
    ]
)

The Effort Parameter: Controlling Reasoning Depth

With Adaptive Thinking, you can use the effort parameter to control how much cognitive effort Claude applies:

# Different effort levels for different task complexities
easy_task_thinking = {
    "type": "adaptive",
    "budget_tokens": 512,
    "effort": 0.3  # Lower effort for simpler tasks
}
complex_task_thinking = {
    "type": "adaptive",
    "budget_tokens": 2048,
    "effort": 0.9  # High effort for complex analysis
}

Effort Guidelines:

• 0.1-0.3: Light reasoning for straightforward tasks
• 0.4-0.6: Moderate reasoning for typical complex tasks
• 0.7-1.0: Deep reasoning for highly complex or critical problems

Practical Use Cases for Extended Thinking

1. Complex Problem Solving

# Business strategy analysis
thinking_config = {
    "type": "adaptive",
    "budget_tokens": 1024,
    "effort": 0.8
}
problem = """Analyze market entry strategy for a new fintech product 
considering: regulatory constraints, competitive landscape, 
target demographics, and technology requirements."""

2. Code Review and Debugging

# Complex code analysis
thinking_config = {
    "type": "adaptive",
    "budget_tokens": 768,
    "effort": 0.7
}
code_review_prompt = """Review this Python function for:
Performance bottlenecks
Security vulnerabilities
Edge cases not handled
Code readability issues"""

3. Creative Brainstorming

# Creative writing or ideation
thinking_config = {
    "type": "adaptive",
    "budget_tokens": 512,
    "effort": 0.6
}

creative_prompt = """Brainstorm 10 innovative features for a 
next-generation project management tool, considering AI integration, 
collaboration trends, and remote work needs."""

Best Practices and Tips

1. Match Thinking Budget to Task Complexity

• Simple tasks: 256-512 tokens
• Moderate complexity: 512-1024 tokens
• Highly complex: 1024-4096 tokens

2. Use Adaptive Thinking for New Projects

Always default to Adaptive Thinking (type: "adaptive") for new implementations, as it's the future-proof approach supported by latest models.

3. Monitor Token Usage

Extended Thinking consumes tokens from your total budget. Ensure your max_tokens parameter accounts for both thinking and final answer tokens.

# Good practice: Account for thinking in total tokens
message = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=2000,  # Includes thinking + final answer
    thinking={
        "type": "adaptive",
        "budget_tokens": 512  # Thinking portion
    },
    # ... rest of configuration
)

4. Parse Responses Efficiently

def extract_thinking_and_answer(response):
    """Helper function to parse Extended Thinking responses"""
    thinking_content = ""
    final_answer = ""
    
    for block in response.content:
        if block.type == "thinking":
            thinking_content = block.thinking
        elif block.type == "text":
            final_answer = block.text
    
    return {
        "thinking": thinking_content,
        "answer": final_answer,
        "has_thinking": bool(thinking_content)
    }

Common Pitfalls to Avoid

• Using deprecated syntax with Opus 4.7+: Always check model compatibility
• Setting budget_tokens too low: Complex tasks need adequate thinking space
• Ignoring total token limits: Remember thinking tokens count toward max_tokens
• Overusing for simple tasks: Not all prompts benefit from Extended Thinking

Migration Path from Manual to Adaptive Thinking

If you're updating from older implementations:

# OLD (deprecated for new models)
thinking_config = {
    "type": "enabled",
    "budget_tokens": 1000
}
NEW (recommended for all models)
thinking_config = {
    "type": "adaptive",
    "budget_tokens": 1000,
    "effort": 0.7  # Add effort parameter for finer control
}

Performance Considerations

• Latency: Extended Thinking increases response time but improves answer quality
• Cost: Thinking tokens are billed the same as output tokens
• Accuracy: The trade-off is usually worth it for complex tasks where accuracy matters

Key Takeaways

• Extended Thinking enhances Claude's reasoning on complex tasks by generating internal thought processes before final answers
• Use Adaptive Thinking (type: "adaptive") for Claude Opus 4.7+ models instead of the deprecated manual configuration
• Control reasoning depth with the effort parameter (0.1-1.0) to match task complexity
• Always account for thinking tokens in your total max_tokens budget to avoid truncated responses
• Parse responses carefully to separate thinking content from final answers in your application logic

Extended Thinking represents a significant advancement in AI transparency and capability. By implementing it strategically in your Claude applications, you can tackle more complex problems with greater confidence in the reasoning behind Claude's answers.