Claude thinking models: when to use extended thinking or standard mode

Claude can answer directly in standard mode or spend extra tokens reasoning before it responds. The second option helps on difficult work, but it also adds latency and cost. The useful question is not whether thinking is better. It is whether a given task benefits enough to justify the extra compute.

This guide compares both modes, explains the available controls, and gives you a practical way to choose a thinking budget for your own workload.

What extended thinking does

Extended thinking gives Claude more room to reason through complex tasks before it returns an answer. When enabled, the response includes a thinking block before the final text.

The closest everyday comparison is a whiteboard: standard mode gives you the answer immediately, while extended thinking allocates time to work through the problem first.

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-3-7-sonnet-20250219",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    messages=[{
        "role": "user",
        "content": "Solve this complex math problem: ..."
    }]
)

# The response includes thinking blocks
for block in response.content:
    if block.type == "thinking":
        print(f"Claude's reasoning: {block.thinking}")
    elif block.type == "text":
        print(f"Final answer: {block.text}")

How extended thinking works

When Claude uses extended thinking, it benefits from what’s called “serial test-time compute”. This means it uses multiple sequential reasoning steps before producing the final output, adding more computational resources as it processes the problem.

The improvement is predictable: Claude’s accuracy on tasks like math problems improves logarithmically with the number of “thinking tokens” it’s allowed to use.

Differences between models

Different Claude models handle extended thinking differently:

• Claude 3.7 Sonnet: Returns the full thinking output, showing you every step of Claude’s reasoning process
• Claude 4 models (Opus 4.6, Sonnet 4.5): Returns a summarized version of Claude’s thinking process. You still get the intelligence benefits without exposing the complete internal reasoning
• Adaptive Thinking (Opus 4.6): The model can automatically decide when deeper reasoning would be helpful

flowchart TD
    Start[User Query] --> Decision{Complex Task?}
    Decision -->|Yes| Extended[Extended Thinking Mode]
    Decision -->|No| Standard[Standard Mode]

    Extended --> Think[Sequential Reasoning Steps]
    Think --> Budget{Within Budget?}
    Budget -->|Yes| MoreThinking[Continue Thinking]
    Budget -->|No| Response[Generate Response]
    MoreThinking --> Think

    Standard --> QuickResponse[Direct Response]

    Response --> User[Return to User]
    QuickResponse --> User

    style Extended fill:#4A90E2
    style Standard fill:#50C878
    style Think fill:#FFB84D

When extended thinking earns its cost

Use it when the task depends on several linked reasoning steps or benefits from checking intermediate work.

1. Complex STEM problems

Math, physics, chemistry, or any problem that requires building mental models and applying specialized knowledge.

# Example: Complex calculus problem
response = client.messages.create(
    model="claude-3-7-sonnet-20250219",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 8000  # Give Claude room to think
    },
    messages=[{
        "role": "user",
        "content": """
        Solve the following differential equation:
        d²y/dx² + 4y = sin(2x)
        with initial conditions y(0) = 1 and y'(0) = 0
        """
    }]
)

2. Large engineering projects

When you need to break down complex tasks into smaller milestones, such as:

• Planning a software release with multiple dependencies
• Outlining an Agile sprint plan with backlog prioritization
• Mapping out a research project with multiple stages
• Architecting a microservices system

3. Coding with test verification

Tasks where Claude needs to write code, verify it against test cases, and iteratively improve the solution.

// Example prompt for complex coding task
const prompt = `
Create a TypeScript implementation of a B-tree data structure
with the following requirements:
1. Support for insertion, deletion, and search operations
2. Self-balancing mechanism
3. Generic type support
4. Comprehensive unit tests
5. O(log n) time complexity for all operations

Please think through the design carefully before implementing.
`;

4. Multi-step analysis

Tasks that require analyzing data from multiple angles, considering various factors, and synthesizing insights.

When standard mode is enough

Standard mode is a better fit when speed and cost matter more than extra reasoning.

1. Quick, straightforward tasks

When you need fast responses without deep reasoning:

• Simple code completion
• Basic question answering
• Content formatting
• Straightforward translations

2. Low-latency requirements

When response time is critical and the task doesn’t benefit from extended reasoning.

