Claude Code Effort Levels Explained (2026)

TL;DR + the two dials

Effort level is a Claude Code setting, separate from model choice, that controls how much work Claude does on a single turn — how many files it reads, how much it verifies, and how far it pushes through a multi-step task before checking in with you. Model choice picks the weights that answer you; effort picks how hard those weights work this turn. Anthropic’s own comparison showed the high-effort path generating roughly 7x more tokens than a lower level on the identical prompt.

Three things explain most of the “Claude Code got expensive” feeling that spread across Hacker News and Reddit in late June and early July 2026:

• Opus 4.8 defaults to high effort. It is also the default model on Max, Team Premium, and pay-as-you-go plans, so upgrading did nothing and your next session ran hotter by default.
• Effort is part of the cache key. Switching it mid-session, like switching models, forces a full-price, uncached re-read of your entire conversation on the next turn.
• Some of the burn has nothing to do with effort. Tool-schema bloat and expired prompt caches show up as the same symptom — quota draining faster — with a different fix.

This post covers all three, plus a decision table for picking model and effort by task, and what to change first if your quota is disappearing faster than your workflow changed.

Why your Claude Code bill jumped

The clearest data point is a developer’s own usage logs, not a rumor. Vincent Schmalbach tracked his raw (non-cached) Opus input-plus-output tokens across three weekly windows on the same machine, doing the same kind of work: two prior heavy weeks logged 8.9M and 8.5M tokens; the current week logged 1.4M — about a sixth of the earlier weeks, for a subscription whose price had not changed (Claude Code Quietly Got 5x More Expensive, June 30, 2026). His post reached the front page of Hacker News under the title “Claude Code Just Got 5x More Expensive.”

Anthropic’s own changelog explains the biggest lever. The entry for v2.1.154 (May 28, 2026) reads: “Opus 4.8 is here! Now defaults to high effort · /effort xhigh for your hardest tasks.” Opus 4.8 is also the account-type default model on Max, Team Premium, and Enterprise pay-as-you-go plans. Two defaults changed at once: which model answers you, and how hard it works by default. Neither is a per-token price change — Anthropic’s published API rates did not move — but the token bill for a “normal” session went up because “normal” now means more verification and more tool calls per turn.

The community reaction wasn’t unanimous, which is itself informative. One HN commenter reported burning a $50 overage limit in an hour, then a further $10 in about 30 minutes, and switched back to the previous model. Another, in the same thread, reported the opposite: fewer tokens for the same outcome on 4.8, just faster. Both experiences are plausible — effort and verbosity vary by task, and a chatty multi-agent workflow burns very differently than a single focused session. The section on community signal below covers both sides in more depth.

Effort vs. model: two independent dials

Anthropic’s own framing, from the July 7, 2026 explainer: model choice determines which set of frozen weights handles your request — the foundational capability. Effort level determines how much work Claude decides to do for each turn with those weights. They are set independently, with /model and /effort, and Claude Code’s own docs are explicit that a session’s cost is a function of both, not either alone.

MODEL  (which weights answer you)
Haiku ──── Sonnet 5 ──── Opus 4.8 ──── Fable 5
 cheap, fast                    deepest reasoning,
                                 longest sessions

EFFORT  (how hard that model works this turn)
low ──── medium ──── high (default) ──── xhigh ──── max
 fewer tool calls,                     more verification,
 terser answers                        more checking-in

Your token bill is a function of BOTH axes together.

A concrete example from the same explainer: run the identical prompt at two effort levels, and the high-effort path generates roughly 7x more tokens to reach a higher-confidence answer — more files read, more verification, more turns before Claude checks back in with you. That multiplier is illustrative for one worked example, not a universal constant, but it is the right order of magnitude to expect between a low-effort skim and a high-effort, fully-verified pass on the same task.

Takeaway: if your bill jumped, ask which dial moved — a model swap, an effort default, or both — before assuming Anthropic changed what a token costs.

The five effort levels, straight from the docs

Anthropic publishes an explicit effort-levels table.high is the API default — setting it explicitly to high produces the exact same behavior as omitting the parameter entirely.

Model support varies: Fable 5, Sonnet 5, Opus 4.8, and Opus 4.7 support all five levels. Opus 4.6 and Sonnet 4.6 stop at max with no xhigh — ask for xhigh on those and Claude Code quietly runs high instead. The default is high everywhere except Opus 4.7, which defaults to xhigh. low, medium, high, and xhigh persist across sessions once set; max applies to the current session only.

Setting it takes one of several forms:

/effort              # open the interactive slider
/effort xhigh        # set directly
/effort auto         # reset to the model's default
claude --effort low  # set for a single session at launch
CLAUDE_CODE_EFFORT_LEVEL=high  # env var, takes precedence over all else

Two related but distinct commands worth knowing: ultrathink, a keyword you drop anywhere in a single prompt for one-off deeper reasoning on that turn without touching your saved session effort, and ultracode, a Claude-Code-only setting (not an API effort level) that runs xhigh plus standing permission for Claude to orchestrate multi-agent workflows on substantive tasks. Confusing the two is a common mistake: ultrathink is cheap and scoped to one turn; ultracode changes behavior for the whole session.

