# Why the first word comes sooner: data kit **What this directory holds.** The records behind the exhibit *Why the first word comes sooner: the Strata engine and llama.cpp on Qwen3.8-Flash-Next, the full bench* (https://research.strata2signal.com/flash-next-why-the-first-word-comes-sooner/). Its short page, *Qwen3.8-Flash-Next on an RTX 5090 laptop, an RTX PRO 6000 Blackwell and an RTX 3090 Ti* (https://research.strata2signal.com/flash-next-on-three-cards/), prints no figure of its own and reads the same rows. The bench ran llama.cpp at commit 3cf03257 (and, on the RTX 3090 Ti, a current build, b11514) beside the Strata engine (github.com/Niko1221/Strata, an unrelated project) on the same Qwen3.8-Flash-Next files, one request at a time, on an RTX 5090 Laptop GPU (24 GB) in a laptop with 64 GB of memory, an RTX PRO 6000 Blackwell (96 GB) at a 300 W cap, and an EVGA GeForce RTX 3090 Ti FTW3 Ultra (24 GB) at a 300 W cap in the same desktop as the 96 GB card. Every speed row of the three cards is here with the model's text withheld, with each attempt's run record, telemetry and engine files, the prompts every request carried, the client that defines the clock of record, the build scripts as they ran, the registration with its amendments, and the laptop bench's summary for the quality rows as counts. The windows, each from its first status line to its last (UTC): | what ran | where | opened | closed | |---|---|---|---| | the laptop's speed attempts, L-IQ3 a1 to S-NEW a2 | the RTX 5090 Laptop GPU | 2026-10-02 20:53:28 UTC | 2026-10-05 21:20:47 UTC | | S-NEW's third attempt, refused at its memory check | the RTX 5090 Laptop GPU | 2026-10-09 12:04:50 UTC | 2026-10-09 12:04:50 UTC | | R-LS-IQ3: llama.cpp, one night | the RTX PRO 6000 Blackwell | 2026-10-06 07:38:08 UTC | 2026-10-06 07:45:02 UTC | | R-S139-IQ3: the Strata engine 0.1.39, the next night | the RTX PRO 6000 Blackwell | 2026-10-07 07:38:21 UTC | 2026-10-07 07:40:57 UTC | | R-S139-IQ3-24G, R-LS-IQ3-24G, R-LS-B11514-IQ3-24G: both engines, one window | the RTX 3090 Ti | 2026-10-09 09:31:47 UTC | 2026-10-09 10:51:44 UTC | **Licence: CC BY 4.0.** Take these rows, re-plot them, check our arithmetic, publish what you find. Attribution: strata→signal research, research.strata2signal.com. If you find an error in any of this, we want to hear about it: hello@strata2signal.com. Machine readers start at `index.json`, which lists every file in this kit but three, each with its byte count and its sha256; the three it leaves out are itself, `provenance.json` and this directory's index page. `provenance.json` is the other half: it names every rule applied to every file, with the count of times each one fired, and says whether any rule touched each file. ## How to read a row Each line of a `rows.jsonl` is one request. Its `row_id` is `/speed/a/run-`: runs 001-003 are the 4K prompt (4,038 tokens), 004-006 the 32K prompt (32,038 tokens) and 007-009 the 128K prompt (128,037 tokens), three requests at each length after one server start, run-001 the first request after the load. A stopped attempt carries the rows it finished. - `ttft_ms` is the wait for the first word and `decode_tok_s` the writing speed, both on our client's clock, the clock of record (`decode_rule` says how the second is counted). `decode_tok_s` is `null` (its value kept in `decode_tok_s_withheld`) when the reply's token count fails its check (`count_check`). - `prompt_tok_s_server`, `decode_tok_s_server` and `server_timings` are the engine's own clock, printed beside ours, never in its place. - `telemetry` is read over the request's own window (`telemetry.window`): board power and energy (`telemetry.board`, trapezoids over nvidia-smi at 1 Hz; board, not wall), the CPU package's energy on the laptop (`telemetry.rapl_package0`, labelled "NOT WALL"), disk reads, card memory, memory pressure and the card's enforced power limit, which the laptop's firmware moves. - On the Strata engine's rows, `strata` carries the engine's own counts: expert-cache hits and lookups, drafts offered and accepted, and `tokens_per_round_derived` (generated ÷ (generated − drafts accepted)). - `completion_sha256` is the digest of the reply the model wrote; `completion_head`, which held the reply's opening, reads `withheld-2026-10-13`. A greedy re-run of the same request can be checked against the digest. The page's Sources table names the file, the rows and the field behind every figure it prints. ## What is in here | path | what it is | |---|---| | `records//speed/a/rows.jsonl` | The attempt's speed rows (above). | | `records//speed/a/RESULT.json`, `STOPPED.json` | The laptop attempt's run record as the driver wrote it at the end: the engine line, the pinned files and their digests, the operating system and driver, the memory plan, the sandbox and its network probe, and how the attempt ended (`STOPPED.json`: which of our guards stopped it, and its reading). | | `records//speed/a/spec.json`, `status.jsonl` | The specification the driver handed the client (the server's command line among it), and the client's status line for each step: the network probe, the launch, readiness, the start-up checks, each request, the end. | | `records//speed/a/telemetry.csv` | The laptop attempt's one-second telemetry: card power, temperature, memory and clocks, the CPU package's energy counter, disk reads, load and memory pressure. | | `records//speed/a/strata-config.json`, `strata-engine.log` | The Strata engine's configuration file, as the engine read it, and its own log: the load lines, the expert-cache and prompt-path sizing, one serve line per request. | | `records/S-NEW/speed/PREFLIGHT-REFUSALS.jsonl` | The refused start of the laptop's 0.1.39 arm's third attempt (2026-10-09): the memory check's sentence and its arithmetic. Nothing ran. | | `records/R-*/speed/a1/run.json`, `row-meta.txt` | The desktop row's record as the window's row server wrote it, and its own account of the row: the engine's build identity, the pins it re-read, the engine line, the sandbox, the cards before and after, how it ended. | | `records/R-*/speed/a1/gpu-1hz.csv`, `memory-receipts.jsonl` | The computer's one-second card log over the row, both cards by index (nvidia-smi's clock, UTC, written without a zone), and the engine unit's memory receipts with the computer's free memory beside them. | | `records/R-*/speed/a1/identity.json`, `fences.json`, `placement.json`, `residency.json`, `strata-line.json`, `arch.json`, `draft-head.json` | The prompt identity check against the laptop's prompts; the two network fences and how each was proven; where each engine put the model; the Strata engine's line on the desktop (the laptop's line, pinned, beside what its setup would have written there); the llama.cpp build's CUDA architecture, read from the server's start line; and the check that the current llama.cpp build ran with no draft head, as registered (the file carries no draft-head block). | | `records/window-24G/telemetry-1hz.csv` | The RTX 3090 Ti's window, one line a second: both cards' power, cap, memory, temperature and use, the computer's free memory, the disk's temperature, the battery backup's status, the running arm's CPU time and the load average. | | `requests/SLICES.json` | The three prompt slices every arm sent, byte for byte, with each slice's digest, its token count and the rule that cut it. | | `client/` | The client that sent every request and timed it (below). | | `build/` | The build scripts as they ran (below). | | `registration/` | The registration, written before the first reading it governs, with its amendments dated and appended (below). | | `SUMMARY.md` | The laptop bench's summary as its harness generated it; its section 3 holds the quality rows as counts (the six-way and the doorman), which is all of the quality rows this kit carries. | The arms: `L-IQ3`, `L-IQ3-t8` and `L-IQ3-ub` are llama.cpp on the IQ3_S file at 4 threads, at 8 threads, and at 8 threads with a 4,096-token micro-batch (the control); `L-Q2` is llama.cpp on the Q2_0 file; `S-IQ3` and `S-Q2` are the Strata engine 0.1.25 on the two files, `S-HEAD` the Strata engine 0.1.36 (exploratory) and `S-NEW` the Strata engine 0.1.39 (exploratory; two attempts stopped by our memory guard and a third refused at its start). On the desktop, `R-LS-IQ3` is llama.cpp and `R-S139-IQ3` the Strata engine 0.1.39 on the 96 GB card, and the three `-24G` arms are the same two plus llama.cpp b11514 on the RTX 3090 Ti. ## The request every arm sent Every request is one streamed chat completion to the engine on loopback: ``` POST /v1/chat/completions {"model": "", "messages": [{"role": "user", "content": "\n\nWrite a detailed, section-by-section summary of the text above."}], "max_tokens": 256, "temperature": 0, "stream": true, "stream_options": {"include_usage": true}, "chat_template_kwargs": {"enable_thinking": false}} ``` `` is the slice's `text` from `requests/SLICES.json` for the request's length. `` is the seeded ticket line `client/vendor/vllm-seats/nonces.py` writes (`Ticket NNNNNNNN.` and a blank line), keyed by the length and the repeat and never by the engine, so the same request sends the same bytes to every arm; each row's `nonce` field prints its ticket, and its `prompt_sha256` the digest of the whole user text. `client/prompts.py` builds it, and `client/inner.py` sends it and times it with the stream reader in `client/vendor/vllm-seats/engine.py`. ## The launch lines, as templates The exact lines each attempt ran are in its `spec.json` (and, for the Strata engine, its `strata-config.json`); the templates below put a name where a path, a port or a file stood. llama.cpp (the laptop, `L-IQ3-t8`; `--n-cpu-moe 24` on the Q2_0 file; `L-IQ3` without `-t 8 -tb 8`; `L-IQ3-ub` with `--n-cpu-moe 42 -b 4096 -ub 4096`; on the 96 GB card `--n-cpu-moe 0`; on the RTX 3090 Ti `--n-cpu-moe 34`, both builds): ``` llama-server -m "$SHARD1" \ --host --port \ -ngl 99 --n-cpu-moe 34 \ -c 131072 -fa on \ -ctk q8_0 -ctv q8_0 \ -lm mmap --lazy-mode on \ -fit off -np 1 --cache-ram 0 \ --no-webui --jinja -lv 4 \ -t 8 -tb 8 ``` The Strata engine (every attempt; its server wrapper reads the configuration file): ``` python3 "$STRATA_SRC/serve/server.py" --engine strata --config strata-config.json --port ``` with the configuration's engine arguments, on every card: ``` strata --pack "$PACK" --native "$SHARD1" --ple-gguf "$SHARD2" \ --expert-profile "$STRATA_SRC/data/expert-profile.bin" \ --expert-cache auto --prefill auto --spec 4 --spec-min-p 0.5 \ --mtp "$DRAFT_HEAD" --max-context 131072 --kv int8 ``` `S-Q2`'s line adds `--kv-resident 32768`. On both desktop cards the engine ran the laptop's IQ3_S line, pinned, without the `--kv-resident 32768` its setup would add there (`strata-line.json`). Every 0.1.39 attempt, on the laptop and on both desktop cards, ran with the environment `STRATA_NO_LARGEPAGES=1` (its large-pages option off). ## The build lines, as templates Each engine was built from source at the pinned commit, as an unprivileged user; the scripts in `build/` are the lines as they ran, with their checks around them. llama.cpp `3cf03257` for the laptop (`build/laptop-llamacpp-3cf03257-sm120.sh`): ``` cmake -S "$SRC" -B "$OUT" -G Ninja -DCMAKE_BUILD_TYPE=Release -DGGML_CUDA=ON -DCMAKE_CUDA_ARCHITECTURES=120 \ -DCMAKE_CUDA_COMPILER="$CUDA/bin/nvcc" -DGGML_NATIVE=ON -DLLAMA_CURL=OFF -DLLAMA_BUILD_TESTS=OFF cmake --build "$OUT" --target llama-server llama-bench llama-cli -j 16 ``` llama.cpp `3cf03257` for the 96 GB card (`build/desktop-llamacpp-3cf03257-sm120.sh`): ``` cmake -S . -B build -G Ninja -DGGML_CUDA=ON -DCMAKE_CUDA_ARCHITECTURES=120 -DLLAMA_USE_PREBUILT_UI=OFF \ -DCMAKE_CUDA_COMPILER="$CUDA/bin/nvcc" cmake --build build -j 16 ``` llama.cpp `3cf03257` and b11514 (`de7fa0a3`) for the RTX 3090 Ti, each inside a sandbox with no network (`build/desktop-24g-llamacpp-3cf03257-strata-6f32ec07-sm86.sh`, `build/desktop-24g-llamacpp-b11514-sm86.sh`): ``` cmake -S "$SRC" -B "$OUT" -G Ninja -DCMAKE_BUILD_TYPE=Release -DGGML_CUDA=ON \ -DCMAKE_CUDA_ARCHITECTURES=86 -DCMAKE_CUDA_COMPILER="$CUDA/bin/nvcc" -DGGML_NATIVE=ON -DLLAMA_CURL=OFF \ -DLLAMA_BUILD_TESTS=OFF -DLLAMA_USE_PREBUILT_UI=OFF -DCMAKE_BUILD_RPATH="$CUDA_LIB" cmake --build "$OUT" --target llama-server llama-bench llama-cli -j "$JOBS" ``` The Strata engine at `8fc40dde` (0.1.25), `36fa455e` (0.1.36) and `6f32ec07` (0.1.39), with ggml from the local llama.cpp `3cf03257` checkout so nothing is fetched at build time (`build/laptop-strata-8fc40dde-36fa455e-sm120.sh`, `build/laptop-strata-6f32ec07-sm120.sh`, `build/desktop-strata-6f32ec07-sm120.sh`; for the RTX 3090 Ti, `-DCMAKE_CUDA_ARCHITECTURES=86` in the 24 GB card's script). The 0.1.39 builds ran inside a sandbox with no network, and the desktop's add `-DCMAKE_BUILD_RPATH="$CUDA_LIB"`: ``` cmake -G Ninja -S "$STRATA_SRC" -B "$OUT" -DCMAKE_BUILD_TYPE=Release -DSTRATA_ENABLE_CUDA=ON -DSTRATA_BUILD_TESTS=OFF \ -DCMAKE_CUDA_ARCHITECTURES=120 -DCMAKE_CUDA_COMPILER="$CUDA/bin/nvcc" -DSTRATA_GGML_DIR="$LLAMA_CPP_3CF03257" cmake --build "$OUT" --target strata -j 8 ``` ## The client `client/inner.py` runs inside the engine's sandbox: the network probe, the server's launch with a fresh API key, its readiness, the start-up checks, then the requests. `client/engines.py` reads each engine's start-up and serve lines, `client/prompts.py` builds the prompts, `client/common.py` holds the shared constants and `client/units.py` the sandbox units. From the house's earlier harness, `client/vendor/vllm-seats/engine.py` is the stream reader that holds the timing rule of record, `engine_llamaserver.py` llama.cpp's device gate, `gates.py` the offload gate and `nonces.py` the seeded ticket. All three desktop windows ran these bytes; the laptop ran the same `inner.py`, `engines.py`, `prompts.py`, `units.py` and vendored files, and its own copy of `common.py`. They are a reading set, not a program you can run: they import modules this kit does not carry (`quality.py`, `egress.py` and the rest of the earlier harness). Two lines from llama.cpp's start log that the page quotes, from `L-IQ3-t8`'s first attempt (lines 183 and 185; the log itself is not here, below): ``` 0.12.609.145 I load_tensors: CPU_Mapped model buffer size = 35835.49 MiB 0.12.609.149 I load_tensors: CPU_Mapped model buffer size = 27465.95 MiB ``` ## The registration `registration/PREREG.md` is the laptop bench's registration (2026-10-02 19:26:17 UTC) with its addenda and nine amendments, each dated and appended. `PREREG-BANDS.md` holds the desktop's bands (2026-10-05 03:01:33 UTC); `PREREG-W1.md` and `PREREG-W2.md` the two 96 GB-card rows'; `PREREG-W0.md` the desktop's first, exploratory row (llama.cpp's own benchmark tool, whose result file is not in this kit); and `AMENDMENT-24G.md` the RTX 3090 Ti's (2026-10-09 01:49:12 UTC) with its addenda. They were written as working files for our own lanes: four of them open with a line saying so ("Internal: names … and local paths; not for shipping"), and the bands file calls itself internal. That was true of them as written, because they named our machines and paths. The copies here are cut by the rules in `provenance.json`, which take those names and paths out; the line itself is left as the record wrote it, its names replaced like every other. The run records print the digest of the laptop registration as it stood when each attempt started, and the 24 GB card's registration prints its own as registered and at its first addendum. Those digests are of earlier versions of files the rules rewrote, so they read `withheld-2026-09-29`, as does every digest a file here printed of a file before a rule rewrote it. ## Names, and what the rules changed Every rewrite is a named rule, counted per file in `provenance.json`; nothing was edited by hand and no figure moved. - The 24 GB card's three arms carry the public ids the page cites (`R-S139-IQ3-24G`, `R-LS-IQ3-24G`, `R-LS-B11514-IQ3-24G`), and in prose the two desktop cards are "the desktop's smaller card" (the RTX 3090 Ti) and "the desktop's larger card" (the RTX PRO 6000 Blackwell). The computers are "the laptop" and "the desktop", a third bench machine "the bench box", and the operator "an operator". Sentences that named them can read a little stiffly. - A home path becomes `/workshop`. - These become `withheld-2026-10-13`: the model's text in every speed row, the ports a run picked on loopback (a port a JSON file held as a number is written as a string, so the file still parses), the port in one service's unit name, each card's PCI bus address, one comment's example log stamp, and the digest of the article corpus the prompts were cut from (this shelf serves that corpus in another kit with digests withheld inside it). ## Not in this kit - **The model's text.** No reply the model wrote is here. The client's inner rows, which carry each whole reply, are not here. - **The engines' start and server logs.** llama.cpp's server logs print elapsed minutes and seconds as dotted numbers, which our redaction gate reads as private addresses, and no rule may move a figure; the Strata engine's server-wrapper logs are left with them. The Strata engine's own logs are here. - **The quality rows themselves.** Only their counts, in `SUMMARY.md` section 3. - **The other phases.** llama.cpp's nine fit attempts, the load and quality attempts, the flash-attention-off arms and the local-auditor arms are named in `SUMMARY.md` and the registration; their records are not here. - **llama.cpp's own benchmark-tool row** on the 96 GB card, and the window logs, battery-backup readings and process maps around the desktop rows. - **The rest of the harness**: the driver, the row servers, the window kits and their tests.