# Fast mode race kit

The same sales request sent to Claude Opus 5.5 twice at the same moment, once at standard speed and once
in fast mode, streamed, timed and priced. I had it run on 19 October 2026 through a GitHub Actions workflow on the Claude API: three tasks, Danish and English,
4 races each, 24 races and 48 calls, no errors, and every fast call reported `usage.speed == "fast"`.

The write-up: [English](https://brinvik.com/en/journal/claude-opus-5-5-fast-mode-price-and-wait) and [Danish](https://brinvik.com/da/journal/claude-opus-5-5-fast-mode-pris-og-ventetid).

The scenario is invented. Brask & Holm Kompressorservice, Fabrikken Vestermølle, Leif the finance
director and Sofie the salesperson do not exist.

## What I found (medians, all 8 races per task)

| Task | Full answer, standard / fast | Stream start, standard / fast | Hidden thinking before the first word, standard / fast | Fast won | Cost per answer, standard / fast |
|---|---|---|---|---|---|
| Two sentences to say on a live call | 6.6 s / 2.7 s | 1.3 s / 1.1 s | 4.1 s / 1.2 s | 8 of 8 | 1.14 / 2.22 US cents |
| A follow-up email, about 150 words | 7.2 s / 3.0 s | 1.1 s / 0.8 s | 2.1 s / 0.7 s | 8 of 8 | 1.31 / 2.61 US cents |
| An offer summary, about 450 words | 19.6 s / 7.3 s | 1.2 s / 1.0 s | 4.6 s / 1.8 s | 8 of 8 | 3.77 / 7.20 US cents |

The three time columns stack: stream start, then hidden thinking, then the writing you see, adds up to
the median full answer. Fast mode finished first in all 24 races.

The stream started almost as fast either way, which is what Anthropic's docs say: fast mode is more
output tokens per second, not a shorter time to the first token. The silence before the first word is
mostly something else. Thinking is always on in Claude Opus 5.5, the thinking is hidden, and
thinking tokens are output tokens, so fast mode produces the thinking faster too. That is where most of
the shorter silence came from.

Price: double per token ($8 / $40 per million input and output tokens against $4 / $20), and about double
per answer at the median. Race by race the ratio ran from 1.18 to 2.98 times, because the two calls in a
race do not think or write the same number of tokens.

## The same races at effort low

Lower effort is the other way to shorten the hidden thinking, at no extra price per token, so I had the
same 24 races run again with `output_config.effort` set to `low`: 48 calls, no errors. 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.

## What is in here

| File | What it is |
|---|---|
| `run-steps-en.md`, `run-steps-da.md` | How to run the same race yourself, and when to use fast mode, in English and Danish |
| `race.py` | The race: two streamed calls at the same moment, timed to the millisecond, on your own API key |
| `score.py` | Turns `runs/runs.jsonl` into `facts.json`. The definitions of wait, write, total and cost are at the top |
| `prompts.json` | The system prompt, the facts and the three tasks, in Danish and English, exactly as sent |
| `runs.jsonl` | My 48 recorded calls, raw: timings, every text chunk with its arrival time, usage and Claude's text exactly as it came back. Seven of the 24 races contain a long dash in an answer; the demo on brinvik.com does not replay those, and this file leaves them untouched |
| `facts.json` | Every number above, computed by `score.py` from `runs.jsonl` |
| `runs-effort-low.jsonl`, `facts-effort-low.json` | The same 24 races at effort `low`, recorded the same evening, raw and scored. `versus_medium` in the facts file sets each task's medians next to the default-effort run |

## Run it yourself

You need the Python SDK, an API key in `ANTHROPIC_API_KEY`, and access to fast mode, which is a research
preview on the Claude API.

```
pip install anthropic
python race.py --runs 1
python score.py
```

`--runs 1` is six races, about $0.37 at list price. Add `--effort low --out runs-low` to race at effort
`low`; without `--effort` no effort is sent and the model default, `medium`, applies. `score.py` reads
`runs/runs.jsonl`, so score a low run in its own copy of the folder. To re-score my runs instead of making your own, put
`runs.jsonl` in a folder called `runs` next to `score.py` and run `python score.py`. It writes over
`facts.json`, and it should come out the same as the one in here.

## What it does not show

- Nothing about quality. I timed and priced the answers; I did not judge which one was better.
- One evening, about five minutes, from one GitHub Actions runner. Speed depends on load, and another
  hour may give other numbers.
- Three invented tasks from one invented sales situation.
- Two effort levels only: the default, `medium`, and `low`. `usage.inference_geo` came back `global` on
  every call.
- Four races per task and language. The medians are medians of four or eight, not a benchmark.