# Run the fast mode race yourself

I sent the same request to Claude Opus 5.5 twice at the same moment, once at standard speed and once in
fast mode, and timed both. Here is how to do the same on your own key, and how I decide when fast mode is
worth twice the price.

## When to use it

- **Someone is waiting: fast mode.** A salesperson with the customer on the line, a chat window, a
  support agent mid-conversation. In my test the two sentences for a live call came back in a median
  2.7 seconds instead of 6.6.
- **Nobody is waiting: standard.** A nightly batch, a summary that lands in an inbox, a report nobody
  reads for an hour. Fast mode costs twice as much per token and the extra seconds buy nothing there.

## The steps (Claude API, Python SDK)

1. Install the SDK and set your key:

   ```
   pip install anthropic
   export ANTHROPIC_API_KEY=...
   ```

   In PowerShell: `$env:ANTHROPIC_API_KEY = "..."`

2. Send the request on the beta endpoint with the fast mode flag and `speed="fast"`, on
   `claude-opus-5-5`, and stream it:

   ```python
   import time, anthropic

   client = anthropic.Anthropic()
   t0 = time.perf_counter()
   token = word = None
   with client.beta.messages.stream(
       model="claude-opus-5-5",
       max_tokens=8000,
       speed="fast",
       betas=["fast-mode-2026-02-01"],
       messages=[{"role": "user", "content": "Leif says: you are 18 percent more expensive. Give me two sentences."}],
   ) as stream:
       for ev in stream:
           if token is None:
               token = time.perf_counter() - t0
           if ev.type == "content_block_delta" and ev.delta.type == "text_delta":
               if word is None:
                   word = time.perf_counter() - t0
               print(ev.delta.text, end="", flush=True)
       final = stream.get_final_message()
   end = time.perf_counter() - t0
   print(f"\nfirst token {token:.1f} s, first word {word:.1f} s, done {end:.1f} s, "
         f"speed {final.usage.speed}, output tokens {final.usage.output_tokens}")
   ```

   For the standard call, leave out `speed` and `betas`. Everything else stays the same.

3. Time three things: **the first event of the stream** (the real time to first token), **the first
   visible word** and **the end**. Claude Opus 5.5 thinks before it writes, and you do not see the
   thinking, so the first word arrives seconds after the first token. In my races the first token came
   almost as fast in both modes, as Anthropic's docs say it will; the hidden thinking is what got
   shorter, because thinking tokens are output tokens and fast mode produces them faster too.

4. **Read `usage.speed`.** It is the API's own record of which speed ran. If it does not say `fast`, the
   call was not a fast mode call, whatever you asked for. I count a fast call only when it says `fast`.

5. To race fairly, send both calls at the same moment, in two threads, so they share the network and
   the load. `race.py` in this kit does exactly that for three tasks in two languages, and `score.py`
   turns the result into medians, wins and cost.

## The price

Claude Opus 5.5 at list price: standard $4 per million input tokens and $20 per million output tokens;
fast mode $8 and $40. Thinking tokens count as output tokens. So it is double per token, and in my 24 races about
double per answer at the median: 2.2 against 1.1 US cents for the short answer, 7.2 against 3.8 cents for
the offer summary. Race by race the ratio ran from 1.18 to 2.98 times, because the two calls do not use
the same number of tokens.

## Or lower the effort

Lower effort shortens the hidden thinking at no extra price per token. On the two-sentence call answer,
effort `low` took a median 4.5 s at standard speed (0.6 US cents) and 2.0 s in fast mode (1.4 cents),
against 6.6 s / 1.1 cents and 2.7 s / 2.2 cents at the default effort. I did not compare quality, and
Anthropic notes that lower effort can lower quality on complex tasks. Set it with
`output_config={"effort": "low"}`, or `--effort low` in `race.py`.

## In Claude Code

In Claude Code, fast mode is the `/fast` command, and it is paid from usage credits.

## What I did not test

- Quality. I timed and priced the answers, nothing more.
- Other hours of the day, other regions, other effort levels than the default `medium` and `low`.
- Rate limits. Fast mode has its own limit, separate from standard. None of my 48 calls hit it.