To see what any of this actually costs, run /usage after a session. On an API key it shows a real dollar estimate; subscribers see plan usage bars instead, since usage is included in the plan rather than billed per token:

Total cost:            $0.55
Total duration (API):  6m 19.7s
Total duration (wall): 6h 33m 10.2s
Total code changes:    0 lines added, 0 lines removed

The cache-invalidation trap

This is the part most cost-shock write-ups miss, and it is documented plainly in Claude Code’s prompt caching reference: both the model and the effort level are part of the cache key. Change either one mid-conversation, and the next request reads your entire conversation history with zero cache hits — the same expensive, slow turn as switching models outright. Claude Code shows a confirmation dialog before applying an effort change that would do this, which is your one warning before the bill lands.

Cache reads are billed at roughly 10% of the standard input rate; a cache write costs a premium on top of that (1.25x for a five-minute TTL, 2x for a one-hour TTL). A cache miss means none of that discount applies — you pay full input price for content you had already paid to process once. The official guidance is blunt about the fix:

Pick your model and effort level at the top of a session, then save /compact for natural breaks between tasks. The fewer changes you make mid-task, the higher your cache hit rate.

A few other actions invalidate the cache the same way: turning on fast mode, connecting or disconnecting an MCP server whose tools load into the prompt prefix rather than being deferred, denying an entire tool, and compacting the conversation on purpose. Subagents get their own cache from a cold start every time, and it always runs on the shorter five-minute TTL, even inside a subscription session that otherwise gets the one-hour TTL for free.

Takeaway: deciding “this task needs xhigh” once, at the start, is close to free relative to deciding it, backing off to medium three turns later, then bumping back to high — each switch is a fresh full-price read of everything that came before it.

Decision table: task type → model + effort

Built directly from Anthropic’s published per-level guidance, mapped onto the kind of work a Claude Code session actually does:

For the deeper version of the model side of this table — when Fable 5 specifically earns its cost over Opus, and how to override the model per subagent — see our Fable 5 routing guide.

Cost-control tactics that actually move the needle

Effort is one lever. Anthropic’s own cost- management docs list several others, in roughly descending order of impact for a typical session:

• Trim context, not just effort. Run /clear between unrelated tasks instead of dragging stale context into the next one, and keep CLAUDE.md under roughly 200 lines — move workflow-specific instructions into skills that load only when invoked. We cover the full trim-and-checkup workflow in our /checkup guide.
• Match model to task, every time, not just once. Sonnet handles most coding well for less than Opus; reserve Opus or Fable 5 for genuinely hard reasoning; set model: haiku in subagent frontmatter for simple delegated work.
• Reduce MCP overhead. Tool definitions are deferred by default so only names enter context until a tool is actually used, but a server that skips deferral, or one you never use, still costs tokens on every turn. Run /mcp to see what is configured and disable what you don’t need — the mechanics of tool-list bloat specifically are covered in our MCP context bloat piece.
• Offload verbose output to hooks. A PreToolUse hook that greps a 10,000-line test log down to the failing lines before Claude ever sees it turns tens of thousands of wasted tokens into a few hundred useful ones.
• Write specific prompts. “Improve this codebase” triggers broad scanning at whatever effort level is set; “add input validation to the login function in auth.ts” lets Claude work narrowly regardless of effort.
• Use plan mode on anything non-trivial. Shift+Tab before implementation lets Claude propose an approach before spending tokens on the wrong one — cheap insurance against expensive rework.

For scale: Anthropic’s own published enterprise figures put average Claude Code cost around $13 per developer per active day and $150–250 per developer per month, with 90% of users staying under $30 on their heaviest day. That is the baseline the tactics above are trying to protect, not blow past.

Subagents: where they help, where they hurt

Subagents are genuinely one of the better cost levers available, and also one of the easiest to misuse. Delegating a verbose operation — running a test suite, fetching documentation, triaging a huge log — to a subagent keeps that noise in the subagent’s own context and returns only a summary to your main conversation. Set CLAUDE_CODE_SUBAGENT_MODEL=haiku (or the per-subagent model frontmatter field) and routine delegated work runs on the cheapest capable model instead of inheriting your main session’s model and effort.

Agent teams — several Claude Code instances working a task in parallel — are the other side of that coin. Anthropic’s cost docs note agent teams use roughly 7x more tokens than a standard session when teammates run in plan mode, because each teammate holds its own context window and runs as a separate instance. That is a different 7x than the effort-level example above — same order of magnitude, unrelated mechanism — and it compounds with a high-effort default rather than replacing it.

A Reddit thread put a real number on that compounding: one $200/month Max-plan user watched their five-hour window last 3–4 hours on Opus 4.5 for a given workflow, then drop to 30–35 minutes on Opus 4.6 with Agent Teams enabled for the same kind of work (r/ClaudeAI, 400+ upvotes). Their own fix, after testing: revert to the smaller model for routine work, and stop using Agent Teams by default — “too chatty,” in their words.

