Claude Opus 5.5 in Claude Code: Defaults, Effort, and Cost

September 23, 2026 claude-codecosts

Claude Code 2.1.280 (published to npm on September 22, 2026) added Claude Opus 5.5 and pointed two things at it: the opus alias, and the default model on Pro, Max, Team, Enterprise and Anthropic API accounts, plus Claude Platform on AWS, Amazon Bedrock and Google Cloud's Agent Platform. The model is priced at $4 per million input tokens and $20 per million output, it has a 1M-token context window with no [1m] variant needed, and its effort level starts at medium instead of high. Thinking cannot be turned off on it.

We ran nine headless turns on 2.1.280 to check what the alias resolves to, what one turn costs on Opus 5.5 against Opus 5, whether the cost line in the JSON result reconciles with the published rates, and how the four effort levels move output tokens on one fixed task. Verified September 23, 2026 against the Claude Code model configuration, prompt caching and changelog pages, and the platform pricing, models overview, Opus 5.5 model, What's new, and migration guide pages.

What changed in 2.1.280

• opus resolves to Opus 5.5 on the Anthropic API, Claude Platform on AWS, Bedrock and Google Cloud. Before 2.1.280 it resolved to Opus 5 (since 2.1.219), and before that to Opus 4.8.
• default resolves to Opus 5.5 on Pro, Max, Team, Enterprise and the API, and on AWS, Bedrock and Google Cloud. Microsoft Foundry stays on Sonnet 4.5. Pro and Team Standard previously defaulted to Sonnet 5, so those plans see a model change as well as a version change.
• Effort starts at medium on Opus 5.5. Every other effort-capable model starts at high except Opus 4.7 (xhigh). A level you saved before /effort became per-model does not carry over.
• Thinking is always on. The session toggle, alwaysThinkingEnabled and MAX_THINKING_TOKENS=0 have no effect on Opus 5.5; the model decides how much to think from the effort level.
• Safety-classifier fallback. When a classifier flags a request on Opus 5.5, biology-flagged requests re-run on Opus 5 and cybersecurity-flagged requests on Opus 4.8, with a notice in the transcript.
• Requires 2.1.280 or later. On an older build the alias keeps resolving to Opus 5; run claude update.

An organization default model set by an Enterprise admin, or a managed availableModels allowlist that excludes Opus 5.5, overrides all of the default behaviour above. If your /model picker shows something other than Opus 5.5 after updating, that is the first place to look.

What opus resolves to now

The JSON result of a -p run names the model that actually served the request under modelUsage, with its context window. This is the whole check:

claude -p "Reply with the single word OK." --model opus --output-format json --tools ""

Trimmed result on our machine:

{
  "modelUsage": {
    "claude-opus-5-5": {
      "inputTokens": 2,
      "outputTokens": 4,
      "cacheCreationInputTokens": 9306,
      "cacheReadInputTokens": 0,
      "costUSD": 0.074536,
      "contextWindow": 1000000,
      "maxOutputTokens": 128000,
      "canonicalModel": "claude-opus-5-5",
      "costBasis": "list"
    }
  }
}

The context window is 1,000,000 with the plain opus alias. On the Anthropic API, Opus 4.7 and later run with the 1M window on every plan, including Pro, and the docs say you do not select a [1m] variant for them. opus[1m] still exists as an alias, but on Opus 5.5 it selects the window the model already has.

The rates, and what one turn actually cost

Opus 5.5 is cheaper than Opus 5 on every line, and the cache-read line drops the most: Opus 5.5 charges 0.05x the input price for a cache hit, where every other current model except Fable 5.1 charges 0.1x.

Long context is standard pricing on both: a 900k-token request bills at the same per-token rate as a 9k one.

We sent the same one-word prompt to each model with every tool disabled, so the prompt is almost entirely the system prompt. Costs are the total_cost_usd Claude Code reports, which it labels costBasis: "list": list price, not what a subscription bills you.

