Claude Effort Levels Explained: Fable 5, Opus 5.5, Haiku 5.5

Last updated: October 9, 2026. This revision re-verifies every table below against Anthropic's docs and adds Haiku 5.5, which supports all five effort levels and defaults to medium on the API and in Claude Code. It also corrects cache-read pricing (Sonnet 5.5 now reads cache at 0.05x, like Opus 5.5), updates when a fallback stops carrying your effort level, and points the per-level thinking table at its new home on Anthropic's Steering thinking page.

Effort is the control that sets how much a current Claude model thinks and spends, and Anthropic's docs call it the primary steering lever for thinking on every model with adaptive reasoning. The API accepts exactly five levels: low, medium, high, xhigh, and max. The API default is high except on Opus 5.5 and Haiku 5.5, where it is medium; in Claude Code, Opus 5.5, Sonnet 5.5 and Haiku 5.5 all start at medium. Effort never changes the per-token price, only how many tokens the model generates. Start at the model default (see the defaults table below), step up to xhigh for the most capability-sensitive agentic and coding work, and step down to medium or low for routine or latency-sensitive work once your evals show quality holds.

Official Sources#

Fable 5 took away most of the dials developers used to tune Claude. Thinking is always on, budget_tokens returns a 400, and the sampling parameters are gone entirely. What is left is one control that now does almost all the work: the effort parameter. The same dial drives the other current Claude models, and it surfaces in Claude Code as /effort. This guide covers what each level changes, which models accept which levels, and how to reason about cost - re-verified against Anthropic's documentation on October 9, 2026.

What Effort Actually Controls#

Effort is set via output_config: {"effort": "..."} in the Messages API. The top-level parameter is GA on supported models with no beta header; per-message effort is beta and covered under Setting It. Per Anthropic's effort documentation, the parameter affects all tokens in the response, not just thinking:

• Text responses and explanations
• Tool calls and function arguments
• Thinking (when active)

That last point is the key difference from the old budget_tokens approach, which only capped thinking. At lower effort, Claude makes fewer tool calls, combines operations into single calls, skips preamble, and confirms tersely. At higher effort, it makes more tool calls, explains its plan before acting, and writes more detailed summaries and code comments. Because effort applies to every output token, it works whether or not thinking is on.

One important framing from the steering docs: effort is "soft guidance" that "shapes behavior but doesn't guarantee a token count." At low, Claude minimizes thinking but still decides per request, so a genuinely hard problem can still get some. If you need a hard ceiling, that is what max_tokens is for.

The Five Levels and Where They Run#

The API accepts exactly five values. These are the complete set - the docs state this explicitly, which matters because Claude Code's /effort slider also carries an Ultracode toggle that is a workflow setting, not a sixth level (more below).

Effort is supported on the Fable, Mythos, Opus 5.5, Opus 5, Opus 4.8, Opus 4.7, Opus 4.6, Opus 4.5, Sonnet 5.5, Sonnet 5, Sonnet 4.6, and Haiku 5.5 lines. Haiku 5.5 is the first Haiku model on the list, and it gets the full ladder including xhigh and max. Models not on Anthropic's supported list (such as Sonnet 4.5 and Haiku 4.5) do not support the parameter. The Fable 5 tool page tracks the current list and per-model rates.

Two subtleties worth internalizing:

• Not every model has xhigh. Opus 4.6 and Sonnet 4.6 do not have it, so on those models the ladder jumps from high straight to max.
• The scale is calibrated per model. The Claude Code model configuration docs state that "the same level name does not represent the same underlying value across models." Do not port effort settings between models without re-testing.

Defaults Differ by Model and Surface#

The API default is high on every effort-capable model except Opus 5.5 and Haiku 5.5, where it is medium. Setting the default explicitly behaves the same as omitting the parameter, and does not break the prompt cache. Claude Code defaults differ per model:

