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

Claude’s extended thinking capability has been a game-changer for complex reasoning tasks—but manually setting a budget_tokens value for every request can feel like guesswork. Do you allocate 8,000 tokens for a simple math proof? 32,000 for a multi-step agentic workflow? What if the task is somewhere in between?

Enter adaptive thinking. Introduced with Claude Opus 4.7, Opus 4.6, Sonnet 4.6, and Claude Mythos Preview, adaptive thinking lets Claude dynamically decide when and how much to think. No more manual budgets. No more under- or over-allocating. Just smarter, more efficient reasoning.

In this guide, you’ll learn exactly what adaptive thinking is, how it works under the hood, and how to use it in your API calls—with practical code examples and best practices for agentic workloads.

---

What Is Adaptive Thinking?

Adaptive thinking is a new mode for Claude’s extended thinking feature. Instead of you specifying a fixed token budget (budget_tokens), Claude evaluates the complexity of each request and decides:

• Whether to use extended thinking at all
• How much thinking to allocate

This makes it ideal for bimodal workloads—where some requests are trivial and others require deep reasoning—and for long-horizon agentic workflows, where thinking needs to happen between tool calls.

Note: On Claude Opus 4.7, adaptive thinking is the only supported thinking mode. The old thinking: {type: "enabled", budget_tokens: N} syntax will return a 400 error. On Opus 4.6 and Sonnet 4.6, the old syntax is deprecated and will be removed in a future release.

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

When you set thinking.type to "adaptive", Claude’s internal router evaluates the incoming request and decides whether extended thinking would be beneficial. At the default effort level (high), Claude almost always thinks. At lower effort levels, it may skip thinking for simpler problems.

Adaptive thinking also automatically enables interleaved thinking. This means Claude can think between tool calls—a critical capability for agentic workflows where the model needs to reason about tool outputs before deciding the next action.

The Effort Parameter

You can combine adaptive thinking with an optional effort parameter to guide how much thinking Claude does. The effort level acts as soft guidance—Claude will follow your hint but still retains the ability to dynamically adjust.

Available effort levels:

• low – Minimal thinking; good for simple, factual queries
• medium – Balanced reasoning
• high – Maximum reasoning (default)

---

How to Use Adaptive Thinking in the API

Using adaptive thinking is straightforward. Simply set thinking.type to "adaptive" in your API request. Optionally, add the effort parameter.

Basic Example (Python)

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}")

Example with Effort Parameter (TypeScript)

import Anthropic from '@anthropic-ai/sdk';
const client = new Anthropic();
const response = await client.messages.create({
  model: 'claude-opus-4-6',
  max_tokens: 16000,
  thinking: {
    type: 'adaptive',
    effort: 'medium'
  },
  messages: [
    {
      role: 'user',
      content: 'Design a scalable architecture for a real-time chat application.'
    }
  ]
});
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});
  }
}

Handling the Response

When adaptive thinking is enabled, the response may contain thinking content blocks. Your code should handle these blocks to access Claude’s reasoning trace. The thinking blocks appear before the final text response and may also appear between tool calls in agentic workflows.

---

Adaptive Thinking for Agentic Workflows

One of the biggest advantages of adaptive thinking is its support for interleaved thinking in tool-use scenarios. In traditional extended thinking, Claude would think once at the beginning and then execute tool calls. With adaptive thinking, Claude can:

• Think about the user’s request
• Make a tool call
• Receive the tool result
• Think again about the result
• Decide the next action

This makes adaptive thinking particularly powerful for:

• Multi-step research tasks
• Code generation and debugging loops
• Complex data analysis pipelines
• Autonomous agentic systems

Example: Agentic Workflow 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": "search_web",
            "description": "Search the web for information",
            "input_schema": {
                "type": "object",
                "properties": {
                    "query": {"type": "string"}
                },
                "required": ["query"]
            }
        }
    ],
    messages=[
        {
            "role": "user",
            "content": "Find the latest AI research papers on reinforcement learning and summarize the top 3."
        }
    ]
)
for block in response.content:
    if block.type == "thinking":
        print(f"[Thinking] {block.thinking}")
    elif block.type == "text":
        print(f"[Response] {block.text}")
    elif block.type == "tool_use":
        print(f"[Tool Call] {block.name}({block.input})")

---

Migrating from Fixed Budgets to Adaptive Thinking

If you’re currently using thinking: {type: "enabled", budget_tokens: N} on Opus 4.6 or Sonnet 4.6, here’s your migration checklist:

• Update your code to use thinking: {type: "adaptive"}
• Optionally add the effort parameter (start with "high" to match your current behavior)
• Remove the budget_tokens field entirely
• Test your workflows to ensure response quality is maintained or improved
• Monitor token usage—adaptive thinking may reduce costs for simple queries

Warning: The old budget_tokens syntax is deprecated on Opus 4.6 and Sonnet 4.6 and will be removed in a future model release. Plan your migration now.

---

Best Practices

• Start with effort: "high" if you’re migrating from a large fixed budget. You can dial it down later.
• Use effort: "low" for high-throughput, simple queries (e.g., classification, extraction) to save tokens.
• Combine with tool use for agentic workflows—interleaved thinking is automatically enabled.
• Handle thinking blocks in your response parsing to capture Claude’s reasoning trace.
• Test on a representative sample of your workload before rolling out to production.

---

Key Takeaways

• Adaptive thinking eliminates manual token budgets—Claude dynamically decides how much to think based on request complexity.
• It’s the only supported mode on Claude Opus 4.7 and the default on Claude Mythos Preview. Legacy budget_tokens is deprecated on Opus 4.6 and Sonnet 4.6.
• Interleaved thinking is automatically enabled, making adaptive thinking ideal for agentic workflows with tool calls.
• Use the effort parameter (low, medium, high) to guide reasoning depth without sacrificing dynamic allocation.
• Migrate now if you’re still using fixed budgets—the old syntax will be removed in future model releases.