Two things in that table are easy to misread.

First, the cold turns cost more than $4 or $5 per million implies, because a cold turn is a cache write, and ours were one-hour writes: usage.cache_creation in the result reported every written token under ephemeral_1h_input_tokens and zero under ephemeral_5m_input_tokens. Claude Code requests the one-hour TTL for the main conversation on a Claude subscription inside the plan's included usage; on an API key or a cloud provider it requests five minutes unless you set promptCacheTtl to 1h. At the five-minute rate the same Opus 5.5 turn would have been $0.0466. Our prompt caching guide covers the TTL rules.

Second, the arithmetic is exact. For all nine runs, input tokens at $4, output at $20, one-hour writes at $8 and reads at $0.20 (or the Opus 5 equivalents) reproduced costUSD to the seventh decimal place. The 0.05x cache read is already in Claude Code's cost table, so the /cost and status-line figures you see on Opus 5.5 reflect it.

The fully cached turn is the number to plan with for long sessions: 9,306 tokens of system prompt read back for $0.0019. On Opus 5 the same read would be $0.0048 at $0.50 per million.

Effort starts at medium

Three rules from the model configuration page decide which effort an Opus 5.5 session runs at:

1. An explicit choice wins: CLAUDE_CODE_EFFORT_LEVEL, --effort, or /effort in the session.
2. Then your saved level for the model (modelSettings in user settings) or an effortLevel key in project, local or managed settings, or in a file passed with --settings. A top-level effortLevel in your user settings file does not count for Opus 5.5: that key is the older form /effort wrote before levels were saved per model, and models released from Opus 5.5 on ignore it.
3. Otherwise the model default, which is medium on Opus 5.5.

The practical consequence: a level you tuned on Opus 5 with /effort is saved under Opus 5's entry in modelSettings, and Opus 5.5 starts fresh at medium until you pick a level for it. The changelog says the same thing from the other direction: an effort saved before /effort became per-model no longer applies to newly released models.

We ran one small fixed task at each of the four persistent levels to see how much the level moves on this model. The prompt asked for every prime between 90 and 130, comma separated and nothing else; all four runs returned the same correct seven numbers.

The JSON result does not name the effort level a run used, so the default row is unlabelled. Our user settings held no effort level for any model, no --effort flag was passed, and the row sits between low and high, which is consistent with the documented medium default. The cost differences are small here because the task is small and the prompt was cached; on real work, effort scales the thinking, the number of tool calls and the visible reply together. Our effort levels guide has the saving rules and the maxEffortLevel cap.

Thinking cannot be turned off

On Opus 5, MAX_THINKING_TOKENS=0 turned thinking off and lowered output spend. On Opus 5.5 the environment variable, the /config toggle and alwaysThinkingEnabled all do nothing, and the costs page says so directly. Effort is the only lever. In the sweep above, low produced zero thinking tokens on the trivial task, so low is the closest thing to "off" for short, scoped work. Anthropic's own guidance in the effort table is to reserve low for tasks that are not intelligence-sensitive.

If you call the API yourself, the same change is a breaking one: a request with thinking: {"type": "disabled"} or a budget_tokens value returns a 400 on claude-opus-5-5. The migration guide has the replacement (output_config with an effort value), along with the other three breaking changes: forced tool use (tool_choice of any or tool) returns an error, thinking blocks are tied to the model and the conversation, and the computer_20251124 tool is not accepted on the Claude API or Google Cloud. Claude Code and the Agent SDK already keep conversations append-only, which is what the thinking-block rule needs, and their thinking toggles simply do nothing on this model; you meet the four changes in your own Messages API code, not in the CLI.

Pin it, or stay on Opus 5

Aliases update over time. To pin:

• Pin Opus 5.5: claude --model claude-opus-5-5, or "model": "claude-opus-5-5" in a settings file. The dateless ID is a fixed snapshot.
• Keep opus on Opus 5: set ANTHROPIC_DEFAULT_OPUS_MODEL=claude-opus-5. The alias, opusplan, and the account-type default all follow it.
• One session on Opus 5: claude --model claude-opus-5, or /model claude-opus-5 inside the session. In a -p run, /model applies to that session only.
• Pro or Team Standard, back to Sonnet: /model sonnet and confirm, or ANTHROPIC_DEFAULT_MODEL=sonnet (2.1.236 or later) to make new sessions start there.

Switching models mid-session while the cache is warm prompts for confirmation in the terminal, because the new model cannot read the old model's cache. That is the one place the Opus 5.5 rollout costs a cache miss.

The Agent SDK reached parity in 0.3.280 on the same day. The model option takes the same aliases and IDs, so an SDK app that passes "opus" moved to Opus 5.5 when it picked up 0.3.280, and one that pinned "claude-opus-5" did not.

FAQ

Is Opus 5.5 cheaper than Opus 5 in Claude Code?

Yes, on every rate: $4 against $5 input, $20 against $25 output, $0.20 against $0.50 per million cached tokens read. Our cold one-word turn cost $0.0745 on Opus 5.5 and $0.1032 on Opus 5, a 28 percent difference, part of which is the Opus 5.5 system prompt being about 1,000 tokens shorter in that run.

Why did my first turn cost more than $4 per million tokens?

Because a first turn is a cache write, not an input read. On a subscription Claude Code writes the main conversation's cache with the one-hour TTL at $8 per million; on an API key it writes five-minute entries at $5. Run claude -p "hello" --output-format json and read usage.cache_creation to see which bucket your writes landed in.

Do I need opus[1m] for the 1M context window?

No. Opus 5.5 reports a 1,000,000-token context window under the plain opus alias, and the docs say the [1m] variant is not something you select on Opus 4.7 and later. The variant matters only for Opus 4.6 and Sonnet 4.6.

Will my saved effort level carry over to Opus 5.5?

Not unless it was set in project, local or managed settings, or through CLAUDE_CODE_EFFORT_LEVEL. A level saved with /effort is stored per model, and a top-level effortLevel in user settings is ignored for Opus 5.5. Pick a level once in /effort or the /model slider and it is saved for this model.

Why did Claude Code switch me to Opus 5 or Opus 4.8 mid-session?

A safety classifier flagged the request. Biology-flagged requests re-run on Opus 5 and cybersecurity-flagged requests on Opus 4.8, with a notice in the transcript. Penetration-testing and CTF work triggers this often, sometimes on the first request.

Which Claude Code version do I need?

2.1.280 or later. Opus 5 needs 2.1.219 and Sonnet 5 needs 2.1.197. Check with claude --version and upgrade with claude update.

How we measured

Nine claude -p runs on Claude Code 2.1.280, Windows 11, a Claude subscription account, all on September 23, 2026. Each run used --output-format json, --tools "", --disallowedTools "mcp__*" and --strict-mcp-config, in an empty working directory with stdin closed, so every arm saw the same system prompt with no tool schemas or MCP servers in it. Model resolution and the context window came from modelUsage in the result; the TTL from usage.cache_creation; costs from total_cost_usd, reconciled against the platform pricing page's rates for each model. The effort sweep passed --effort low, high and xhigh, and no flag for the default row. Total list-price spend for the nine runs was $0.51.

# alias resolution and context window
claude -p "Reply with the single word OK." --model opus \
  --output-format json --tools "" --disallowedTools "mcp__*" --strict-mcp-config

# effort sweep, one level at a time
claude -p "List every prime number between 90 and 130 in ascending order, comma separated, and nothing else." \
  --model claude-opus-5-5 --effort low \
  --output-format json --tools "" --disallowedTools "mcp__*" --strict-mcp-config

If you re-run this on an API key, expect ephemeral_5m_input_tokens instead of the one-hour bucket and cold turns at $5 per million written rather than $8. Everything else should reproduce.