// Standard mode for quick responses
const response = await client.messages.create({
    model: "claude-sonnet-4-5-20250929",
    max_tokens: 1024,
    // No thinking parameter = standard mode
    messages: [{
        role: "user",
        content: "Convert this JavaScript to TypeScript: const x = 5;"
    }]
});

3. Cost-sensitive applications

When you need to minimize costs and the task doesn’t require deep reasoning.

4. Tasks below 1,024 thinking tokens

If you need thinking below the minimum budget (1024 tokens), use standard mode with traditional chain-of-thought prompting:

# Chain-of-thought prompting in standard mode
response = client.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=2048,
    messages=[{
        "role": "user",
        "content": """
        <thinking>
        Let me work through this step by step:
        1. First, I'll analyze the requirements
        2. Then, I'll consider edge cases
        3. Finally, I'll provide the solution
        </thinking>

        Calculate the compound interest for...
        """
    }]
)

Choosing a thinking budget

The thinking budget determines how many tokens Claude can use for its internal reasoning. Here’s how to optimize it:

A sensible starting point

• Minimum budget: 1024 tokens (enforced by the API)
• Recommended approach: Start with 1024 and incrementally increase based on results
• Complex tasks: Start with 16,000+ tokens
• Very complex tasks: 32,000+ tokens (use batch processing to avoid timeouts)

# Progressive budget testing
budgets = [1024, 2048, 4096, 8192, 16384]

for budget in budgets:
    response = client.messages.create(
        model="claude-3-7-sonnet-20250219",
        max_tokens=16000,
        thinking={
            "type": "enabled",
            "budget_tokens": budget
        },
        messages=[{"role": "user", "content": complex_problem}]
    )

    # Analyze quality vs cost trade-off
    evaluate_response_quality(response, budget)

Budget ranges

Task Complexity	Recommended Budget	Use Case
Simple reasoning	1024-2048 tokens	Basic logic, simple math
Moderate complexity	4096-8192 tokens	Multi-step problems, code review
Complex tasks	16384+ tokens	Architecture design, research planning
Very complex	32768+ tokens	Advanced STEM, large system design

Adaptive thinking in Opus 4.6

With Claude Opus 4.6 (released in 2026), Anthropic introduced adaptive thinking. This feature allows Claude to automatically decide when deeper reasoning would be helpful.

Four effort levels

• Low: Minimal thinking, prioritize speed
• Medium: Balanced approach
• High (default): Use extended thinking when useful
• Max: Maximum reasoning effort for critical tasks

import anthropic

client = anthropic.Anthropic()

# Adaptive thinking with high effort (default)
response = client.messages.create(
    model="claude-opus-4-6-20260205",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000,
        "effort": "high"  # low, medium, high, max
    },
    messages=[{
        "role": "user",
        "content": "Design a scalable microservices architecture for..."
    }]
)

# Claude decides when to use extended thinking
# You get the best of both worlds: speed when possible,
# deep reasoning when necessary

When to use each effort level

• Low: Production APIs where speed is critical, simple tasks
• Medium: General-purpose applications, balanced performance
• High: Default recommendation for most use cases
• Max: Critical decisions, complex analysis, safety-critical systems

The trade-offs

Performance versus cost

Extended thinking provides more thorough responses but comes with trade-offs:

Pros:

• More accurate results on complex problems
• Visible reasoning process (transparency)
• Better handling of edge cases
• Improved logical consistency

Cons:

• Increased latency (takes longer to respond)
• Higher costs (more tokens consumed)
• May be overkill for simple tasks

graph LR
    A[Extended Thinking] --> B[Higher Accuracy]
    A --> C[More Tokens]
    A --> D[Longer Latency]

    E[Standard Mode] --> F[Fast Response]
    E --> G[Lower Cost]
    E --> H[Sufficient for Simple Tasks]

    style A fill:#4A90E2
    style E fill:#50C878
    style B fill:#90EE90
    style C fill:#FFB84D
    style D fill:#FFB84D
    style F fill:#90EE90
    style G fill:#90EE90

A practical cost comparison

The following example makes the token cost visible:

# Example cost comparison
# Assuming Claude Opus 4.6 pricing (example rates)

