# Why fast mode isn't a lower effort level

> Fast mode buys up to 2.5x speed on Opus for a flat ~2x per-token premium with no quality change; lower effort cuts tokens instead. Two controls that stack.

URL: https://bartlomiejkrupa.dev/articles/claude-effort-thinking-fast-mode/
Published: 2026-07-21
Updated: 2026-10-07
Tags: claude, claude-code, effort, extended-thinking, fast-mode, cost-optimization
Summary: Fast mode buys up to 2.5x speed on Opus for a flat ~2x per-token premium with no quality change; lower effort cuts tokens instead. Two controls that stack.

Effort level, extended-thinking budget, and fast mode are three separate controls on a Claude session, not one setting. Effort scales every token Claude spends - text, tool calls, and thinking together. Thinking budget caps reasoning tokens specifically, but only on models still running the older fixed-budget mode. Fast mode changes neither: it pays a flat $10/$50 per-million-token premium on Opus 5 and Opus 4.8 for the same model to answer up to 2.5x faster. Anthropic's own docs recommend stacking them, not picking one.

## Definitions

**Effort** - a parameter (`low`/`medium`/`high`/`xhigh`/`max`) that scales how many tokens Claude spends on a response: text, tool calls, and any thinking together. It works with or without extended thinking turned on.

**Extended thinking (adaptive reasoning)** - the reasoning Claude emits before responding. Recent models decide per step whether and how much to think; older models use a manually set token budget instead.

**Fast mode** - a Claude Code setting that runs Opus through a different API configuration prioritizing speed over cost. Same model, same weights, same output quality - just faster and pricier per token.

**MTok** - one million tokens, the unit Anthropic's per-token prices are quoted against ("$10 per MTok" means $10 per million tokens).

## The levers at a glance

| Lever | What it scales | Cost effect | Latency effect | How to set it |
| --- | --- | --- | --- | --- |
| Effort level | All response tokens: text, tool calls, thinking | Lower level = fewer tokens = lower cost | Usually faster at lower levels | `/effort`, `--effort`, `CLAUDE_CODE_EFFORT_LEVEL`, `effortLevel` |
| Thinking budget | Reasoning tokens only, fixed-budget models only | Thinking bills as output tokens; lower budget = lower cost | Lower budget = faster | `MAX_THINKING_TOKENS`, `CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING` |
| Fast mode | Nothing - same tokens, same quality | Flat premium, roughly 2x standard: $8/$40 on Opus 5.5, $10/$50 on Opus 5 and 4.8 | Up to 2.5x faster | `/fast`, `fastModePerSessionOptIn` |

## Effort level: the token-spend dial

Effort is a behavioral signal, not a hard token cap - at low effort Claude still thinks on a genuinely hard step, just less than it would at high effort on the same step. It affects every token in the response, which is what makes it different from a thinking-only control: lower effort also means fewer tool calls and terser explanations, not just less reasoning.

| Level | What it trades | Typical use |
| --- | --- | --- |
| `max` | No constraint on token spend | Frontier problems, deepest reasoning |
| `xhigh` | Extended capability for long-horizon work | Agentic/coding tasks over 30 minutes, million-token budgets |
| `high` (default on most models) | Balanced depth and cost | Complex reasoning, difficult coding, agentic tasks |
| `medium` | Moderate token savings | Agentic work trading some depth for speed and cost |
| `low` | Biggest savings, some capability loss | Simple, latency-sensitive tasks - Anthropic names subagents explicitly |

Level availability and defaults vary by model: Fable 5.1, Fable 5, Opus 5.5, Sonnet 5.5, Opus 5, Sonnet 5, Opus 4.8, and Opus 4.7 support all five levels; Opus 4.6 and Sonnet 4.6 skip `xhigh` but keep `low`/`medium`/`high`/`max`. In Claude Code the default is `high`, except that Opus 5.5 and Sonnet 5.5 default to `medium` and Opus 4.7 to `xhigh`. Model choice and effort choice are two separate decisions - [Why most agents default to the wrong Claude tier](/articles/claude-model-tier-comparison) covers picking the tier itself.

Set it through any of:

