Claude Fast Mode Guide (2026): Fable 5.2 Speed, Price, Setup and When It Pays Off

On November 9, 2026, Anthropic added fast mode to Claude Fable 5.2. It streams output up to 2.5x faster from the same model, and you pay double the normal per-token price for it.

This guide shows how to turn it on in the Messages API, what it costs on each model, and when the extra money actually buys you something.

What Claude Fast Mode Is (and Is Not)

Fast mode is not a new or smaller model. Anthropic’s docs describe it as the same model running on a faster inference configuration. Intelligence and capabilities stay the same.

The gain is in output tokens per second. Long answers, big code edits and long tool-call plans finish sooner, and you notice it most when you stream the response.

Here is what changes and what stays the same:

• Changes: generation speed (up to 2.5x), the per-token price, and a separate rate limit.
• Stays the same: model weights, quality, context window, tools, vision and thinking.
• Does not improve: time to first token (TTFT). If your app waits mostly on the first token, fast mode will not help much.

Fable 5.2 is already quicker than its predecessor. Anthropic says it generates output up to 30% faster than Fable 5.1 at normal speed. Fast mode stacks on top of that.

Supported Models and Exact Prices

Fast mode is priced as a multiplier on standard rates. On Fable 5.2 and Opus 5.5 that works out to exactly 2x. The rate is flat across the full context window, including requests over 200K input tokens.

Two pricing modifiers stack on top of fast mode rates:

• Prompt caching: the usual cache write and cache read multipliers apply to the fast mode price.
• Data residency: setting inference_geo to US-only adds a 1.1x multiplier, on top of fast mode.

Warning: Fast mode on Opus 4.8 stops working on November 30, 2026. After that date, speed: "fast" on claude-opus-4-8 returns an error. Move that code to Opus 5.5 or Fable 5.2 now.

For the full standard price list, including cache rates, see our Claude API pricing guide. For more on the model itself, read the Fable 5.2 and Mythos 5.2 overview.

Where Fast Mode Works

Availability depends on the model, the API and the cloud platform. This is the part that trips people up most, so check it before you build.

• Claude API (first party): Fable 5.2, Mythos 5.2, Opus 5.5, plus Opus 5 and Opus 4.8 with the beta header.
• Managed Agents: only Opus 5.5, Opus 5 and Opus 4.8. Fable 5.2 fast mode is Messages API only.
• Claude Models on Google Cloud (Anthropic managed): Fable 5.2 and Opus 5.5.
• Claude Models on Google Cloud (Google managed): Fable 5.2, with prices set by Google Cloud.
• Microsoft Foundry: separate fast model IDs. claude-fable-5-2-fast runs on Anthropic hosting, and claude-opus-5-5-fast runs on Azure hosting.
• Not available: Message Batches API and Priority Tier commitments, on any model.

Fast mode is also eligible for zero data retention (excluding Covered Models such as Fable 5.2) and for HIPAA. Your retention setting applies whatever speed you pick.

How to Enable Fast Mode in the Messages API

On the Claude API, fast mode is one top-level request field. It is not a header and it does not go inside extra_body.

1. Check your usage tier. Fable 5.2, Mythos 5.2 and Opus 5.5 get a default fast mode limit on the Start, Build and Scale tiers. The free Evaluation tier must move up first.
2. Update the SDK. Install a recent anthropic (Python) or @anthropic-ai/sdk (TypeScript) package so the speed field is typed.
3. Pick a supported model. Use claude-fable-5-2 or claude-opus-5-5. Other models either need a beta header or return an error.
4. Add the speed field. Set speed="fast" (Python) or speed: "fast" (TypeScript) next to model and max_tokens.
5. Stream the response. Fast mode improves tokens per second, so streaming is where users feel the change.
6. Confirm the speed. Read response.usage.speed. It returns "fast" or "standard".
7. Add a fallback. Catch fast mode 429 errors and resend at standard speed if you cannot wait.

Note: On Microsoft Foundry, do not send speed. Point your client at a -fast deployment instead. Sending speed to a standard deployment returns an error.

Code Examples: Python and TypeScript

Python: basic fast mode request

