extended-thinking

• Complex problem solving requiring multi-step reasoning
• Code architecture decisions with multiple trade-offs
• Debugging complex issues needing systematic analysis
• Strategic planning with many variables
• Mathematical or logical proofs
• Security analysis requiring threat modeling
• Performance optimization with multiple factors

| Model | Extended Thinking | Summarized Thinking |

|-------|------------------|---------------------|

| Claude Opus 4.5 | ✓ Full | - |

| Claude Opus 4.1 | ✓ Full | - |

| Claude Opus 4 | ✓ | ✓ Summarized |

| Claude Sonnet 4.5 | ✓ Full | - |

| Claude Sonnet 4 | ✓ | ✓ Summarized |

| Claude Haiku 4.5 | ✓ Full | - |

Basic Extended Thinking (Python)

```python

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(

model="claude-sonnet-4-20250514",

max_tokens=16000,

thinking={

"type": "enabled",

"budget_tokens": 10000 # Minimum 1,024

},

messages=[{

"role": "user",

"content": "Analyze this complex architecture decision..."

}]

)

# Access thinking and response

for block in response.content:

if block.type == "thinking":

print(f"Thinking: {block.thinking}")

elif block.type == "text":

print(f"Response: {block.text}")

```

TypeScript Configuration

```typescript

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

const response = await client.messages.create({

model: "claude-sonnet-4-20250514",

max_tokens: 16000,

thinking: {

type: "enabled",

budget_tokens: 10000,

},

messages: [

{

role: "user",

content: "Analyze this complex architecture decision...",

},

],

});

```

Streaming (Required for max_tokens > 21,333)

```python

with client.messages.stream(

model="claude-sonnet-4-20250514",

max_tokens=32000,

thinking={

"type": "enabled",

"budget_tokens": 20000

},

messages=[{"role": "user", "content": prompt}]

) as stream:

for event in stream:

if event.type == "content_block_delta":

if hasattr(event.delta, "thinking"):

print(event.delta.thinking, end="", flush=True)

elif hasattr(event.delta, "text"):

print(event.delta.text, end="", flush=True)

```

| Task Complexity | Budget Tokens | Use Case |

|-----------------|---------------|----------|

| Light | 1,024 - 4,000 | Simple clarifications, basic analysis |

| Medium | 4,000 - 10,000 | Code review, debugging, design decisions |

| Heavy | 10,000 - 20,000 | Architecture planning, security audits |

| Complex | 20,000 - 32,000 | Multi-system analysis, comprehensive reviews |

| Maximum | 32,000+ | Use batch API for budgets exceeding 32k |

CRITICAL: When using tools with extended thinking, you MUST preserve thinking blocks in the conversation history.

```python

# Initial request with thinking

response = client.messages.create(

model="claude-sonnet-4-20250514",

max_tokens=16000,

thinking={"type": "enabled", "budget_tokens": 8000},

tools=[{

"name": "analyze_code",

"description": "Analyze code for issues",

"input_schema": {

"type": "object",

"properties": {"code": {"type": "string"}},

"required": ["code"]

}

}],

messages=[{"role": "user", "content": "Analyze this code..."}]

)

# MUST include ALL content blocks including thinking

tool_use_block = next(b for b in response.content if b.type == "tool_use")

tool_result = execute_tool(tool_use_block)

# Continue with thinking blocks preserved

follow_up = client.messages.create(

model="claude-sonnet-4-20250514",

max_tokens=16000,

thinking={"type": "enabled", "budget_tokens": 8000},

tools=[...],

messages=[

{"role": "user", "content": "Analyze this code..."},

{"role": "assistant", "content": response.content}, # Includes thinking!

{"role": "user", "content": [{

"type": "tool_result",

"tool_use_id": tool_use_block.id,

"content": tool_result

}]}

]

)

```

For Claude 4 models, use interleaved thinking for thinking between tool calls:

```python

response = client.messages.create(

model="claude-sonnet-4-20250514",

max_tokens=16000,

thinking={"type": "enabled", "budget_tokens": 10000},

betas=["interleaved-thinking-2025-05-14"], # Required for Claude 4

messages=[...]

)

```

• Minimum budget: 1,024 tokens
• Maximum output: 128k tokens (thinking + response)
• Temperature: Must be 1 (default) - cannot modify
• top_k: Cannot be used with extended thinking
• Streaming required: When max_tokens > 21,333
• System prompts: Fully compatible

1. Start conservative: Begin with lower budgets, increase as needed
2. Monitor actual usage: Track thinking_tokens in response usage
3. Use streaming: For better UX and larger outputs
4. Preserve thinking blocks: Critical for multi-turn tool use
5. Batch for heavy workloads: Use batch API for budgets > 32k tokens
6. Match budget to task: Don't over-allocate for simple tasks

When using Claude Code CLI with extended thinking models:

```bash

# The CLI automatically handles extended thinking for supported models

# Use opus or sonnet models for complex tasks

claude --model claude-opus-4-5-20250514 "Analyze this codebase architecture"

```

• [[complex-reasoning]] - Multi-step reasoning patterns
• [[deep-analysis]] - Analytical thinking templates
• [[llm-integration]] - General LLM API patterns