Enabling Adaptive Thinking with thinking: {type: 'adaptive'}

Adaptive thinking lets Claude decide, per request, how much visible reasoning a task actually needs, instead of you guessing a fixed budget up front.

Summary

Extended thinking exposes Claude's reasoning as a separate thinking content block returned alongside the final answer.

Adaptive thinking is the recommended mode for turning this on, because it hands the depth decision to Claude itself.

You enable it with a single thinking parameter on the messages.create call.

Once enabled, your response parsing needs to handle two content block types instead of one, thinking and text.

This page covers the exact config, a complete working example, and the gotchas that come up most often when teams first wire this in.

Recipe

Quick-reference recipe card - copy-paste ready.

import anthropic
 
client = anthropic.Anthropic()
 
response = client.messages.create(
    model="claude-sonnet-5",
    max_tokens=1024,
    thinking={"type": "adaptive"},
    messages=[{"role": "user", "content": "Design a rollback plan for a failed deploy."}],
)
 
for block in response.content:
    print(block.type)

When to reach for this:

• Multi-step reasoning tasks: planning, debugging, math, logic puzzles.
• Tasks where you want Claude to self-calibrate effort instead of you hardcoding a depth.
• Any workload where you might later want to inspect or log Claude's reasoning path.
• Building toward tuning the effort parameter, which composes with thinking.
• Migrating from a fixed-budget thinking setup to a simpler adaptive one.

Working Example

import anthropic
 
client = anthropic.Anthropic()
 
 
def ask_with_adaptive_thinking(prompt: str) -> dict:
    response = client.messages.create(
        model="claude-sonnet-5",
        max_tokens=2048,
        thinking={"type": "adaptive"},
        messages=[{"role": "user", "content": prompt}],
    )
 
    thinking_text = None
    answer_text = None
 
    for block in response.content:
        if block.type == "thinking":
            thinking_text = block.thinking
        elif block.type == "text":
            answer_text = block.text
 
    return {
        "reasoning": thinking_text,
        "answer": answer_text,
        "stop_reason": response.stop_reason,
    }
 
 
if __name__ == "__main__":
    result = ask_with_adaptive_thinking(
        "A service has three replicas. One is failing health checks intermittently. "
        "Walk through how you would diagnose the root cause before restarting anything."
    )
 
    if result["reasoning"]:
        print("--- Reasoning ---")
        print(result["reasoning"])
 
    print("--- Answer ---")
    print(result["answer"])

What this demonstrates:

• A reusable helper function that separates the thinking block from the text block on every call.
• Checking block.type inside the loop rather than assuming a fixed content shape.
• Handling the case where reasoning may be None for a prompt that did not need visible reasoning.
• Reading response.stop_reason alongside the content, useful for detecting truncated responses.
• A prompt genuinely suited to adaptive thinking: multi-step diagnostic reasoning, not a trivial lookup.

Deep Dive

How It Works

• The thinking parameter accepts a config object; {"type": "adaptive"} is the value this site's examples use throughout.
• With adaptive thinking on, Claude evaluates the incoming request and decides internally how much reasoning to produce before answering.
• The API returns the reasoning as one or more thinking content blocks in response.content, ordered before the corresponding text block.
• response.content is always a list, even for a single-block reply, so code should iterate rather than index a fixed position.
• Claude Fable 5 runs with always-on adaptive thinking by default, reflecting that this mode is treated as the baseline behavior for that model rather than an opt-in extra.

Content Block Shapes

Python Notes

# Defensive extraction pattern used throughout this section's examples.
def split_content(response):
    thinking, text = None, None
    for block in response.content:
        if block.type == "thinking":
            thinking = block.thinking
        elif block.type == "text":
            text = block.text
    return thinking, text

Treat block.thinking as optional in every code path. A getattr-style guard or the if block.type == "thinking" check shown above avoids AttributeError when a simple prompt skips reasoning entirely.

Gotchas

• Assuming response.content[0] is always the text answer. With adaptive thinking on, index 0 may be the thinking block instead. Fix: iterate over response.content and switch on block.type rather than indexing by position.
• Treating a missing thinking block as an error. Simple prompts often produce no visible reasoning at all, that is adaptive thinking working correctly, not a bug. Fix: guard with is not None checks and only log it as unexpected if the prompt was genuinely complex.
• Forgetting max_tokens has to cover thinking plus the answer. A low max_tokens value can truncate the reasoning before the final answer is written. Fix: budget max_tokens generously for tasks you expect to trigger deep reasoning, and check response.stop_reason for "max_tokens".
• Confusing thinking with output_config.effort. Enabling adaptive thinking does not by itself set a reasoning depth ceiling. Fix: pair thinking={"type": "adaptive"} with an explicit output_config={"effort": ...} when you need to control cost, see the effort tuning page.
• Displaying raw reasoning to end users unfiltered. The thinking block can be verbose and is meant for debugging or optional disclosure, not as the primary UI response. Fix: show the text block by default, and gate any reasoning display behind an explicit "show reasoning" affordance.
• Re-sending the thinking block back as conversation history unmodified. Some multi-turn flows accidentally include prior thinking blocks as if they were normal assistant text, bloating token usage. Fix: strip or summarize prior thinking blocks before appending them to the next turn's messages list.

Alternatives

FAQs

response = client.messages.create(
    model="claude-sonnet-5",
    max_tokens=1024,
    thinking={"type": "adaptive"},
    messages=[{"role": "user", "content": "..."}],
)

for block in response.content:
    if block.type == "thinking":
        print(block.thinking)

Related

• Extended Thinking and the Effort Parameter Explained - the conceptual foundation for this config.
• Extended Thinking, Effort & Multimodal Basics - a broader set of minimal examples covering thinking, effort, and images together.
• Tuning the effort Parameter for Cost and Speed - pair adaptive thinking with an explicit cost ceiling.
• Effort Levels and Thinking Display Options Reference - reference table for display modes that pair with this config.
• Extended Thinking, Effort & Multimodal Best Practices - numbered practices for using this in production.

Stack versions: Written against the Claude model lineup current as of ~June 2026 - Claude Fable 5, Claude Opus 4.8, Claude Sonnet 5 (the default), and Claude Haiku 4.5 - and the official anthropic Python SDK (latest 0.x release). Model names, SDK versions, and pricing move quickly - verify current specifics at platform.claude.com/docs before relying on them.