Adaptive Thinking in Claude: Smarter, Dynamic Reasoning Without Manual Budgets

Claude’s extended thinking capability has long been a powerful tool for complex reasoning, but it required you to manually set a budget_tokens value—a fixed number of tokens allocated for thinking. This worked well for predictable workloads, but it often led to overthinking simple requests or underthinking complex ones. Enter adaptive thinking: a smarter, dynamic approach that lets Claude decide when and how much to think.

In this guide, you’ll learn what adaptive thinking is, which models support it, how to use it in your API calls, and best practices for getting the most out of this feature.

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 manually setting a thinking token budget, you simply enable adaptive mode, and Claude evaluates the complexity of each request to determine whether—and how much—to use extended thinking.

Key benefits:

• Dynamic allocation: Claude thinks more for complex tasks, less for simple ones.
• Interleaved thinking: Claude can think between tool calls, making it ideal for agentic workflows.
• Better performance: Especially effective for bimodal tasks (mixing simple and complex requests) and long-horizon agentic workflows.
• No beta header required: Adaptive thinking is fully supported without special headers.

Important: On Claude Opus 4.7, adaptive thinking is the only supported thinking mode. Manual thinking: {type: "enabled", budget_tokens: N} is no longer accepted and will return a 400 error.

Supported Models

Older models (Sonnet 4.5, Opus 4.5, etc.) do not support adaptive thinking and still require thinking.type: "enabled" with budget_tokens.

How Adaptive Thinking Works

In adaptive mode, thinking is optional for the model. Claude evaluates the complexity of each request and decides:

• Whether to use extended thinking at all
• How many tokens to allocate for thinking

At the default effort level (high), Claude almost always thinks. At lower effort levels, Claude may skip thinking for simpler problems, saving latency and cost.

Adaptive thinking also automatically enables interleaved thinking, meaning Claude can think between tool calls. This is a game-changer for agentic workflows where the model needs to reason about tool outputs before deciding the next action.

How to Use Adaptive Thinking

Basic Usage

Set thinking.type to "adaptive" in your API request:

Python (Anthropic SDK)

import anthropic
client = anthropic.Anthropic()
response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=4096,
    thinking={"type": "adaptive"},
    messages=[
        {"role": "user", "content": "Analyze the pros and cons of quantum computing for cryptography."}
    ]
)
print(response.content)

TypeScript (Anthropic SDK)

import Anthropic from '@anthropic-ai/sdk';
const client = new Anthropic();
const response = await client.messages.create({
  model: 'claude-opus-4-7',
  max_tokens: 4096,
  thinking: { type: 'adaptive' },
  messages: [
    { role: 'user', content: 'Analyze the pros and cons of quantum computing for cryptography.' }
  ]
});
console.log(response.content);

Using the Effort Parameter

You can combine adaptive thinking with the effort parameter to guide how much thinking Claude does. The effort level acts as soft guidance—Claude may still adjust based on task complexity.

Example with effort:

response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=4096,
    thinking={"type": "adaptive", "effort": "high"},
    messages=[
        {"role": "user", "content": "Explain the difference between TCP and UDP protocols."}
    ]
)

Best Practices

1. Use Adaptive Thinking for Bimodal Workloads

If your application handles both simple queries (e.g., "What's the weather?") and complex reasoning tasks (e.g., "Analyze this financial model"), adaptive thinking is ideal. It saves tokens on simple requests while allocating more thinking to complex ones.

2. Leverage Interleaved Thinking for Agentic Workflows

Adaptive thinking automatically enables interleaved thinking, which is perfect for multi-step tool use. For example, in a research agent that searches the web, reads documents, and synthesizes findings, Claude can think between each tool call to decide the next best action.

3. Start with high Effort, Then Tune

The default high effort works well for most use cases. If you find Claude is overthinking simple requests, try medium or low. If you need maximum reasoning depth (e.g., for complex math or code generation), use max.

4. Migrate from Manual Budgets

If you're currently using thinking.type: "enabled" with budget_tokens on Opus 4.6 or Sonnet 4.6, plan to migrate to adaptive thinking. The manual approach is deprecated and will be removed in a future model release.

Migration example:

Before (deprecated):

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

After (recommended):

thinking={"type": "adaptive"}

5. Monitor Token Usage

Adaptive thinking can reduce token consumption for simple tasks, but it may increase usage for complex ones. Monitor your API usage and adjust the effort parameter if costs are higher than expected.

Limitations and Considerations

• Not supported on older models: Sonnet 4.5, Opus 4.5, and earlier models require manual budget_tokens.
• No disabled on Mythos Preview: You cannot disable thinking on Claude Mythos Preview; it's always active.
• Soft guidance: The effort parameter is guidance, not a hard limit. Claude may still think more or less than expected.
• Zero Data Retention: Adaptive thinking is eligible for ZDR, meaning data is not stored after the API response is returned.

Conclusion

Adaptive thinking represents a significant evolution in how Claude handles extended reasoning. By removing the need for manual token budgets and enabling dynamic, interleaved thinking, it simplifies development while improving performance—especially for agentic and bimodal workloads.

If you're using Claude Opus 4.7, adaptive thinking is your only option (and it's excellent). If you're on Opus 4.6 or Sonnet 4.6, now is the time to migrate from manual budgets. And if you're on older models, consider upgrading to take advantage of this smarter approach.

Key Takeaways

• Adaptive thinking lets Claude dynamically decide when and how much to think, replacing manual budget_tokens for a more efficient and effective reasoning process.
• It's the only supported mode on Claude Opus 4.7 and the default on Claude Mythos Preview; manual thinking is deprecated on Opus 4.6 and Sonnet 4.6.
• Use the effort parameter (max, xhigh, high, medium, low) to guide thinking depth without hard-coding token budgets.
• Interleaved thinking is automatically enabled, making adaptive thinking ideal for agentic workflows with multiple tool calls.
• Migrate existing code from thinking.type: "enabled" to thinking.type: "adaptive" to future-proof your applications.