Adaptive Thinking in Claude: Smarter, Dynamic Reasoning for Complex Tasks

Claude’s extended thinking capability has been a game-changer for tasks requiring deep reasoning, multi-step analysis, and complex problem-solving. But until recently, you had to manually set a thinking token budget—a fixed number that might be too small for hard problems or wasteful for simple ones.

Adaptive thinking changes that. Now, Claude can dynamically decide when and how much to think, based on the complexity of each request. This guide explains 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 it.

What Is Adaptive Thinking?

Adaptive thinking is the recommended way to use extended thinking with Claude Opus 4.7, Claude Opus 4.6, Claude Sonnet 4.6, and Claude Mythos Preview. Instead of locking in a fixed budget_tokens value, you let Claude evaluate each request and decide:

• Whether extended thinking is needed
• How much thinking to allocate

This makes adaptive thinking particularly powerful for bimodal workloads—where some queries are trivial and others require deep reasoning—and for long-horizon agentic workflows where Claude needs to think between tool calls.

Key Benefits

• Better performance on complex tasks compared to fixed budgets
• Cost efficiency—no wasted tokens on simple requests
• Automatic interleaved thinking for tool-using agents
• Simpler code—no need to guess token budgets

Supported Models

⚠️ Important: On Opus 4.6 and Sonnet 4.6, thinking.type: "enabled" with budget_tokens is deprecated and will be removed in a future release. Migrate to thinking.type: "adaptive" with the effort parameter as soon as possible.

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

How Adaptive Thinking Works

In adaptive mode, thinking is optional for the model. At the default effort level (high), Claude almost always thinks. At lower effort levels, Claude may skip thinking for simpler problems.

Adaptive thinking also automatically enables interleaved thinking—Claude can think between tool calls, making it especially effective for agentic workflows where the model needs to reason about tool results before taking the next action.

The Effort Parameter

You can control how aggressively Claude uses thinking with the optional effort parameter:

• high (default): Claude almost always thinks, even on simpler tasks
• medium: Balanced approach—thinks on moderately complex tasks
• low: Minimal thinking; Claude skips thinking for straightforward requests

This gives you fine-grained control without needing to specify exact token counts.

How to Use Adaptive Thinking in the API

Using adaptive thinking is straightforward. Set thinking.type to "adaptive" in your API request. No beta header is required.

Python Example

import anthropic
client = anthropic.Anthropic()
response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=16000,
    thinking={
        "type": "adaptive",
        "effort": "high"  # optional, defaults to high
    },
    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',
        effort: 'high'
    },
    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});
    }
}

cURL Example

curl https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-opus-4-7",
    "max_tokens": 16000,
    "thinking": {
      "type": "adaptive",
      "effort": "high"
    },
    "messages": [
      {
        "role": "user",
        "content": "Explain why the sum of two even numbers is always even."
      }
    ]
  }'

Adaptive Thinking with Tool Use

One of the most powerful features of adaptive thinking is automatic interleaved thinking during tool use. When Claude calls a tool and receives results, it can think again before deciding the next action. This is ideal for agentic workflows.

Here’s an example of adaptive thinking combined with tool use:

import anthropic
client = anthropic.Anthropic()
response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=32000,
    thinking={"type": "adaptive"},
    tools=[
        {
            "name": "get_weather",
            "description": "Get the current weather for a location",
            "input_schema": {
                "type": "object",
                "properties": {
                    "location": {"type": "string"}
                },
                "required": ["location"]
            }
        }
    ],
    messages=[
        {
            "role": "user",
            "content": "What's the weather in Tokyo and should I bring an umbrella?"
        }
    ]
)
for block in response.content:
    if block.type == "thinking":
        print(f"Thinking: {block.thinking}")
    elif block.type == "tool_use":
        print(f"Tool call: {block.name}({block.input})")
    elif block.type == "text":
        print(f"Response: {block.text}")

Best Practices

1. Start with the Default Effort

For most use cases, the default effort: "high" works well. It ensures Claude thinks deeply when needed without wasting tokens on trivial requests.

2. Lower Effort for Simple, High-Volume Tasks

If your application handles many simple queries (e.g., basic Q&A, simple classification), try effort: "low" to reduce latency and token usage.

3. Use Adaptive Thinking for Agentic Workflows

If you’re building a tool-using agent, adaptive thinking is a must. The automatic interleaved thinking allows Claude to reason about tool results before taking the next action, leading to more coherent multi-step behavior.

4. Monitor Token Usage

Even though adaptive thinking optimizes token allocation, you should still monitor your usage. The thinking blocks in the response contain the actual thinking content and token counts.

5. Migrate from Fixed Budgets

If you’re using budget_tokens on Opus 4.6 or Sonnet 4.6, plan to migrate to adaptive thinking. The legacy approach still works but is deprecated and will be removed in a future model release.

Common Pitfalls to Avoid

• Don’t set thinking.type: "enabled" on Opus 4.7—it will return a 400 error. Use "adaptive" instead.
• Don’t try to disable thinking on Mythos Preview—it’s always enabled.
• Don’t assume adaptive thinking is available on older models—Sonnet 4.5 and earlier require the legacy budget_tokens approach.

Key Takeaways

• Adaptive thinking dynamically allocates reasoning effort based on request complexity, replacing manual budget_tokens on supported models.
• It’s the only supported thinking mode on Claude Opus 4.7 and the default on Claude Mythos Preview.
• Use the effort parameter (high, medium, low) to control how aggressively Claude thinks.
• Automatic interleaved thinking makes adaptive thinking ideal for tool-using agents and complex workflows.
• Migrate from fixed budgets now if you’re using Opus 4.6 or Sonnet 4.6—the legacy approach is deprecated.