Claude Code also has fallback behavior: set a level the active model does not support and it falls back to the highest supported level at or below it. Set xhigh and switch to Opus 4.6, and you silently run at high. Automatic model fallback works differently: if a safety classifier flags a request and moves it to the fallback model, Claude Code keeps the effort level the flagged request ran at instead of applying the fallback model's default, so an Opus 5.5 session at medium that falls back to Opus 4.8 stays at medium even though Opus 4.8 normally defaults to high. The carry-over ends once you choose an effort level, pick a model in /model, or resume the session later, and a level set by a skill's effort frontmatter applies only to that turn. Run /effort status to see the level actually in effect.

Claude Code resolves the session level in this order: an explicit choice (CLAUDE_CODE_EFFORT_LEVEL, --effort, or /effort), then your settings (a per-model level saved under modelSettings, or the older effortLevel key), then the model's default. Levels are saved per model, so a model you have not set a level for starts at its own default; on Enterprise, an organization can also set a default effort level for its organization default model, which becomes the starting level when you run that model.

One more wrinkle: how long a level lasts depends on how you confirm it. Enter in the /effort slider or the /model picker saves the level as your default for later sessions; s applies it to this session only (Claude Code v2.1.257 or later). max is the exception: unless you set it through the CLAUDE_CODE_EFFORT_LEVEL environment variable, it applies to the current session only. /effort auto clears your saved level for the active model.

How Effort Interacts with Thinking#

On Fable 5, thinking cannot be turned off - effort is the only depth control, and the docs name it the primary steering lever for thinking wherever adaptive reasoning is available. Claude Code likewise cannot turn thinking off on Opus 5.5, Sonnet 5.5, Haiku 5.5, or the Fable models. The steering thinking docs describe how each effort level steers it:

• max: thinks the most readily and at the greatest depth, with no constraint on thinking length
• xhigh: thinks more readily and at greater depth than high, suited to extended exploration
• high: thinks on most requests that benefit from it
• medium: moderate thinking; may skip it for simple queries
• low: minimizes thinking; skips it for simple tasks where speed matters most

At every level Claude decides per request whether to think, so no level guarantees a thinking block. In a tool-use loop, the first request after new user input usually carries most of the reasoning, and follow-ups that only process tool results can skip thinking even at xhigh and max.

Two model-specific notes from the current effort docs. On Sonnet 5.5, the lowest thinking setting is thinking: {"type": "between_tools"}, which skips up-front thinking and works at low, medium, and high; at xhigh or max it returns a 400, so use adaptive thinking there. On Haiku 5.5, thinking: {"type": "disabled"} works at high or below and returns a 400 at xhigh or max; on Opus 5.5 it returns a 400 at every level. On Opus 5, effort controls thinking volume rather than visible response length - changing effort will not reliably shorten a chatty reply, so prompt for length instead.

If you are coming from budget_tokens code, this mapping is your migration path - there is no 1:1 token conversion. The full migration checklist covers the other breaking changes that land alongside it.

What Each Level Costs You: the Math#

Here is the part pricing pages will not spell out for you: effort does not change the per-token rate. Fable 5 bills $10 per million input tokens and $50 per million output at every effort level; Opus 4.8 and 4.7 bill $5/$25, Opus 5.5 bills $4/$20, Sonnet 5.5 bills $2/$10, Haiku 5.5 bills $0.10/$0.50 for prompts up to 100,000 tokens ($0.50/$2.50 above that), and Fable 5.1 bills the same $10/$50 as Fable 5, per the pricing page. The only documented price modifiers are caching, batch, fast mode, data residency, and Haiku 5.5's prompt-length tier - effort is not on the list. Cache reads vary by model (0.025x base input on Fable 5.1 and Mythos 5.1, 0.05x on Opus 5.5 and Sonnet 5.5, 0.1x on everything else), which changes what a long cached agent loop costs without touching effort at all.

What effort changes is volume, almost entirely on the output side, because thinking tokens bill as output tokens even when you never see them (the display: "omitted" setting hides thinking text but bills it identically).

A worked illustration. Suppose an agentic task on Opus 4.8 sends 20,000 input tokens per turn. These output volumes are hypothetical, but the shape matches how the docs describe the levels:

