← Overview

1. Architectural Foundation: What effort Can and Cannot Be

Understanding the effort Parameter: Architecture, Mechanics, and Practical Prompt Design

This guide consolidates the current understanding of Claude's effort parameter and extended thinking. It explains the underlying architectural constraints, corrects persistent misconceptions about how effort is implemented, and derives practical guidance for prompt design and effort-level selection. Each recommendation follows directly from the architectural analysis.

1.1 The Three Degrees of Freedom at Inference Time

A deployed language model has exactly three channels through which its output can be influenced at inference time:

| Channel | Location | Controller | |---|---|---| | Input tokens (prompt, system prompt, special tokens) | Outside the network | API layer / caller | | Sampling parameters (temperature, top-p, logit bias) | Outside the network | API layer / caller | | Weights | Inside the network | Fixed after training |

This is not a design choice — it is a structural consequence of how autoregressive transformers operate. During inference, no external process can modify the weights or inject a state variable into the network. The only path into the model's computation is through the input token sequence.

This architectural fact carries a direct implication: any parameter that appears to change model behavior at inference time must be implemented either as a modification to the input token stream or as an external intervention in the decoding loop. There is no third option.

1.2 What effort Actually Is: The Only Possible Implementation

Anthropic describes effort as a "behavioral signal." This is accurate as a description of the result — the model does behave differently at different effort levels. It is, however, an abstraction that obscures the mechanism.

Given the architectural constraints above, effort can only be implemented as a combination of two things.

Prompt-level conditioning. The effort level is encoded as a special token or system-prompt segment injected into the input stream. The model has been trained via reinforcement learning to associate this signal with specific behavioral patterns: whether to engage extended thinking at all, how many tool calls to perform, and how elaborately to respond. The RL training has baked this conditional behavior into the weights — but it is accessed exclusively through the input channel. This means effort is, at the implementation level, structurally identical to an elaborated system prompt. It is not a model parameter in any intrinsic sense; it is an external input the model has learned to respond to.

External budget cutoff. A separate external mechanism monitors the length of the thinking block. When the token budget is exhausted, the decoding loop intervenes: it replaces the model's end-of-thinking token with a continuation signal (such as "Wait") to force further reasoning, or it hard-terminates the thinking block and forces the model into output generation. This intervention happens in the API layer, entirely outside the neural network. The model itself has no awareness that a budget exists and cannot anticipate when a cutoff will occur.

The key correction: Calling effort a "behavioral signal" does not contradict the claim that it is not an intrinsic model parameter. The terminology describes the outcome, not the mechanism. The mechanism is, necessarily, prompt-level conditioning plus decoding-time intervention — because those are the only mechanisms available in the current LLM paradigm.

1.3 Contrast with Biological Effort Systems

The architectural limitation becomes clearest in contrast with biological neural networks, where effort is an intrinsic dimension of the network itself.

In biological systems, neuromodulators — noradrenaline, dopamine, acetylcholine — perform global gain control: they dynamically scale the effective strength of synaptic connections across the entire network, without any change to the input. This is a true in-network state variable. The anterior cingulate cortex computes a prospective effort prediction — an estimate of the energetic cost of a candidate solution — before committing resources to it. Based on this estimate, the network can compress or expand its effective solution space by modulating weights from within.

| Dimension | Biological | LLM | |---|---|---| | Mechanism | Global weight modulation via neuromodulators | Input-token conditioning via prompt | | Location of control | Intrinsic (inside the network) | Extrinsic (at the input channel) | | Effect on solution space | True compression / expansion of effective weights | Navigation steering through prompt space | | Effort prediction | Prospective (cost estimated before execution) | Reactive (cutoff applied after threshold is crossed) | | Separability from architecture | No (inseparable from network state) | Yes (removable without architectural change) |

The consequence is precise: an LLM cannot reduce or expand its solution space through effort the way a biological system can. It can only be steered toward different regions of a fixed space — and it can have its search truncated externally when the allocated trajectory length is exhausted.

2. Mechanics of Budget, Solution Space, and Self-Correction

2.1 The External Budget Cutoff

Because the model cannot anticipate the cost of a solution before generating it — a direct consequence of the token-by-token, lookahead-free nature of autoregressive generation — the budget mechanism is necessarily reactive, not predictive.

The sequence is as follows. The model begins a thinking block and generates reasoning tokens. It has no internal representation of the remaining budget. At some point it produces an end-of-thinking token, signaling that it believes its reasoning is complete. The external decoding algorithm then checks the budget. If sufficient budget remains, it discards the end-of-thinking token and appends a continuation signal, forcing the model to continue reasoning. If the budget is exhausted, it accepts the termination — or, if the thinking block was truncated mid-stream, it injects the end-of-thinking token forcibly.

Two points follow directly from this.

The cutoff is mechanical, not cognitive. The model does not decide to stop; the external loop decides for it. The neural network has no agency over the budget boundary.

Under-budgeting degrades quality. When the reasoning trajectory is truncated before a solution can be reached, the output reflects a partial or abandoned reasoning path. This is the primary risk of setting effort too low for a given task. In this case, effort does not merely fail to improve quality — it actively degrades it by preventing the model from completing the necessary reasoning steps.