- `/effort` - opens a slider, or takes a level name directly; `/effort auto` resets to the model default
- `--effort <level>` - sets it for one CLI session
- `CLAUDE_CODE_EFFORT_LEVEL` environment variable - highest precedence, overrides everything else
- `effortLevel` in `settings.json` - a persistent default (accepts `low`/`medium`/`high`/`xhigh`, not `max` or `ultracode`; a top-level `effortLevel` doesn't apply to Opus 5.5 - set a per-model level in `modelSettings` instead)
- `effort:` in a skill or subagent's frontmatter - overrides the parent session's level while that skill or subagent runs, but not the environment variable

`ultracode` sits in the `/effort` menu but isn't a sixth level: it sends `xhigh` to the model and lets Claude Code orchestrate multiagent workflows for a substantive task, session-only. `ultrathink`, dropped anywhere in a prompt, requests deeper reasoning for that one turn without touching the session's effort setting at all.

On the API directly, the same parameter lives under `output_config`:

```python
from anthropic import Anthropic

client = Anthropic()

response = client.messages.create(
    model="claude-sonnet-5",
    max_tokens=4096,
    messages=[{"role": "user", "content": "Analyze the trade-offs between microservices and monolithic architectures"}],
    output_config={"effort": "medium"},
)
```

## Extended thinking: adaptive vs. fixed budget

The Fable models, Sonnet 5 and later, and Opus 4.7 and later always use adaptive reasoning - the model decides per step whether to think and how much, guided by effort level. On these models, a nonzero `MAX_THINKING_TOKENS` value is ignored; effort is the only real dial. Opus 4.6 and Sonnet 4.6 default to adaptive too, but can revert to the older fixed-budget mode with `CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING=1`, at which point `MAX_THINKING_TOKENS` sets an actual token ceiling on reasoning.

One control cuts across both modes: `MAX_THINKING_TOKENS=0` turns thinking off entirely on the Anthropic API, with three exceptions. Opus 5.5, Sonnet 5.5, and the Fable models cannot disable thinking under any setting - the session toggle, `alwaysThinkingEnabled`, and `MAX_THINKING_TOKENS=0` all have no effect there.

Thinking tokens bill as output tokens whether or not you ever look at them - collapsed by default, expandable with `Ctrl+O`. That's the direct link to cost: a model defaulting to `high` effort with adaptive reasoning can spend tens of thousands of thinking tokens on a request before it writes a single word of visible output.

```bash
# Session-wide spend dial (Claude Code only; on adaptive models this is the only thinking control)
export CLAUDE_CODE_EFFORT_LEVEL=medium

# Fixed-budget models only: revert from adaptive, then set a token ceiling
export CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING=1
export MAX_THINKING_TOKENS=8000
```

## Fast mode: paying for latency

Fast mode is a research-preview Claude Code setting, Opus-only, that runs the same model through a different API configuration prioritizing speed. It is not a cheaper or smaller model - output quality is identical, and the only thing that changes is how fast tokens arrive and how much each one costs.

| Model | Fast mode input / output ($/MTok) | Speedup |
| --- | --- | --- |
| Opus 5.5 | $8 / $40 | Up to 2.5x |
| Opus 5 | $10 / $50 | Up to 2.5x |
| Opus 4.8 | $10 / $50 | Up to 2.5x |
| Opus 4.7 | Removed 2026-07-24 | - |

Toggle it with `/fast`, or set `"fastMode": true` in your settings file. Fast mode on Opus 4.7 was deprecated 2026-06-25 and removed 2026-07-24 - switching to Opus 4.7 now turns fast mode off. Migrate to Opus 5.5 (`claude-opus-5-5`, the Claude Code fast-mode default since v2.1.280; Opus 5 was the default from v2.1.219), Opus 5, or Opus 4.8. The base `claude-opus-4-7` model still runs at standard speed and pricing. Either way, once it's on it carries over into future sessions by default - Claude Code remembers however you last left it. The first fast-mode message in a conversation pays the full, uncached fast-mode input price for the *entire* existing context - not just the new message - so turning fast mode on at the start of a session is cheaper than switching mid-conversation. That cost applies once per conversation; toggling it off and back on later doesn't repeat it.

Turning it on also requires usage credits, and for Team and Enterprise organizations, explicit enablement by an Owner - it's off by default at the org level even when available on the plan. `fastModePerSessionOptIn: true` in settings overrides the default carry-over: every new session starts with fast mode off, no matter what you set last time.

```json
{
  "fastMode": true,
  "effortLevel": "medium"
}
```

## Combine them

Fast mode and effort level solve different problems, and the docs are explicit that you can run both at once:

| Setting | Effect |
| --- | --- |
| Fast mode | Same model quality, lower latency, higher cost |
| Lower effort level | Less thinking and fewer tool calls, faster responses, potentially lower quality on complex tasks |

For maximum speed on a straightforward task, stack low effort with fast mode: fewer tokens generated, and each one arrives faster. For a task where quality matters more than either speed or cost, drop fast mode and raise effort instead - paying more per token for identical output makes no sense next to a setting that changes what the model actually produces. Model choice still sits underneath both: [Claude Opus 5 closes on Fable at Opus price](/articles/claude-opus-5), [Claude Sonnet 5 closes the gap to Opus without the Opus bill](/articles/claude-sonnet-5), and [Claude Fable 5: refusals are an API contract, not an error](/articles/claude-fable-5) cover the per-model effort defaults these two levers ride on top of.

The garden rule [Effort vs fast mode](/notes/effort-vs-fast-mode) is the one-liner: they stack, they do not substitute.

Effort and fast mode are two of several levers for cutting what an agent costs to run - [Stop paying full price for repeat LLM calls](/articles/llm-cost-optimization) covers the other three: prompt caching, batching, and model-tier routing, which stack with everything here.

Sources:
- Speed up responses with fast mode: https://code.claude.com/docs/en/fast-mode
- Model configuration: https://code.claude.com/docs/en/model-config
- Effort: https://platform.claude.com/docs/en/build-with-claude/effort
- Pricing: https://platform.claude.com/docs/en/about-claude/pricing