Same model, same prices, roughly 7x spread per turn purely from behavior. On Fable 5 double every number. Multiply by hundreds of turns in a long agent run and the effort setting is a bigger budget lever than the model choice in many cases - which is why effort deserves a row in any cost-per-task analysis you run. Model choice has not stood still either: September reset the frontier price sheet in the GPT-6 Sol vs Opus 5.5 vs Grok 4.7 comparison, and that is the other half of the same budget question.

Three practical cost notes, all from the docs:

1. Measure, do not guess. usage.output_tokens_details.thinking_tokens reports how many billed output tokens went to reasoning. Run the same eval at two effort levels and compare.
2. Give high effort room. On Opus 5, 4.8 and 4.7 at xhigh or max, Anthropic suggests starting max_tokens at 64,000 and tuning from there - it is a hard ceiling on thinking plus response text, per request, so it does not bound a whole tool-use turn. Seeing stop_reason: "max_tokens" means raise the ceiling or lower the effort.
3. The tokenizer compounds it. Claude 4.7 and later models (including Fable 5) use a newer tokenizer that produces approximately 30% more tokens for the same text, so old cost baselines do not transfer.

Counterintuitively, higher effort is sometimes the cheaper total: a run that finishes in one pass at xhigh can undercut three failed retries at medium. The Fable 5 vs Opus 4.8 decision guide works through that completion-rate math for model choice; the same logic applies at the effort dial.

Task Budgets: the Loop-Level Companion (Beta)#

Effort controls how deeply Claude reasons on each step. Since the September docs revision, Anthropic also documents the other half of agent cost control: task budgets, an advisory token allowance for a whole agentic loop - thinking, tool calls, tool results and output - that the model sees as a running countdown and uses to pace itself and finish gracefully.

It is a beta parameter on output_config, enabled with the task-budgets-2026-03-13 header, and it takes a minimum of 20,000 tokens; anything smaller returns a 400. Adapted from the docs' example:

response = client.beta.messages.create(
    model="claude-opus-5-5",
    max_tokens=128000,
    output_config={
        "effort": "high",
        "task_budget": {"type": "tokens", "total": 64000},
    },
    messages=[{"role": "user", "content": "Review the codebase and propose a refactor plan."}],
    betas=["task-budgets-2026-03-13"],
)

Three things to know before you ship it:

• It is advisory, not enforced. Claude can exceed the budget to finish an action mid-flight, and a budget that is clearly too small can make it refuse or scope the task down instead of starting. Use max_tokens as the hard ceiling and the task budget as the pacing signal.
• The countdown is model-only. The response usage has no remaining-budget field; track spend client-side, and pass remaining yourself only when your own code compacts the history.
• It is not everywhere. Task budgets work on Fable 5 and 5.1, Mythos 5 and 5.1, Opus 5.5, Opus 5, Opus 4.8, Opus 4.7, Sonnet 5.5 and Haiku 5.5. Sonnet 5, Opus 4.6, Sonnet 4.6 and Haiku 4.5 do not support them, and neither does Claude Code or Cowork, so it lives in your own harness - the agent harness map is the layer view of where this fits.

Picking a Level per Task Type#

Synthesizing Anthropic's per-model recommendations:

On Fable 5 and Fable 5.1: start at high (the default) for most work and reserve xhigh or max for the most capability-sensitive workloads. Anthropic's docs note that lower effort settings on Fable 5 "still perform well and often exceed xhigh performance on prior models" - a vendor claim, but a useful prior: do not assume Fable 5 needs the dial maxed. Step down to medium or low if tasks complete correctly but take longer than necessary.

On Opus 4.8 and 4.7: start with xhigh for coding and agentic work, treat high as the floor for anything intelligence-sensitive, and drop to medium only after evals confirm quality holds. Use max only when your evals show measurable headroom at xhigh. On Opus 5.5: the default is medium, and Claude Code's docs say to start there rather than carrying over the level you used on Opus 5; in Anthropic's testing, Opus 5.5 at medium matches or exceeds Opus 5 at high on coding and knowledge-work evaluations. The Opus 5.5 Claude Code playbook covers where that default holds and where it breaks.

