Claude Extended Thinking: Deep Reasoning in Practice

What is Extended Thinking?

Extended Thinking is a feature that allows Claude to think deeply before responding. Instead of immediately generating a response, Claude:

1. →Explores different approaches to the problem
2. →Verifies its reasoning step by step
3. →Corrects its errors along the way
4. →Formulates a more reliable final response

It's the equivalent of asking an expert to take time to think rather than answering instantly.

Without vs With Extended Thinking

The honest state of "extended thinking" features across frontier models — Anthropic's extended thinking, OpenAI's o-series, DeepSeek's reasoning mode — is that they trade latency and cost for a real but narrow quality gain. Practitioners on r/MachineLearning and r/LocalLLaMA keep landing on the same profile: math, logical multi-step reasoning, and code with non-obvious constraints benefit clearly; rephrasing, summarization, and single-hop Q&A do not. Turning on extended thinking for every task is a waste of tokens; turning it off for the tasks that actually need it is a waste of accuracy.

Where the community correctly pushes back on the marketing: "thinking" tokens are not observable reasoning in any philosophical sense — they are an extended scratchpad that statistically correlates with better final answers on reasoning-heavy tasks. Research like Chain-of-Thought prompting and the subsequent debates about whether CoT faithfully represents model cognition are the right context here. The short version: assume the thinking trace is useful for you as a debugging tool, not as a literal transcript of the model's beliefs.

Pragmatic operating rule: benchmark your own workload with and without extended thinking on a fixed eval set, then adopt it only where the accuracy gain exceeds the latency and token cost. For most production workflows, a small budget (1-4k thinking tokens) on the 20% of hardest tasks pays for itself; blanket enabling rarely does.

Enabling Extended Thinking via the API

Basic Implementation

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000  # Maximum budget for thinking
    },
    messages=[{
        "role": "user",
        "content": "Solve this dynamic programming problem: given an array of integers, find the longest increasing subsequence."
    }]
)

# Iterate through response blocks
for block in response.content:
    if block.type == "thinking":
        print("🧠 Thinking:")
        print(block.thinking)
        print("---")
    elif block.type == "text":
        print("💬 Response:")
        print(block.text)

Adaptive Thinking (Claude 4.6)

Claude 4.6's adaptive thinking automatically adjusts reasoning effort based on complexity:

response = client.messages.create(
    model="claude-opus-4-20250918",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000  # MAXIMUM budget, not fixed
    },
    messages=[{
        "role": "user",
        "content": "What is the capital of France?"
    }]
)
# → Minimal thinking (~50 tokens) because the question is simple

response2 = client.messages.create(
    model="claude-opus-4-20250918",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    messages=[{
        "role": "user",
        "content": "Prove that the square root of 2 is irrational."
    }]
)
# → Extended thinking (~5000 tokens) because the problem is complex

Budget Tokens: Optimizing Cost

The budget_tokens defines the maximum number of tokens Claude can use for thinking.

Allocation Strategy

def get_thinking_budget(task_type):
    """Returns a thinking budget suited to the task type."""
    budgets = {
        "simple_qa": 1000,
        "code_review": 5000,
        "bug_fix": 8000,
        "algorithm_design": 12000,
        "math_proof": 20000,
        "architecture": 15000,
    }
    return budgets.get(task_type, 5000)

# Usage
budget = get_thinking_budget("bug_fix")
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=16000,
    thinking={"type": "enabled", "budget_tokens": budget},
    messages=[{"role": "user", "content": "..."}]
)

Important Constraints

• →Minimum: budget_tokens must be ≥ 1024
• →Maximum: budget_tokens + max_tokens must not exceed the model's limit
• →Billing: Thinking tokens are billed at the output token rate
• →No cache: Thinking tokens are not eligible for prompt caching

When to Use Extended Thinking?

✅ Use It

❌ Avoid It

• →Simple factual questions: "What is the capital of France?" → Not needed
• →Free creative tasks: "Write a poem" → Thinking doesn't improve creativity
• →Low-latency chatbots: Thinking adds latency
• →Tight budget: Thinking tokens are billed and add up quickly

Streaming with Extended Thinking

with client.messages.stream(
    model="claude-sonnet-4-20250514",
    max_tokens=16000,
    thinking={"type": "enabled", "budget_tokens": 8000},
    messages=[{"role": "user", "content": "Design a database for a social network."}]
) as stream:
    current_type = None
    for event in stream:
        if hasattr(event, 'type'):
            if event.type == "content_block_start":
                block_type = event.content_block.type
                if block_type == "thinking":
                    print("\n🧠 Thinking in progress...")
                    current_type = "thinking"
                elif block_type == "text":
                    print("\n💬 Response:")
                    current_type = "text"
            elif event.type == "content_block_delta":
                if current_type == "thinking" and hasattr(event.delta, 'thinking'):
                    print(event.delta.thinking, end="")
                elif current_type == "text" and hasattr(event.delta, 'text'):
                    print(event.delta.text, end="")

Block Order in Streaming

1. message_start
2. content_block_start (type: "thinking")
3. content_block_delta (thinking content...)  ← thinking blocks
4. content_block_stop
5. content_block_start (type: "text")
6. content_block_delta (text content...)     ← final response
7. content_block_stop
8. message_stop

Performance Benchmarks

Extended Thinking significantly improves performance on reasoning benchmarks:

Advanced Patterns

Multi-Turn Conversation with Thinking

messages = []

def chat_with_thinking(user_msg, budget=5000):
    messages.append({"role": "user", "content": user_msg})
    
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=16000,
        thinking={"type": "enabled", "budget_tokens": budget},
        messages=messages
    )
    
    # Add the complete response (without thinking blocks)
    assistant_content = [
        block for block in response.content
        if block.type == "text"
    ]
    messages.append({"role": "assistant", "content": assistant_content})
    
    return response

# Usage
chat_with_thinking("Design a recommendation algorithm.", budget=10000)
chat_with_thinking("Optimize it for scalability.", budget=8000)

Dynamic Budget Based on Complexity

def estimate_complexity(message):
    """Estimates question complexity to adjust the budget."""
    complexity_indicators = {
        "prove": 3, "demonstrate": 3, "optimize": 2,
        "algorithm": 2, "architecture": 2, "compare": 1,
        "design": 2, "debug": 2, "why": 1,
        "analyze": 1, "explain": 0.5
    }
    
    score = sum(
        weight for keyword, weight in complexity_indicators.items()
        if keyword in message.lower()
    )
    
    if score <= 1:
        return 2000
    elif score <= 3:
        return 6000
    elif score <= 5:
        return 12000
    else:
        return 20000

budget = estimate_complexity("Prove and demonstrate that this algorithm is optimal.")
# → 20000 tokens (high complexity)

Common Errors