Claude Opus 5.5 Fast Mode Leaves Preview With No Waitlist

Anthropic took Claude Opus 5.5 fast mode out of research preview on October 15, 2026. Add speed: "fast" to a request and you get up to 2.5x higher output tokens per second at premium pricing, with no waitlist and no beta header.

The question for a project manager is not whether it works. It is whether faster output is worth double the bill, and for which workflows.

What changed on October 15

The API release notes list three changes:

• Fast mode is out of research preview for Opus 5.5. There is no access request, and the fast-mode-2026-02-01 beta header is optional: requests that still send it keep working.
• Opus 5.5 has a default fast mode rate limit in the Start, Build and Scale usage tiers. Evaluation tier organizations need to move up first.
• Fast mode for Opus 5.5 is also available on Claude in Microsoft Foundry, for deployments hosted on Azure.

Fast mode for Opus 5 and Opus 4.8 is still a research preview that needs the beta header and an access request.

What Claude Opus 5.5 fast mode buys you

Per the fast mode docs, it is the same model weights and behavior on a faster inference configuration, so intelligence does not change. The speedup is in output tokens per second, not time to first token.

Fast mode costs $8 input and $40 output per million tokens (MTok), exactly double the $4 and $20 at standard speed, per the pricing page. It applies across the full context window, and prompt caching and data residency multipliers stack on top.

Take a request with 50,000 input tokens and 15,000 output tokens. At standard speed that is $0.20 plus $0.30, so $0.50. In fast mode it is $0.40 plus $0.60, so $1.00.

The docs say "up to" 2.5x, so treat it as a ceiling: a 100-second answer (an illustrative number, measure your own) takes 40 seconds at best.

Where fast mode fits

Use it where a person or a loop sits waiting on long output:

• Interactive coding sessions, such as large refactors.
• Agent loops where each step writes a lot of text and the next step waits on it.

Skip it elsewhere:

• Short replies, which gain little because time to first token does not change.
• Bulk or overnight jobs, where nobody watches the clock.

Turn it on and confirm it worked

This Python sketch tries fast mode first and drops to standard speed if the fast lane is full:

import anthropic

client = anthropic.Anthropic()


def ask(prompt: str):
    params = dict(
        model="claude-opus-5-5",
        max_tokens=4096,
        messages=[{"role": "user", "content": prompt}],
    )
    try:
        # max_retries=0: fail fast on a fast-mode rate limit instead of waiting
        return client.with_options(max_retries=0).messages.create(speed="fast", **params)
    except anthropic.APIStatusError as e:
        if e.status_code not in (429, 529):
            raise
    return client.messages.create(**params)  # standard speed, default retries


response = ask("Refactor this module to use dependency injection")
print(response.usage.speed)  # "fast" or "standard"

A fast request that exceeds the fast mode rate limit or capacity returns a 429 or 529 rather than quietly running slow, so you need a fallback policy. usage.speed reports which speed a response actually used, so log it with cost. The docs' full fallback example also retries 5xx errors.

Fast mode has its own rate limit, separate from standard Opus. These response headers show where you stand:

curl -s -D - -o /dev/null https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{"model": "claude-opus-5-5", "max_tokens": 64, "speed": "fast", "messages": [{"role": "user", "content": "Hello"}]}' \
  | grep -i '^anthropic-fast'

This prints the anthropic-fast-input-tokens-* and anthropic-fast-output-tokens-* limit, remaining and reset headers.

Gotchas before you commit

• Switching speed costs you the prompt cache. Requests at different speeds do not share cached prefixes, so a fallback or a mid-session flip re-reads your whole prefix uncached. Pick one speed per session.
• 429s come with a retry-after header. The SDK retries twice by default and the wait is usually short. Setting max_retries to 0 skips the wait but also disables retries for other transient errors.
• Some places are off the list. No Batch API, no Priority Tier, no Claude Platform on AWS, and no Claude in Microsoft Foundry deployments hosted on Anthropic.

What to do on Monday morning

1. Confirm your organization is above the Evaluation tier in the Claude Console, then pick one interactive workflow where someone waits on long output.
2. Put speed behind a config flag and log usage.speed plus cost per finished task for a week.
3. Agree with your team what happens on a 429: wait, or fall back to standard.
4. Compare minutes saved against the doubled token bill, and keep fast mode only where the minutes are worth it.

Fast mode turns latency into a setting you can price per task, which is what you need before deciding whether a production agent should pay for speed.