How the speed tool works

If you're new here: strata→signal is a small workshop that builds things on its own machines and writes up what it measures. This page prints nothing it did not read from the tool's files.

The words this page leans on

• Token. The unit a model reads and writes in; each model splits text its own way. In the prose the tool types, a token is about four-fifths of a word (343 words, 415 to 420 tokens).
• Writing speed (decode). Tokens a second once the answer has started.
• Wait before the first word (time to first token, TTFT). From pressing send to the first word, the reading of the question included.
• Quantization. Storing a model's weights in fewer bits: Q8_0 keeps about 8, Q3_K_M about 3.
• Engine. The program that loads a model and serves it: llama.cpp, vLLM, Ollama, or the Strata engine (open source; despite the similar name, unrelated to this workshop).
• The roster. The hardware roster, the hub's table of every figure its exhibits (its measured write-ups) printed about a card or a computer, one row per figure, with its page and conditions.

Three boxes and one answer

A speed is a number; watching it type is a feeling. So the page opens on the question its playback answers, "How fast is 136.3 tokens a second?", then: "Press Start to watch an AI's answer appear at this speed. Change any number, or fill them in from a graphics card we tested." The three starting numbers were all measured on our NVIDIA GeForce RTX 3090 (24 GB); the fold below the playback, “Where these numbers come from”, names each run:

• Writing speed, 136.3 tokens a second. The row prints 136.274 tokens a second: gemma4:26b under Ollama 0.32.13, Q4_K_M, at the card's stock 350 W limit, from RTX 3090 vs RTX 3090 Ti: an inference and diffusion bench; the card list's RTX 3090 · gemma4:26b cell, the lower-middle of four runs (135.2 to 146.3 tokens a second).
• Wait, 0.51 s. The row prints 510.56 ms: mistral-nemo:12b-instruct-2407, Q3_K_M, Ollama 0.32.13, 300 W, a 519-token question, from The quantization ladder; five waits on that card and model, one per weight format, 0.48 to 0.55 s. About 0.49 s of that wait is Ollama 0.32.13 re-reading the model file's metadata on every request (the step its API reports as load_duration), with the model already loaded; Ollama 0.32.15 keeps that metadata in memory instead (pull request #17752). The question was a repeat, too: the engine had kept 518 of its 519 tokens from the request before, so reading it took 16 ms of the wait.
• Reading speed, 2,271 tokens a second. The row prints 2,270.547 tokens a second: the same card reading a 98,000-token document. Its exhibit does not name the model, so the card list never offers this figure; the fold says so.

A chip reads "Faster than you read (238 words a minute)", "About as fast" (0.8 to 1.25 times your pace) or "Slower"; 238 is the average for silent reading of English non-fiction in Brysbaert's 2019 review.

Why one run, and why no mean

Press Fill in from a graphics card we tested and two selects open: a card, named in full, then its models with their counts ("gemma4:26b · 4 measurements"). A pick fills all three boxes and names its source: "one run of gemma4:26b on the NVIDIA GeForce RTX 3090 (24 GB), from the middle of our 4 measurements".

The run is chosen by one rule, printed on the page: of our runs of that card, model and engine that measured the most of the three numbers, the one in the middle by writing speed (with an even count, the lower middle). The wait and the reading speed come from that same run. Nothing is averaged, so every number a pick shows was measured, on a day, under conditions the fold prints.

