# Kør fast mode-løbet selv

Jeg sendte den samme forespørgsel til Claude Opus 5.5 to gange i samme øjeblik, én gang ved
standardhastighed og én gang i fast mode, og tog tid på begge. Her er, hvordan du gør det samme med din
egen nøgle, og hvordan jeg afgør, hvornår fast mode er den dobbelte pris værd.

## Hvornår du skal bruge det

- **Nogen venter: fast mode.** En sælger med kunden i røret, et chatvindue, en supportmedarbejder midt i
  en samtale. I min test kom de to sætninger til et kundeopkald tilbage på 2,7 sekunder i median i stedet
  for 6,6.
- **Ingen venter: standard.** En kørsel om natten, et resumé, der lander i en indbakke, en rapport, ingen
  læser den næste time. Fast mode koster det dobbelte pr. token, og de sparede sekunder giver dig intet
  dér.

## Trinene (Claude API, Python SDK)

1. Installér SDK'et, og sæt din nøgle:

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

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

2. Send forespørgslen til beta-endpointet med fast mode-flaget og `speed="fast"` på `claude-opus-5-5`,
   og stream den:

   ```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 siger: I er 18 procent dyrere. Giv mig to sætninger."}],
   ) 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"\nførste token {token:.1f} s, første ord {word:.1f} s, færdig {end:.1f} s, "
         f"speed {final.usage.speed}, output-tokens {final.usage.output_tokens}")
   ```

   Til standardkaldet udelader du `speed` og `betas`. Alt andet er det samme.

3. Tag tid på tre ting: **streamens første hændelse** (den reelle tid til første token), **det første
   synlige ord** og **slutningen**. Claude Opus 5.5 tænker, før den skriver, og du ser ikke
   overvejelserne, så det første ord kommer flere sekunder efter det første token. I mine løb kom det
   første token næsten lige hurtigt i begge tilstande, som Anthropics dokumentation siger; det var de
   skjulte overvejelser, der blev kortere, fordi tænke-tokens er output-tokens, og fast mode også
   producerer dem hurtigere.

4. **Læs `usage.speed`.** Det er API'ets egen registrering af, hvilken hastighed der kørte. Står der ikke
   `fast`, var det ikke et fast mode-kald, uanset hvad du bad om. Jeg tæller kun et hurtigt kald med, når
   der står `fast`.

5. Et fair løb sender begge kald i samme øjeblik, i to tråde, så de deler netværk og belastning.
   `race.py` i pakken gør præcis det for tre opgaver på to sprog, og `score.py` regner medianer, sejre og
   pris ud.

## Prisen

Claude Opus 5.5 til listepris: standard 4 dollar pr. million input-tokens og 20 dollar pr. million
output-tokens; fast mode 8 og 40 dollar. Tænke-tokens tæller som output-tokens. Det er altså det dobbelte pr. token, og i mine 24 løb
cirka det dobbelte pr. svar i median: 2,2 mod 1,1 US-cent for det korte svar, 7,2 mod 3,8 cent for
tilbudsresuméet. Løb for løb lå forholdet mellem 1,18 og 2,98 gange, fordi de to kald ikke bruger lige
mange tokens.

## Eller sæt effort ned

Lavere effort gør de skjulte overvejelser kortere uden ekstra pris pr. token. På de to sætninger til
kundeopkaldet tog effort `low` i median 4,5 s ved standardhastighed (0,6 US-cent) og 2,0 s i fast mode
(1,4 cent), mod 6,6 s / 1,1 cent og 2,7 s / 2,2 cent ved standard-effort. Jeg sammenlignede ikke
kvaliteten, og Anthropic skriver, at lavere effort kan give lavere kvalitet på komplekse opgaver. Du
sætter det med `output_config={"effort": "low"}`, eller `--effort low` i `race.py`.

## I Claude Code

I Claude Code er fast mode kommandoen `/fast`, og den betales af dine forbrugskreditter.

## Det, jeg ikke testede

- Kvalitet. Jeg tog tid på svarene og regnede prisen ud, intet andet.
- Andre tidspunkter på døgnet, andre regioner, andre effort-niveauer end standardindstillingen
  `medium` og `low`.
- Rate limits. Fast mode har sin egen grænse, adskilt fra standard. Ingen af mine 48 kald ramte den.