Introduction

Claude's extended thinking capability has been a game-changer for complex reasoning tasks. But until recently, you had to manually set a fixed thinking budget (budget_tokens) for every request—a one-size-fits-all approach that either wasted tokens on simple queries or fell short on truly difficult problems.

Adaptive thinking changes that. Now, Claude dynamically decides whether and how much to think, based on the complexity of each individual request. This results in better performance, lower costs, and a smoother developer experience—especially for bimodal tasks and long-horizon agentic workflows.

In this guide, you'll learn:

• What adaptive thinking is and how it differs from manual extended thinking
• Which models support adaptive thinking
• How to configure it in your API calls (with code examples)
• How to use the effort parameter to fine-tune thinking depth
• Best practices for migrating from budget_tokens

Let's dive in.

What Is Adaptive Thinking?

Adaptive thinking is the recommended way to use extended thinking with Claude Opus 4.7, Claude Opus 4.6, and Claude Sonnet 4.6. Instead of you guessing how many tokens Claude should spend on reasoning, Claude evaluates each request and decides:

• Whether thinking is needed at all
• How much thinking is appropriate

This is especially powerful for agentic workflows where Claude makes multiple tool calls. Adaptive thinking automatically enables interleaved thinking—Claude can think between tool calls, refining its strategy as it gathers more information.

Note: Adaptive thinking is eligible for Zero Data Retention (ZDR). When your organization has a ZDR arrangement, data sent through this feature is not stored after the API response is returned.

Supported Models

How to Use Adaptive Thinking

Basic Setup

To enable adaptive thinking, set thinking.type to "adaptive" in your API request. Here's a complete 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});
  }
}

The Effort Parameter: Fine-Tuning Thinking Depth

Adaptive thinking comes with an optional effort parameter that acts as soft guidance for how much thinking Claude should do. This is a beta feature, but it's incredibly useful for balancing performance and cost.

Effort Levels

Example with Effort

response = client.messages.create(
    model="claude-opus-4-6",
    max_tokens=16000,
    thinking={
        "type": "adaptive",
        "effort": "medium"  # or "low", "high"
    },
    messages=[
        {
            "role": "user",
            "content": "Design a distributed caching system for a social media platform."
        }
    ]
)

Important: The effort parameter is a beta feature. You may need to include the anthropic-beta: thinking-effort-2025-04-15 header in your request.

Adaptive Thinking in Agentic Workflows

One of the biggest advantages of adaptive thinking is interleaved thinking—Claude can think between tool calls. This is a game-changer for agentic workflows where the model needs to:

• Receive a complex task
• Think about the approach
• Call a tool to gather data
• Think about the results
• Call another tool
• Synthesize the final answer

With manual budget_tokens, Claude would exhaust its thinking budget upfront and have nothing left for later steps. Adaptive thinking allocates tokens dynamically across the entire conversation.

Example: Multi-Step Research Agent

response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=32000,
    thinking={"type": "adaptive"},
    tools=[
        {
            "name": "web_search",
            "description": "Search the web for information",
            "input_schema": {
                "type": "object",
                "properties": {
                    "query": {"type": "string"}
                },
                "required": ["query"]
            }
        }
    ],
    messages=[
        {
            "role": "user",
            "content": "Research the latest AI regulations in the EU and compare them with US approaches."
        }
    ]
)

Migrating from Manual budget_tokens

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

For Claude Opus 4.7

Manual thinking is not supported. You must switch to adaptive thinking:

# ❌ Old way (will fail with 400 error)
thinking = {"type": "enabled", "budget_tokens": 8000}
✅ New way
thinking = {"type": "adaptive"}

For Claude Opus 4.6 and Sonnet 4.6

Manual thinking is deprecated but still functional. Plan to migrate:

# ❌ Deprecated
thinking = {"type": "enabled", "budget_tokens": 8000}
✅ Recommended
thinking = {"type": "adaptive"}
✅ With effort control
thinking = {"type": "adaptive", "effort": "high"}

For Older Models (Sonnet 4.5, Opus 4.5, etc.)

No change needed—these models don't support adaptive thinking. Continue using budget_tokens.

Best Practices

• Start with effort: "high" for complex tasks, then dial down if you're over-spending on thinking tokens.
• Use effort: "low" for high-throughput applications where most queries are simple (e.g., customer support FAQs).
• Combine with tool use for maximum benefit—adaptive thinking shines in agentic loops.
• Monitor your token usage—adaptive thinking can sometimes use more tokens than a fixed budget on very complex tasks, but it avoids waste on simple ones.
• Test with your specific workload—the optimal effort level depends on your use case.

Key Takeaways

• Adaptive thinking dynamically allocates thinking tokens based on request complexity, replacing the need for manual budget_tokens.
• It's the only supported mode on Claude Opus 4.7 and the default on Claude Mythos Preview. Manual budget_tokens is deprecated on Opus 4.6 and Sonnet 4.6.
• The effort parameter (low, medium, high) gives you soft control over thinking depth without hard token limits.
• Interleaved thinking enables Claude to reason between tool calls, making it ideal for agentic workflows.
• Migrate now if you're using budget_tokens on supported models—the old API will be removed in a future release.