Claude Code ultrathink: what it does now, and what it doesn't

TL;DR In the terminal, since v2.1.311, ultrathink sends that turn at xhigh and the next turn is back at your level. With claude -p it leaves effort alone and only adds a note; that's where I measured it on Opus 5.5: 27% more reasoning than medium for 9% more cost. Neither way gets more answers right on work medium already handles, so save it for the turn that really needs it.

Search for ultrathink and half the results say it's dead while the other half sell it as Claude's maximum mode. It's neither. And since v2.1.311, what it does depends on where you type it.

What it does now

Claude Code spots the word anywhere in your prompt and attaches an in-context instruction to that turn. This one, verbatim:

The user included the keyword "ultrathink", requesting deeper reasoning on this turn.
Reason as thoroughly as the task warrants.

A note for one turn. Your next prompt goes out without it.

It's also the last keyword standing. think, think hard and think more reach the model as plain text, and Claude Code adds nothing for them.

In the terminal, it also raises that turn to xhigh. Since v2.1.311, type it in the interactive session's prompt on Opus 5.5, Sonnet 5.5, Haiku 5.5 or Fable 5.1 through Anthropic's API, and that turn goes out at xhigh effort. You can tell because the word turns rainbow-colored. The transcript of a v2.1.311 session on Opus 5.5 records the effort of every response:

❯ ultrathink: what is 17*23? answer with the number only
  "effort":"xhigh","perTurnEffort":"xhigh"

❯ what is 19*21? number only
  "effort":"medium","perTurnEffort":"medium"

Type it while Claude is working and it raises the rest of that turn.

If the word doesn't turn rainbow, effort stays put and all you get is the note. That happens inside quotes, a path or a command, in a prompt that starts with /, with CLAUDE_CODE_EFFORT_LEVEL set below xhigh, with a lower maxEffortLevel, on any model other than those four, or on Bedrock.

With claude -p, just the note. The level sent to the API is still yours. I checked with the /whicheffort skill from the effort precedence chain, which prints ${CLAUDE_EFFORT}, and v2.1.311 gives the same result:

$ claude -p "/whicheffort" --model claude-opus-5-5
EFFORT=medium

$ claude -p "ultrathink /whicheffort" --model claude-opus-5-5
EFFORT=medium

What it doesn't do

It doesn't stick. Your settings.json and your per-model effort are left alone. In the terminal, the next turn drops back to your level on its own.

It doesn't buy extra right answers on problems medium already solves. Not with the note alone, which is what I measured below, and not with xhigh either: on tasks full of hidden edge cases, xhigh got the same results as medium at three times the cost.

How I measured it

I measured this on v2.1.281 with claude -p, and it's still what happens there: the note alone, with effort at medium. In the terminal, that turn now goes out at xhigh and costs what xhigh costs.

Five problems with an exact, checkable answer (combinatorics, probability and a coin count), with tools switched off so Claude couldn't write code and had to reason its way through. Three Opus 5.5 configurations, three runs each, 45 runs in total:

claude -p "<problem>" --model claude-opus-5-5 [--effort high] \
  --tools "" --setting-sources project --strict-mcp-config \
  --no-session-persistence --output-format json

In the ultrathink configuration the prompt starts with ultrathink. and nothing else changes. Reasoning is thinkingTokens from each run's JSON; cost is total_cost_usd at API list price.

Reasoning and time are medians over the two long problems (permutations and coins). On the other three, no configuration went past 300 reasoning tokens.

With ultrathink, Opus 5.5 reasoned 27% more than at medium, close to what high did (22% more), and cost 9% more. Around three extra seconds per answer.

Accuracy didn't move, because medium was already getting everything right. The single miss in 45 runs came from ultrathink: 22 ways to make a dollar where there are 24. Three runs per cell can't show it makes things worse. They do show it didn't help here.

When to use it

For one specific turn, instead of raising effort for the whole session. A design call, a bug that spans several modules, a migration you want reasoned through carefully. Put ultrathink in that prompt, that turn goes out at xhigh, and the next one is back at your usual level, with nothing to remember to turn down.

It doesn't cost you an uncached reread. On Opus 5 and Sonnet 5, changing effort mid-session means the next request reads the whole conversation without the cache, and that's billed; there ultrathink leaves effort alone, so that reread never happens. The models where it does raise effort, Opus 5.5, Sonnet 5.5, Haiku 5.5 and Fable 5.1 with a subscription or an API key, keep the cache when effort changes: in the session above, the medium turn right after the xhigh one read all 34,357 tokens of its context from the cache.

Don't put it in every prompt. In the terminal that's running at xhigh without admitting it, and xhigh costs about three times what medium does and takes about three times as long. If all your work needs more, set high for that model with /effort and save ultrathink for the exceptions. In my Opus 5.5 benchmark, going to high changed nothing on everyday tasks.

What this doesn't measure

• Problems where medium falls short. Almost everything came back right, so this measures how much it reasons and what it costs, not whether it reasons better. On a task medium gets wrong, the extra note might show. I went looking for tasks like that, full of hidden edge cases, and medium solved every one.
• Scale. Five problems, three runs, one model, one day.
• Sessions with tools. I ran it with --tools "". If the note makes Claude read more files before it writes, this test can't see it.

If what you actually want is to see Claude's thinking, ultrathink won't show it to you: that takes something else. And why effort is the only thinking knob still wired to anything is in Claude Code thinking.

On well-scoped tasks, raising Sonnet 5.5 to high bought nothing either: keep the default level and use ultrathink on the turn that needs it.

Official docs: Model configuration: use ultrathink for one-off deep reasoning · Prompt caching: changing effort level

Requirements

• The jump to xhigh in the terminal, checked on Claude Code v2.1.311 with Opus 5.5, on October 27, 2026.
• The claude -p measurements, on v2.1.281 with Opus 5.5, on September 24, 2026.