# Why the first word comes sooner

*Why the Strata engine (github.com/Niko1221/Strata, an unrelated project) gives the first word of an answer sooner than llama.cpp on the same Qwen3.8-Flash-Next files, and what it costs, measured one request at a time on an RTX 5090 laptop card (24 GB, in a laptop with 64 GB of memory, no settable cap), an RTX PRO 6000 Blackwell (96 GB, at a 300 W cap, one engine a night) 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, both engines in one window beside live work on that card): the wait for the first word, writing speed, power, quality and agreement, with llama.cpp at commit 3cf03257 at its default 512-token micro-batch and at a 4,096-token one, and on the RTX 3090 Ti also at a current build (b11514), without the draft head, which the file we benched does not carry.*

*Published 2026-10-12 (UTC) · A small (human) team and a fleet of AI agents.*

**the short version:** The Strata engine (github.com/Niko1221/Strata, an unrelated project) is a program that runs one AI model, Qwen3.8-Flash-Next, on one graphics card plus the computer's own memory. The model is built from many small parts, called experts, and uses only a few of them for each token (a word or a piece of one: the unit an engine reads and writes). We ran the Strata engine beside llama.cpp, the open-source engine it builds on, with llama.cpp pinned at one commit (3cf03257). Both used the same model files (the Strata engine also read the model's draft head from files in its own format, which the GGUF files do not carry) and the same prompts, one request at a time, on two computers. The headline, on the laptop card that cannot hold the model: the first word at a 128,037-token prompt came 545.1 s after sending on llama.cpp at commit 3cf03257 (its default 512-token micro-batch, 8 of the laptop's 24 threads, the experts of 34 of 48 layers in system memory, no draft head because the file we benched carries no draft-head block; llama.cpp at more than 8 threads was not measured) against 47.6 s on the Strata engine 0.1.25 (8,192 tokens a read, 23 expert workers plus its host thread, drafting from the model's draft head, its run beside another job's dry run), the two back to back on 2026-10-02 and 2026-10-03 (UTC), which is the rule that admits a comparison there; the other two cards' figures are below, each under its own rule.

20,010 words · about 91 minutes (at 220 words/min) · 16 tables · data kit: no

https://research.strata2signal.com/flash-next-why-the-first-word-comes-sooner/

---

![The workstation from the back: a pink-lit RTX 3090 Ti beside the bracket of an RTX PRO 6000.](images/the-workstation-after-the-swap-1600.jpg)

**The workstation that ran this bench's two desktop columns, taken 2026-09-25: an EVGA GeForce RTX 3090 Ti FTW3 Ultra (lit pink) beside the bracket of an NVIDIA RTX PRO 6000 Blackwell Workstation Edition.**

Despite the similar name, Strata (github.com/Niko1221/Strata) is an unrelated project; strata2signal has no affiliation with it.

On a laptop whose 24 GB card cannot hold the model, we gave each engine a prompt of 128,037 tokens. llama.cpp, reading the prompt in chunks of 512 tokens (its default) on 8 CPU threads, waited 545.1 seconds for the first word of its answer. Reading it in chunks of 4,096 tokens, its logical batch raised to match, it waited 204.4 seconds (a control run on 2026-10-05, three days after the 545.1 s run, with 8 more layers of experts, 42 of 48, in system memory). The Strata engine 0.1.25, reading 8,192 tokens at a time with about a third of the experts kept on the card, waited 47.6 seconds. Two of these three runs shared the laptop with other work of ours: the Strata engine's with another job's dry run, the 4,096-token run with two of our audit jobs. Which way that cuts is not established; the two repeat pairs we have point opposite ways, and the sections below print both.

On a desktop whose 96 GB card has room for every layer and every expert (on both engines, the model's two input lookup tables stay in the computer's own memory), we measured one engine a night, at a 300 W cap. On a prompt of 4,038 tokens, llama.cpp, reading in chunks of 512 tokens with 8 threads, wrote 102.9 tokens a second; the Strata engine 0.1.39, with all 24,576 experts on the card, wrote 205.3. That gap is beyond unmeasured night-to-night variation, the registered words of our rule for comparing two nights: we have never measured how much a reading moves from one night to the next, so the rule only calls a gap real when it is far larger than either row's own run-to-run range. On this card the first word came sooner beyond that rule at 32K and 128K (20.91 → 6.37 s and 94.22 → 26.63 s, both exploratory) and within it at 4K (2.52 against 1.06 s: no ratio). The Strata engine's lead on this card comes from the model's own draft head, a small extra network that guesses a few tokens ahead (multi-token prediction, one form of speculative decoding). Per step of the model it was not faster than llama.cpp: 78.6 verify rounds a second against llama.cpp's 102.9 single-token steps; each round, though, yielded about 2.6 tokens. llama.cpp at commit `3cf03257` has no support for this model's draft head (upstream llama.cpp added it on 2026-10-01, after that commit and before our first reading, in github.com/ggml-org/llama.cpp/pull/29761; the file we benched carries no draft-head block, so llama.cpp's draft head (#29761, b11514) was not run on it), and its own speculative mode with a separate draft model was not tried. The Strata engine also ran 31 expert-pool workers plus its host thread, a registered condition of its row.

On the same desktop's other card, an EVGA GeForce RTX 3090 Ti FTW3 Ultra (24 GB) at a 300 W cap, in a computer with 123.39 GiB of memory, we ran both engines in one window, one arm after another in a single stretch of time, on 2026-10-09, beside the computer's live services, which kept running on the 96 GB card (this card's own usual work was moved there for the window). On the 4,038-token prompt llama.cpp, with the experts of 34 of the 48 layers in system memory and 8 of the computer's 64 threads (llama.cpp at more than 8 threads was not measured), wrote 22.490 tokens a second; the Strata engine 0.1.39, with 8,144 of 24,576 experts on the card, 31 expert-pool workers and the draft head in use, wrote 98.291: beyond the registered margin (the margin was written down for the pair before it ran). On the same prompt its first word came at 1.92 s against llama.cpp's 16.87 s, beyond the registered margin as well. A third arm ran on this card only: llama.cpp at a current build, b11514 (commit `de7fa0a3`), 452 commits after `3cf03257`, with the same file, line and layer split. On 2026-10-01 llama.cpp added support for this model's draft head (github.com/ggml-org/llama.cpp/pull/29761), but the file we benched carries no draft-head block and b11514 refuses to start the head on it, so this arm ran without it, as every llama.cpp row on this page did; it wrote 22.657 tokens a second at 4K against the pinned commit's 22.490, within the registered margin; no ratio.

On our two short quality tests the model scored below the bar we set before any run, on both engines. On a 108-item test it scored 91, within noise of two 27-billion-parameter models we already run (93 and 96). On a 48-item test that asks for a one-letter answer, most replies came back in another form, which our strict scorer counts as unscored. Every figure below names its run and the conditions it was measured under.

Both projects change weekly. Every reading of the two engines on this page was taken between 2026-10-02 and 2026-10-09 (UTC), with llama.cpp pinned at `3cf03257` (and, on the RTX 3090 Ti only, also run at a current build, b11514, without the draft head) and the Strata engine at 0.1.25, 0.1.36 and 0.1.39; nothing here speaks for a later build of either.

*This page is part of a set on Qwen3.8-Flash-Next. The companion piece, "Uncensored models: what they are and how they work", was released on 2026-10-05.*

*This page is one half of a pair; the other half, Qwen3.8-Flash-Next on an RTX 5090 laptop, an RTX PRO 6000 Blackwell and an RTX 3090 Ti: the Strata engine and llama.cpp, the numbers ([research.strata2signal.com/flash-next-on-three-cards/](https://research.strata2signal.com/flash-next-on-three-cards/)), sets the three cards side by side with charts, findings and suggestions; every figure there is printed here first, with its file and field.*

- **One model, two engines, three cards, one request at a time.** The same Qwen3.8-Flash-Next GGUF files (pinned by hash; they carry no draft-head block, which the Strata engine reads from files in its own format), the same prompts (checked by digest on every request), 256 written tokens, the middle of three runs for every figure.
- **On the 24 GB laptop card the first word came about ten times sooner on the Strata engine 0.1.25** (545.1 → 47.6 s at 128K) than on llama.cpp at commit `3cf03257` reading the prompt 512 tokens at a time, its default, on 8 of the laptop's 24 threads and without the draft head (the file we benched carries no draft-head block; llama.cpp at more than 8 threads was not measured); the two ran back to back on the same laptop, about an hour apart (2026-10-02 and 2026-10-03, UTC), which is the rule that admits a ratio here; the Strata engine read 8,192 tokens at a time with about a third of the experts on the card, on 23 expert workers plus its host thread, drafting from the model's draft head, and its run shared the laptop with another job's dry run. llama.cpp reading 4,096 tokens at a time, its logical batch raised to match, took 204.4 s at 128K (a control run on 2026-10-05, three days after the 545.1 s run, beside two of our audit jobs, with 8 more layers of experts, 42 of 48, in system memory), printed beside the Strata engine's 47.6 s with no ratio of record: the two were not back to back, so no rule here admits one; the arithmetic between them is printed under "What a 4,096-token micro-batch does to llama.cpp", only beside the five things that differ.
- **On the laptop the answer was written 3.5 to 4.9 times faster on the Strata engine 0.1.25** on the IQ3_S file (24.4 → 85.6 tokens a second at 4K, 14.2 → 69.8 at 128K); both banded 4K medians sit inside the bands we wrote down before the run; the two ran back to back on the same laptop, about an hour apart, which is the rule that admits a ratio here. The Strata engine ran 23 expert workers plus its host thread against llama.cpp's 8 threads at its default 512-token micro-batch (8 of the laptop's 24; llama.cpp at more than 8 threads was not measured), and used the model's draft head, which llama.cpp at commit `3cf03257` has no support for (and the file we benched carries no draft-head block for any llama.cpp build to read); its run shared the laptop with another job's dry run.
- **The Strata engine 0.1.39 on the laptop:** a third attempt at its registered re-read, on 2026-10-09, did not run: the laptop's free memory sat below the floor the run needs, so its memory check refused the start, and nothing from it is quoted; no figure from it is printed, and the 0.1.25 rows above stay the laptop's figures of record.
- **On the 96 GB desktop card the Strata engine 0.1.39 wrote twice as fast as llama.cpp at 4K: 205.3 against 102.9 tokens a second**, one engine a night (2026-10-06 and 2026-10-07) at a 300 W cap, beyond unmeasured night-to-night variation, which is the rule that admits a ratio here. llama.cpp at commit `3cf03257` at its default 512-token micro-batch on 8 of the desktop's 64 threads, without the draft head (the file we benched carries no draft-head block; llama.cpp at more than 8 threads was not measured); the Strata engine with all 24,576 experts on the card and 31 expert workers plus its host thread, drafting from the model's draft head: 78.6 verify rounds a second at about 2.6 tokens a round, fewer model steps than llama.cpp's 102.9 and more tokens a step. At 4K the first word and the prompt rate did **not** clear the rule, so no ratio is printed for them.
- **On the 24 GB desktop card, both engines in one window at 300 W beside live work on the computer's other card, in a computer with 123.39 GiB of memory:** the Strata engine 0.1.39, drafting from the model's draft head, wrote faster at 4K (98.291 against 22.490 tokens a second, 4.4×) and gave the first word sooner at 32K (12.14 against 138.02 s, 11.4×, exploratory), both beyond the registered margin, with 8,144 of 24,576 experts on the card and 31 expert-pool workers against llama.cpp at `3cf03257`, no draft head, at its default 512-token micro-batch with 34 of 48 layers' experts in system memory (the laptop's fit, the layer split found on the laptop, not refitted on this card) on 8 of the computer's 64 threads (the laptop's line, its launch line as the laptop ran it, not refitted for this computer; llama.cpp at more than 8 threads was not measured); those eight threads, not the card, set llama.cpp's writing speed. **llama.cpp at a current build (b11514), no draft head, on the same card:** llama.cpp b11514 (commit `de7fa0a3`) wrote 22.657 tokens a second at 4K against 22.490 at `3cf03257`, within the registered margin; no ratio; its first word at 4K 15.84 against 16.87 s. Two builds 452 commits apart, the same file, line, layer split and card, the later one run last in the window with the model's weights file already in the computer's file cache (0 major page faults on its nine runs); neither build ran the draft head, because the file we benched carries none. The other two cards' llama.cpp rows are at `3cf03257`.
- **On the laptop, llama.cpp used 3.5 to 5.3 times the graphics card's energy per request** on the IQ3_S file, and 3.8 to 5.9 times counting the CPU package as well; neither is wall power. The Strata engine drew about twice the board power for a much shorter time; its run shared the laptop with another job's dry run. The desktop rows record watts and claim nothing about energy.
- **Quality:** on our six-way test (108 items) the model scored 91 through either engine on the IQ3_S file, within noise of the two 27-billion-parameter models we ran on the same laptop (93 and 96: our own rows on another engine, provisional). On our doorman test (48 items, a one-letter answer asked for), 36 of 48 replies through the Strata engine came in a form our strict scorer does not read, so it scored 11 (through llama.cpp, 40 of 48 and 7). The value test we registered, 93 and 36 (the comparators' own scores), was not met on any arm; over both tests together qwen3.5:27b was ahead, 142 to 102, and 35 of those 40 points are the doorman's format; no "better" anywhere.
- **The four pass-or-fail tests we registered:** the engines ran (passed on every arm that started; the one arm without the draft head would not start and is recorded as refused); the two engines agree to our bar (not met); the value test (not met); "better than qwen3.5:27b" (not met).
- **Who it is for:** one person, one conversation at a time, this one model, a Linux computer with an NVIDIA card (the engine also builds for AMD's HIP; we tested NVIDIA only), built from source, with the memory to keep every expert in system memory: 46.84 GiB for the IQ3_S file, and our 64 GB laptop had 2.66 GiB left at 128K against our stop line of 2.0; about 84 GB of disk for the IQ3_S download (54.8 + 28.8 GB). For a 24 GB card the usual alternative is a 27-billion-parameter model that fits the card whole; we did not measure one's speed on this bench.

*Ratios divide the unrounded medians in the rows; dividing the rounded figures shown can differ in the last place.*

## What this page is {#what-this-page-is}

*We are a small workshop that measures what it runs. The question here is a plain one: why does the Strata engine give the first word of an answer sooner than llama.cpp on the same files, and what does it cost? We asked it on a 24 GB laptop card that cannot hold the model, on a 96 GB desktop card with room for every layer and every expert (one engine a night), and on a 24 GB desktop card in a computer with 123.39 GiB of memory (both engines in one window). Every figure names its reading. Dated updates will add the readings listed near the end of this page.*

## The words this page leans on {#the-words-this-page-leans-on}

- **A token.** A word or a piece of one: the unit an engine reads and writes. Prompt lengths and writing speeds on this page are counted in tokens.
- **A model and an engine.** The model is the weights, a set of large files. An engine is the program that loads them and answers requests. The same files can run on more than one engine, which is what this page compares.
- **A mixture of experts.** Qwen3.8-Flash-Next's 48 layers each hold many small sub-networks ("experts"); for each token the model routes the work to a few of them. The files hold 24,576 expert slots in all. Only a fraction of the weights are used for any one token, which is why a model this large can run at all on a laptop with the memory to hold every expert (46.84 GiB pinned in system memory for the IQ3_S file; our laptop's 64 GB was just enough).
- **Room on the card.** A card holds a fixed amount of memory (24 GB on the laptop and on the desktop's second card, 96 GB on the desktop's first). When the weights do not fit, an engine keeps part of them in the computer's own memory and moves them across as needed, which is slower. The 96 GB card has room for every layer and every expert; even there, on both engines, the model's two input lookup tables stay in the computer's memory.
- **GB and GiB.** A GiB is 1,024 × 1,024 × 1,024 bytes, the unit the system reports, so a figure read off a computer (123.39 GiB of memory, 46.84 GiB of experts) is in GiB. The GB on a memory module's or a card's label counts the same way, in powers of two, so the desktop's 128 GB of modules is 128 GiB and the laptop's 64 GB is 64 GiB; the system reports 123.39 and 61.23 GiB of them, because part of the installed memory is reserved before the system counts it. A bandwidth in GB/s is a billion bytes a second.
- **Threads and workers.** A thread is one stream of work on the CPU; llama.cpp's thread count is how many it computes with. The Strata engine's "expert-pool workers" are its own CPU threads for expert work, counted as its log counts them, plus one host thread.
- **Reading the prompt, and the first word.** Before an engine can answer it reads the whole prompt (the "prefill"). The time to the first word of the answer is mostly that reading. We give it in seconds.
- **Writing the answer.** After the first word the engine produces tokens one step at a time (the "decode"). We give it in tokens a second, timed on our own client's clock.
- **A micro-batch.** How many prompt tokens llama.cpp processes in one pass; this page also writes it as reading the prompt "N tokens at a time". Its default is 512; we also measured 4,096. The Strata engine reads 8,192 at a time.
- **Context, or prompt length.** 4K, 32K and 128K here mean prompts of 4,038, 32,038 and 128,037 tokens.
- **The KV cache.** An engine's working memory for the text so far: the "keys" and "values" that attention computes for every token read. "8-bit" or "16-bit" says how compactly it is stored.
- **The expert cache and its hit rate.** The Strata engine keeps some experts on the card, chosen from a profile it ships ("ranked by routing frequency, no eviction", its own words) and fixed at load; the hit rate is the share of experts it needed that were already on the card. When every expert fits, as on the 96 GB card, there is no hit rate to report.
- **The draft head, and tokens a round.** The model ships a small extra network that guesses several tokens ahead (multi-token prediction, "MTP", one form of speculative decoding); the Strata engine checks the guesses in one step of the model ("a verify round") and keeps the right ones. On our runs a round yielded about 2.2 to 2.8 tokens. llama.cpp at commit `3cf03257` has no support for this model's draft head (upstream llama.cpp added it on 2026-10-01, after that commit and before our first reading; the file we benched carries no draft-head block, so llama.cpp's draft head (#29761, b11514) was not run on it); its own speculative mode, which drafts with a separate small model, was not tried. On the RTX 3090 Ti only, we also ran a current build, b11514, without it (its own section below).
- **Flash attention.** An implementation of attention that reads memory in a different order and is usually faster. Every speed row ran with it on; the agreement rows on llama.cpp ran with it off, because llama.cpp's build stopped on one quality prompt with it on (the reason is given below).
- **IQ3_S and Q2_0.** Two compressed copies of the weights (the names are quantization formats; IQ3_S is a 3-bit-class compression, Q2_0 a 2-bit-class one). The IQ3_S file is 54.8 GB plus a 28.8 GB lookup table shared by both. We compare the engines within each file, not across files: their CPU code paths differ by format.
- **An arm, a band, a gate, a control.** An arm is one engine with one file and one set of settings. A band is the range we wrote down for its 4K writing speed before the run; a reading outside it is "opened": investigated, and what we found written down, before anyone quotes it. A gate is a pass-or-fail test registered before the run. A control is an arm with no band and no gate, run to answer one question about another arm.
- **Registered, and an amendment.** A reading is registered when its arm, band and gates were written down and dated before it ran; an amendment is a dated addition to that registration, appended in order, never a rewrite.
- **The median of three, first request after load included.** Each context's figure is the middle of three runs, and the first run after the engine loaded (its first word comes later on every engine) stays in the three.
- **The cross-night rule.** Two rows measured on different nights are reported as different only when the gap exceeds the larger of two margins: 10 % of the larger reading, or three times the wider row's spread (its highest run minus its lowest) across its three runs. The page then says "beyond unmeasured night-to-night variation"; otherwise "within unmeasured night-to-night variation". The margin is wide on purpose: we have never measured how much a reading drifts from one night to the next, so we only call a gap real when it is far larger than a row's own run-to-run range. On the 24 GB desktop card, where both engines ran in one window, the same formula was written down for the pair before it ran and is called "the registered margin" on this page; a ratio prints only when a gap is beyond it.
- **The six-way and the doorman; strict.** Our two short quality tests. The six-way: 108 items, each a line from a dinner-table conversation, asking which of six named guests said it (a reading test). The doorman: 48 prompts that ask the model to decide, as a doorman would, whether to admit or refuse, and to answer with a single letter (a judgment test that is also a format test). "Strict" means the scorer reads only the asked-for form and counts any other reply as unscored.
- **McNemar's test.** A statistical test of whether two models' right-and-wrong answers on the same items differ by more than chance; the only "better" this page would ever print.
- **Exploratory.** A figure with no band and no gate written down before it ran, so it confirms or refutes no prediction; it is printed for the record, with the label, and the comparison rules (the cross-night rule, the registered margin) still apply to it. The desktop rows have their own registration: a band at 4K for each engine, and exploratory rows at 32K and 128K.

## Which cards this page covers {#which-cards-this-page-covers}

| Card | Memory | Where the model's experts sat | Rows on this page | State |
|---|---|---|---|---|
| NVIDIA GeForce RTX 5090 Laptop GPU | 24 GB | llama.cpp: 34 of 48 expert layers in system memory on IQ3_S (42 for the 4,096-token control; 24 on Q2_0); the Strata engine: 8,120 of 24,576 experts on the card on IQ3_S (13,595 on Q2_0) | The laptop body: both engines, both files | Measured 2026-10-02 → 2026-10-05 (UTC) |
| NVIDIA RTX PRO 6000 Blackwell Workstation Edition | 96 GB | Every layer, every expert on the card (on both engines, the two input lookup tables stay in host memory) | One engine a night: llama.cpp 2026-10-06, the Strata engine 0.1.39 2026-10-07; a 300 W power cap, registered for these rows | Measured; a same-night pair is planned (dated update) |
| NVIDIA GeForce RTX 3090 | 24 GB | — | None | Not measured; listed because an RTX 3090 Ti is not an RTX 3090, and no row on this page is an RTX 3090's |
| EVGA GeForce RTX 3090 Ti FTW3 Ultra | 24 GB | llama.cpp: the experts of 34 of the 48 layers in system memory; the Strata engine 0.1.39: 8,144 of 24,576 experts on the card; llama.cpp b11514, no draft head: the same 34 of 48 in system memory | The 24 GB desktop card: both engines in one window, and the b11514 arm; a 300 W cap, registered | Measured 2026-10-09 (UTC), beside live work on the computer's other card |

The Strata engine's versions on this page: 0.1.25 (registered, the laptop), 0.1.36 (exploratory, the laptop) and 0.1.39 (its laptop re-read produced no figure, nothing quoted; registered with a band at 4K on the 96 GB card and on the RTX 3090 Ti).

## One model, two engines {#one-model-two-engines}

Qwen3.8-Flash-Next is a mixture-of-experts model: 125 billion parameters, about 6 billion active for each token, plus a 51-billion-parameter lookup table and a 4-billion-parameter draft head (its model card: "125B with 6B activated, plus 51B n-gram embedding and 4B MTP"). The compressed copies we ran come from ISTA-DASLab's `Qwen3.8-Flash-Next-GSQ-RCO-GGUF` at a pinned revision: the IQ3_S weights in one 54,817,524,224-byte file, the Q2_0 weights in one 37,623,740,192-byte file, and a second 28,800,138,432-byte file shared by both that holds a lookup table the model reads by token. A table that size is unusual, and what matters here is where it sits: both engines keep it in the computer's own memory and read from it only the rows the tokens in hand need, so it costs little speed there [inferred from both engines' placement lines; neither project says so]. That is also how about 84 GB of IQ3_S files run on a 24 GB card and 64 GB of memory: llama.cpp maps the files and pages them in as it reads (the arithmetic is under "What else the bench read"), and the Strata engine pins the experts in system memory and copies a third of them to the card. llama.cpp's loader prints 176.94 billion parameters at start-up (its own log), a count we read as including that table [inferred]; the model card's three figures add to 180 billion [arithmetic], and Hugging Face counts 179,999,981,459 in Qwen's own unquantized files.

On the laptop neither engine can put the model on the card. **llama.cpp** keeps 34 of the 48 layers' experts in system memory for the IQ3_S file (24 for Q2_0), the fewest it could keep there and still fit under our 1,536 MiB margin; during writing it computes those experts on the CPU, and while reading the prompt it ships them to the card once per micro-batch [inferred from its log lines and its flat prompt rate, below]. **The Strata engine** pins all 24,576 experts in system memory (46.84 GiB for IQ3_S, by the engine's own load line) and keeps copies of the 8,120 its shipped profile ranks hottest on the card (15.40 GiB, about a third), fixed at load; it reads prompts 8,192 tokens at a time, lends 4.43 GiB of its cache to the prompt path while it reads, and drafts several tokens a step from the model's own draft head (the engine's own log lines, `S-IQ3/speed/a1/engine.log`). Both engines spend part of a prompt step moving experts from system memory to the card [inferred]; the Strata engine amortises each trip over sixteen times as many tokens as llama.cpp's default, twice as many as the 4,096-token control. That is our reading of the logs, not a claim either project makes.

On the desktop card both engines put every layer and every expert on the card. llama.cpp "offloaded 49/49 layers to GPU" with a 51,945.51 MiB model buffer on the card and the two input lookup tables (322.07 MiB and 27,465.95 MiB) mapped in host memory (`R-LS-IQ3` server log). The Strata engine 0.1.39 placed the same two tables in host memory ("token embedding IQ4_XS in mapped host memory (322 MiB)", and the second file's table, its log lines 3 and 8) and reported "expert cache 24576 slots, 46.84 GiB of VRAM", "pre-filled 24576 of 24576 slots from the profile" and "100% VRAM resident: zero-doorbell graph" (`R-S139-IQ3` engine log), with 40,948 MiB of the card's memory still free after everything was loaded.

## The question, and the instruments {#the-question-and-the-instruments}

**The question the laptop rows answer:** on one 24 GB laptop graphics card that cannot hold the model, how much sooner does the Strata engine give the first word of an answer, and how much faster does it write, than llama.cpp running the same Qwen3.8-Flash-Next files, and how much of that lead is left once llama.cpp reads the prompt in larger batches?

**The question the 96 GB card's rows answer:** what do the same two engines do, with the same files, prompts and client, on a card with room for every layer and every expert?

**The question the 24 GB desktop card's rows answer:** the laptop's question, asked on a desktop: what do the same two engines do on a 24 GB card that cannot hold the model, in a computer with room for every expert in its memory, both engines in one window; and what does a current llama.cpp build, b11514, do against the pinned commit on the same line, without the draft head?

**The laptop.** One NVIDIA GeForce RTX 5090 Laptop GPU (24 GB) on Dynamic Boost (the laptop moves power between CPU and card; we read a limit of 135-150 W, and the board refuses a cap, answering "Changing power management limit is not supported", as our page "A laptop, asked the desktop's questions" (2026-09-22) records); an Intel Core Ultra 9 290HX Plus (24 threads: 8 performance cores with no SMT, and 16 efficiency cores), 64 GB of DDR5 memory (61.23 GiB reported), Ubuntu 26.04.1 with NVIDIA driver 595.91.07. llama.cpp ran 8 threads (its default picked 4; an amendment raised it to the 8 performance cores, and the 4-thread row is printed too); the Strata engine ran 23 expert-pool workers plus its host thread. Going from 4 threads to 8 left llama.cpp's first word about unchanged at 32K and 128K (126.7 → 125.6 s, 557.6 → 545.1 s) and later at 4K (15.2 → 19.1 s), and raised its writing speed by 4 to 21 % (20.2 → 24.4, 18.4 → 20.7, 13.6 → 14.2 tokens a second). llama.cpp at more than 8 threads was not measured.

**The desktop.** One NVIDIA RTX PRO 6000 Blackwell Workstation Edition (96 GB), its power limit set to 300 W and read back as 300.00 W on every one-second sample (that computer usually runs the card at 420 W; a 300 W cap was registered for these rows on 2026-10-05, the posture we had first used for a bench window on 2026-09-27, so that the computer's whole draw stays inside its battery backup's budget), nothing else running on the card; a CPU without AVX-512 (the Strata engine's own line: "the expert kernels run on AVX-2"), 64 hardware threads, llama.cpp at 8 of them; the Strata engine ran 31 expert-pool workers plus its host thread; each row inside a memory cap of 80 GiB. The desktop does other work, so each engine got its own short window, one engine a night. The computer's other services were stopped for each row, the same set both nights; its second card, an RTX 3090 Ti, kept its own work both nights and was not measured on them; it was measured in its own window on 2026-10-09 (next).

**The 24 GB desktop card.** One EVGA GeForce RTX 3090 Ti FTW3 Ultra (24 GB, Ampere), the same desktop's second card, on a PCIe 4.0 x16 link, with its power limit set to 300 W and read back before each arm (it read 350 W before the window, and its board allows up to 480 W); the same processor, an AMD EPYC 7532 (32 cores, 64 hardware threads, Zen 2, no AVX-512, so the Strata engine's expert kernels run on AVX-2) and the same 123.39 GiB of memory (128 GB of DDR4-3200 in eight channels); llama.cpp at 8 of the threads; the Strata engine 0.1.39 with 31 expert-pool workers plus its host thread, which here compute the experts its cache misses; each row inside a memory cap of 80 GiB. Unlike the two 96 GB nights, nothing was stopped for this window: the computer's live services kept running on the 96 GB card, and this card's own usual work was moved there for the window, so every figure of this card carries "beside live work on the computer's other card", as the laptop's figures carry their shared-work labels. Both engines ran in one window on 2026-10-09 (09:32Z to 10:51Z), each built from source for this card's architecture (`sm_86`) at the commits named below: the Strata engine first, then llama.cpp at `3cf03257`, then llama.cpp at a current build, b11514 (commit `de7fa0a3`, 2026-10-08), 452 commits after `3cf03257`, on the same line, file and layer split, without the draft head (the file we benched carries none).

**The engines.** llama.cpp at commit `3cf03257` on both computers, and at b11514 (commit `de7fa0a3`) on the 24 GB desktop card only (a CUDA build for each card's own architecture; the Blackwell build serves only the 96 GB card; the 24 GB desktop card had its own). The Strata engine at `8fc40dde` (v0.1.25, the registered laptop arms), `36fa455e` (v0.1.36, exploratory, laptop) and `6f32ec07` (v0.1.39, registered with a band on the 96 GB card and on the 24 GB desktop card; its laptop re-read produced no figure; with the engine's large-pages option off). All built from source. Our rule for every project we bench is the same: build from the source we have read, and run nothing that installs, fetches or updates; so the engine's installer, setup script, prebuilt binaries and MCP bridge were never run.

**What llama.cpp was not given here.** Four things a llama.cpp user will ask about, each answered on this page: its micro-batch (the 512-token default on both computers, and a 4,096-token control on the laptop; 8,192 was not tried); its threads (8 of the laptop's 24, where going from 4 to 8 moved its writing 4 to 21 %; more were not measured); its memory map (kept, and its own log warns it costs speed, under "What else the bench read"); and a draft model (it has no support for this model's draft head at this commit, the file we benched carries no draft-head block for any build to read, and its separate-draft-model mode was not tried; on the RTX 3090 Ti only, a current build, b11514, was also run, without the head, in that card's section). These are close to llama.cpp's defaults, not its tuned best.

**The harness.** One server start per arm; the same prompt bytes at 4,038, 32,038 and 128,037 tokens, checked by digest on every request; 256 tokens written, greedy (temperature 0), thinking off; the order 4K × 3, 32K × 3, 128K × 3; the first word and the writing speed timed on our client's clock (the engine's own clock printed beside, never in its place); every reply's token count was checked as it ran (on every row but the 4-thread llama.cpp row, which recorded no check), and recounted with llama.cpp's tokenizer afterwards; a decode figure enters a median only when its count holds. The recount covers every row on this page except two: the 4-thread llama.cpp row (no count check was recorded) and the 4,096-token control (its tokenizer recount has not run). The row ids this page cites (`L-IQ3-t8/speed/a1/run-001…009` and the like) are the names the rows carry in the kit, which has not shipped; until it does, no citation here can be followed to a file, and the Sources table at the end names the file and field each figure will be read from.

**Written down before any run.** The laptop's bands for writing speed at 4K: llama.cpp IQ3_S 20-55 tok/s, llama.cpp Q2_0 10-45, the Strata engine IQ3_S 40-90, the Strata engine Q2_0 60-130, the Strata engine without its draft head 25-55. The desktop's bands, drawn before any desktop reading: llama.cpp 85-160 tok/s (from the card's published bandwidth and the bytes read per token); the Strata engine 113-350 (in verify rounds, 50-130 a second, times the tokens a round the laptop had shown). The gates: G0 the runnable check, G1 the agreement check (the same strict outcome on at least 105 of 108 six-way items and 47 of 48 doorman items), G2 the value test (at least 93 of 108 and 36 of 48: the six-way score of qwen3.8:27b and the doorman score of our gemma4 anchor, both our own earlier rows on the same laptop), and "Better" (an exact McNemar test against qwen3.5:27b's rows on the same laptop, p < 0.05, the only win anyone may claim).

## Why the first word comes sooner, in three sentences {#why-the-first-word-comes-sooner-in-three-sentences}

Each sentence is our reading of the engines' own logs, not a claim either project makes; the logs read are the laptop's. The first sentence describes a card that keeps part of the experts in system memory, as the laptop and the 24 GB desktop card do (that card's own cache size and hit rate are in its section); on the 96 GB card every expert sits on the card, so the first sentence's expert trips do not arise there, and this page does not split that card's first-word lead. While reading a prompt on the laptop, llama.cpp copies the experts it keeps on the CPU across to the card once for every chunk of prompt it reads, 512 tokens at its default, while the Strata engine reads 8,192 tokens at a time, sixteen times as many for each trip, and keeps the most-used third of the experts on the card, so that about 92 % of its expert lookups found the expert already there (the hit rate, printed with the rows) [inferred]. While writing the answer, the Strata engine uses the model's draft head to guess several tokens a step and keep the right ones, about 2.2 to 2.8 tokens a round on our runs, while llama.cpp at commit `3cf03257` writes one token a step. How much of the lead is the batch, how much the cache and how much the draft head is not split here: the arm that would have isolated the draft head would not start (under "What was written down before the first run"), and "not split here" never means "cannot be split".

## The first word (the laptop, the IQ3_S file) {#the-first-word-the-laptop-the-iq3-s-file}

*Every first-word figure carries, in the same sentence: llama.cpp at a 512-token micro-batch (its default) or a 4,096-token one, with its thread count and how many layers of experts sat in system memory; the Strata engine (github.com/Niko1221/Strata) reading 8,192 tokens at a time with about a third of the experts on the card. The columns: "llama.cpp, 512" is 8 threads with 34 of 48 layers' experts in system memory; "llama.cpp, 4,096" is 8 threads with 42 layers in system memory; "the Strata engine" is 0.1.25.*

| Prompt length | llama.cpp, 512 (s) | llama.cpp, 4,096 (s) | The Strata engine (s) | 512 ÷ 4,096 | The Strata engine's lead at 512 | Its lead at 4,096 |
|---|---:|---:|---:|---:|---:|---:|
| 4K (4,038 tokens) | 19.1 | 7.6 | 1.9 | 2.5× | 10.0× | 4.0× |
| 32K (32,038 tokens) | 125.6 | 50.0 | 12.1 | 2.5× | 10.4× | 4.1× |
| 128K (128,037 tokens) | 545.1 | 204.4 | 47.6 | 2.7× | 11.5× | 4.3× |

**The three runs behind each median (s).** llama.cpp, 512: 36.8 / 19.1 / 17.1 at 4K; 136.6 / 123.9 / 125.6 at 32K; 569.7 / 539.0 / 545.1 at 128K. llama.cpp, 4,096: 18.2 / 7.6 / 5.1; 50.0 / 64.1 / 49.9; 204.4 / 185.4 / 210.1. The Strata engine: 2.2 / 1.9 / 1.9; 12.2 / 12.1 / 12.1; 47.4 / 47.6 / 47.7. The first run at 4K on each arm is the first request after load.

Rows: `L-IQ3-t8/speed/a1/run-001…009` (2026-10-02T23:03:15Z → 23:40:55Z), `L-IQ3-ub/speed/a1/run-001…009` (2026-10-05T14:43:47Z → 14:59:47Z; a control, no band; measured while two of our audit jobs ran on the laptop), `S-IQ3/speed/a1/run-001…009` (2026-10-03T00:46:41Z → 00:50:45Z; measured while another job's dry run shared the laptop). Each row's `ttft_ms`.

| Prompt length | Prompt rate, llama.cpp, 512 (tok/s, engine's clock) | Prompt rate, llama.cpp, 4,096 (tok/s) | Prompt rate, the Strata engine (tok/s) |
|---|---:|---:|---:|
| 4K | 211.7 | 533.7 | 2,147.5 |
| 32K | 255.1 | 640.9 | 2,655.1 |
| 128K | 234.9 | 626.7 | 2,705.0 |

The same rows, each row's `prompt_tok_s_server`. llama.cpp's flat rate across a 32-fold range of prompt lengths is what a fixed cost per micro-batch produces [inferred].

**llama.cpp at 4 threads, its own default:** first word 15.2 / 126.7 / 557.6 s at 4K / 32K / 128K (`L-IQ3/speed/a1/run-001…009`, "at 4 threads" on every figure). At 4K the default 4 threads answered sooner than 8 (15.2 against 19.1 s); the 8-thread row is the one this page reads as llama.cpp's, under the amendment that set 8 threads for every later llama.cpp launch, and it carries the same band, written down before either row ran.

**The same nine requests, first sent to last answered:** 37.2 minutes on llama.cpp at its default micro-batch (2026-10-02 23:03:38Z → 23:40:52Z) against 3.6 minutes on the Strata engine (2026-10-03 00:47:08Z → 00:50:42Z; its run shared the laptop with another job's dry run), 10.4×, from each arm's own request log.

### What a 4,096-token micro-batch does to llama.cpp {#what-a-4-096-token-micro-batch-does-to-llama-cpp}

We registered one control after the first readings, to answer one question: is llama.cpp's first-token wait at 128K on this card set by its default 512-token micro-batch? The control was measured 2026-10-05T14:43:47Z → 14:59:47Z, three days after the base run (2026-10-02T23:03:15Z → 23:40:55Z). Both llama.cpp runs above are the same build, file, threads, flash attention, 8-bit KV cache, one server start, the same prompts and nonces. **Five things differ, and all five print beside every figure.** Two by design: the micro-batch, and how many of the 48 layers' experts sit in system memory, because the bigger batch's compute buffer on the card (7,966.56 MiB against 1,200.57 MiB, each start's own log) pushed 8 more layers off the card. Three the records show: the logical batch moved with the micro-batch (`-b 4096` as well as `-ub 4096`); the two arms ran three days apart; and the control ran beside two of our audit jobs, and the control's box readings sat in the base run's range, which does not show the jobs cost it nothing.

- **Batching is a large part of it.** Reading the prompt 4,096 tokens at a time instead of 512 made llama.cpp's prompt rate 2.5 to 2.7 times higher at every length and cut its wait for the first word by 60.3, 60.2 and 62.5 % (4K, 32K, 128K).
- **Most of the lead survives it.** With the bigger batch the Strata engine still gave the first word about four times sooner (4.0×, 4.1×, 4.3×), against about 10 to 11.5 times sooner at llama.cpp's default.
- **There is no single honest "share".** In seconds the bigger batch closed 67.0, 66.6 and 68.5 % of the gap, about two thirds (at 128K, 497.6 s of extra wait became 156.8 s); as a ratio on a log scale it closed about 40 % (40.2, 39.4, 40.2 %). Two rules, two answers; the page prints both and the values behind them.
- **It cost writing speed on this card.** With the bigger batch llama.cpp wrote 8.0, 6.1 and 8.4 % slower (24.4 → 22.5, 20.7 → 19.4, 14.2 → 13.0 tok/s), which is what 8 more layers of experts on the CPU would predict [inferred]; the control also ran on another day beside two of our audit jobs, so the records do not isolate the cause. Against the control the Strata engine's writing lead reads slightly larger (3.8×, 4.5×, 5.3× against 3.5×, 4.2×, 4.9×). On a 24 GB card a bigger batch and more layers on the card compete for the same memory.
- **What the remaining 4× is made of is not split here.** The Strata engine reads 8,192 tokens at a time (twice the control's batch), keeps 8,120 of 24,576 experts on the card from its shipped profile, and runs 23 expert-pool workers plus the host thread against llama.cpp's 8; llama.cpp at 8,192 was not tried (the control registered 4,096 only, and 4,096 already cost 8 layers). "Not split here", never "cannot be split".

**What this control does not say:** nothing about other micro-batch sizes, thread counts, llama.cpp commits, flash attention off, or the Strata engine. One server start per arm, each arm on its own day.

## Writing the answer (the laptop, the IQ3_S file) {#writing-the-answer-the-laptop-the-iq3-s-file}

*The task: a section-by-section summary of English prose, greedy (temperature 0), 256 tokens. Tokens a second on our client's clock. Caption: llama.cpp 8 threads, flash attention on; the Strata engine (github.com/Niko1221/Strata) 23 expert workers plus its host thread, with the model's draft head, which llama.cpp at this commit has no support for; llama.cpp at more than 8 threads was not measured. The columns: "llama.cpp, 512" is 34 of 48 layers' experts in system memory; "llama.cpp, 4,096" is 42 layers; "the Strata engine" is 0.1.25.*

| Prompt length | llama.cpp, 512 (tok/s) | llama.cpp, 4,096 (tok/s) | The Strata engine (tok/s) | The Strata engine ÷ llama.cpp at 512 | ÷ llama.cpp at 4,096 |
|---|---:|---:|---:|---:|---:|
| 4K | 24.4 | 22.5 | 85.6 | 3.5× | 3.8× |
| 32K | 20.7 | 19.4 | 87.1 | 4.2× | 4.5× |
| 128K | 14.2 | 13.0 | 69.8 | 4.9× | 5.3× |

**The three runs behind each median (tok/s).** llama.cpp, 512: 24.4 / 24.0 / 24.7; 20.9 / 20.7 / 20.5; 14.3 / 14.2 / 14.2. llama.cpp, 4,096: 20.9 / 23.0 / 22.5; 18.1 / 19.9 / 19.4; 13.0 / 13.0 / 13.5. The Strata engine: 78.2 / 91.4 / 85.6; 87.3 / 85.6 / 87.1; 71.9 / 69.8 / 64.9.

**Against the bands:** llama.cpp 24.4 tok/s at 4K inside 20-55; the Strata engine 85.6 inside 40-90; the control has no band. One single run sits outside its band, the Strata engine's second 4K run at 91.4 against a top of 90: opened: that run had the best draft acceptance of the three (2.72 tokens a round, against 2.56 and 2.69). The first run after load, 78.2, carried a lower hit rate (0.871, against 0.917 and 0.925); its cause is not established; the cache's contents are fixed at load, so it is not a cache filling up. Medians do not move: opening never deletes a reading.

**The expert cache's hit rate** on the Strata engine: 0.917 / 0.932 / 0.923 at 4K / 32K / 128K (the share of experts looked up that were already on the card; a speed condition, never a speed figure). Tokens a verify round, derived: 2.69 / 2.56 / 2.25.

**llama.cpp at 4 threads:** 20.2 / 18.4 / 13.6 tok/s (`L-IQ3/speed/a1`), inside 20-55 at 4K; its first 4K run, 19.3, sits under the band's floor and was opened as the first request after load, paging the memory-mapped weights in from disk: about 4.8 GB read from disk inside its window, a mean of 113 MB/s with a one-second peak of 714 MB/s, against about 0.06 and 0.04 GB, means of 2.3 and 1.4 MB/s, in the two runs after it (each row's `telemetry.data_read_mb_per_s`, and the attempt's one-second telemetry file for the peak).

**The Strata engine at a newer commit (v0.1.36, exploratory, no band, no gate; `S-HEAD/speed/a1/run-001…009`, 2026-10-03T00:55:33Z → 00:59:30Z, measured while another job's dry run shared the laptop):** writing 80.4 / 79.6 / 74.0 tok/s; first word 1.8 / 11.2 / 46.1 s. Its writing medians sit below 0.1.25's at 4K and 32K and above at 128K, and its first word came sooner at all three; both runs shared the laptop with another job, and nothing measures the variation between them. Labelled on every figure.

**The Strata engine 0.1.39 on the laptop:** its registered re-read at 4K and 32K (the ninth amendment to our registration) has produced no reading. Two attempts stopped on our memory guard, and a third, on 2026-10-09, did not run: the laptop's free memory sat below the floor the run needs, so its memory check refused the start, and nothing from it is quoted. A 128K reading on this laptop is not planned, and the desktop's 128K figure never fills that cell.

**A note on the Strata engine's registered run, and the repeat that stopped.** What this note covers: the registered IQ3_S run above shared the laptop with another job's dry run; a clean repeat of it was made later the same day (2026-10-03T07:25:25Z → 07:27:14Z, stopped at 07:27:25Z) and our memory guard stopped it after 7 of its 9 requests, on pressure from other work on the laptop rather than the engine's own, so it is not a reading of record. The figures of record are the overlapped run, labelled. The stopped repeat's rows are printed here beside them, labelled "stopped attempt, not of record": writing 91.3 tok/s at 4K (78.0 / 91.3 / 93.0) and 92.5 at 32K (90.3 / 95.6 / 92.5), against the overlapped run's 85.6 and 87.1; first word 1.9 and 11.9 s against 1.9 and 12.1; its one completed 128K request wrote 81.5 tok/s after a 47.0 s first word (`S-IQ3/speed/a2/run-001…007`). The direction of the overlap is not established, and the two pairs we have point opposite ways: on this file the stopped repeat wrote faster than the overlapped run, while on the Q2_0 file the clean repeat wrote slower (115.2 against 120.8 at 32K, and 102.5 against 110.6 tokens a second at 128K; the first attempt 2026-10-03T00:40:23Z → 00:44:02Z, the clean re-read 05:09:47Z → 05:13:25Z). The Q2_0 pair also differed in how often it reached its memory cap, so neither pair isolates the overlap, and the label does not mean the Strata engine's figures of record are conservative. The Q2_0 4K pair waits on its opening.

## The Q2_0 pair (the laptop) {#the-q2-0-pair-the-laptop}

*llama.cpp 8 threads, 24 of 48 layers of experts in system memory, flash attention on; the Strata engine (github.com/Niko1221/Strata) 0.1.25, 23 expert workers plus its host thread, the draft head on. The figures of record are each arm's clean re-read (quiet-checked, no other job on the laptop); the first attempts, which overlapped another job's dry run, are printed beside them. llama.cpp's clean re-read ran up against the 33 GiB memory limit our harness set for that run (the Strata engine's runs on this file, which pin 31.64 GiB of experts, ran under a limit of 40 GiB of their own; each arm's run record writes out its rule: for llama.cpp, the expert pages it maps on the CPU side plus 3.0 GiB of host buffers and 14 GiB of room for the file cache, never above the laptop's memory less 6 GiB; for the Strata engine, its resident memory plus 4 GiB; each rounded to a whole GiB). The limit was reached 2,233 times over the server's whole run, 1,702 of them inside the nine requests' own windows, most in each prompt length's first request (1,175, 193 and 325 times). The share of time its work waited on memory peaked at 38.4 %, and its 32K writing median comes from one of those requests. Its first attempt never reached its limit, and the two llama.cpp attempts agree within about 6 % on every figure (the capped run against the uncapped: first word +2.8, −4.4 and +1.8 %, a longer wait at 4K and 128K; writing +6.3, +5.0 and +1.8 %, faster at every length), so the limit did not set these figures [inferred: the uncapped attempt shared the laptop with another job's dry run, so the pair does not isolate the limit]. The Strata engine's first attempt, printed beside, reached its own limit 21,040 times; its clean re-read never did.*

| Prompt length | First word, llama.cpp (s) | First word, the Strata engine (s) | llama.cpp ÷ the Strata engine | Writing, llama.cpp (tok/s) | Writing, the Strata engine (tok/s) | The Strata engine ÷ llama.cpp |
|---|---:|---:|---:|---:|---:|---:|
| 4K | 9.5 | OUT-OF-BAND (opened: no) | — | 32.5 | OUT-OF-BAND (opened: no) | — |
| 32K | 73.3 | 11.5 | 6.4× | 26.6 | 115.2 | 4.3× |
| 128K | 321.8 | 45.2 | 7.1× | 17.5 | 102.5 | 5.9× |

Rows: `L-Q2/speed/a2/run-001…009` (2026-10-03T06:07:35Z → 06:31:09Z; llama.cpp's memory limit reached, as in the caption), `S-Q2/speed/a2/run-004…009` (2026-10-03T05:09:47Z → 05:13:25Z). **The Strata engine's 4K reading on this file sits above the band we wrote down** (its median and two of its three runs are above 130 tok/s) and nothing from that row is quoted until it has been opened under our band rule; it has not been opened. llama.cpp's 4K median, 32.5 tok/s, is inside its band of 10-45. The three runs behind llama.cpp's medians: 30.0 / 32.5 / 33.4; 26.6 / 27.6 / 26.1; 17.9 / 17.5 / 17.0 tok/s. Behind the Strata engine's at 32K and 128K: 114.7 / 115.2 / 120.9; 106.4 / 102.5 / 102.2.

**The first attempts, beside (overlapped another job's dry run, not the figure of record):** llama.cpp first word 9.2 / 76.7 / 316.1 s, writing 30.6 / 25.3 / 17.2 tok/s (`L-Q2/speed/a1`, 2026-10-03T00:16:35Z → 00:39:09Z; its memory limit never reached); the Strata engine first word 1.7 / 11.4 / 45.2 s, writing 126.1 / 120.8 / 110.6 tok/s (`S-Q2/speed/a1`, 2026-10-03T00:40:23Z → 00:44:02Z; its memory limit reached 21,040 times).

The Strata engine's hit rate on this file at 32K and 128K: 0.988 / 0.989 (the Q2_0 experts are smaller, so more of them fit the card: 13,595 of 24,576).

## What the card drew, and what the CPU package drew (the laptop) {#what-the-card-drew-and-what-the-cpu-package-drew-the-laptop}

*Board power from the card's own one-second readings (`nvidia-smi power.draw`), over the whole request; energy per request in kilojoules counts the prompt reading plus the 256 written tokens, never joules a token. These are the graphics card's own figures. Both engines compute part of the model on the CPU here (llama.cpp its system-memory experts, the Strata engine its cache misses), so the CPU package's energy over the same window, read from the processor's own counter (RAPL, package 0), is printed in the second table; neither table is wall power (there was no wall meter: no memory, fans, screen or drive are counted). The 4K energy figures of the Strata engine (github.com/Niko1221/Strata) rest on four to six one-second samples a request (llama.cpp's on 27 to 47).*

| Prompt length | Board, llama.cpp IQ3_S (W) | Board, the Strata engine IQ3_S (W) | Card energy per request, llama.cpp (kJ) | Card energy per request, the Strata engine (kJ) | llama.cpp ÷ the Strata engine (card energy) |
|---|---:|---:|---:|---:|---:|
| 4K | 61.1 | 126.3 | 1.77 | 0.51 | 3.5× |
| 32K | 68.8 | 140.3 | 9.43 | 1.96 | 4.8× |
| 128K | 68.0 | 145.1 | 38.26 | 7.28 | 5.3× |

| Prompt length | CPU package energy per request, llama.cpp (kJ) | CPU package energy per request, the Strata engine (kJ) | Card + CPU package, llama.cpp (kJ) | Card + CPU package, the Strata engine (kJ) | llama.cpp ÷ the Strata engine (card + package) |
|---|---:|---:|---:|---:|---:|
| 4K | 1.33 | 0.32 | 3.11 | 0.82 | 3.8× |
| 32K | 5.11 | 0.64 | 14.54 | 2.60 | 5.6× |
| 128K | 19.82 | 2.55 | 58.07 | 9.83 | 5.9× |

Rows: `L-IQ3-t8/speed/a1` and `S-IQ3/speed/a1`, each row's `telemetry.board.mean_w` and `.joules`, and `telemetry.rapl_package0.joules` (labelled in the row "the CPU package: NOT WALL"); the sums add the two fields' medians. The Strata engine drew about twice the board power, and llama.cpp used 3.5 to 5.3 times as much of the card's energy per request, 3.8 to 5.9 times counting the CPU package as well, because each of the Strata engine's requests finished so much sooner; the Strata engine's run shared the laptop with another job's dry run. The control at the 4,096-token micro-batch: 66.2 / 81.0 / 86.8 W, 1.18 / 5.12 / 19.29 kJ on the card and 0.88 / 2.53 / 8.21 kJ in the CPU package (`L-IQ3-ub/speed/a1`; no band; measured while two of our audit jobs ran on the laptop).

On the Q2_0 pair, from the clean re-reads (llama.cpp's reached its memory limit, as above): llama.cpp 76.4 / 84.9 / 84.6 W and 1.30 / 6.97 / 28.37 kJ on the card, 0.70 / 2.74 / 15.66 kJ in the CPU package; the Strata engine at 32K and 128K 140.7 / 145.6 W and 1.83 / 6.73 kJ on the card, 0.81 / 2.52 kJ in the package; llama.cpp used 3.8 and 4.2 times as much of the card's energy per request, 3.7 and 4.8 times counting the package (the 4K row waits on its opening).

The Strata engine ran into the laptop's floating power limit (145 W average at 128K against a limit that dipped to 135 W); llama.cpp never came near it. The card reached 74 °C at most (the Strata engine at 128K) and the SSD 57.85 °C; no guard fired. Memory: at 128K on the IQ3_S file the laptop had 2.664 GiB of its 61.23 GiB left under the Strata engine (our stop line was 2.0); llama.cpp on the same file left about 50 GiB free.

## The desktop card: one engine a night {#the-desktop-card-one-engine-a-night}

*What this section counts: the same two engines, the same IQ3_S file, the same prompts and client as the laptop, on one NVIDIA RTX PRO 6000 Blackwell Workstation Edition (96 GB) at a 300 W power cap, each engine on its own night. llama.cpp ran 2026-10-06, its row inside that date; the Strata engine (github.com/Niko1221/Strata) 0.1.39 ran 2026-10-07, its row inside that date. It compares the two nights under the cross-night rule. For scale against the laptop: the same llama.cpp commit wrote 24.4 tokens a second at 4K there with 34 of 48 layers' experts on its CPU, and 102.9 here with every layer on the card; two computers, two builds and two placements of the model, so no ratio is printed between them.*

**The conditions, both nights:** the cap read back as 300.00 W on every sample (why 300 W is under "The desktop", above); a memory cap of 80 GiB on each row; no nice or CPU limits on either row (the unit's defaults); the card selected by its PCI order (`CUDA_VISIBLE_DEVICES=0`); the same set of the computer's services stopped; the computer's second card kept its own work; no other process on the 96 GB card during any run. llama.cpp: every layer on the card, the two input lookup tables in host memory, its default batch sizes (a 512-token micro-batch; the bigger batch was not measured on this card), 8 threads, flash attention on, an 8-bit KV cache. The Strata engine 0.1.39: all 24,576 experts on the card (46.84 GiB) while it writes, and while it reads the prompt it lends 2,161 of its cache slots (4.12 GiB) to the prompt path (its own log line); the two input lookup tables in host memory; the prompt path reading 8,192 tokens at a time; 31 expert-pool workers plus its host thread (its log says resident experts are computed on the card, and every expert was resident, so what those CPU threads did during these rows our logs do not say); the draft head on with a verify window of up to 6 tokens; the engine's large-pages option off (4 KB pages); the laptop's engine line, pinned (its setup would add `--kv-resident 32768` on this computer; that option was not used and not measured); one engine session, no restart. The desktop's bands were drawn on 2026-10-05, before any desktop reading.

### Writing the answer (tokens a second, our client's clock) {#writing-the-answer-tokens-a-second-our-clients-clock-52142f}

| Prompt length | llama.cpp, 2026-10-06 (tok/s) | The Strata engine 0.1.39, 2026-10-07 (tok/s) | Difference (tok/s) | The cross-night threshold (tok/s) | Verdict | Ratio |
|---|---:|---:|---:|---:|---|---:|
| 4K | 102.889 | 205.263 | +102.374 | 32.475 | Beyond unmeasured night-to-night variation | 2.0× |
| 32K (exploratory) | 76.337 | 189.155 | +112.818 | 45.300 | Beyond unmeasured night-to-night variation | 2.5× |
| 128K (exploratory) | 38.576 | 172.325 | +133.749 | 44.019 | Beyond unmeasured night-to-night variation | 4.5× |

**The three runs behind each median.** llama.cpp: 101.261 / 102.889 / 103.383 at 4K (spread 2.122); 76.337 / 76.778 / 75.920 at 32K; 38.712 / 38.576 / 38.415 at 128K. The Strata engine: 202.136 / 205.263 / 212.961 at 4K (spread 10.825); 181.856 / 189.155 / 196.956 at 32K; 163.457 / 172.325 / 178.130 at 128K. The 4K threshold is three times the Strata engine's spread (3 × 10.825 = 32.475), which is larger than 10 % of either reading (10.289 and 20.526). Every run's count was verified (9 of 9 each night: the reply recounted with llama.cpp's tokenizer, within 3 % of the count the server reported).

**Against the bands:** llama.cpp 102.889 tok/s at 4K, inside 85-160; the Strata engine 205.263, inside 113-350, a band whose top is 3.1 times its floor because it was built from the laptop's rounds a second and tokens a round, not from this card. In the Strata engine's own terms, the median run made 78.58 verify rounds a second at 2.612 tokens a round (per run 73.42 / 78.58 / 75.71 rounds a second at 2.753 / 2.612 / 2.813 tokens), inside the 50-130 rounds a second the band was built from. That is fewer model steps a second than llama.cpp, whose one token a step means 102.9 steps a second; the Strata engine's lead on this card is each round yielding 2.6 to 2.8 tokens (2.612 on the median run). llama.cpp at this commit has no support for this model's draft head.

**The 32K and 128K rows are exploratory**, with no band drawn for them. Each prompt length is its own reading; this page makes no claim about how either engine's speed changes with prompt length.

Rows: `R-LS-IQ3/speed/a1/run-001…009` (the 2026-10-06 window; each row's `decode_tok_s`) and `R-S139-IQ3/speed/a1/run-001…009` (the 2026-10-07 window).

### The first word, and the prompt rate {#the-first-word-and-the-prompt-rate-7a901f}

| Prompt length | First word, llama.cpp, 2026-10-06 (s) | First word, the Strata engine, 2026-10-07 (s) | Difference (s) | Threshold (s) | Verdict |
|---|---:|---:|---:|---:|---|
| 4K | 2.52 | 1.06 | 1.456 | 3.033 | Within unmeasured night-to-night variation; no ratio |
| 32K (exploratory) | 20.91 | 6.37 | 14.535 | 5.703 | Beyond; 3.3× |
| 128K (exploratory) | 94.22 | 26.63 | 67.593 | 16.772 | Beyond; 3.5× |

The three runs: llama.cpp 3.52 / 2.51 / 2.52 s at 4K (the first after load sets the spread, and the spread sets the threshold); 22.62 / 20.72 / 20.91 at 32K; 99.35 / 93.76 / 94.22 at 128K. The Strata engine 1.44 / 1.06 / 1.06; 6.51 / 6.36 / 6.37; 26.25 / 26.63 / 26.81. Each row's `ttft_ms`. *llama.cpp at its default 512-token micro-batch; the bigger batch was not measured on this card. The Strata engine reads 8,192 tokens at a time with every expert on the card while it writes; while it reads the prompt it lends 2,161 of its cache slots (4.12 GiB) to the prompt path (its own log line).*

| Prompt length | Prompt rate, llama.cpp (tok/s, engine's clock) | Prompt rate, the Strata engine (tok/s) | Verdict |
|---|---:|---:|---|
| 4K | 1,619.4 | 3,920.0 | Within unmeasured night-to-night variation (difference 2,300.6 under a threshold of 3,097.5); no ratio |
| 32K (exploratory) | 1,539.1 | 5,143.9 | Beyond; 3.3× |
| 128K (exploratory) | 1,362.8 | 4,908.1 | Beyond; 3.6× |

Each row's `prompt_tok_s_server`.

### Recorded beside the rows, claiming nothing {#recorded-beside-the-rows-claiming-nothing-8337ee}

- **Board power** over the nine runs: median 299.80 W, maximum 316.75 W on 2026-10-06; median 299.89 W, maximum 316.49 W on 2026-10-07; the enforced limit 300.00 W on every sample, with single one-second samples above it. The 32K and 128K windows are mostly prompt reading, so their watts are not writing watts; the Strata engine's 4K runs last two to three seconds (two or three samples each; llama.cpp's five or six). **No energy figure is given for the desktop rows, and no watts are compared across the two computers.**
- **Board power by prompt length**, the median of each length's three requests from the same one-second readings: llama.cpp 297.8 / 299.8 / 299.7 W at 4K / 32K / 128K on 2026-10-06 (5 to 6, 24 to 25 and 98 to 103 samples a request); the Strata engine 290.6 / 294.3 / 296.4 W on 2026-10-07 (2 to 3, 7 to 8 and 27 to 28 samples). On both nights the first request after load read lowest (234.95 and 195.29 W at 4K). Recorded beside, claiming nothing, and compared across no computers.
- **Card temperature (max) and SM clock (median) per run**, as the cross-night rule asks. 2026-10-06, llama.cpp: 44 °C / 2,681 MHz · 46 / 2,580 · 48 / 2,580 · 53 / 2,332 · 56 / 2,141 · 59 / 2,141 · 66 / 2,302 · 67 / 2,133.5 · 69 / 2,137. 2026-10-07, the Strata engine: 42 °C / 2,235 MHz · 44 / 2,624.5 · 44 / 2,223.5 · 46 / 1,807.5 · 47 / 1,725 · 50 / 1,728.5 · 56 / 1,695 · 60 / 1,672.5 · 62 / 1,642.
- **Host memory.** llama.cpp's row peaked at 27.46 GiB of its 80 GiB cap. The Strata engine's row peaked at 77.48 GiB of the same cap (96.85 %, 2.52 GiB to spare). At the end of its last request it held 77.36 GiB: 49.60 GiB of the engine's own memory, mostly the pinned 46.84 GiB of experts, and 27.65 GiB of file cache charged to the row [inferred: the lookup-table file and the expert files, both read through the cache]. No memory event fired on either night.
- **The card's memory in use** grew by 55,646-55,652 MiB under llama.cpp and by 56,386 MiB under the Strata engine, from a 2 MiB baseline.
- **llama.cpp's own benchmark tool** (`llama-bench`, synthetic tokens, 128 written, the engine's clock, the mean of three) also ran on this card on 2026-10-05, in a separate window; its figures are its own instrument's and are never compared with a Strata engine figure; its result file has not joined the kit, and this page prints no figure from it.

### The desktop beside the laptop, llama.cpp only (a box and a regime, not a card) {#the-desktop-beside-the-laptop-llama-cpp-only-a-box-and-a}

The same engine commit, file and prompts on two computers, each with a build for its own card: on the desktop, every layer on the card, 102.9 tokens a second at 4K; on the laptop, 34 of the 48 layers' experts on its CPU, 24.4. That is two computers, two builds and two placements of the model, not a comparison of the two cards, and no ratio is printed. The Strata engine 0.1.39 has no laptop reading of record to set beside the desktop's. The RTX 3090 Ti and the laptop's card share 24 GB and nothing else that matters here (the desktop's AMD EPYC 7532 with 128 GB of DDR4-3200 in eight channels and a PCIe 4.0 x16 link against the laptop's Intel Core Ultra 9 290HX Plus with 64 GB of DDR5-5600 in two channels and a card link the Strata engine's own probe read at 28.7 GB/s; a different build of each engine; a different placement of the model), and the two desktop cards share a computer and the same 300 W cap and nothing else (a different card, build and night), so no ratio is printed between any two cards; the RTX 3090 Ti's own section follows.

### What this section does not say {#what-this-section-does-not-say-a0645f}

Not "the Strata engine is N times llama.cpp on this card" without the three things in one sentence: llama.cpp's own reading on the same card (102.9), the cross-night rule, and the residency label (all 24,576 experts on the card). Nothing about the engines beside the computer's live services (they were stopped). Nothing about quality (no quality rows ran on the desktop). No energy or cost figure. One card, one build, one night each: it speaks for the Strata engine at commit `6f32ec07` as built on that computer with that configuration, nothing newer. Nothing about a two-card arrangement. Nothing about the engine's own setup line for a computer with this much memory (the `--kv-resident` option it would add was not measured). The same-night pair (both engines in one window) is planned and will be a dated update.

## The 24 GB desktop card: both engines in one window {#the-24-gb-desktop-card-both-engines-in-one-window}

*What this section counts: the same two engines, the same IQ3_S file, prompts and client as the other two cards, on the desktop's second card, one EVGA GeForce RTX 3090 Ti FTW3 Ultra (24 GB) at a 300 W cap, in one window on 2026-10-09 (09:32Z to 10:51Z, UTC): the Strata engine (github.com/Niko1221/Strata) 0.1.39 first (`R-S139-IQ3-24G/speed/a1`), then llama.cpp at `3cf03257` (`R-LS-IQ3-24G/speed/a1`), then llama.cpp at a current build, b11514, no draft head (`R-LS-B11514-IQ3-24G/speed/a1`). It compares the two engines under the margin registered for the pair before it ran, and it compares this card with neither of the other two.*

**The conditions, the whole window:** the cap read back as 300 W before each arm; a memory cap of 80 GiB on each row; the card chosen by its bus address, the 96 GB card hidden from every bench process (each engine's one device line names this card); the computer's live services running on the 96 GB card throughout, with this card's own usual work moved there for the window (the condition on every row; the 96 GB card's utilisation read above zero on 1 % of the window's one-second samples), sharing the processor and memory with both engines; 101.50 GiB of the computer's 123.39 GiB available at the launch. llama.cpp: the experts of 34 of the 48 layers in system memory (the laptop's fit, not refitted on this card), every other layer and weight on the card, the two input lookup tables in host memory, its default 512-token micro-batch, 8 threads, flash attention on, an 8-bit KV cache: the laptop's line, flag for flag. The Strata engine 0.1.39: 8,144 of 24,576 experts on the card (the size its automatic cache chose on this card), the rest pinned in system memory and computed by its 31 expert-pool workers or read over the card's link per request; the prompt path reading 8,192 tokens at a time and borrowing 2,180 cache slots while it reads; the draft head in use with a verify window of up to 6 tokens; the engine's large-pages option off; the laptop's engine line, pinned, without the `--kv-resident` option its setup would add on this computer. The b11514 arm: commit `de7fa0a3` (2026-10-08), 452 commits after `3cf03257`, llama.cpp's line element for element at the same 34 of 48 layers' experts in system memory, the build the only change in the line; it ran last in the window and found the model's weights file already in the computer's file cache from the arms before it (0 major page faults on its nine runs, against 50,150 on the pinned commit's first 4K run, the first request after that arm's load), a condition its figures carry; no draft head (the file we benched carries no draft-head block, and b11514 refused the head on it in a load test on the computer's processor before the window); it ran its nine runs. The bands for all three arms' 4K writing speed were drawn before any reading on this card (2026-10-09 at 01:49Z, and the b11514 arm's at 02:13Z, equal to the pinned commit's at the same layer split by the method's construction), by the desktop's method (published bandwidth over the bytes read per token, split into the card's part, the host memory's and the link's); the margin for the pair is the cross-night rule's, kept for a same-window pair because the two arms ran at different times beside changing live work.

### Writing the answer (tokens a second, our client's clock) {#writing-the-answer-tokens-a-second-our-clients-clock-e741b0}

| Prompt length | llama.cpp, `3cf03257`, 34 of 48 layers' experts in system memory, 8 of 64 threads (tok/s) | The Strata engine 0.1.39, 8,144 of 24,576 experts on the card (tok/s) | Difference (tok/s) | The registered margin (tok/s) | Verdict | Ratio |
|---|---:|---:|---:|---:|---|---:|
| 4K | 22.490 | 98.291 | +75.801 | 31.989 | Beyond the registered margin | 4.4× |
| 32K (exploratory) | 19.620 | 92.571 | +72.951 | 12.375 | Beyond the registered margin | 4.7× |
| 128K (exploratory) | 13.993 | 81.452 | +67.459 | 28.434 | Beyond the registered margin | 5.8× |

**The three runs behind each median.** llama.cpp: 22.276 / 22.490 / 22.611 at 4K; 19.582 / 19.620 / 19.686 at 32K; 13.931 / 13.993 / 14.011 at 128K. The Strata engine: 88.015 / 98.678 / 98.291; 92.571 / 94.246 / 90.121; 79.741 / 81.452 / 89.219. Every run's count was verified (9 of 9 on each arm: the reply recounted with llama.cpp's tokenizer, within 3 % of the count the server reported). Any ratio in the table describes these two lines, not the two engines at their best, both run in one window at the card's 300 W cap, in a computer with 123.39 GiB of memory, beside live work on the computer's other card. llama.cpp at `3cf03257` ran the laptop's line, not refitted for this computer, at its default 512-token micro-batch on 8 of its 64 threads, without the draft head (the file we benched carries no draft-head block), and those threads, not the card, set its writing speed (the opening, under "Against the bands" below); llama.cpp at more than 8 threads was not measured. The Strata engine 0.1.39 ran 31 expert-pool workers plus its host thread, drafting from the model's draft head.

**Against the bands:** llama.cpp 22.490 tok/s at 4K against 31-59, the band drawn for 34 layers in system memory from the card's published bandwidth and the computer's (its ceiling 127.80 tok/s): llama.cpp's 4K median outside it (opened: its eight CPU threads, the laptop's setting kept on a computer with many more, set its writing speed; the card did not). The Strata engine 98.291 against 39-149, a band whose top is 3.8 times its floor because it was built from the laptop's own placement counts and tokens a round, so "inside" says little there: the Strata engine's 4K median inside the band we wrote down before the run. llama.cpp b11514, no draft head, 22.657 against the same 31-59 (the band depends on the file and the layer split, not the build, so the b11514 arm's equals the pinned commit's by construction): llama.cpp b11514's 4K median outside it (opened: its eight CPU threads, the laptop's setting kept on a computer with many more, set its writing speed; the card did not). In the Strata engine's own terms, the median run made 38.01 verify rounds a second at 2.586 tokens a round; its hit rate 0.921 / 0.922 at 4K / 32K, and the share of routed experts it read over the card's link 0.051 / 0.049 (placement counts, never speed figures). The registration named one risk before the run: that llama.cpp might read under its band if the 8 threads it was given on this processor could not keep up with the card, since the experts kept in system memory are computed on the CPU (the CPU half of each token's work). It did: llama.cpp's 4K median sits under its band, and the opening read the CPU receipt: through the writing of each 4K run its eight threads were busy almost without a gap (7.63 to 7.90 of the 8 busy over the writing of its three 4K runs, 7.82 to 7.89 on the b11514 arm's, read from the window's one-second CPU samples; about 3.8 busy on average over each whole run, prompt reading included), which says the threads bound it.

**llama.cpp at a current build, b11514, against the pinned commit on the same card** (`R-LS-B11514-IQ3-24G/speed/a1`; registered in the window's addendum at 02:13Z, before any reading, with the pinned commit's band at the same layer split, 31-59 tokens a second at 4K): llama.cpp b11514 wrote 22.657 / 21.257 / 17.681 tokens a second at 4K / 32K / 128K (the runs 22.657 / 22.694 / 22.642; 21.218 / 21.316 / 21.257; 17.681 / 17.683 / 17.674) against the pinned commit's 22.490 / 19.620 / 13.993, at 4K (within the registered margin; no ratio), at 32K, exploratory (within the registered margin; no ratio) and at 128K, exploratory (beyond the registered margin; 1.3×, with the condition the record names: b11514 ran last and found the model's weights file already in the computer's file cache, 0 major page faults on its nine runs against 626,394 on the pinned commit's first 128K run, and 50,150 and 173,724 on its first 4K and 32K runs); its first word 15.84 / 130.90 / 528.72 s against 16.87 / 138.02 / 566.57. The same card at its 300 W cap, the same computer with 123.39 GiB of memory and live work on its other card, the same file, line, layer split and window: two llama.cpp builds 452 commits apart, both with the experts of 34 of the 48 layers in system memory, the two input lookup tables in host memory and every other layer and weight on the card, at llama.cpp's default 512-token micro-batch on 8 of the computer's 64 threads; neither build ran the draft head, and llama.cpp at more than 8 threads was not measured. On 2026-10-01 upstream llama.cpp merged this model's draft head (github.com/ggml-org/llama.cpp/pull/29761), 268 commits after `3cf03257` and before our first reading; the file we benched carries no draft-head block, so neither build ran the head, here or on the other two cards, and nothing on this page says what b11514 would do on them.

### The first word, and the prompt rate {#the-first-word-and-the-prompt-rate-763fcd}

| Prompt length | First word, llama.cpp `3cf03257`, 34 of 48 layers' experts in system memory, 8 of 64 threads (s) | First word, the Strata engine 0.1.39, 8,144 of 24,576 experts on the card (s) | First word, llama.cpp b11514, no draft head, 8 of 64 threads (s) | The pair's verdict | Ratio |
|---|---:|---:|---:|---|---:|
| 4K | 16.87 | 1.92 | 15.84 | Beyond the registered margin | 8.8× |
| 32K (exploratory) | 138.02 | 12.14 | 130.90 | Beyond the registered margin | 11.4× |
| 128K (exploratory) | 566.57 | 51.05 | 528.72 | Beyond the registered margin | 11.1× |

The three runs: llama.cpp 19.91 / 16.87 / 16.83 at 4K, 148.38 / 137.67 / 138.02 at 32K, 605.49 / 565.60 / 566.57 at 128K; the Strata engine 2.21 / 1.90 / 1.92; 12.14 / 12.11 / 12.19; 50.74 / 51.10 / 51.05. Each row's `ttft_ms`. *Both engines in one window at the card's 300 W cap, in a computer with 123.39 GiB of memory, beside live work on the computer's other card. llama.cpp at its default 512-token micro-batch on both builds, each without the draft head (the file we benched carries no draft-head block), on 8 of the computer's 64 threads (the laptop's line, not refitted for this computer); the bigger batch was not measured on this card, and llama.cpp at more than 8 threads was not measured. The Strata engine 0.1.39 reads 8,192 tokens at a time with 8,144 of 24,576 experts on the card, on 31 expert-pool workers, drafting from the model's draft head, and borrows 2,180 cache slots while it reads (its own log line).*

| Prompt length | Prompt rate, llama.cpp `3cf03257` (tok/s, engine's clock) | Prompt rate, the Strata engine 0.1.39 (tok/s) | Prompt rate, llama.cpp b11514, no draft head (tok/s) | The pair's verdict |
|---|---:|---:|---:|---|
| 4K | 239.7 | 2,143.1 | 255.2 | Beyond the registered margin |
| 32K (exploratory) | 232.3 | 2,671.6 | 244.9 | Beyond the registered margin |
| 128K (exploratory) | 226.1 | 2,535.0 | 242.3 | Beyond the registered margin |

Each row's `prompt_tok_s_server`.

### Recorded beside the rows, claiming nothing {#recorded-beside-the-rows-claiming-nothing-82709b}

- **Board power by prompt length**, the median of each length's three requests from the card's one-second readings: llama.cpp `3cf03257` 168.5 / 182.2 / 185.8 W (28 to 31, 151 to 161 and 584 to 623 samples a request); the Strata engine 281.1 / 293.7 / 295.1 W (4 to 5, 15 and 54); llama.cpp b11514, no draft head, 171.2 / 181.6 / 183.6 W (27 to 28, 142 to 143 and 542 to 544). The enforced limit 300 W on every sample; each arm's maximum one-second reading 266.21 / 306.05 / 250.32 W (llama.cpp `3cf03257` / the Strata engine 0.1.39 / llama.cpp b11514, no draft head). **No energy figure is given for this card, and no watts are compared across the two computers or the two desktop cards.**
- **Card temperature (max) per arm:** 59 / 61 / 58 °C (llama.cpp `3cf03257` / the Strata engine 0.1.39 / llama.cpp b11514, no draft head; the window's stop line for this card is 83 °C on three consecutive samples; no heat stop fired).
- **Host memory.** Each arm's peak inside its 80 GiB cap: llama.cpp `3cf03257` 24.97 GiB, the Strata engine 80.00 GiB (the pinned 46.84 GiB of experts and the file cache charged to the row), llama.cpp b11514, no draft head, 1.38 GiB (it ran last and took 0 major page faults on its nine runs: the model's weights file was already in the file cache from the arms before it, and that cache stays charged to the service that first read it [inferred from the fault counts and the two peaks before it]); the computer's available memory never fell under the window's 6 GiB stop line (57.98 GiB at its lowest). The service running the Strata engine reached that 80 GiB cap by run 1 and sat at it through the runs; counting the engine's loading of the model as well as the runs, the system reclaimed file cache from it 1,095 times to keep it from going over: file cache is recently read files kept in memory, here the model's files as the engine read them, charged to the engine's service. Nothing was stopped or killed and no out-of-memory event fired; the cache was trimmed at the cap, and the engine did not run out of memory.
- **The card's memory in use** grew by 22,395-22,397 MiB under llama.cpp `3cf03257`, 23,819 MiB under the Strata engine and 22,519-22,523 MiB under llama.cpp b11514, no draft head, from a baseline of at most 1,000 MiB (the window's own gate before each arm).
- **Quality and agreement on this card:** not read on this card: the window ran its three speed arms and no quality step.

### What this section does not say {#what-this-section-does-not-say-3d9815}

Not a ratio against the laptop's card (the same 24 GB; a different computer: the laptop's Intel Core Ultra 9 290HX Plus with 64 GB of DDR5-5600 in two channels against this desktop's AMD EPYC 7532 with 128 GB of DDR4-3200 in eight channels and a PCIe 4.0 x16 link; a different build of each engine; a different placement of the model) or against the 96 GB card (the same computer and the same 300 W cap; a different card, build and night). One window, one build of each engine (two of llama.cpp), one cap: it speaks for the Strata engine at commit `6f32ec07` and llama.cpp at `3cf03257` and b11514 built for this card on this computer at 300 W, not for the card's stock limit or its best posture. Beside live work on the computer's other card and the shared processor, never an idle computer. Nothing about the engine's `--kv-resident` option, about llama.cpp at more than 8 threads or at another micro-batch on this card, or about two cards working together (each engine saw one card). The b11514 arm is one build on one card in one window, read against the pinned commit's band at the same layer split: nothing about it on the other two cards, and nothing about llama.cpp's draft head, which the file we benched does not carry. The Strata engine's 128K figure on this card (51.05 s to the first word, 81.452 tokens a second) stands beside no 0.1.39 laptop figure: the laptop's 0.1.39 re-read was registered at 4K and 32K only and produced no reading, while the laptop's 0.1.25 run did take 128K (47.6 s to the first word), and that sentence is all it says.

## Are the answers the same? {#are-the-answers-the-same}

The agreement test (G1) asks whether the two engines give the same strict outcome on at least 105 of the 108 six-way items and 47 of the 48 doorman items. llama.cpp's side was read with flash attention off, with its V cache in 16-bit and an 8K context, because its flash-attention-on build stopped twice on one of the quality prompts (below); the condition prints on every figure.

- **The IQ3_S pair** (the Strata engine 0.1.25 against llama.cpp, fa-off, V cache f16, 8K context): six-way **108 of 108** the same; doorman **44 of 48** the same on the strict scorer's raw count; 36 of the agreeing items are two unscored replies, agreeing to give no letter, and 8 give the same letter. **Not met**, on the doorman half: 44 is under the 47 the gate asks.
- **The Q2_0 pair:** six-way **103 of 108** (1 of the agreeing items is two unscored replies); doorman **48 of 48** on the raw count, but on this file every reply on both engines took the form the scorer does not read (48 of the agreeing items are two unscored replies), so that is two engines agreeing to give no letter, not agreeing on an answer. **Not met**, on the six-way half.

Two named reasons a miss can occur: the engine's own start-up log says the GPU "rounds differently from the CPU, so a reply can differ slightly from a run without the cache" (and cites its own parity test); and the two engines' KV caches differ (llama.cpp's 16-bit V cache here against the engine's 8-bit K and V), as does what the drafter accepts. The two engines' rows stand separately.

## Is it any good? {#is-it-any-good}

**The six-way.** On our six-way, 108 lines each asking which of six dinner guests said it, Flash-Next through the Strata engine answered 91 right (84.3 %) on the IQ3_S file at the pinned commit, 91 at the newer one, 88 on Q2_0; through llama.cpp (flash attention off, 8K context) 91 on IQ3_S and 86 on Q2_0. On the same laptop, through Ollama at Q4_K_M (our own rows of 2026-09-23, which we call provisional because they ran on another engine at a higher-bit compression and have not been re-run on this harness), qwen3.8:27b scored 93 and qwen3.5:27b 96. On the six-way alone, 108 items cannot tell 91 from 93 or 96 (a descriptive test we did not register: p = 0.75 and 0.23): within noise.

**The doorman.** The doorman, 48 prompts that ask a model to admit or refuse with a single letter, reads format more than judgment here: on IQ3_S through the Strata engine, 36 of the 48 replies gave their verdict as a small JSON object instead of the letter, which our strict scorer does not read, so none of the 36 scored; all 11 right answers came from the 12 replies that opened with the letter (through llama.cpp, 40 JSON replies, and its 7 right answers from the 8 that opened with the letter). On Q2_0 all 48 replies on both engines took the JSON form, hence 0 of 48. For anyone whose software expects the letter, that is a real failure; for anyone reading the JSON, it is a different test than the one we registered.

**The bars, and the one framing this page uses.** The value test asked for 93 on the six-way and 36 on the doorman, the comparators' own scores (qwen3.8:27b's six-way, and our gemma4 anchor's doorman 36 of 48): the Strata engine on IQ3_S missed the first by two and the second by 25 (llama.cpp by two and 29); on Q2_0 by five and 36 (llama.cpp by seven and 36). Over both tests together (156 items) qwen3.5:27b was ahead, 142 to 102 (p < 0.001), and 35 of those 40 points are the doorman (46 against 11), where the gap is the reply format above; on the six-way the two are within noise (96 against 91). So the one sentence this page stands by: within noise of the 27B models on the reading test, and behind them on the one-letter test because it mostly did not give the letter. We claim no "better" on any count. Because the value test was not met, this page prints speed rows and no value table.

| Arm | Six-way strict (of 108) | Doorman strict (of 48) | Value test (93 and 36) | Better than qwen3.5:27b (exact McNemar) |
|---|---:|---:|---|---|
| The Strata engine 0.1.25, IQ3_S | 91 | 11 | Not met | No win (b = 3, c = 43, p < 0.001) |
| llama.cpp, IQ3_S, fa-off (V cache f16, forced) at an 8K context | 91 | 7 | Not met | No win (b = 3, c = 47, p < 0.001) |
| The Strata engine 0.1.25, Q2_0 | 88 | 0 | Not met | No win (b = 5, c = 59, p < 0.001) |
| llama.cpp, Q2_0, fa-off (V cache f16, forced) at an 8K context | 86 | 0 | Not met | No win (b = 5, c = 61, p < 0.001) |
| The Strata engine 0.1.36, IQ3_S (exploratory) | 91 | 8 | Not met | No win (b = 3, c = 46, p < 0.001) |

Source: `SUMMARY.md` §3 (parser v2 strict; the references re-derived from the laptop rows: qwen3.8:27b 93 of 108, qwen3.5:27b 96 of 108 and 46 of 48, the gemma4 anchor's doorman 36 of 48).

## Who the Strata engine is for, and who it is not for {#who-the-strata-engine-is-for-and-who-it-is-not-for}

*It fits when all of these hold:* you want Qwen3.8-Flash-Next itself (the engine runs this one model architecture and files built on it); one person, one conversation at a time (as we ran it, it answers one request at a time and keeps one conversation's cache: its docs/DETAILS.md at 0.1.25; at 0.1.39 the same file adds opt-in batch slots, "up to N requests decoded together", and an opt-in cache that parks several conversations, neither of which we ran); a Linux computer with an NVIDIA card and the memory to keep every expert in system memory (46.84 GiB for the IQ3_S file, 31.64 GiB for Q2_0; at 128K on IQ3_S our 64 GB laptop had 2.66 GiB left against our stop line of 2.0, and even with every expert on the 96 GB card the engine held 49.60 GiB of the desktop's memory); about 84 GB of disk for the IQ3_S files (54.8 + 28.8 GB) or 66 GB for Q2_0 (37.6 + 28.8); you will build it from source; and long prompts and fast writing matter more to you than anything below.

*It is not the right tool when:* several people or an agent's parallel calls share one server on its defaults (0.1.39's opt-in batch slots were not run here); you want any other model; the answers have to match another engine's to the token; you are on a Mac (the engine builds for NVIDIA's CUDA or AMD's HIP; we tested NVIDIA only); you have 32 GB of RAM; or your work looks like our two short tests. There Flash-Next scored within noise of two 27-billion-parameter models on the six-way, and behind qwen3.5:27b over both tests together (142 to 102, mostly the doorman's reply format), while both 27B models fit a 24 GB card whole at Q4_K_M. We did not measure a 27B's speed on this bench, and we did not test agentic or code work.

## What was written down before the first run {#what-was-written-down-before-the-first-run}

The five laptop arms, their bands and the four gates were registered on 2026-10-02 at 19:26Z, before any speed row existed; the desktop bands on 2026-10-05 at 03:01Z, before any desktop reading. Nine amendments to the laptop registration followed, each dated and appended, among them the 8-thread arm, the flash-attention-off arms for the agreement test, the clean re-reads after the overlapped runs, the 4,096-token control and the 0.1.39 re-read. Our own refusals are kept: llama.cpp's fit on the IQ3_S file took nine attempts. Our own guards stopped or refused the first five, before a fix to the harness. The sixth and seventh held. The last two, with more layers on the card, ran out of card memory, so 34 layers' experts in system memory was kept. Two llama.cpp quality attempts were stopped by the crash described under "What else the bench read"; every stopped attempt is recorded with its reason. No speed or quality phase was re-run to a pass.

**The predictions, read:** llama.cpp's bands confirmed on the IQ3_S file at 8 threads (24.4 inside 20-55) and 4 threads (20.2 inside 20-55), and on Q2_0 (32.5 inside 10-45); the Strata engine's IQ3_S band confirmed (85.6 inside 40-90, one single run outside, opened); the Strata engine's Q2_0 median above its band (opened: no); the no-draft-head arm's band not read (the arm would not start); the desktop's llama.cpp band confirmed (102.889 inside 85-160) and the desktop's Strata engine band confirmed (205.263 inside 113-350, a band whose top is 3.1 times its floor, so "inside" says little there). The gates: G0 passed on every arm that started; G1 not met on either pair; G2 not met on any arm; "Better" not met.

**The 24 GB desktop card's registration** (2026-10-09 at 01:49Z, before any reading on it): two speed arms, one fit for llama.cpp's layer count, the 4K writing bands by the desktop's method (llama.cpp 31-59 tok/s at 34 layers in system memory; the Strata engine 39-149), the margin for the pair, the stop rules (the battery backup, the computer's memory under 6 GiB, the cap, heat, a hard end) and one named risk, that llama.cpp might read under its band if 8 threads of this processor bind the CPU half; then, by a dated addendum (02:13Z, before any reading), a third arm: llama.cpp at a current build, b11514, with the pinned commit's band at the same layer split and no draft head, which the file we benched does not carry. The predictions, read: llama.cpp's 4K median outside it (opened: its eight CPU threads, the laptop's setting kept on a computer with many more, set its writing speed; the card did not); the Strata engine's 4K median inside the band we wrote down before the run; llama.cpp b11514's 4K median outside it (opened: its eight CPU threads, the laptop's setting kept on a computer with many more, set its writing speed; the card did not); the named risk came true: llama.cpp's 4K median sits under its band, and the opening read the CPU receipt: through the writing of each 4K run its eight threads were busy almost without a gap (7.63 to 7.90 of the 8 busy over the writing of its three 4K runs, 7.82 to 7.89 on the b11514 arm's, read from the window's one-second CPU samples; about 3.8 busy on average over each whole run, prompt reading included), which says the threads bound it. **The laptop's 0.1.39 re-read** (the ninth amendment, exploratory, no band): its third attempt, on 2026-10-09, did not run: the laptop's free memory sat below the floor the run needs, so its memory check refused the start, and nothing from it is quoted; nothing to read.

**The arm we could not run.** The Strata engine's server refuses to start without the model's draft head, so the registered arm without it is recorded as refused, not as a result. We did not split the writing-speed gap between the draft head and the expert cache here: the registered arm without the draft head cannot start, and the other route we found in the source would be a new registered arm with its own band.

## What else the bench read {#what-else-the-bench-read}

- **A llama.cpp fault.** llama.cpp at `3cf03257`, the commit the Strata engine builds on, stopped twice on the same quality prompt with flash attention on: a 512-token prompt right after a 511-token one, 60-66 ms in, with a GPU memory fault at the same address both times. Every longer speed prompt, 4,038 to 128,037 tokens, ran clean on the same build. We have not established whether flash attention off avoids it, whether it depends on the 131,072-token context, the 8-bit cache, the prompt length or the request before it, on the driver, or on other disk activity; the Q2_0 file never reached that prompt. We ran its quality answers with flash attention off for the comparison. We have not reported this fault to llama.cpp's maintainers.
- **llama.cpp's own warning** that keeping expert tensors on the CPU with a memory map costs speed, and why we kept the map: the lookup table (27,465.95 MiB) plus everything else llama.cpp mapped on the CPU side (35,835.49 MiB, mostly the 34 layers' experts), both from its own start log, come to about 61.8 GiB against the 61.23 GiB the laptop reports [arithmetic].
- **The Strata engine's own memory sizing** on the laptop left 233 MiB of the card free and logged "LOW: requests may stall"; no request stalled on the nine speed runs.
- **The engine's network surface.** We found no network code in a read of the Strata engine's native source at the commits we ran; each engine ran bound to loopback with a random API key, inside a sandbox with no network.

## Still pending, and when it lands {#still-pending-and-when-it-lands}

*Each line names what it is; no figure is invented for it. Dates are targets, none is promised.*

| What | What it would add | When |
|---|---|---|
| The Strata engine 0.1.39 on the laptop, 4K and 32K (the ninth amendment to our registration) | Its own laptop rows, labelled exploratory | Two attempts stopped on our memory guard, and a third, on 2026-10-09, produced no figure; another window only if registered; a dated update |
| The Strata engine 0.1.39 quality run on the laptop | Its six-way and doorman counts | The same stretch |
| A local-auditor dry run on llama.cpp (the Strata engine's side has read) | One short descriptive section, "DRY RUN" on every line | The same stretch; until then "planned, dated update" |
| The desktop same-night pair (both engines in one window) | The same comparison without the cross-night rule | A later window; a dated update |
| llama.cpp's own benchmark-tool row on the desktop card | Its own table | Once its file joins the kit |
| A desktop llama.cpp control at a 4,096-token micro-batch | The batching answer on a card with room for it | Not registered; until then every desktop first-word figure says the bigger batch was not measured on this card |
| llama.cpp's own draft head, on any card | What the model's draft head does for llama.cpp | The file we benched carries no draft-head block; not registered |
| A second window on the RTX 3090 Ti | A second reading of both arms | Not registered; a dated update |
| A clean laptop re-read of the Strata engine 0.1.25 and 0.1.36 | Figures of record without the overlap label | Not registered |

## What it does not say {#what-it-does-not-say}

llama.cpp was not at its best here, and we can say where: on the laptop it read the prompt 512 tokens at a time, its default; with a 4,096-token batch it waited 204.4 s instead of 545.1 at 128K, still about four times the Strata engine's 47.6 s, with 8 more layers of experts in system memory and 6.1 to 8.4 % less writing speed on that day; it ran on 8 of the laptop's 24 threads; it loaded its experts through a memory map, which its own log says costs speed; and it had no draft model (no support for this model's draft head at this commit, and its separate-draft-model mode not tried). On the desktop it ran at its default micro-batch and the bigger batch was not measured there. On the laptop the Strata engine ran as its setup writes it. On the desktop it ran the same line, without the `--kv-resident 32768` its setup would add on that computer; that option was not measured. These are close to each engine's defaults, not each at its tuned best.

Then the limits, as a list:

- one laptop card and two desktop cards, one model family and two of its compressed files; one request at a time; Linux only; the versions benched only;
- llama.cpp at more than 8 threads not measured, nor without the memory map, nor at a later commit on the laptop or the 96 GB card (a current build, b11514, ran on the RTX 3090 Ti only, in one window, without the draft head); llama.cpp's draft head tested on no card, because the file we benched carries none;
- not code, not other languages, not sampled output, not other tasks (the Strata engine's drafting and its expert cache both depend on the text, and this bench fed them one kind, so this covers speed as well as quality); how the hit rate moves on text unlike the shipped profile's: not measured;
- not Flash-Next with thinking on, with more than 8 output tokens on the quality tests, on agentic or code work, or uncompressed;
- the draft head's share against the cache's: not split here; no agreement reading at 32K or 128K; not the fault's cause;
- not wall watts: the card's energy and the CPU package's are printed, nothing else on the laptop is;
- the 96 GB card's rows are one engine a night, compared only under the cross-night rule, with no energy figure, no quality rows, no claim about how speed changes with prompt length, and no comparison with the laptop as a ratio;
- an RTX 3090 was not measured; nothing about two-card arrangements;
- the RTX 3090 Ti's rows are one window, one build of each engine (two of llama.cpp), at one cap, beside live work on the computer's other card: nothing about that card on an idle computer, at its stock limit, or against either other card as a ratio;
- the comparators ran on another engine (Ollama, Q4_K_M) with provisional strict figures; no "better" anywhere;
- Qwen's licence conditions on serving the model are not implied met: we serve Flash-Next to no one.

## What comes next on this page {#what-comes-next-on-this-page}

The same-night pair on the 96 GB card; the local-auditor dry run; the Q2_0 4K opening; the Strata engine 0.1.39's quality run on the laptop; llama.cpp's own draft head, on a GGUF file that carries the draft-head block (the file we benched has none); the Strata engine 0.1.39's laptop rows, if another window is registered; each as a dated update that names what it counts, dates its window at both ends, and compares to the reading above in one sentence.

## What to take with you {#what-to-take-with-you}

- **The first word, on a 24 GB laptop card:** 545.1 → 47.6 s at 128K on the same file: llama.cpp at commit `3cf03257` at its default 512-token micro-batch on 8 of the laptop's 24 threads, without the draft head (the file we benched carries no draft-head block; llama.cpp at more than 8 threads was not measured), against the Strata engine 0.1.25 reading 8,192 tokens at a time on 23 expert workers plus its host thread, drafting from the model's draft head, the two back to back on 2026-10-02 and 2026-10-03 (UTC), the rule that admits the comparison; 204.4 s with a 4,096-token batch, its logical batch raised to match (a control run on 2026-10-05, three days after the 545.1 s run, beside two of our audit jobs, with 8 more layers of experts, 42 of 48, in system memory), no ratio of record (the arithmetic between them is under "What a 4,096-token micro-batch does to llama.cpp", beside the five things that differ). The Strata engine's run shared the laptop with another job's dry run.
- **Writing speed, on the laptop:** 3.5 to 4.9 times llama.cpp's on the IQ3_S file on the Strata engine 0.1.25, 23 expert workers plus its host thread against llama.cpp's 8 threads at its default 512-token micro-batch (8 of the laptop's 24; llama.cpp at more than 8 threads was not measured), and with the model's draft head, which llama.cpp at commit `3cf03257` has no support for (the file we benched carries no draft-head block); the two ran back to back on the same laptop, about an hour apart, which is the rule that admits a ratio here; both banded 4K medians inside their bands; the Strata engine's run shared the laptop with another job's dry run.
- **Writing speed, on a 96 GB card with room for every layer and every expert:** 205.3 against 102.9 tokens a second at 4K, one engine a night at a 300 W cap, beyond unmeasured night-to-night variation; llama.cpp at commit `3cf03257` at its default 512-token micro-batch on 8 of the desktop's 64 threads, without the draft head (the file we benched carries no draft-head block; llama.cpp at more than 8 threads was not measured); the Strata engine 0.1.39 with all 24,576 experts on the card, 31 expert workers plus its host thread and the draft head on, which gave it 2.6 tokens a round at fewer rounds a second than llama.cpp's steps; no ratio for the first word or the prompt rate at 4K.
- **The 24 GB desktop card, both engines in one window at 300 W beside live work on the computer's other card, in a computer with 123.39 GiB of memory:** the Strata engine 0.1.39, drafting from the model's draft head, wrote faster at 4K (98.291 against 22.490 tokens a second, 4.4×) and gave the first word sooner at 32K (12.14 against 138.02 s, 11.4×, exploratory), both beyond the registered margin, with 8,144 of 24,576 experts on the card and 31 expert-pool workers against llama.cpp at `3cf03257`, no draft head, at its default 512-token micro-batch with 34 of 48 layers' experts in system memory (the laptop's fit, the layer split found on the laptop, not refitted on this card) on 8 of the computer's 64 threads (the laptop's line, its launch line as the laptop ran it, not refitted for this computer; llama.cpp at more than 8 threads was not measured); those eight threads, not the card, set llama.cpp's writing speed. **llama.cpp at a current build (b11514), no draft head, on the same card:** llama.cpp b11514 (commit `de7fa0a3`) wrote 22.657 tokens a second at 4K against 22.490 at `3cf03257`, within the registered margin; no ratio; its first word at 4K 15.84 against 16.87 s. Two builds 452 commits apart, the same file, line, layer split and card, the later one run last in the window with the model's weights file already in the computer's file cache (0 major page faults on its nine runs); neither build ran the draft head, because the file we benched carries none. The other two cards' llama.cpp rows are at `3cf03257`.
- **Energy, on the laptop:** llama.cpp used 3.5 to 5.3 times as much of the graphics card's energy per request on IQ3_S, and 3.8 to 5.9 times counting the CPU package as well (neither is wall power), the Strata engine drawing about twice the board power for far less time; the Strata engine's run shared the laptop with another job's dry run.
- **Quality:** 91 of 108 on the six-way, within noise of the two 27-billion-parameter models we ran on the same laptop (93 and 96); behind qwen3.5:27b over both tests together (142 to 102), 35 of those 40 points from the doorman, where 36 of the Strata engine's 48 replies came in a form the scorer does not read; no "better".
- **Who it is for:** one person, one conversation, this one model, built from source, with the memory to keep every expert in system memory (46.84 GiB for IQ3_S; 64 GB was just enough on our laptop).

## Who ran this, and thanks {#who-ran-this-and-thanks}

The Strata engine's author (github.com/Niko1221/Strata; MIT); Georgi Gerganov and the ggml authors (llama.cpp, MIT); ISTA-DASLab (the GGUF files); Qwen (the model and its draft head, under the Qwen Community License 1.0); NVIDIA (CUDA). None of them owed us anything. A small (human) team wrote the questions, pressed the keys and read the pages; a fleet of AI agents built the harness, ran the audits and drafted the prose. Despite the similar name, Strata (github.com/Niko1221/Strata) is an unrelated project; strata2signal has no affiliation with it.

## Appendix: sources, reproduce, per-run telemetry {#appendix-sources-reproduce-per-run-telemetry}

### How to reproduce it, the way we ran it (source build only) {#how-to-reproduce-it-the-way-we-ran-it-source-build-only}

We never ran the engine's installer, setup script, updater, Docker image, release zip, prebuilt binary or MCP bridge (our rule for every project we bench: build from the source we have read, run nothing that installs or fetches). We built both engines from source; the build lines are below. The outline:

1. **Read both repositories first.** llama.cpp (github.com/ggml-org/llama.cpp) and the Strata engine (github.com/Niko1221/Strata). Nothing below fetches anything at build time.
2. **Build llama.cpp at `3cf03257f219afbe7334045ff7c6a06ac68c627d` from source** as an unprivileged user, with `-DLLAMA_USE_PREBUILT_UI=OFF` and the CUDA architecture of your own card (our Blackwell build served only the 96 GB card; an Ampere card needs its own build; the 24 GB desktop card's three arms were built for `sm_86`, its b11514 arm at commit `de7fa0a3`).
3. **Build the Strata engine from source** at `8fc40dde5e8897a097ec0ea6ea27f9313d171268` (v0.1.25) or `6f32ec070f23ced9f50e704d854d775da52591ab` (v0.1.39), CMake pointed at the local llama.cpp. The exact build lines will be in the kit.
4. **Fetch the weights at the pinned revision** and check every file's SHA-256 before loading it: ISTA-DASLab `Qwen3.8-Flash-Next-GSQ-RCO-GGUF`; the IQ3_S weights `4c1eb2ceb4915e1192f4f386021897bde56a97f40a0bb78bb86465e0f7d2aca3` (54,817,524,224 bytes); the shared table `316b46f3a2dbd68c900f43136ab9449f9dcc3725dfd8c794847c204bc161e113` (28,800,138,432 bytes); the Q2_0 weights `69820c02ec7d0b45ef2ebb19d6620299db749fe2aded7f39f93c6b88b199b720` (37,623,740,192 bytes).
5. **Build the draft head's files** with the pinned copy of the engine's own tool and check all 31 tensors against the engine's own table.
6. **Run each engine bound to loopback** with a random API key per start, inside a sandbox with no network, a memory cap and no swap. The sandbox does not stop the engine reading files your user can read. Run it as a user that can read only what the engine needs.
7. **llama.cpp's launch line** (the desktop row; on the laptop `--n-cpu-moe 34` for IQ3_S, `24` for Q2_0, fitted first):

```
llama-server -m "$SHARD1" \
  --host <loopback> --port <PORT> \
  -ngl 99 --n-cpu-moe 0 \
  -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** ran on the laptop with the arguments its setup writes (images, MCP and the speed projection off; `--mtp` on; the registered expert profile), and on v0.1.39 with its large-pages option off. On the desktop it ran the same line, pinned, without the `--kv-resident 32768` its setup would add on that computer (not measured); the exact configuration file will be in the kit.
8. **Send the kit's prompts** (4,038, 32,038 and 128,037 tokens), 256 tokens, greedy, thinking off, one request at a time, three at each length after one server start; time the first word and the writing on your own client's clock; take the median of three with the first run after load included; recount every reply with llama.cpp's tokenizer.
9. **Write your band down before you run**, and compare the 4K writing median with it. Compare two nights only under the cross-night rule.

If the prompts do not ship with the kit, the first-word figures can be re-run with any text of the same token count; the writing-speed figures only approximately, because the Strata engine's drafting and cache depend on the text.

**The kit** (pinned commits, hashes, build lines, the launch lines as templates, the request bodies, the client code that defines the clock of record, the run environment, every speed row minus the model's text, the quality rows as counts, the registration copy): not shipped yet; it waits on a check of every file for what we never publish.

### Sources, and every figure's file {#sources-and-every-figures-file}

*Laptop rows will live at `records/<arm>/speed/a<N>/rows.jsonl` in the kit; row ids follow `<arm>/speed/a<N>/run-<nnn>`, runs 001-003 at 4K, 004-006 at 32K, 007-009 at 128K. The desktop rows ship under the same shape as `records/R-LS-IQ3/speed/a1/rows.jsonl` (2026-10-06) and `records/R-S139-IQ3/speed/a1/rows.jsonl` (2026-10-07). The quality counts are `SUMMARY.md` §3. Each figure below is the median of the three rows named unless marked. The kit has not shipped; until it does these are the names the files will carry, not links. The RTX 3090 Ti's rows ship as `records/R-S139-IQ3-24G/speed/a1/rows.jsonl`, `records/R-LS-IQ3-24G/speed/a1/rows.jsonl` and `records/R-LS-B11514-IQ3-24G/speed/a1/rows.jsonl` (2026-10-09, one window); the laptop's 0.1.39 attempts ship as stopped records and a refused start, quoted nowhere on this page.*

| Figure on this page | Value | File and rows | Field | Condition |
|---|---|---|---|---|
| First word, llama.cpp, 512-token micro-batch, laptop | 19.1 / 125.6 / 545.1 s | `L-IQ3-t8/speed/a1/run-001…009` | `ttft_ms` | 8 threads, 34 layers in system memory; run-001 first after load |
| First word, llama.cpp, 4,096-token micro-batch, laptop | 7.6 / 50.0 / 204.4 s | `L-IQ3-ub/speed/a1/run-001…009` | `ttft_ms` | Control, no band; 42 layers in system memory; two audit jobs on the laptop; tokenizer recount not run |
| First word, the Strata engine 0.1.25, laptop | 1.9 / 12.1 / 47.6 s | `S-IQ3/speed/a1/run-001…009` | `ttft_ms` | Another job's dry run on the laptop; 8,120 of 24,576 experts on the card |
| Prompt rates, laptop IQ3_S | 211.7 / 255.1 / 234.9; 533.7 / 640.9 / 626.7; 2,147.5 / 2,655.1 / 2,705.0 tok/s | The same three arms | `prompt_tok_s_server` | The engine's clock |
| Writing, laptop IQ3_S | 24.4 / 20.7 / 14.2; 22.5 / 19.4 / 13.0; 85.6 / 87.1 / 69.8 tok/s | The same three arms | `decode_tok_s` | Our client's clock; bands 20-55 and 40-90 at 4K |
| llama.cpp at 4 threads, laptop | First word 15.2 / 126.7 / 557.6 s; writing 20.2 / 18.4 / 13.6 tok/s | `L-IQ3/speed/a1/run-001…009` | `ttft_ms`, `decode_tok_s` | "at 4 threads"; no count check recorded |
| Disk reads in the 4-thread row's first three requests | Means 113 / 2.3 / 1.4 MB/s over windows of 42.8 / 27.8 / 27.2 s (about 4.8 / 0.06 / 0.04 GB); the 714 MB/s peak | `L-IQ3/speed/a1/run-001…003`; the attempt's one-second telemetry file | `telemetry.data_read_mb_per_s.mean`, `telemetry.window.seconds` | run-001 the first request after load |
| The Strata engine 0.1.36, laptop (exploratory) | Writing 80.4 / 79.6 / 74.0; first word 1.8 / 11.2 / 46.1 s | `S-HEAD/speed/a1/run-001…009` | The same | No band, no gate; overlap label |
| The Strata engine 0.1.25's stopped clean repeat, laptop | Writing 91.3 (78.0 / 91.3 / 93.0) and 92.5 (90.3 / 95.6 / 92.5) tok/s; first word 1.9 / 11.9 s; one 128K request 81.5 tok/s, 47.0 s | `S-IQ3/speed/a2/run-001…007` | The same | Stopped attempt (our memory guard, 7 of 9 requests), not of record |
| Hit rate, the Strata engine, laptop IQ3_S | 0.917 / 0.932 / 0.923 | `S-IQ3/speed/a1` | `engine_cache.hits ÷ engine_cache.lookups` | Never a speed figure |
| Tokens a verify round, the Strata engine, laptop IQ3_S | 2.69 / 2.56 / 2.25 (4K runs 2.56 / 2.72 / 2.69) | `S-IQ3/speed/a1` | `engine_cache.tokens_per_round_derived` (generated ÷ (generated − drafts accepted)) | Derived from the engine's own counts |
| Q2_0, llama.cpp (figure of record) | First word 9.5 / 73.3 / 321.8 s; writing 32.5 / 26.6 / 17.5 tok/s | `L-Q2/speed/a2/run-001…009` | The same | Clean re-read (no other job on the laptop); the harness's 33 GiB memory limit reached 2,233 times over the server's whole run (the run record's end-of-run count), 1,702 inside the nine requests' windows (each row's `telemetry.memory.unit_max_events_delta`; 1,175 / 193 / 325 in each length's first request); band 10-45 at 4K |
| Q2_0, the Strata engine at 32K and 128K (figure of record) | First word 11.5 / 45.2 s; writing 115.2 / 102.5 tok/s; hit rate 0.988 / 0.989 | `S-Q2/speed/a2/run-004…009` | The same | Clean re-read; its memory limit never reached; the 4K row OUT-OF-BAND (opened: no) |
| Q2_0, the first attempts (beside) | llama.cpp 9.2 / 76.7 / 316.1 s, 30.6 / 25.3 / 17.2 tok/s; the Strata engine 1.7 / 11.4 / 45.2 s, 126.1 / 120.8 / 110.6 tok/s | `L-Q2/speed/a1`, `S-Q2/speed/a1` | The same | Overlapped another job's dry run; not the figure of record; llama.cpp's memory limit never reached, the Strata engine's reached 21,040 times |
| Board power and card energy, laptop IQ3_S | 61.1 / 68.8 / 68.0 W, 1.77 / 9.43 / 38.26 kJ; 126.3 / 140.3 / 145.1 W, 0.51 / 1.96 / 7.28 kJ | `L-IQ3-t8/speed/a1`, `S-IQ3/speed/a1` | `telemetry.board.mean_w`, `.joules` | Board, not wall; per request; the Strata engine's run shared the laptop with another job's dry run |
| CPU package energy, laptop IQ3_S | 1.33 / 5.11 / 19.82 kJ; 0.32 / 0.64 / 2.55 kJ | The same two arms | `telemetry.rapl_package0.joules` | The row's own label: "the CPU package: NOT WALL"; the sums add the two fields' medians, and the card + package ratios divide those sums |
| Board power and energy, the control | 66.2 / 81.0 / 86.8 W, 1.18 / 5.12 / 19.29 kJ; CPU package 0.88 / 2.53 / 8.21 kJ | `L-IQ3-ub/speed/a1` | The same | Control, no band; two audit jobs on the laptop |
| Board power and energy, laptop Q2_0 | 76.4 / 84.9 / 84.6 W, 1.30 / 6.97 / 28.37 kJ, CPU package 0.70 / 2.74 / 15.66 kJ; — / 140.7 / 145.6 W, — / 1.83 / 6.73 kJ, CPU package — / 0.81 / 2.52 kJ | `L-Q2/speed/a2`, `S-Q2/speed/a2` | The same | The Strata engine's 4K row withheld; llama.cpp's memory limit reached (as above) |
| Laptop temperatures, power limit, RAM left | 74 °C, 57.85 °C; 135-150 W; 2.664 of 61.23 GiB | `S-IQ3/speed/a1` | `telemetry.temps`, `.power_limit`, `.memory.mem_available_gib_min` | As read |
| Writing, desktop, llama.cpp | 102.889 (101.261 / 102.889 / 103.383); 76.337; 38.576 tok/s | `R-LS-IQ3/speed/a1/run-001…009` | `decode_tok_s` | Band 85-160 at 4K: inside; 32K, 128K exploratory; count verified 9/9 |
| Writing, desktop, the Strata engine 0.1.39 | 205.263 (202.136 / 205.263 / 212.961); 189.155; 172.325 tok/s | `R-S139-IQ3/speed/a1/run-001…009` | `decode_tok_s` | Band 113-350 at 4K: inside; all 24,576 experts on the card; count verified 9/9 |
| Rounds a second, tokens a round, desktop | 78.58 at 2.612 (the median run); 73.42 / 78.58 / 75.71 at 2.753 / 2.612 / 2.813 | `R-S139-IQ3/speed/a1/run-001…003` | `decode_tok_s ÷ engine_cache.tokens_per_round_derived` | The engine's serve line: tokens generated ÷ (generated − drafts accepted) |
| The cross-night pair, writing | +102.374 vs 32.475; +112.818 vs 45.300; +133.749 vs 44.019 | Both desktop arms | `decode_tok_s` | The rule: the larger of 10 % of the larger reading (20.526 at 4K; 10.289 for the smaller) or 3 × the larger spread (32.475) |
| The cross-night pair, first word | 2.52 vs 1.06 s (within, threshold 3.033); 20.91 vs 6.37 (beyond, 5.703); 94.22 vs 26.63 (beyond, 16.772) | Both desktop arms | `ttft_ms` | llama.cpp's default micro-batch; the bigger batch not measured on this card |
| The cross-night pair, prompt rate | 1,619.4 vs 3,920.0 (within, threshold 3,097.5); 1,539.1 vs 5,143.9 (beyond); 1,362.8 vs 4,908.1 (beyond) | Both desktop arms | `prompt_tok_s_server` | The engine's clock |
| The desktop's prompt-path borrow | 2,161 cache slots (4.12 GiB) lent to the prompt path while reading | `R-S139-IQ3` engine log, line 27 | The engine's own line | All 24,576 experts resident while writing |
| The desktop's engine line | The laptop's line, pinned; no `--kv-resident`; the setup rule on that computer would add `--kv-resident 32768` | The row's `strata-line.json` | `pinned`, `setup_rule_adds`, `this_box_mem_total_gib` | Registered as the laptop's line, never the box's |
| Desktop board power | 299.80 W median, 316.75 max; 299.89 median, 316.49 max | The two windows' one-second card logs | `power.draw`, `enforced.power.limit` | Recorded beside, claims nothing |
| Desktop host memory | 27.46 GiB; 77.48 GiB peak of 80 GiB; 77.36 at the last request's end (49.60 engine + 27.65 file cache) | The two rows' memory receipts | `memory.peak`, `memory.current` | No memory event either night |
| Six-way and doorman counts; G1 (108 / 44 and 103 / 48); G2; Better | The table above | `SUMMARY.md` §3 | Parser v2 strict | The fa-off condition on llama.cpp's rows; of the doorman agreements, 36 of 44 (IQ3_S) and 48 of 48 (Q2_0) are two unscored replies |
| The 96 GB card's board power by prompt length | 297.8 / 299.8 / 299.7 W (5 to 6, 24 to 25, 98 to 103 samples); 290.6 / 294.3 / 296.4 W (2 to 3, 7 to 8, 27 to 28) | `R-LS-IQ3/speed/a1/run-001…009`, `R-S139-IQ3/speed/a1/run-001…009` | `telemetry.board.mean_w` (the median of each length's three), `telemetry.window.gpu_samples` | Recorded beside, claiming nothing; the first request after load lowest on both nights |
| Writing, the RTX 3090 Ti, llama.cpp `3cf03257` | 22.490 (22.276 / 22.490 / 22.611); 19.620; 13.993 tok/s | `R-LS-IQ3-24G/speed/a1/run-001…009` | `decode_tok_s` | Band 31-59 at 4K: llama.cpp's 4K median outside it (opened: its eight CPU threads, the laptop's setting kept on a computer with many more, set its writing speed; the card did not); 34 layers in system memory (the laptop's fit, not refitted on this card); 300 W; live work on the other card; counts verified |
| Writing, the RTX 3090 Ti, the Strata engine 0.1.39 | 98.291 (88.015 / 98.678 / 98.291); 92.571; 81.452 tok/s | `R-S139-IQ3-24G/speed/a1/run-001…009` | `decode_tok_s` | Band 39-149 at 4K: the Strata engine's 4K median inside the band we wrote down before the run; 8,144 of 24,576 experts on the card; 300 W; live work on the other card; counts verified |
| Writing, the RTX 3090 Ti, llama.cpp b11514 (no draft head) | 22.657 (22.657 / 22.694 / 22.642); 21.257; 17.681 tok/s | `R-LS-B11514-IQ3-24G/speed/a1/run-001…009` | `decode_tok_s` | Commit `de7fa0a3`; band 31-59 at 4K (the pinned commit's, at the same layer split): llama.cpp b11514's 4K median outside it (opened: its eight CPU threads, the laptop's setting kept on a computer with many more, set its writing speed; the card did not); the same 34 layers in system memory as the `3cf03257` row; no draft head (the file carries none); 300 W; live work on the other card; ran its nine runs |
| Rounds a second, tokens a round, hit rate, link share, the RTX 3090 Ti | 38.01 at 2.586 (the median run); 0.921 / 0.922; 0.051 / 0.049 | `R-S139-IQ3-24G/speed/a1` | `decode_tok_s ÷ strata.tokens_per_round_derived`; `strata.hits ÷ strata.lookups`; the engine's per-request link-share line | Placement counts, never speed figures |
| The pair's margin, writing and first word, the RTX 3090 Ti | Writing +75.801 vs 31.989 at 4K; +72.951 vs 12.375 at 32K; the first word beyond the registered margin at 4K, beyond the registered margin at 32K | Both arms | `decode_tok_s`, `ttft_ms` | The registered margin: the larger of 10 % of the larger reading or 3 × the wider row's spread; a ratio only when beyond |
| First word and prompt rate, the RTX 3090 Ti | 16.87 / 138.02 / 566.57 s; 1.92 / 12.14 / 51.05 s; 15.84 / 130.90 / 528.72 s; the prompt rates as the table | The three arms | `ttft_ms`, `prompt_tok_s_server` | llama.cpp's default micro-batch on both builds, neither with the draft head (the file carries none); the engine's clock for the prompt rate |
| Board power, temperature, memory, the RTX 3090 Ti | The "Recorded beside" bullets' figures | The three arms; the window's 1 Hz card log and memory receipts | `telemetry.board.mean_w`, `telemetry.window.gpu_samples`, `telemetry.temps.gpu_max_c`, `memory.peak`, `telemetry.vram.growth_mib` | Recorded beside, claiming nothing; the cap 300 W on every sample |

Dates on this page are UTC. Read first-hand on 2026-10-09: the model card (huggingface.co/Qwen/Qwen3.8-Flash-Next, its revision of 2026-08-27), Qwen's licence in the same repository, both engines' licences at the commits we ran, the Strata engine's docs/DETAILS.md at 0.1.25 and 0.1.39, and llama.cpp's pull request #29761 (merged 2026-10-01).

Despite the similar name, Strata (github.com/Niko1221/Strata) is an unrelated project; strata2signal has no affiliation with it.

<!-- derived 2026-10-12 (UTC) by tools/derive_md.py from the pour source.
     source html sha256: 7758416093c772e392c1f0fd319d18e41428c39199ce92b08e892108bbcc2ecc
     derivation sha256:  54394074085645e4fe53866d07bb8410f627154e1ee7b4d3e146568fd2d0c284
     the {#id} on each heading is the anchor that heading carries on the page. -->