Study guide
1.3 Thinking: Adaptive Mode, Effort & Reasoning Budgets
Claude Certified Developer - Foundations CCDV-F
Track your progress as you read
Finished sections get a check mark.
1 Chapter 1: Core Messages API & Streaming
1.1 Messages API Fundamentals & Request Lifecycle 1.2 Streaming & Server-Sent Events (SSE) 1.3 Thinking: Adaptive Mode, Effort & Reasoning Budgets
2 Chapter 2: Optimization & Asynchronous Batches
2.1 Prompt Caching Mechanics & Breakpoints 2.2 Message Batches API & Asynchronous Workloads
3 Chapter 3: Structured Outputs, Documents & Files API
3.1 Structured Outputs & JSON Extraction 3.2 Files API, Document Blocks & Citations
4 Chapter 4: Application Design, Resilience & Delivery Life Cycle
4.1 API Resilience, Error Handling & Retries 4.2 Production Backend Architecture & State Management 4.3 Requirements Analysis & Claude Application Design 4.4 The Claude Application Life Cycle & Configuration Management
5 Chapter 5: LLM Fundamentals, Model Selection & Versioning
5.1 LLM & Technical Fundamentals: Tokens, Context Windows & Sampling 5.2 Claude Model Family Selection 5.3 Model Versioning, Snapshot Pinning & Migration 5.4 Latency & Throughput Optimization
6 Chapter 6: Cost Engineering & Context Management
6.1 Production Cost Optimization Strategies 6.2 Context Window Management & Compaction
7 Chapter 7: Foundations of Workflows & Deterministic Patterns
7.1 Agent vs. Workflow Architectural Foundations 7.2 Workflow Patterns: Prompt Chaining & Routing 7.3 Workflow Patterns: Parallelization & Voting
8 Chapter 8: Autonomous Agents & Multi-Step Systems
8.1 Workflow Patterns: Orchestrator-Workers & Evaluator-Optimizer 8.2 Agent Loop Implementation & State Tracking 8.3 Agent Frameworks & Human-in-the-Loop (HITL)
9 Chapter 9: Prompt and Context Engineering
9.1 System Prompt Design & Role Framing 9.2 XML Tags & Structural Prompt Delimiters 9.3 Few-Shot Prompting & In-Context Learning 9.4 RAG Context Injection & Document Formatting
10 Chapter 10: Tool Calling & Model Context Protocol (MCP)
10.1 Tool Schema Design & Parameter Validation 10.2 Tool Execution, Multi-Tool Calls & Error Handling 10.3 MCP Architecture & Core Primitives 10.4 MCP Transports & Client/Server Integration 10.5 Agentic Customization: Built-in Tools, Custom Tools, Skills & MCP
11 Chapter 11: Security, Safety & Governance
11.1 Direct & Indirect Prompt Injection Defenses 11.2 Tool Permissions, Sandboxing & Least Privilege 11.3 Data Privacy, Redaction & Audit Logging 11.4 Identity, Secrets & API Key Management
12 Chapter 12: Claude Code Developer Tooling
12.1 Claude Code Architecture & Project Configuration 12.2 Permissions, Modes & Hooks
13 Chapter 13: Evaluation, Testing & Production Observability
13.1 Evaluation Design & Golden Datasets 13.2 Production Observability, Tracing & Debugging
1.3 Thinking: Adaptive Mode, Effort & Reasoning Budgets
Key Takeaways Explain This Topic AI
On the current lineup (Claude Fable 5.1, Claude Opus 5.5, Claude Sonnet 5.5, and Claude Haiku 5.5) thinking is adaptive and already on; display defaults to omitted, so thinking text is hidden until you set thinking type adaptive with display summarized.
Manual extended thinking with thinking.budget_tokens is deprecated on Claude Opus 4.6 and Claude Sonnet 4.6 and is not accepted on later models, so pinning a token budget on a current model is not a valid configuration.
output_config.effort takes low, medium, high, xhigh, and max; the default is medium on Claude Opus 5.5 and Claude Haiku 5.5 and high on other models, setting the model's default is exactly equivalent to omitting the parameter, and adaptive is a thinking mode rather than an effort value.
Thinking tokens are billed as output tokens even when the text is not returned, and they count against max_tokens alongside the response text.
Thinking blocks must be passed back unchanged with their signature in multi-turn and tool-use conversations, and any thinking or top-level effort change starts a new prompt-cache prefix.
Last updated: October 2026
Thinking: Adaptive Mode, Effort & Reasoning Budgets
Exam Blueprint Focus: Thinking sits inside Claude API Mechanics (6.8%) and drives Cost and Token Management . The configuration surface changed across generations, and CCDV-F grades the current one: adaptive thinking steered by effort on the current lineup, with manual budget_tokens surviving only on older extended-thinking-only models. Confusing the two is the single most common way to get a thinking question wrong.
Architectural Purpose: Separating Reasoning from the Answer
A model that answers in one pass has to be right on its first token. It cannot backtrack, cannot check an intermediate result, and cannot abandon a bad approach halfway. For a proof, a subtle bug, or a long agentic task, the first approach is often not the best one.
Thinking removes that constraint. When thinking is active, Claude works the problem in its own words first — restating the ask, trying approaches, checking intermediate results, discarding paths that do not hold up — and that reasoning arrives in thinking content blocks ahead of the response. Three engineering benefits follow:
Backtracking becomes possible. A discarded approach lives in the thinking block, not in the answer the user reads.
The output payload stays clean. Your parser reads text blocks; scratch work never pollutes them.
Deliberation beats greedy decoding. The model is not forced toward the locally-plausible next token when a globally better structure exists.
The cost is real and billed: thinking tokens are billed as output tokens even when the text is not returned to you, and they count against max_tokens alongside the response text.
- Configuring Thinking on the Current Lineup
- Adaptive thinking (the current lineup)
On Claude Fable 5.1, Claude Opus 5.5, Claude Sonnet 5.5, and Claude Haiku 5.5 (and on the earlier Claude Opus 5 and Claude Sonnet 5), thinking is already on and needs no configuration . Claude decides whether to think on a given request, and how deeply, based on the request and the resolved effort level.
What you do configure is whether you get to see it. The display field defaults to "omitted" on these models, which returns thinking blocks with an empty thinking field. Opt in explicitly: {
- "model": "claude-opus-5-5",
- "max_tokens": 16000,
- "thinking": { "type": "adaptive", "display": "summarized" },
- "output_config": { "effort": "high" },
- "messages": [
- { "role": "user", "content": "Find the race condition in this lock-free ring buffer." }
- ]
- }
On Claude Opus 4.8, 4.7, 4.6 and Claude Sonnet 4.6, thinking is off until you set thinking: {"type": "adaptive"} .
The effort parameter is the depth dial
thinking controls whether Claude reasons in thinking blocks. output_config.effort controls how much work Claude puts into the whole response , which in adaptive mode includes how often and how deeply it thinks.
- Level Behaviour Typical use
- max No constraint on token spending Frontier problems where depth justifies cost
- xhigh Extended capability for long-horizon work Multi-hour agentic and coding tasks
high Default on most models (identical to omitting the parameter there) Complex reasoning, difficult coding, agentic work
medium Balanced, moderate token savings. Default on Claude Opus 5.5 and Claude Haiku 5.5 Agentic work balancing speed, cost, quality
low Most efficient, some capability reduction Simple tasks, subagents, latency-sensitive paths
Three rules the exam can test directly:
Setting the model's default is exactly equivalent to omitting effort . The default is medium on Claude Opus 5.5 and Claude Haiku 5.5 and high on the other models, so a request that omits effort on Claude Opus 5.5 runs one level lower than it did on Claude Opus 5.
adaptive is a thinking mode, not an effort level. Passing "effort": "adaptive" is a mistake.
Effort applies to all output tokens — text, tool calls, and thinking — so lower effort also produces fewer and terser tool calls, not just less reasoning.
The current fast tier, Claude Haiku 5.5, supports all five effort levels (default medium ). The legacy Claude Haiku 4.5 does not support effort at all; it uses manual extended thinking.
Manual extended thinking (legacy models only)
On models that support only extended thinking, you configure thinking: {"type": "enabled", "budget_tokens": N} and the old arithmetic applies: budget_tokens has a 1,024-token minimum and max_tokens must be strictly greater than budget_tokens , because thinking and the visible answer share the max_tokens ceiling. Violating it returns a 400 invalid_request_error .
Critical currency rule: manual extended thinking is deprecated on Claude Opus 4.6 and Claude Sonnet 4.6, and is not accepted on later models. Sending thinking: {"type": "enabled", "budget_tokens": 4096} to Claude Opus 5.5, Claude Sonnet 5.5, Claude Haiku 5.5, or Claude Fable 5.1 returns a 400 error. If an exam option pins a reasoning budget in tokens on a current model, that option is wrong.
Turning thinking off
The rules differ by model:
Claude Opus 5.5 and Claude Fable 5.1: thinking cannot be turned off; thinking: {"type": "disabled"} returns a 400 error. Lower effort instead.
Claude Sonnet 5.5: "disabled" returns a 400 error; its lowest setting is thinking: {"type": "between_tools"} , which turns off up-front thinking and is accepted at effort high or below.
Claude Haiku 5.5 and Claude Opus 5: "disabled" is accepted at effort high or below; combined with xhigh or max it returns a 400 error.
With thinking disabled, Opus 5 can occasionally emit tool calls as plain text or leak internal XML tags into visible output, so disabling it is a deliberate trade, not a free latency win.
- Reading Thinking Output
- A response returns one or more thinking blocks before the text blocks: {
- "content": [
- {
- "type": "thinking",
- "thinking": "Two writers can observe the same tail index before either CAS lands...",
- "signature": "WaUjzkypQ2mUEVM36O2Txu...=="
- },
- { "type": "text", "text": "The race is in the producer's tail advance..." }
- ]
- }
Two properties matter in production:
You never see the raw chain of thought. The text in a thinking block is a summary of Claude's reasoning. Do not build logic that depends on token-level reasoning fidelity.
Every thinking block carries a signature — an encrypted copy of the full reasoning. Whether display is "summarized" or "omitted" , the block is billed the same and passed back the same.
The multi-turn preservation rule
Mandatory: in multi-turn and tool-use conversations, pass previous thinking blocks back unchanged, signature intact .
Stripping the signature, editing the thinking text, or dropping the block breaks the conversation's integrity guarantee. In an agent loop this is not cosmetic: the model relies on its own preserved reasoning to continue a plan across tool results.
Interleaved thinking — reasoning between tool calls — is automatic on every model that supports adaptive thinking, with no beta header required . The legacy Claude Haiku 4.5 does not support it. Under interleaved thinking the reasoning allocation can span the whole assistant turn rather than a single response.
Redacted thinking
Occasionally a thinking block returns as redacted_thinking with encrypted content instead of readable text, when internal safety systems flag the reasoning. Your client must pass redacted blocks back unchanged like any other thinking block and must not crash on the unfamiliar type. A client that only handles thinking and text will throw on the first redacted_thinking block it sees.
Thinking, Caching, and the Context Window
Configuration changes invalidate the prompt cache. The thinking configuration and the resolved effort level are rendered into the prompt itself, so switching between adaptive , enabled , and disabled , or changing the effort value, starts a new cache prefix. Message-level breakpoints always miss; tool and system breakpoints can miss too. Practical rule: pick an effort level at the start of a cached conversation and hold it constant. On Claude Fable 5.1, Claude Opus 5.5, Claude Opus 5, Claude Sonnet 5.5, and Claude Haiku 5.5 you can change effort mid-conversation with a per-message output_config in a role: "system" message (beta), which preserves the cached prefix.
Thinking blocks are cached with tool results. During a tool-use loop, prior thinking blocks are cached along with the rest of the history and count as input tokens when read back — automatically, even without explicit cache_control markers. Reasoning you never see again still shows up in your input-token bill.
Workload Decision Matrix
Workload Thinking posture Rationale
Intent classification, tagging, extraction Haiku 5.5 at low effort Single-step; deliberation adds latency and billed tokens for no accuracy gain
Customer-facing chat under a latency SLA Sonnet 5.5 at low / medium Effort is the latency dial before you change tier
RAG answer synthesis over 20 documents Sonnet 5.5 at high Cross-document reconciliation genuinely benefits
Multi-file refactor with tool loops Opus 5.5 at xhigh , large max_tokens Long horizon; thinking and text share the ceiling
Algorithmic proof, hard debugging Opus 5.5 at max , or Fable 5.1 Deep deliberation is the deliverable
Prompting note: with adaptive thinking, do not micro-manage the reasoning. Do not ask Claude to "think step by step in your thinking block" — that is what the mode already does. State the problem, the constraints, and the success criteria, then steer depth with effort rather than with prose.