Adaptive Thinking for Product Managers: How Claude's Dynamic Reasoning System Works
TL;DR
Claude Fable 5 and Sonnet 5 replaced the manual budget_tokens approach with adaptive thinking: the model itself decides when to reason and how deeply, based on the complexity of each request. You control this with the effort parameter (low, medium, high, xhigh, max). Thinking tokens are billed regardless of whether you see them. For products built on Claude, this changes cost modeling, latency expectations, and how you handle agentic multi-tool workflows. Here is what you need to know.
The AI PM Minute
One tactic to make you a sharper AI PM, twice a week. 60 seconds to read. Free.
No fluff. Unsubscribe anytime.
What Adaptive Thinking Is and Why It Replaced Budget Tokens
The old extended thinking model required you to set a budget_tokens value: a fixed ceiling telling Claude how much to think. You guessed at the right number per use case. A simple question consumed the same allocated thinking budget as a hard one, or you maintained separate budget configurations per task type. That was a product engineering burden.
Adaptive thinking removes that burden. On Claude Fable 5, Mythos 5, Sonnet 5, and Opus 4.8, the model evaluates each incoming request and allocates thinking proportionally to its complexity. A simple lookup gets a short thinking pass or none at all. A multi-step reasoning task gets deep thinking. You stop micromanaging tokens and start managing effort levels.
This is a paradigm shift, not just an API change. The older thinking: {type: "enabled", budget_tokens: N} parameter is now deprecated on Opus 4.8, Sonnet 5, Fable 5, and Mythos 5. On Fable 5 and Mythos 5, thinking: {type: "disabled"} is not even accepted. Thinking is always on, and the model owns when to use it.
The core change
Instead of 'think for exactly N tokens,' the instruction is now 'apply this much effort across the whole request.' Claude decides how much of that effort goes to thinking vs. direct generation.
Interleaved thinking
Adaptive thinking also enables thinking between tool calls automatically. Claude can reason after seeing a tool result before deciding the next action. This is a major upgrade for agentic workflows.
Deprecation timeline
budget_tokens is deprecated on Opus 4.6 and Sonnet 4.6 and will be removed in a future release. On newer models it is already rejected with a 400 error. Plan your migration now if you are on the old API.
Mythos 5 difference
Claude Mythos 5 shares adaptive thinking with Fable 5 but is only available through Project Glasswing (limited enterprise access). Both models always have thinking on.
The Effort Parameter: Your Primary Control Lever
Since you no longer set a token budget, the effort parameter inside output_config is your main dial. Five levels. The default is high, which means Claude almost always thinks. Lower it for speed and cost; raise it for hard tasks where quality matters most.
| Effort Level | Thinking Behavior | When to Use It |
|---|---|---|
| low | Minimizes thinking. Skips it for simple tasks. | Classification, extraction, simple rewrites. Latency matters more than reasoning depth. |
| medium | Moderate thinking. May skip for simple queries. | Mixed workloads where most requests are routine but some need analysis. |
| high (default) | Claude almost always thinks. Deep reasoning on complex tasks. | General production use. Good balance of quality and cost. |
| xhigh | Always thinks deeply with extended exploration. | Complex research, multi-step planning, code architecture decisions. |
| max | Always thinks with no constraints on depth. | The hardest possible tasks: legal analysis, complex debugging, long-horizon agentic work. |
The effort level is soft guidance, not a hard ceiling. Claude uses it to calibrate thinking allocation, but the actual token count varies per request. If you need predictable cost per call, max_tokens is your hard cap. Set it high enough to cover both thinking and the final response.
Product design implication
Route requests by detected complexity rather than applying one effort level globally. A simple autocomplete feature can run at low. A research synthesis task gets xhigh. The API call is identical except for the effort value, so the routing logic stays simple. This is a more principled version of what teams used to do with separate budget_tokens configurations.
Cost and Latency: What You Are Actually Paying For
Here is the billing rule that trips up most teams: thinking tokens are billed at output token rates even when you do not see them. If you set thinking.display: "omitted" (the default on Fable 5 and Sonnet 5), the thinking blocks in the response have an empty thinking field. You see nothing. But the model still generated those reasoning tokens, and you pay for them.
Display: summarized
Thinking blocks contain a readable summary of the reasoning. Useful for debugging, audit trails, and UIs that surface the model's reasoning to users. You are charged for the full thinking, not just the summary.
Display: omitted (default on Fable 5, Sonnet 5)
Thinking blocks return with an empty thinking field. Lower latency because the server skips streaming thinking tokens. Still billed for full thinking. Use for production where users do not see the reasoning.
output_tokens_details.thinking_tokens
The API response includes this field showing how many tokens were spent on internal reasoning. Subtract it from output_tokens to see the text generation portion. Essential for cost analysis.
max_tokens as a hard ceiling
max_tokens caps total output including thinking plus response text. On high effort requests, Claude may exhaust this budget before finishing. If you see stop_reason: max_tokens, raise the limit or lower the effort level.
On Claude Fable 5, the raw chain of thought is never returned in any mode. You get either a summary or nothing. This is intentional: Anthropic treats the full reasoning chain as proprietary. If your product depends on showing users the literal reasoning steps, account for this limitation in your UX design.
Build AI Products With Deep Technical Fluency
The AI PM Masterclass covers adaptive thinking, API design decisions, and how to translate model capabilities into product architecture. Taught live by a Salesforce Sr. Director PM.
Adaptive Thinking in Agentic Product Architecture
Interleaved thinking is the biggest architectural win in the adaptive thinking model. On earlier Claude models, thinking happened once before the first response. With adaptive mode, Claude can think again after receiving each tool result before deciding its next action. This matters significantly for agentic workflows.
Research agent with multiple tools
Before adaptive: One reasoning pass upfront, then tool calls executed without further deliberation. Errors compound if early decisions are wrong.
With adaptive: Claude reasons after each search result, re-evaluating its search strategy before the next query. Better results with fewer tool calls.
Code generation with test execution
Before adaptive: Claude writes code, executes tests, sees failures. Little structured reasoning about why the test failed before attempting a fix.
With adaptive: After test failure output, Claude takes a thinking pass to diagnose the root cause before writing the correction. Higher first-fix rate.
Multi-document analysis
Before adaptive: Fixed thinking budget allocated before reading documents. May run out of budget mid-analysis on long documents.
With adaptive: Thinking allocation adjusts dynamically as document complexity becomes apparent. No arbitrary caps on analysis depth.
One practical note: interleaved thinking blocks must be passed back unchanged in multi-turn API calls. The signature field in each thinking block is an encrypted payload the model uses to reconstruct its reasoning history. If you strip thinking blocks when passing history back, Claude loses the context it built during prior reasoning passes.
Migration Checklist and Common Pitfalls
If your product is currently using manual extended thinking with budget_tokens, here is what to audit before migrating to adaptive mode on newer models.
Replace budget_tokens with effort
Map your existing budget sizes to effort levels. Budget under 10K tokens roughly maps to medium effort. 32K maps to high. 100K maps to xhigh. For the hardest tasks, use max.
Audit max_tokens settings
Your max_tokens must cover both thinking and response. If you had max_tokens: 4096 for a short response, that may now hit the ceiling during thinking. A safe default for high-effort tasks is 16K or higher.
Update thinking display configuration
New models default to display: omitted. If you were logging thinking chains for debugging, you now need to explicitly set display: summarized to get any visible thinking content.
Handle temperature and sampling restrictions
Fable 5, Mythos 5, Sonnet 5, Opus 4.8, and Opus 4.7 reject non-default temperature, top_p, and top_k values with a 400 error. Remove these parameters from calls targeting new models.
Strip thinking blocks on model switches
If your product falls back to a different model (e.g., after a Fable 5 refusal), strip thinking and redacted_thinking blocks from prior turns. They are tied to the model that produced them.
Prompting note
Adaptive thinking behavior is promptable. Add "Think carefully before responding" to system prompts on tasks where you want consistent reasoning. Add "Answer directly without deliberating" to prompts where latency matters more than depth. These steer thinking frequency independently of the effort level.
Master the Technical Decisions That Drive AI Product Quality
The AI PM Masterclass gives you the fluency to make reasoning model, effort tuning, and cost optimization decisions with confidence.
Related Articles
Before you go: get the AI PM Minute
One tactic to make you a sharper AI PM, twice a week. 60 seconds to read. Free.
No fluff. Unsubscribe anytime.