This is the smallest working request. Fable 5.2 always thinks, so do not send a disabled thinking setting. Use effort to control depth instead.

import anthropic

client = anthropic.Anthropic()  # reads ANTHROPIC_API_KEY

response = client.messages.create(
    model="claude-fable-5-2",
    max_tokens=16000,
    speed="fast",
    output_config={"effort": "high"},
    messages=[
        {"role": "user", "content": "Refactor this module to use dependency injection: ..."}
    ],
)

if response.stop_reason == "refusal":
    print("Request was declined:", response.stop_details)
else:
    for block in response.content:
        if block.type == "text":
            print(block.text)

print("Speed used:", response.usage.speed)  # "fast" or "standard"

Python: streaming with fast mode

Streaming shows the speed gain best, and it also avoids HTTP timeouts on long Fable 5.2 turns.

with client.messages.stream(
    model="claude-fable-5-2",
    max_tokens=64000,
    speed="fast",
    messages=[{"role": "user", "content": "Write a full test suite for this file: ..."}],
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)
    final = stream.get_final_message()

print()
print("Output tokens:", final.usage.output_tokens, "| speed:", final.usage.speed)

TypeScript: fast mode request

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

const msg = await client.messages.create({
  model: "claude-opus-5-5",
  max_tokens: 16000,
  speed: "fast",
  messages: [{ role: "user", content: "Summarise this incident log: ..." }],
});

console.log(msg.usage.speed); // "fast" or "standard"

Opus 5 research preview (beta endpoint)

Opus 5 and Opus 4.8 still need the beta endpoint and the beta flag. Opus 5 also needs access from your account manager or the waitlist.

response = client.beta.messages.create(
    model="claude-opus-5",
    max_tokens=16000,
    speed="fast",
    betas=["fast-mode-2026-02-01"],
    messages=[{"role": "user", "content": "Hello"}],
)

Rate Limits and Falling Back to Standard Speed

Fast mode has its own rate limit, separate from your normal limits. Going over it returns a 429 with a retry-after header. Running out of fast capacity can also return a 529.

Every response carries fast mode headers, so you can watch your headroom:

• anthropic-fast-input-tokens-limit / -remaining / -reset: fast mode input tokens per minute.
• anthropic-fast-output-tokens-limit / -remaining / -reset: fast mode output tokens per minute.

The SDK retries 429 errors two times by default and honours the retry-after delay. If you would rather not wait, turn retries off for the fast call and resend without speed:

import anthropic

client = anthropic.Anthropic()

def create_with_fast_fallback(**params):
    try:
        return client.with_options(max_retries=0).messages.create(**params)
    except anthropic.RateLimitError:
        if params.get("speed") == "fast":
            params.pop("speed")
            return client.messages.create(**params)  # standard speed, normal retries
        raise

msg = create_with_fast_fallback(
    model="claude-fable-5-2",
    max_tokens=4096,
    speed="fast",
    messages=[{"role": "user", "content": "Hello"}],
)

Tip: Setting max_retries=0 also turns off retries for 529 and 5xx errors. Wrap those too, or your fallback will fail on a brief overload. Our 429 and 529 error guide has a full retry pattern.

Remember the cache cost. Requests at different speeds do not share cached prefixes, so each fallback is a cache miss.

When Fast Mode Pays Off (and When It Does Not)

Fast mode doubles your bill for the same tokens. It is worth it when a human or a time-critical system is waiting on long output.

A simple cost example

Take one Fable 5.2 call with 20,000 input tokens and 4,000 output tokens, with no caching. The numbers below use the official per-token prices.

So if the output takes 50 seconds to stream normally, the best case on fast mode is about 20 seconds. You pay 32 cents more to save up to 30 seconds of waiting.

Good fits

• Interactive coding: rapid edit and test loops where a developer watches every reply.
• Live debugging: incident response where minutes matter more than cents.
• Customer-facing long answers: reports or drafts that a user waits for on screen.
• Agent loops with long tool plans: each step writes many tokens, and the steps add up.

Poor fits

• Batch and overnight jobs: use the Message Batches API at 50% off instead.
• Short replies: a 100-token answer finishes fast anyway, and TTFT dominates.
• CI pipelines: nobody is watching, so speed rarely beats cost.
• Cost-capped apps: doubling the price can break your unit economics.

