Tokens per second (tok/s) is how fast a language model writes its answer. One token is about three-quarters of a word, so a model running at 50 tok/s produces roughly 37 words a second, or about 2,250 words a minute, which is far faster than you can read. For live chat, anything above 15–20 tok/s already beats reading speed and feels smooth. For batch work where you wait for the full result, higher tok/s directly cuts your wait.
Drop a token count and a speed into the LLM speed calculator to see exactly how long a response will take.
Tokens, and why we count them
Models do not read or write in words, they work in tokens: chunks that are often a whole short word, a word-piece, or a punctuation mark. A useful rule of thumb is 1 token ≈ 0.75 words, or about 4 characters of English. So 1,000 tokens is roughly 750 words, a bit over a page.
Tok/s measures how many of those chunks the model emits per second. It is the single best number for “how fast will this feel”, but only once you split it into two parts.
TTFT vs decode: the two halves of speed
“Speed” is really two separate measurements, and they feel completely different:
- TTFT (time to first token) is the pause between hitting send and the first word appearing. It covers the model reading your prompt and starting to generate. Long prompts and reasoning models push TTFT up. This is what makes a model feel snappy or sluggish.
- Decode speed is the steady tok/s at which the rest of the answer streams once it starts. This is what people usually mean by “tokens per second”.
A model with a 3-second TTFT but fast decode feels laggy to start, then races. A model with instant TTFT but slow decode feels responsive, then crawls through a long answer. Total wait is simply TTFT plus (output tokens ÷ decode tok/s).
Converting tok/s to words per minute
To translate a raw speed into something human:
- Words per second = tok/s × 0.75
- Words per minute = words per second × 60
| Decode speed (tok/s) | Words per minute | Feel |
|---|---|---|
| 10 | ~450 | Visibly streaming, fine for short chat |
| 20 | ~900 | Comfortably past reading speed |
| 50 | ~2,250 | Answer appears almost as fast as you scan |
| 100 | ~4,500 | Effectively instant for chat-length replies |
For reference, a fast human reads around 250–300 words per minute, so even 10 tok/s outpaces reading. The reason higher speeds still matter is long outputs and batch jobs, where you wait for the whole thing rather than reading as it streams.
Worked example: turning tokens into a real wait
Say you ask for a 1,200-word summary from a model running at 40 tok/s decode with a 0.8-second TTFT.
- Output tokens: 1,200 words ÷ 0.75 ≈ 1,600 tokens
- Decode time: 1,600 ÷ 40 = 40 seconds
- Plus TTFT: 40 + 0.8 = ~40.8 seconds total
Now swap in a faster model at 100 tok/s:
- Decode time: 1,600 ÷ 100 = 16 seconds
- Plus a 0.8s TTFT = ~16.8 seconds total
Same task, 24 seconds saved. For one request that is minor. For an automated job running that prompt 500 times, it is the difference between about 5.7 hours and 2.3 hours. Run your own numbers in the LLM speed calculator.
What “fast enough” actually means
It depends entirely on whether a human is watching the output stream:
- Interactive chat: You read as it types, so once decode passes ~15–20 tok/s, extra speed is barely noticeable. TTFT matters more here, keep it under a second or two and it feels instant.
- Long single answers: You are waiting for a wall of text, so decode speed dominates. Faster is genuinely better.
- Batch and agent workflows: No human waits on each step, and total time scales linearly with tok/s. Here speed is money. Reasoning models are the trap, they emit huge numbers of hidden tokens, so even at high tok/s the wall-clock time balloons, as our reasoning-model cost guide explains.
Because agents chain many calls back to back, slow tok/s compounds fast, which is a big part of why AI agents cost so much in both time and tokens.
The short version: figure out your output token count, divide by decode speed, add TTFT, and you have your real wait. The LLM speed calculator does the arithmetic so you can compare models before you commit to one.