2.2 Iteration, Backtracking, and the KV-Cache

Extended thinking enables iterative self-correction through a mechanism that is worth understanding precisely, because it determines how prompt instructions interact with the available budget.

When the model generates a thinking block, every token produced is stored as key-value pairs in the KV-cache. Each new token generated within the thinking block has attention access to all previously cached tokens. This means that a later section of the thinking block can, in effect, re-read and evaluate everything generated so far — without recomputing those tokens. When the decoding loop appends a continuation signal, the model re-enters the thinking block with the full prior reasoning in its attention context. It can then identify errors, dead ends, or incomplete steps in earlier reasoning and generate a corrected path forward.

Self-correction in extended thinking works as follows: later reasoning segments use the KV-cache to attend to and evaluate earlier segments, then generate a revised logical path. The token budget determines the mechanical upper limit of this cycle. Every additional correction pass consumes tokens. A budget that is too small may permit only one reasoning pass, preventing the model from catching errors it would otherwise identify and correct. A larger budget allows more correction cycles — up to the point of diminishing returns.

2.3 The Solution Space Is Defined by Weights, Not by Effort

The set of solutions a model can produce is determined entirely by its trained weights. effort — whether understood as the token budget or the higher-level conditioning signal — does not modify the weights during inference. It therefore cannot expand or contract the solution space. It controls only how much of that space is explored along a given reasoning trajectory, and for how long.

A direct consequence: the prompt is the primary instrument for steering the model toward a specific region of its solution space. Prompt instructions that change how the model frames a problem, what strategies it considers, or how it evaluates its own output have a more fundamental effect on solution quality than the effort level. Effort sets the capacity; the prompt sets the direction.

3. Practical Guide: Prompt Design and Effort Selection

3.1 The Prompt Is the Primary Control Mechanism

Because effort operates through the same input channel as the prompt — and because the solution space itself is defined by fixed weights — the prompt has greater leverage over output quality than the effort parameter in most scenarios.

Prompt instructions directly navigate the solution space. Instructions such as "think step by step," "be concise," or "verify your answer" change which reasoning paths the model pursues. They work independently of the effort level, though their effectiveness is bounded by the available budget.

Effort sets capacity, not direction. Raising the effort level without changing the prompt gives the model more runway but no new destination. If the prompt does not direct the model toward a better solution, additional budget will not produce one. A well-directed prompt with modest effort will frequently outperform a poorly-directed prompt with maximum effort.

A practical mental model: the prompt is the navigation system; effort is the fuel. This analogy requires one important extension, however — at low effort, the engine may not start at all. When effort is set to low, Claude may skip the thinking block entirely for problems it assesses as straightforward. effort therefore influences both whether extended thinking is engaged and how long it runs, not only the latter.

3.2 How to Choose an Effort Level

Effort level selection should be driven by the expected complexity of the reasoning trajectory required by the task — not by a general preference for higher quality.

Use 0 effort when the task requires a direct lookup, classification, or straightforward generation with no multi-step reasoning; when latency and cost are primary constraints; or when the prompt contains no verification or iterative-refinement instructions.

Use 0 or adaptive (default) effort when the task involves moderate reasoning that benefits from a single coherent thinking pass; when the problem complexity is not known in advance and should be assessed by the model; or when verification instructions are absent or minimal.

Use 0 or 1 effort when the task requires multi-step reasoning, mathematical derivation, complex code generation, or logical proof; when the prompt explicitly requests verification, review, or iterative refinement; when solution quality is the primary constraint and cost is secondary; or when the expected reasoning trajectory is long relative to typical tasks.

A practical starting procedure: test at low or medium effort first. If the output quality is insufficient and the failure mode appears to be a truncated reasoning path — the model arrives at a partial or inconsistent answer — increase the effort level. If the failure is directional — the model reasons coherently but toward the wrong solution — revise the prompt instead.

3.3 The Validation Pattern: When and How to Use It

The most practically consequential interaction between prompt design and effort level is the validation pattern: the use of instructions such as "validate," "verify," "check your answer," or "review your reasoning."

These instructions trigger an additional self-correction cycle within the thinking block. Upon reaching a candidate solution, the model re-reads its prior reasoning via the KV-cache and generates a critical evaluation pass before committing to a final answer. This is one of the highest-leverage prompt mechanisms available for improving solution reliability — and it has a hard dependency on the available budget.

The critical constraint: the validation pass consumes tokens. If the budget is exhausted before the validation cycle completes, the model is cut off mid-verification. The result is worse than either a completed solution without verification or a completed verification: it is a truncated, structurally incomplete output.

This creates a direct dependency between prompt complexity and effort level that must be actively managed:

The broader principle is that prompt complexity and effort level must be matched. A prompt requesting elaborate multi-step reasoning and iterative verification is only effective if the effort level provides sufficient budget to complete those steps. Mismatches in either direction produce suboptimal results: truncated output when the prompt outpaces the budget; wasted cost when the budget far exceeds what the task requires.