A mean can be a speed no run produced. Our NVIDIA RTX PRO 6000 Blackwell Workstation Edition (96 GB) wrote gemma4:26b at 139.55 tokens a second on 2026-08-14 under Ollama 0.32.9 (its exhibit's median of six runs, 137.75 to 150.49), and its exhibit traces the jump the next Ollama brought; on 2026-09-16 it wrote 205.85 tokens a second (A Short History of Mistral). Their mean, 172.7 tokens a second, is a speed neither reading comes near: 137.75 to 150.49 before the fix, 202 to 214 after. The tool shows 205.9 tokens a second and lists the 139.55 on its data page with its reason: Ollama 0.32.9, before the fix its exhibit traces. A median fails the same way with an even count: six gemma4:26b runs on our pair of NVIDIA GeForce RTX 3080 (10 GB each) sit at 113.8 to 115.4 and 124.0 to 124.7 tokens a second, and the median, 119.7, lands in the gap; the run shown is 115.4.

What each box means

• Writing speed is the only box that must hold a number, 0.5 to 2,000 tokens a second; each token of the text lands at the wait plus its index divided by it.
• Wait before the first word is played as its box shows it, 0.01 to 120 seconds. Every first-token row on the roster is measured end to end, reading included, so the tool never adds a reading time: on a 4,038-token question our NVIDIA RTX PRO 6000 Blackwell Workstation Edition (96 GB) under llama.cpp waited 2.52 s, and 4,038 ÷ its 1,619-a-second reading speed is 2.49 s.
• Reading speed, 1 to 100,000 tokens a second, is used only when the wait box is empty. The wait is then the question's length divided by it, and the status says so: "a 519-token question ÷ 1,619 tokens a second = 0.32 s (reading only; setup time not included)". Otherwise a line under the box reads "Not used right now: the wait already includes reading."

A bad figure is refused, never clamped: the box names its range and Start stays off. A box a pick could not fill reads "We didn't measure this one."; a filled number you change is marked "typed in — not measured by us".

Which runs can fill the boxes

The build reads the roster's own rows.json and records its hash and row count. It starts from the roster's 143 playable writing speeds, 89 first-token rows and 27 reading rates, then applies seven rules, every left-out row listed on the data page with its reason:

1. A graphics card, one of six named in a reviewed file; the 36 rows measured on processor-only computers are out.
2. A model a reader can pick. Sixteen rows name none.
3. One request at a time. Twelve waits were measured under several at once.
4. A short question, an open window. Rows at a filled window or a 32K or 128K question are out (61). A wait counts only when its question was at most 600 tokens or not stated; the nine waits measured at 4,038 tokens are out, their runs keep their writing and reading speeds, and those options get a wait worked out at 519 tokens, in italics, marked "worked out".
5. Reviewed exclusions, ten, each with its reason: the pre-fix 139.55 above, five rounded reprints of figures another exhibit prints more precisely, two second-clock readings of runs already counted, two models split over two cards.
6. One engine and version. llama.cpp never pools with the Strata engine; vLLM never pools with Ollama. Where one card ran one model on one engine at two versions, a reviewed line names the version shown and why; the other version's nine rows are out.
7. The card's stock power limit. Where the card's exhibit names its stock limit (350 W on the NVIDIA GeForce RTX 3090 (24 GB), 450 W on the NVIDIA GeForce RTX 3090 Ti (24 GB), 95 W on the NVIDIA GeForce RTX 5090 Laptop GPU (24 GB)) and the pool has writing rows at it, only those count; 38 rows at other limits are out. Otherwise every limit counts and the fold says "mixed power limits".

What is left is 47 writing speeds, 14 waits and 7 reading rates, in 22 options on six cards, from seven exhibits; 191 rows are out. Within one option the runs still differ in weights, cache, window and settings, so the fold shows every row of the pool with those columns, the shown run first, each linked to its exhibit's section.

The text it types is the opening of Reading is fast, writing is slow, 343 words of the hub's own prose (three of its five paragraphs by default), or a 45-line function from the tool's own source, split with the picked model's own tokenizer: eight tokenizer files, each pinned by hash, split the prose into 415 to 420 tokens and the code into 402 to 484. With no model picked, a stand-in is used and the fold says so.

A new card appears when its rows publish on the roster and a reviewed line names it; a second engine version with no reviewed line, an exclusion that matches no row, or a starting number that no longer equals its cell stops the build.

The settings panel

At the foot of the page, four settings:

• The question's length, 10 to 131,072 tokens, starting at 519, the question our starting wait was measured with. It moves only a worked-out wait, never a measured one.
• The answer's length, 1 to 5 paragraphs or 10 to 4,096 tokens (3 paragraphs to start); past the text's end it plays again from the top.
• The text, prose or code, and your reading pace, 100 to 600 words a minute, starting at 238, for the chip.

Comparing. "+ Compare with another speed", below the playback, adds one more set of boxes, copied from the first, so you change one thing; two sets at most, one Start for both on one clock. A set with no wait says "No wait measured".

What it cannot tell you

This plays an answer back at a steady rate. A live model's stream is not steady, and real use moves it: the question's length, how full the window is, other people on the same card, the power limit, the weights, the cache, the engine, heat, and the tokenizer. The runs were measured on different days for different pages, under labels that vary ("spread of three", "95th percentile", or a bare unit), so the page prints each exhibit's label beside its figure and never calls one a median; whether two options are a fair comparison is yours to judge.

What the page keeps, and does not

The page makes no third-party request: no fonts, no analytics, no content network; after it loads, its security header refuses every request it could make, to anyone, this workshop included. The web server keeps its ordinary log line for each fetch, for 30 days, as for every page of the research hub: the time, the page asked for, the internet address it came from, and the headers the request carried, among them what kind of browser it is, its language and the page that linked here. The rule deletes cookies, credentials and the five common forwarding-address headers a proxy adds, and cuts any query from the address and from the linking page; Where your question goes says more.

The numbers you type and the card you pick stay in the tab until you copy the link; then they sit after the # in the address, which a browser never sends to a server, so the workshop never learns them. Copying the link writes it to your clipboard and the address bar (each set's numbers and pick, the text, and any changed question or answer length; never your reading pace). Your browser keeps that address in its history (a browser that syncs its history or open tabs to an account sends it there), and anyone you share it with, and the app you share it through, can read it.

How to check our work

Who ran this, and thanks

Ollama, llama.cpp, vLLM and the Strata engine served every run a pick can show; the figures are theirs before they are ours. The Hugging Face tokenizers library (0.23.2) split the two texts, and Google, OpenBMB, Mistral AI, Unsloth, NVIDIA, Microsoft and Qwen published the eight tokenizer files the tool carries, each named with its repository and revision in samples.json. Marc Brysbaert's 2019 review gives the chip its 238 words a minute. None of them owed us anything. If we have named your work wrongly, tell us at hello@strata2signal.com; corrections are dated on this page.

A small (human) team asked for the tool and this page, ruled the open questions the agents brought it, and signed both for publication. A fleet of AI agents built the tool, drafted this page with a table tracing each figure to the tool's files, audited both, and checked every figure against those files before release. The agents are Anthropic's Claude models; no Anthropic model is measured by the tool or on this page.

Corrections and later measurements will be added below, each dated (UTC), with a window at both ends where one applies, saying in plain words what it counts. The tool's figures are rows from other exhibits, so when a starting number or the card list changes, the dated block here names the exhibit row the new figure was read from and the one it replaces, in one sentence.