On Sonnet 5.5: its levels were recalibrated, so a level does not produce the same amount of thinking as the same level on Sonnet 5 - run a fresh effort sweep rather than porting settings. Start at high unless the workload is agentic or latency-sensitive; for agentic coding, start at medium for well-specified tasks and move to high for harder or longer ones, and use xhigh or max only where your evals show a gain. For agentic coding, the docs recommend max_tokens at the model's 128,000 maximum with streaming. The Sonnet 5.5 release guide covers what else changed in the model.

On Haiku 5.5: start at medium, the default, for most work including agentic coding. Use low for chat, short tool tasks, and simple high-volume requests, but note the docs' warning that in long agent prompts Haiku 5.5 at low is more likely to skip a search, stop early, or skip a check. Use high for knowledge work, longer agent tasks, and strict instruction following, and reach for xhigh or max only where evals show a gain - at that point Anthropic suggests comparing against Sonnet 5.5 on performance, cost, and speed. The Haiku 5.5 release guide covers the rest of the model, and the Haiku 5.5 vs GPT-6 Luna subagent comparison prices it as a worker.

Everywhere: low is the documented home for subagents, classification, quick lookups, and high-volume latency-sensitive paths. If you orchestrate subagents, agent teams, or workflows, running workers at low while the orchestrator sits at high or xhigh is the cleanest cost win available. Anthropic's own Spending your effort write-up on Opus 5.5 and Fable 5.1 shows the tradeoff: at higher levels Claude tested more edge cases and verified more of its work, while lower levels returned a starting point sooner, which suits work you review step by step.

Setting It: Claude Code and the API#

Claude Code resolves the session level the same way in every surface. The mechanisms:

• /effort opens an interactive slider; /effort xhigh sets directly; /effort auto clears your saved level for the active model. You can run it while Claude is working, and the new level applies to the next request in the turn once the cache warning is confirmed
• The effort slider also appears in the /model picker; how you confirm decides how long the level lasts (Enter saves it as your default, s applies it to this session only, on Claude Code v2.1.257 or later)
• --effort <level> at launch, for a single session
• From a phone or browser connected through Remote Control, pick a level in the effort control; it applies to that session only (Claude Code v2.1.234 or later)
• effortLevel in settings still accepts low, medium, high, or xhigh, but it is the older form: it keeps applying where it applied before (Opus 5, Fable 5.1, and earlier), while Opus 5.5 and later models start at their own default until you set a level for them, saved per model under modelSettings
• effort in skill or subagent frontmatter, overriding the session level while that skill or subagent runs, though an organization cap or maxEffortLevel still limits it; skill packs such as Superpowers are the common case

Models have version floors: Sonnet 5.5 requires Claude Code v2.1.284 or later, Opus 5.5 requires v2.1.280 or later, and Haiku 5.5 needs v2.1.293 or later (the version where the haiku alias moved to it). The newest release on npm's latest tag at the time of this update is v2.1.295 (October 8, 2026).

Organization effort limits. On an Enterprise plan (Claude Code docs), admins can cap effort per model for each custom role, and on any plan or provider the maxEffortLevel managed setting caps it on the client; when both apply, the lower cap wins. Levels above the cap are not offered in the /effort picker, and naming a higher one with --effort or /effort runs at the cap instead - with a warning in interactive and plain-text runs, silently in JSON output and background agents. The per-role caps require Claude Code v2.1.195 or later.

Provider-pinned model IDs. Claude Code decides whether a model supports effort by matching the model ID. Custom Amazon Bedrock ARNs and deployment names often do not match, which silently disables effort and the /effort command. Pin the model and declare what it supports: export ANTHROPIC_DEFAULT_OPUS_MODEL_SUPPORTED_CAPABILITIES='effort,xhigh_effort,max_effort,thinking,adaptive_thinking,interleaved_thinking'. The same _SUPPORTED_CAPABILITIES suffix works for the Sonnet, Haiku, Fable and custom model variables, and anything you leave off the list is treated as unsupported.