Takeaway: subagents cut cost when they isolate noisy work on a cheap model; they inflate it when a whole team of teammates duplicates a high-effort context each. Keep teams small and short-lived, and shut a teammate down the moment its job is done.

What people are building to route around this

The cost shock produced a small wave of third-party tools that route prompts to cheaper models automatically instead of relying on manual /effort and /model discipline. Worth knowing about, not necessarily worth adopting sight unseen — these are independent projects, unaffiliated with Anthropic, and the savings figures below are each project’s own claim rather than something we independently benchmarked:

• workweave/router — a model router for agentic systems that claims to route each prompt to an appropriate model in under 50ms, marketed as a drop-in endpoint swap.
• Kulaxyz/token-diet — an always-on token-efficiency skill that targets Claude Code, Codex, Cursor, Windsurf, and Cline alike, aimed at trimming context rather than swapping models.
• Nanako0129/pilotfish — a multi-model orchestration layer built specifically for Claude Code: a frontier model plans and reviews, cheaper models execute the volume work, with a verification pass guarding quality.

All three are reacting to the same gap: Claude Code gives you the dials (/model, /effort, subagent overrides) but expects you to operate them manually. If you want that routing logic without a third-party dependency, the native path — opusplan, subagent model overrides, and Fable-5-specific routing — is covered in full in our Fable 5 routing guide.

What we got wrong

A few assumptions we had to correct while researching this piece:

• We assumed the “5x more expensive” framing meant a price change. It doesn’t. Every source we checked, official and third-party, confirms per-token API pricing is unchanged. What moved is what a default session spends — a behavior change, not a rate-card change, though the effect on your bill is identical either way.
• We assumed switching effort mid-task was free, like a volume knob. It is not. It is a cache-invalidating action with the same cost profile as switching models outright — see the cache-invalidation trap above. Committing to a level at the start of a session is measurably cheaper than adjusting it as you go.
• We assumed low effort meant proportionally lower quality everywhere. It is model-relative. Anthropic’s own guidance states that lower effort settings on Fable 5 “still perform well and often exceed xhigh performance on prior models” — the effort scale is calibrated per model, so the same level name is not the same underlying capability across models.

Community signal

The reaction was immediate once higher effort — and the token bill that rides on it — became the default for a model generation. The bluntest example was a Hacker News thread, “Claude Code Just Got 5x More Expensive,” capturing the sticker shock of watching the same task burn far more tokens with no obvious change on the user’s side.

The most useful contrarian voice we found wasn’t arguing Anthropic is blameless; it was arguing the cause is more addressable than “they’re squeezing power users.” A developer on r/ClaudeCode built a local token-usage auditor across 858 sessions and roughly 18,900 turns (an estimated $1,619 over 33 days) and found that just over half of their turns followed an idle gap longer than five minutes — each one paying full, uncached price on resumption. Cache expiry, in their own data, was the single biggest waste category, ahead of tool-schema bloat and redundant file reads. Their fix was a Stop hook plus a UserPromptSubmit hook that warns before an idle-triggered, full-price turn fires — a homegrown version of the “protect your cache” advice above.

Not every complaint traces back to effort or caching. On r/ClaudeAI, a 400-plus-upvote thread traced a 10x usage jump to Opus 4.6’s output verbosity and Agent Teams specifically, and resolved it by reverting to the prior model for routine work — a reminder that model choice and team size are levers independent of effort. Anthropic’s own explainer post reached Hacker News too, as a direct submission of the blog covered throughout this piece.

The verdict

Frequently Asked Questions

Glossary

Sources

• Primary — Anthropic, “Choosing a Claude model and effort level in Claude Code” (July 7, 2026): claude.com/blog/claude-model-and-effort-level-in-claude-code
• Primary — effort-level API reference: platform.claude.com/docs/en/build-with-claude/effort
• Primary — Claude Code model configuration (effort levels, aliases, opusplan): code.claude.com/docs/en/model-config
• Primary — prompt caching mechanics and invalidation triggers: code.claude.com/docs/en/prompt-caching
• Primary — cost tracking and reduction strategies: code.claude.com/docs/en/costs
• Primary — Claude Code changelog, v2.1.154 (May 28, 2026): code.claude.com/docs/en/changelog
• Community — “Claude Code Just Got 5x More Expensive”: Hacker News · source article
• Community — official explainer mirrored to Hacker News: item 48824259
• Community — “anthropic isn’t the only reason you’re hitting claude code limits”: r/ClaudeCode
• Community — “Is anyone else burning through Opus 4.6 limits 10x faster than 4.5?”: r/ClaudeAI
• Cost-routing tools referenced (third-party, unaffiliated with Anthropic): workweave/router, Kulaxyz/token-diet, Nanako0129/pilotfish
• Related guides: Fable 5 routing guide · MCP context bloat fix · /checkup command guide
• Client reference: mcp.directory/clients/claude-code