Mastering Adaptive Thinking in Claude: Smarter Reasoning Without Manual Budgets

Introduction

Claude’s extended thinking capability has been a game-changer for complex reasoning tasks. But until now, you had to manually set a budget_tokens value—essentially guessing how much thinking your request would need. Too low, and Claude might cut off reasoning mid-stream. Too high, and you waste tokens and latency.

Adaptive thinking eliminates that guesswork. Claude now evaluates each request in real time and decides whether—and how much—to think. This guide walks you through everything you need to know: supported models, API usage, the effort parameter, migration from fixed budgets, and best practices for agentic workflows.

What Is Adaptive Thinking?

Adaptive thinking is a new mode for Claude’s extended thinking feature. Instead of you specifying a fixed token budget, Claude dynamically determines the appropriate thinking depth based on the complexity of each request.

Key characteristics:

• Optional thinking: At the default effort level, Claude almost always thinks. At lower effort levels, it may skip thinking for simple requests.
• Interleaved thinking: Claude can think between tool calls, making it ideal for multi-step agentic workflows.
• No beta header required: Unlike some earlier features, adaptive thinking works without any special headers.

Supported Models

Warning: On Opus 4.6 and Sonnet 4.6, thinking.type: "enabled" and budget_tokens are deprecated and will be removed in a future model release. Plan to migrate to adaptive thinking now.

How to Use Adaptive Thinking

Basic Usage

Set thinking.type to "adaptive" in your API request. Here’s a Python example:

import anthropic
client = anthropic.Anthropic()
response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=16000,
    thinking={"type": "adaptive"},
    messages=[
        {
            "role": "user",
            "content": "Explain why the sum of two even numbers is always even."
        }
    ]
)
for block in response.content:
    if block.type == "thinking":
        print(f"\nThinking: {block.thinking}")
    elif block.type == "text":
        print(f"\nResponse: {block.text}")

TypeScript Example

import Anthropic from '@anthropic-ai/sdk';
const client = new Anthropic();
const response = await client.messages.create({
  model: 'claude-opus-4-7',
  max_tokens: 16000,
  thinking: { type: 'adaptive' },
  messages: [
    {
      role: 'user',
      content: 'Explain why the sum of two even numbers is always even.'
    }
  ]
});
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});
  }
}

Controlling Thinking Depth with the Effort Parameter

Adaptive thinking includes an optional effort parameter that acts as soft guidance for how much thinking Claude should allocate. This is especially useful when you want to balance reasoning depth against latency and cost.

Effort Levels

Example with Effort Parameter

response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=16000,
    thinking={
        "type": "adaptive",
        "effort": "medium"  # Options: "low", "medium", "high"
    },
    messages=[
        {
            "role": "user",
            "content": "What is the capital of France?"
        }
    ]
)

Note: The effort parameter is a beta feature. You may need to include the "anthropic-beta": "thinking-config-2025-05-02" header in your requests to use it.

When to Use Adaptive Thinking vs. Fixed Budgets

Migrating from Fixed Budgets to Adaptive Thinking

If you’re currently using thinking: {type: "enabled", budget_tokens: N}, here’s your migration plan:

• Identify your models: Check which models you’re using. Opus 4.7 requires adaptive thinking. Opus 4.6 and Sonnet 4.6 still support fixed budgets but they are deprecated.
• Update your code: Change thinking.type from "enabled" to "adaptive" and remove budget_tokens.
• Test with effort levels: Start with effort: "high" (the default) to match your current behavior, then experiment with "medium" or "low" for cost savings.
• Monitor performance: Compare response quality and latency. Adaptive thinking often matches or exceeds fixed budgets for complex tasks while saving tokens on simple ones.

Before (Fixed Budget)

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

After (Adaptive Thinking)

thinking={
    "type": "adaptive"
}

Best Practices for Agentic Workflows

Adaptive thinking shines in agentic workflows where Claude needs to reason between tool calls. Here’s how to get the most out of it:

• Use interleaved thinking: Adaptive thinking automatically enables thinking between tool calls. This allows Claude to reflect on previous results before deciding the next action.
• Set appropriate max_tokens: Even though thinking is adaptive, you still need max_tokens to cap the total response (thinking + visible text). For complex agentic tasks, start with 8,000–16,000 tokens.
• Handle thinking blocks in streaming: If you stream responses, watch for thinking blocks in the content stream. They contain Claude’s internal reasoning and can be displayed or logged for debugging.
• Combine with structured outputs: Use adaptive thinking with structured outputs (JSON mode) for tasks that require both reasoning and formatted responses.

Limitations and Considerations

• Zero Data Retention (ZDR): Adaptive thinking is eligible for ZDR. If your organization has a ZDR arrangement, data sent through this feature is not stored after the API response is returned.
• Not available on older models: Sonnet 4.5, Opus 4.5, and earlier models do not support adaptive thinking. You must continue using fixed budgets for those models.
• Effort is soft guidance: The effort parameter is not a hard constraint. Claude may still think more or less than the effort level suggests based on the actual complexity of the request.

Conclusion

Adaptive thinking represents a major step forward in Claude’s reasoning capabilities. By letting Claude decide when and how much to think, you get better performance on complex tasks without overpaying for simple ones. Whether you’re building a simple Q&A bot or a sophisticated agentic system, adaptive thinking simplifies your code and improves your results.

Key Takeaways

• Adaptive thinking is the recommended mode for Claude Opus 4.7, Opus 4.6, Sonnet 4.6, and Mythos Preview. Fixed budgets are deprecated on Opus 4.6 and Sonnet 4.6.
• No more manual token budgets – Claude dynamically allocates thinking based on request complexity, saving you time and tokens.
• Use the effort parameter (low, medium, high) to softly guide thinking depth. Default is high.
• Ideal for agentic workflows – interleaved thinking lets Claude reason between tool calls automatically.
• Migrate now if you’re using fixed budgets on supported models. The change is simple: switch thinking.type to "adaptive" and remove budget_tokens.