# Standard mode
standard_input_tokens = 1000
standard_output_tokens = 500
standard_cost = (standard_input_tokens * 0.015/1000) +
                (standard_output_tokens * 0.075/1000)

# Extended thinking mode
extended_input_tokens = 1000
extended_thinking_tokens = 8000
extended_output_tokens = 500
extended_cost = (extended_input_tokens * 0.015/1000) +
                (extended_thinking_tokens * 0.015/1000) +
                (extended_output_tokens * 0.075/1000)

print(f"Standard mode: ${standard_cost:.4f}")
print(f"Extended thinking: ${extended_cost:.4f}")
print(f"Cost increase: {(extended_cost/standard_cost - 1) * 100:.1f}%")

A practical operating approach

These practices make it easier to control quality, latency, and spend in production.

1. Start small and increase deliberately

Begin with standard mode or minimal thinking budgets. Only increase when you see quality improvements that justify the cost.

2. Use adaptive thinking when it fits

If you’re on Claude Opus 4.6, leverage adaptive thinking with the “high” effort level. Let the model decide when to think deeply.

3. Benchmark your own tasks

Create a test suite of representative tasks and measure quality vs cost across different modes and budgets.

# Example benchmarking approach
test_cases = [
    ("simple_query", "What is 2+2?"),
    ("moderate_task", "Refactor this code to use async/await"),
    ("complex_problem", "Design a fault-tolerant distributed system")
]

configs = [
    {"mode": "standard"},
    {"mode": "thinking", "budget": 2048},
    {"mode": "thinking", "budget": 8192},
]

for name, query in test_cases:
    for config in configs:
        result = run_test(query, config)
        log_metrics(name, config, result)

4. Monitor thinking-token usage

Track how many thinking tokens are actually used vs budgeted. This helps optimize your budgets.

5. Use batch processing for large budgets

For thinking budgets above 32K tokens, use batch processing to avoid timeout issues.

6. Match the mode to the task

Create a decision matrix for your team:

flowchart TD
    Start[New Task] --> Q1{Requires multi-step reasoning?}
    Q1 -->|No| Standard[Use Standard Mode]
    Q1 -->|Yes| Q2{Time sensitive?}

    Q2 -->|Yes| Q3{Critical accuracy needed?}
    Q2 -->|No| Extended[Use Extended Thinking]

    Q3 -->|Yes| Extended
    Q3 -->|No| Standard

    Extended --> Q4{Task complexity?}
    Q4 -->|Simple| Budget1[1024-2048 tokens]
    Q4 -->|Moderate| Budget2[4096-8192 tokens]
    Q4 -->|Complex| Budget3[16384+ tokens]

    Standard --> Done[Execute]
    Budget1 --> Done
    Budget2 --> Done
    Budget3 --> Done

    style Extended fill:#4A90E2
    style Standard fill:#50C878

Example: a code architecture review

Here is the same review request in both modes:

# Standard mode
# Fast but might miss edge cases
response = client.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=2048,
    messages=[{
        "role": "user",
        "content": "Review this code for issues"
    }]
)
# Response time: ~2 seconds
# Finds: 3 obvious bugs

# Extended thinking mode
# Slower but more thorough
response = client.messages.create(
    model="claude-3-7-sonnet-20250219",
    max_tokens=8000,
    thinking={
        "type": "enabled",
        "budget_tokens": 4096
    },
    messages=[{
        "role": "user",
        "content": "Review this code for issues"
    }]
)
# Response time: ~8 seconds
# Finds: 3 bugs + 2 edge cases +
#        1 architectural concern

A simple decision rule

Neither mode wins by default. Choose the one that matches the task and the constraints around it.

Use Extended Thinking when:

• The task requires multi-step reasoning
• Accuracy is more important than speed
• You’re working on complex STEM, engineering, or analytical problems
• The cost trade-off is justified by the quality improvement

Use Standard Mode when:

• You need fast responses
• The task is straightforward
• Cost optimization is a priority
• Latency is a critical factor

Use Adaptive Thinking when:

• You want the model to decide automatically
• You’re using Claude Opus 4.6
• You want a balanced approach across varied tasks

Start with standard mode or a small budget, measure the result on representative tasks, and increase the budget only when the quality gain is worth the added cost and latency.

Read the official Claude extended thinking documentation