Contents
That slider next to the model name in Claude Code — the "Effort" control that runs from "Faster" to "Smarter" — decides how much work (thinking and tokens) the AI puts into each reply. Slide left for fast and cheap, right for deep and smart.
Here's the big picture first. The effort setting itself (the API effort levels) has 5 steps: low to max, and Claude Code's /effort slider picks among them. Ultracode is not a sixth step: it's a separate on/off switch that works at any level (v2.1.284 and later). So think "a 5-step dial + an Ultracode switch." Keep that in mind and the rest falls into place.
One dial from "Faster" to "Smarter"
— it shifts thinking depth and tool calls together
= the 5 API effort levels (low–max)
The slider reads Low · Medium · High · Extra · Max.
So "Extra" = xhigh, and the top effort is "Max." Ultracode isn't a step — it's a separate switch that works at any step.
1. What "effort" is
Effort is the setting that controls how many tokens Claude spends on a single reply. Lower means shorter, faster, and cheaper; higher means deeper, more thorough, and smarter. If you've searched "Claude Code effort" or wondered what the "Faster / Smarter" dial does, this is it.
The key point is that effort affects your whole reply, not just the thinking. Specifically, it touches all three of these (source: Anthropic's official "Effort" docs — Extended thinking / Tool calls and function arguments / Text responses and explanations).
Thinking depth
How much it reasons before answering. Higher effort allows multi-step analysis and backtracking.
Tool calls
How many times it reads, searches, or edits. Lower effort bundles and reduces calls.
Amount of response text
Explanations, summaries, comments. Lower effort means less preamble and terser output.
💡 In a nutshell: effort is a behavioral signal, not a fixed token budget. Even at low effort Claude will still think on genuinely hard problems — just less than it would at higher effort for the same problem.
2. The slider's 5 levels and labels
As an API setting, effort has 5 levels: low → medium → high → xhigh → max. The default depends on the model: high on most models, medium on Opus 5.5 and a few others (see section 3). Claude Code's /effort slider is the dial that picks among these 5.
One thing trips people up: "Extra" is not the maximum. The slider reads Low · Medium · High · Extra · Max, where "Extra" = xhigh and "Max" = max. So "Extra" is second from the top, not the top. And Ultracode isn't an effort step at all — it's a separate on/off switch with different behavior (see section 6). Before v2.1.284, Ultracode sat at the right end of the slider as a sixth stop; now it's an independent switch you flip with the Tab key inside /effort (in the VS Code extension, a switch under the slider).
Fewest tokens, lowest latency
Short, scoped tasks, formatting, boilerplate, subagents. Speed and cost first.
Cost-conscious middle ground
Solid quality while keeping tokens in check for everyday work.
The quality/cost sweet spot
The standard for complex reasoning and hard coding. "Just right" for most work.
Long-running agentic work
For coding with repeated tool calls and deep search. Uses far more tokens than high.
Maximum thinking, no cap
Deepest reasoning with no token limit. For truly hard problems only; can overthink.
Multi-agent automation
Not an effort "step" but a Claude Code setting you can turn on at any effort level. See section 6.
⚠️ What persists and what doesn't: low, medium, high, and xhigh are saved per model when you confirm them with Enter in the slider, and carry over to your next session (confirm with s to apply them to this session only). "Max" is session-only (it persists only if set via the CLAUDE_CODE_EFFORT_LEVEL environment variable). Ultracode turned on with /effort ultracode lasts for the session, but writing "ultracode": true in a settings file starts every session with it on (see section 6).
3. Model support and auto-downgrade
The levels you can pick depend on the model. xhigh ("Extra") is limited to relatively recent models. The current Fable 5.1, Opus 5.5, Sonnet 5.5, and Haiku 5.5 give you every level, while the legacy Haiku 4.5 doesn't support effort at all (on Haiku, effort arrived with Haiku 5.5, released October 7, 2026). How to choose the effort level for Haiku 5.5 is covered in chapter 6 of our Claude Haiku 5.5 guide.
Watch the defaults. Opus 5.5, Claude Code's default model, starts at medium — one level below Opus 5's default of high.
| Model | Effort levels (low–max) | Claude Code default | API default |
|---|---|---|---|
| Fable 5.1 | low · medium · high · xhigh · max | high | high |
| Opus 5.5 | low · medium · high · xhigh · max | medium | medium |
| Sonnet 5.5 | low · medium · high · xhigh · max | medium | high |
| Haiku 5.5 | low · medium · high · xhigh · max | medium | medium |
| Legacy: Fable 5 / Opus 5 / Sonnet 5 / Opus 4.8 | low · medium · high · xhigh · max | high | high |
| Legacy: Opus 4.7 | low · medium · high · xhigh · max | xhigh | high |
| Legacy: Opus 4.6 / Sonnet 4.6 | low · medium · high · max (no xhigh) | high | high |
| Legacy: Haiku 4.5 | Not supported (no effort control) | — | — |
* As of October 12, 2026. "Legacy" means the models Anthropic lists as legacy (still available). Sources: Claude Code model configuration (levels and Claude Code defaults), plus the API effort docs and models overview (API defaults).
* Sonnet 5.5 and Opus 4.7 have different defaults in Claude Code and in the API. In Claude Code, leaving effort unset runs the "Claude Code default" column.
* Claude Code needs v2.1.293 or later for Haiku 5.5. The haiku alias points to Haiku 5.5 on the Anthropic API; on Amazon Bedrock, Google Cloud, Microsoft Foundry, and other providers it still points to Haiku 4.5.
* Ultracode (a switch separate from effort) is only available on xhigh-capable models (Fable 5.1 / Opus 5.5 / Sonnet 5.5, etc.) — on Opus 4.6 and Sonnet 4.6 the switch doesn't appear in /effort.
If you pick a level the model doesn't support, it doesn't error — it auto-downgrades to the nearest supported level at or below it. For example, xhigh ("Extra") on Opus 4.6 runs as high (those two models jump from high straight to max, with no xhigh in between). Note too that the same level name means different amounts on different models — the effort scale is calibrated per model.
4. How to set it (/effort and more)
Start here: the /effort command. Run it with no arguments and an interactive slider opens (the dial in the screenshot), navigated with the arrow keys. This alone is all most people need.
# Open the slider (arrow keys, then Enter)
/effort
# Set a level directly
/effort low
/effort xhigh
# Clear your saved level and go back to the model's default
/effort auto
# Turn Ultracode on / off (effort stays the same)
/effort ultracode
/effort ultracode offOther options, depending on your needs (the later ones are for advanced users):
- The slider inside
/model: in the model picker, use the left/right arrow keys to adjust the effort dial. --effortflag: launch withclaude --effort medium(that session only).CLAUDE_CODE_EFFORT_LEVELenvironment variable: a level name orauto. Takes highest priority.modelSettings/effortLevelin settings: alow/medium/high/xhighlevel you confirm in/effortor/modelis saved per model undermodelSettingsin your user settings (v2.1.251 and later; earlier versions wrote a singleeffortLevel). To edit by hand, set a level per model inmodelSettings, or useeffortLevelas the default for models without a saved level (buteffortLevelin your user settings,~/.claude/settings.json, doesn't apply to Opus 5.5 and later models).maxisn't accepted in either key, and Ultracode has its own"ultracode": truekey.- skill / subagent frontmatter: overrides effort while that skill or subagent is running.
To change the effort and model of several open sessions in Claude Code Desktop at once, you can simply ask the assistant; the steps and checks are in Change Model & Effort for All Claude Code and Codex Sessions.
💡 Priority: environment variable ＞ frontmatter (only while that skill/subagent runs; never beats the env var) ＞ your configured/session value ＞ the model default. The current level shows next to the logo and spinner, e.g. "with low effort," so you can confirm what's active.
5. Quick reference: which level when
The official guidance is simple. The model's default suits most coding work (medium on Opus 5.5 and Sonnet 5.5, high on Fable 5.1). Go to high when verification matters, xhigh ("Extra") for long, deeper work, low for quick exchanges, and reserve max for genuinely hard problems. Reach for Ultracode only when you want to power through a large, multi-step task at once.
| Item (display) | When to use it |
|---|---|
| low | Short, scoped, latency-sensitive tasks that don't need much intelligence |
| medium | Day-to-day implementation with a clear scope (the default on Opus 5.5, Sonnet 5.5, and Haiku 5.5). On other models, cost-sensitive work where you can trade a little intelligence |
| high | Work where verification matters or edge cases are likely, such as fixing a bug in existing code (the default on Fable 5.1 and others) |
| xhigh (Extra) | Long coding/agentic runs with repeated tool calls and deep search |
| max (Max) | Hardest problems only. Gains plateau and overthinking is a risk — test first |
| Ultracode | Large, multi-step tasks (big refactors, audits) you want broken up across multiple agents. An on/off switch separate from the effort steps; not for everyday use (→ §6) |
When you raise effort for heavy work, set a generous max_tokens (around 64k+) so the model has room to think and act across tool calls.
6. What is Ultracode? How it differs from Max effort (in depth)
Ultracode is a Claude Code setting — an on/off switch you flip with the Tab key inside /effort. The crucial part: it is not an API effort level (low–max). Two points to know.
Effort stays where it is
Turning it on doesn't change the effort level: it runs at whatever step you're on (Low to Max). The one exception is launching with claude --effort ultracode, which also sets xhigh ("Extra").
It auto-launches dynamic workflows
For each substantive task, Claude plans and launches a multi-agent workflow on its own, running several subagents in parallel.
"Dynamic workflows" (point 2) means Claude writes a script on the fly that runs many subagents in the background, in parallel. Intermediate results stay in the script; only the final result returns to Claude's context. A single request can fan out into several workflows (e.g. "understand the code → change it → verify"). By default up to 16 agents run at once (fewer on machines with fewer CPUs; the CLAUDE_CODE_WORKFLOW_MAX_CONCURRENT_AGENTS environment variable changes it), with up to 1,000 agents per run.
🔑 Ultracode vs. xhigh: xhigh = thinking depth (an effort step). Ultracode = a switch that auto-launches multi-agent workflows per task, independent of effort. That means combinations like "Medium + Ultracode" work. Before v2.1.284, turning Ultracode on locked the session to xhigh, picking another step turned it off, and an effort cap below xhigh made it unavailable.
How to turn it on
/effort ultracode: on for the rest of the session (each substantive task is auto-turned into a workflow)./effort ultracode offturns it off. Neither changes your effort level.- In the
/effortslider, pressTabto flip the Ultracode switch, thenEnterto apply it (in the VS Code extension, use the switch under the slider). - Launch with
claude --effort ultracode: starts with Ultracode on and effort at xhigh ("Extra"). - To start every session with it on, write
"ultracode": truein a settings file (you can also pass it via--settingsor an Agent SDK control request). - For a one-off, put the keyword
ultracodein your prompt (e.g. "ultracode: audit every endpoint under src"). Your session effort stays unchanged.
⚠️ Model support and persistence: Ultracode requires an xhigh-capable model (Fable 5.1 / Opus 5.5 / Sonnet 5.5, etc.); the switch doesn't appear in /effort on Opus 4.6, Sonnet 4.6, or the legacy Haiku 4.5 (which has no effort control). /effort ultracode is session-only; the way to make it stick is "ultracode": true in a settings file (effortLevel and the CLAUDE_CODE_EFFORT_LEVEL environment variable don't accept it). To return to routine work, run /effort ultracode off (before v2.1.284, picking another step such as /effort high turned it off).
When to use it
✅ Good fit
Large refactors, migrations across hundreds of files, codebase-wide bug or authorization audits, multi-perspective cross-checks — multi-step work too big to steer in one conversation.
⛔ Poor fit
Small, scoped tasks, latency-sensitive work, routine edits. Each request costs noticeably more tokens and time, so it's wasteful here.
Cost note: because every substantive request fans out into workflows, Ultracode burns far more tokens and time than usual and can eat into your plan usage and rate limits quickly. Try it on a small slice first (one directory) to gauge the scale. The dynamic-workflows feature itself can be disabled via /config, the setting "disableWorkflows": true, or the env var CLAUDE_CODE_DISABLE_WORKFLOWS=1 — which also removes the Ultracode switch from /effort.
* Behavior is per Anthropic's official docs (Effort / Model configuration / Workflows / Settings reference); Ultracode as a switch and per-model saving are as of September 29, 2026 (v2.1.284). The slider labels were confirmed in the live Claude Code desktop UI (as of June 2026). Effort and Ultracode evolve quickly — check the official docs and your app for the latest.
7. Related features and common mix-ups
A few features are easy to confuse with effort. Here's how they differ.
ultrathink
A keyword that makes Claude think harder for that one turn only; your session effort is unchanged. Since v2.1.311, when you use Opus 5.5, Sonnet 5.5, Haiku 5.5 or Fable 5.1 through Anthropic's API, it runs that turn at xhigh effort (typed mid-task, it raises the rest of that turn; official changelog). Since v2.1.316, the CLAUDE_CODE_DISABLE_ULTRATHINK environment variable turns this keyword off, and it also works at xhigh in the VS Code extension (v2.1.316 changelog). Phrases like "think" or "think hard" are treated as plain text and do nothing.
/fast (fast mode)
A separate axis. It runs the same model faster (it doesn't drop to a smaller one), at a higher cost. Pair it with low effort for snappy routine work.
Ultracode
Not an effort step but an on/off switch that has Claude build multi-agent workflows on its own. Works at any effort level. Details in section 6.
The common mix-up is "pick 'Extra' and it's the smartest." In fact "Extra" = xhigh, and the top effort is "Max" to its right. Even Max isn't always best — on structured output or light tasks it can overthink and hurt quality. The official advice to start coding at xhigh ("Extra") was written for Opus 4.7 and 4.8; on the current Opus 5.5, the starting point is its default, medium. When in doubt, the model's default is usually enough. If your setup gets stuck, see common Claude Code errors and fixes.
Summary
Three takeaways on Claude Code's effort setting.
- What it is: the tokens-per-reply setting — your "Faster ↔ Smarter" dial. It affects thinking, tool calls, and response text alike.
- Steps and labels: the API has 5 effort levels (low–max). The slider reads Low · Medium · High · Extra · Max, and Ultracode is a separate on/off switch, not a step. "Extra" = xhigh; the top is "Max." Defaults vary by model (medium on Opus 5.5, Sonnet 5.5, and Haiku 5.5, high on Fable 5.1); xhigh needs a relatively recent model; the legacy Haiku 4.5 has no effort control (Haiku 5.5 supports every level); unsupported levels auto-downgrade.
- Which when: start from the model's default, high when verification matters, xhigh ("Extra") for long, deep work, low for quick tasks, max for hard problems only. Big multi-step jobs → Ultracode (multi-agent automation you can turn on at any effort level;
/effort ultracode offturns it back off).
One dial gives you the balance between speed and smarts. Read it alongside the loop command and our AI coding tool comparison to get the most out of Claude Code.
The other selector sitting right next to the effort dial is Claude Code's permission modes. Where effort decides how hard Claude thinks, permission mode decides how much it's allowed to run on its own — pairing the two takes the guesswork out of everyday driving.
FAQ
Q. Is picking "Extra" on the slider the smartest setting?
A. No. "Extra" is xhigh (second from the top), not the maximum. The top effort is "Max," just to its right. But Max isn't always best — on structured output or light tasks it can overthink. On the current Opus 5.5, official guidance is to start at its default, medium.
Q. Which effort level should I use?
A. When unsure, keep the model's default (medium on Opus 5.5 and Sonnet 5.5, high on Fable 5.1). Raise it to high for work that needs verification, such as fixing bugs in existing code, or to xhigh ("Extra") for long, deep work. For formatting or light work where speed matters, drop to low.
Q. How is Ultracode different from Max?
A. Max is an effort level (the deepest thinking). Ultracode isn't an effort step — it's a Claude Code on/off switch that auto-launches multi-agent workflows. Because it's independent of effort, both "Max + Ultracode" and "Medium + Ultracode" work (v2.1.284 and later). It's for large, multi-step tasks and limited to xhigh-capable models.
Q. Why can't I pick xhigh ("Extra") or Ultracode?
A. Both require an xhigh-capable model (Fable 5.1, Opus 5.5, Sonnet 5.5, etc.). The legacy Opus 4.6 and Sonnet 4.6 have no xhigh (the legacy Haiku 4.5 has no effort control at all, while Haiku 5.5 does offer xhigh), and Ultracode doesn't show in the /effort menu there (xhigh requests auto-downgrade to high). Switch models to get them.
Q. How do I make my setting stick across sessions?
A. For low/medium/high/xhigh, just confirm the level with Enter in the /effort slider (or type it, as in /effort high): it's saved per model under modelSettings in your user settings and carries over. Max is normally session-only but persists if set via the CLAUDE_CODE_EFFORT_LEVEL environment variable. For Ultracode, write "ultracode": true in a settings file and every session starts with it on (effortLevel and the environment variable don't accept it).
Related: Claude Opus 5 release guide, Claude adaptive thinking explained.