Cheaper ways to get faster replies first

• Lower the effort: output_config.effort at low or medium cuts thinking time on easy tasks.
• Pick a lighter model: Opus 5.5 at standard speed costs half of Fable 5.2 and may be enough.
• Cache the prefix: prompt caching lowers input cost and can cut latency on long prompts.
• Cap output length: ask for shorter answers in the prompt so there is less to generate.

Fast mode and low effort also combine well. Anthropic’s Claude Code docs suggest fast mode with a lower effort level for maximum speed on straightforward tasks.

Fast Mode in Claude Code

Claude Code has its own fast mode toggle. The official Claude Code docs describe it for Opus models: Opus 5.5 is the default fast mode model from v2.1.280, at $8 / $40 per million tokens.

• Toggle: run /fast in the CLI, or set "fastMode": true in your user settings file.
• Indicator: a small lightning icon appears next to the prompt while fast mode is on.
• Billing on plans: Pro, Max, Team and Enterprise pay for fast mode from usage credits, not the plan’s included limits.
• Admins: Team and Enterprise Owners must enable it first. CLAUDE_CODE_DISABLE_FAST_MODE=1 turns it off entirely.
• Per-session opt-in: "fastModePerSessionOptIn": true makes every session start with fast mode off.

Anthropic’s Fable 5.2 announcement also lists Claude Code among fast mode surfaces. Run /fast in your version to see which models it offers. For more cost control in the CLI, read our guide to reducing Claude Code token usage.

Troubleshooting: Common Problems and Fixes

400 error when sending speed

The model probably does not support fast mode, or you are on Foundry with a standard deployment. Switch to claude-fable-5-2 or claude-opus-5-5, or use the -fast Foundry deployment and drop speed.

Constant 429 errors on fast mode

You are over the fast mode limit, or your organization is on the Evaluation tier. Check the anthropic-fast-* headers and the Rate limits page in the Claude Console, then add the fallback shown above.

usage.speed says “standard”

On Opus 4.6, a fast request with the beta header succeeds but runs at standard speed. Use a supported model. Also confirm your fallback code did not quietly drop the field.

The response does not feel faster

Fast mode speeds up output, not the first token. Short answers or long thinking pauses hide the gain. Stream the reply and compare total generation time on long outputs.

Opus 5 fast mode is rejected

Opus 5 is a research preview. Use client.beta.messages, add fast-mode-2026-02-01, and make sure your organization has been given access.

My cache hit rate dropped

Fast and standard requests keep separate caches. Switching speed mid-conversation, or falling back, rereads the prefix uncached. Pick one speed per conversation where you can.

Frequently Asked Questions

How much faster is Claude fast mode?

Anthropic says up to 2.5x higher output tokens per second. Real gains vary with load and output length, and time to first token does not change.

How much does Fable 5.2 fast mode cost?

Fable 5.2 fast mode costs $16 per million input tokens and $80 per million output tokens. That is double the standard $8 / $40 rate.

Does fast mode make Claude smarter or worse?

No. It runs the same model with the same capabilities. Only speed and price change.

Do I need a beta header for Fable 5.2 fast mode?

No. Set speed: "fast" on a normal Messages request. A request that still sends the fast-mode-2026-02-01 flag also works.

Can I use fast mode with the Batch API?

No. Fast mode is not available with Message Batches or Priority Tier. For bulk jobs, standard-speed batches at 50% off are the cheaper choice.

Does prompt caching still work in fast mode?

Yes. Cache multipliers apply on top of fast mode prices. Fast and standard requests do not share a cache, though, so switching speeds causes a miss.

Can I use Fable 5.2 fast mode in Managed Agents?

Not at the time of writing. Managed Agents supports fast mode on Opus 5.5, Opus 5 and Opus 4.8 only. Fable 5.2 fast mode works through the Messages API.

Sources

• Claude Docs: Fast mode
• Claude Docs: Pricing
• Anthropic: Claude Fable 5.2 and Mythos 5.2 announcement
• Claude Code Docs: Speed up responses with fast mode
• 9to5Mac: Anthropic upgrades Claude with new Fable 5.2 model