About ultracode: it is a toggle in the /effort slider, not an API effort level and not a sixth rung. With it on, Claude Code orchestrates dynamic workflows at whichever effort level the session is running at; --effort ultracode is the one entry point that also sets the level to xhigh. /effort ultracode turns it on and /effort ultracode off turns it off (the off form, the slider toggle, and keeping it on at levels other than xhigh require Claude Code v2.1.284 or later). It has its own ultracode setting and is not accepted by effortLevel or CLAUDE_CODE_EFFORT_LEVEL. Related but different: typing ultrathink in a prompt requests deeper reasoning for that one turn via an in-context instruction - the effort level sent to the API is unchanged. Ultracode has its own explainer.

On the API, the syntax is one field:

response = client.messages.create(
    model="claude-fable-5",
    max_tokens=64000,
    output_config={"effort": "xhigh"},
    messages=[{"role": "user", "content": "..."}],
)

On Fable 5, omit the thinking parameter (thinking is always on, and an explicit disabled returns a 400).

Per-message effort (beta). On Claude Fable 5.1, Mythos 5.1, Opus 5.5, Opus 5, Sonnet 5.5, and Haiku 5.5 you can change the level mid-conversation with an effort-only system message, and the cached prefix still matches. Adapted from the docs' example:

response = client.beta.messages.create(
    model="claude-fable-5-1",
    max_tokens=4096,
    output_config={"effort": "high"},
    messages=[
        {"role": "user", "content": "Plan the migration in three steps."},
        {"role": "assistant", "content": "1. Export. 2. Schema. 3. Import."},
        {"role": "system", "content": [], "output_config": {"effort": "low"}},
        {"role": "user", "content": "Summarize the plan in one sentence."},
    ],
    betas=["mid-conversation-output-config-2026-07-01"],
)

The new level takes effect from the next user turn. Models without per-message effort, including Fable 5, return a 400. On Sonnet 5.5 with thinking: {"type": "between_tools"} and on Haiku 5.5 with thinking disabled, effort cannot change mid-conversation - a different per-message level returns a 400, so use adaptive thinking if you need to vary effort per turn. Platform support is narrower than the model list: on Amazon Bedrock, per-message effort covers only Fable 5.1, Mythos 5.1, and Opus 5.5. On Fable 5.1, Anthropic recommends the per-message form over changing the top-level value, because a top-level change restarts the prompt cache and steers the model less reliably.

If raw speed is the constraint rather than depth, see whether fast mode is worth it - fast mode changes price-per-token, effort changes token volume.

FAQ#

Is xhigh available on every Claude model?#

No. Opus 4.6 and Sonnet 4.6 support low, medium, high, and max but skip xhigh. It is available on the Fable 5 and 5.1, Opus 5.5, Opus 5, Opus 4.8, Opus 4.7, Sonnet 5 and 5.5, and Haiku 5.5 lines, among others. In Claude Code, setting xhigh on an unsupported model silently falls back to high.

Does higher effort cost more per token?#

No. Per-token rates are fixed per model ($10/$50 for Fable 5, $5/$25 for Opus 4.8 and 4.7) and effort is not a pricing multiplier. Higher effort costs more because the model generates more tokens - more thinking (billed as output even when hidden), more tool calls, longer explanations. Check usage.output_tokens_details.thinking_tokens to see where the spend goes.

What is ultracode, and is it an API effort level?#

It is a Claude Code toggle, not an API level. The API accepts exactly low, medium, high, xhigh, and max. With ultracode on, Claude Code orchestrates dynamic workflows at whichever effort level the session is running at; --effort ultracode is the one entry point that also sets the level to xhigh. It has its own setting and does not persist through effortLevel.

Can I change effort level mid-conversation?#

Yes, on Claude Fable 5.1, Mythos 5.1, Opus 5.5, Opus 5, Sonnet 5.5, and Haiku 5.5 (on the Claude API and Google Cloud; Bedrock covers fewer models), in beta with the mid-conversation-output-config-2026-07-01 header. Add a system message with empty content and output_config.effort set to the new level; it applies from the next user turn and preserves the cached prefix. Fable 5 does not support per-turn effort and returns a 400.

Can my organization cap the effort level?#

