Extended thinking and reasoning effort: when to spend it

What the dial actually does

At higher effort the model produces more internal reasoning before committing: considering alternatives, checking its own logic, exploring consequences. That reasoning is real work, and it is billed as output tokens whether or not you ever see it.

Current models use adaptive reasoning, which makes thinking optional on each step rather than a fixed budget spent every turn. The model can answer a routine prompt quickly and reserve deliberation for the steps that benefit. Effort sets how freely it may do that.

• The default is high on every model that supports effort, except Opus 4.7 which defaults to xhigh.
• Set a level the active model does not support and Claude Code falls back to the highest supported level at or below it. xhigh runs as high on Opus 4.6.
• low, medium, high, and xhigh persist across sessions when set interactively. max applies to the current session only, unless set through the environment variable.
• The effort scale is calibrated per model. The same level name does not represent the same underlying amount of reasoning across two models, so re-tune when you switch.
• On Enterprise plans an administrator can cap the maximum level per model per role. A higher level then runs at the cap, with a warning in interactive sessions and silently in JSON output.

The five places you can set it

# 1. settings file: accepts low, medium, high, xhigh only
#    { "effortLevel": "medium" }

# 2. skill or subagent frontmatter: applies while that skill or agent runs
#    effort: low

# 3. in session
/effort              # interactive slider
/effort xhigh        # set directly
/effort auto         # back to the model default
/model               # left and right arrows move the effort slider here too

# 4. at launch, for one session
claude --effort high

# 5. environment variable: outranks everything above
export CLAUDE_CODE_EFFORT_LEVEL=medium

The current level is shown in the session header next to the model name, as "with low effort" or similar, so you can confirm what is active without opening anything.

ultrathink, for one turn

Include the word ultrathink anywhere in a prompt to request deeper reasoning on that turn without changing your session setting. Claude Code recognises the keyword and adds an in-context instruction; the effort level sent to the API is unchanged.

ultracode, which is not an effort level

The /effort menu also offers ultracode. It is a Claude Code setting rather than a model level: it sends xhigh to the model and has Claude orchestrate a dynamic workflow for substantive tasks. It applies to the current session only, and neither the persisted effortLevel setting nor CLAUDE_CODE_EFFORT_LEVEL accepts it. Requires Claude Code v2.1.203 or later.

Turning thinking off, and where you cannot

On Opus 4.6 and Sonnet 4.6 you can set CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING=1 to revert to the older fixed thinking budget controlled by MAX_THINKING_TOKENS. Fable 5, Sonnet 5, and Opus 4.7 and later always use adaptive reasoning, so neither that variable nor a nonzero budget applies to them: use effort levels instead.

When it pays and when it does not

Anthropic own guidance on max is unusually blunt and worth repeating: it can improve performance on demanding tasks, but it shows diminishing returns and is prone to overthinking, so test it before adopting it broadly. high is described as the balance point, and xhigh as the deeper option for coding and agentic work.

What it costs

Thinking tokens are output tokens, which are the most expensive category on every model. Output is priced five times input across the Claude lineup, so effort is a multiplier on the costliest part of a request.

The other cost is attention. Higher effort means noticeably longer before the first token, and on a task where you were going to read and correct the output anyway, latency you spend waiting is not obviously better than latency you spend iterating.

A routing habit that works

1. Leave it at the default. high is the balance point and it is already selected.
2. Drop to low the moment a task turns mechanical, which often happens partway through: once a decision is made, applying it across thirty files is not a thinking problem.
3. Escalate on evidence. One failed attempt is the signal, not a suspicion that something might be hard.
4. Escalate for the plan, not the implementation. High effort deciding the approach and the default executing it is the best value pairing available, and opusplan automates the model half of the same idea.
5. Pin it in frontmatter for work that always has the same shape: effort: low on a mechanical migration subagent, effort: xhigh on a review skill.

Questions people ask

Keep reading