Yes. Enterprise admins can set per-role, per-model maximums, and any plan can set the maxEffortLevel managed setting. Levels above the cap are not offered in the picker, and a higher level passed to --effort or /effort runs at the cap instead. When both are configured, the lower cap applies.

What is a task budget and does it replace effort?#

No. A task budget is an advisory token allowance for a whole agentic loop, set as output_config.task_budget with the task-budgets-2026-03-13 beta header and a 20,000-token minimum. Effort controls how deeply Claude reasons per step; the task budget caps total work across the loop. It is a soft hint - Claude can exceed it to finish an action - so pair it with max_tokens for a hard ceiling. It is not available in Claude Code or Cowork.

Does effort change when Claude Code falls back to another model?#

It can. If a safety classifier moves a request to the fallback model, Claude Code keeps the effort level the flagged request ran at instead of the fallback model's default, so an Opus 5.5 session at medium stays at medium on Opus 4.8. Choosing a level, picking a model in /model, or resuming the session later ends the carry-over. This is separate from the fallback for unsupported levels, where setting xhigh on Opus 4.6 silently runs at high.

Should I run Fable 5 at xhigh by default?#

Anthropic says no - start at high, the default. Fable 5's lower effort levels are documented as often exceeding the xhigh performance of prior models, and blanket xhigh gets expensive fast. Move up only when a capability-sensitive task measurably benefits.

What is the default effort level for Claude models?#

high on every effort-capable model except Opus 5.5 and Haiku 5.5, which default to medium. In Claude Code the default varies: Opus 4.7 runs at xhigh, and Opus 5.5, Sonnet 5.5 and Haiku 5.5 run at medium. Setting a level explicitly overrides these defaults.

Does Claude Haiku 5.5 support effort levels?#

Yes. Haiku 5.5 is the first Haiku model with effort, and it accepts all five levels including xhigh and max. It defaults to medium on the API and in Claude Code, where it needs v2.1.293 or later. Anthropic recommends medium for most work, low for chat and simple high-volume requests, and high for longer agent tasks and strict instruction following.

Continue Reading#

• How Claude's Usage Limits Work With Fable 5 - how the effort dial interacts with your 5-hour rolling window
• Ultracode: Claude Code Multi-Agent Orchestration Mode Explained - the toggle that runs at any effort level, and how it differs from ultrathink
• Opus 5.5 vs Sonnet 5.5 vs Haiku 5.5 - which current Claude model to run before you tune its effort level
• Claude Opus 5.5 Developer Guide - why the newest Opus defaults to medium
• Fable 5 vs Opus 4.8: When to Use Which - the completion-rate math behind picking a model, not just an effort level

Sources#

• Effort parameter - Anthropic docs - levels, availability, defaults, Haiku 5.5 guidance, per-message effort and its platform coverage, tool-use behavior (accessed October 9, 2026)
• Steering thinking - Anthropic docs - effort-to-thinking table, soft-guidance framing, max_tokens cost control, billing of thinking tokens, thinking_tokens usage field (accessed October 9, 2026)
• Thinking - Anthropic docs - per-model thinking configuration table, disabled and between_tools limits by effort level (accessed October 9, 2026)
• Task budgets - Anthropic docs - beta header, 20,000-token minimum, advisory behavior, supported models including Haiku 5.5, Claude Code exclusion (accessed October 9, 2026)
• Model configuration - Claude Code docs - /effort command, per-model level tables, defaults, ultracode, organization effort caps, effort after a fallback, _SUPPORTED_CAPABILITIES, version floors and alias history (accessed October 9, 2026)
• Pricing - Anthropic docs - per-model token rates, Haiku 5.5 prompt-length tier, cache multipliers, tokenizer note (accessed October 9, 2026)
• Using Claude Code: Spending your effort - claude.dev blog - Anthropic's Opus 5.5 and Fable 5.1 tests of what each level changes, published September 25, 2026 (accessed October 9, 2026)
• @anthropic-ai/claude-code on npm - current release v2.1.295 on the latest tag, published October 8, 2026 (accessed October 9, 2026)