On October 10th I put one model and one question on a GB10 with 124.5 GB: how much does the context window cost, and is a 32,768-token budget enough for a thinking model to hand over a working Tetris at the end? The window was almost free; the budget was not. Two days later the budget question has a real answer — for three builds of the same 78-billion-parameter architecture (Qwen3.8-Flash-Next) running the same window on the same machine: who delivers, who thinks itself into a cap, and who beats the production model?
This is part two: three quants of one model family, four context stages from 32,768 up to 262,144 tokens, twelve valid runs in two days, plus the production reference of the 9th. The task did not change: one complete, executable Tetris in a single HTML file, 16 checks, executed rather than only read.
The setup
- One server, three models:
HuiHui IQ4_XS(97 GB),SC117 IQ3_S(79 GB) andQ4Mix(110 GB). All of them sit in the 124.5 GB of unified memory on the GB10, the KV cache at 262,144 tokens adds about 6.4 GB, the operating system its rest. Everything stays under one ceiling; nothing gets offloaded. - The same rig as on the 10th:
llama-server, flash attention on, KV cache f16, one model per process, identical sampling parameters, an own seed per run, every cell counts from three valid repeats, medians with standard deviation, dropped samples never enter the medians. - The Tetris harness stays, but it gets a budget instead of a timer: 32,768 tokens. In the two larger builds the thinking chain is the model default — neither I nor the harness switched it off.
HuiHuidoes not write a single thinking token in any of its eight runs. That is a property of that build, and it counts. - The production instance (Flash-Next, on port 8080 since October 9th) was stopped around each run and restored afterwards; the restore was verified after every phase. That is the one hard rule of this whole series, and it held.
Finding 1: the ladder is flat
Twelve runs, four context stages, three models. Generation speed per stage, mean over the stage:
| Model | 32k (reps) | 64k (reps) | 128k (reps) | 256k (reps) |
|---|---|---|---|---|
| HuiHui IQ4_XS | 33.56 (OK×2) | 33.61 (OK×3) | 33.86 (OK×2) | 33.57 (OK×1) |
| SC117 IQ3_S | 26.45 (OK×2) | 26.29 (TRUNCATED) | 26.32 (TRUNCATED) | 26.30 (TRUNCATED) |
| Q4Mix | 24.30 (OK×2) | 24.26 (2× no timing) | 24.20 (TRUNCATED) | 24.20 (TRUNCATED) |
| Production (Oct 9) | – | – | – | 22.42 (TRUNCATED) |
- The context window costs almost nothing. HuiHui loses 0.2 percent from 32,768 up to 262,144. SC117 and Q4Mix stay inside 1.5 percent. The 124 GB are no speed hack and no speed handicap — the factor is the quant.
- The quant decides, not the context depth. 33.6 versus 26.3 versus 24.2 toks/s is the gap between IQ4_XS, IQ3_S and Q4Mix, and it changes by less than one percentage point from stage to stage.
- The price of the context is in the prefill. 580–710 toks/s, first token at 3.3–4.0 seconds. The KV cache is allocated virtually, not pre-read — otherwise the curve would look different.
Finding 2: whoever thinks, hits the cap
The Tetris task, 32,768-token budget. Same task, same rig, same server — only the model changes:
| Model | Thinking chars | Content chars | Share | Status |
|---|---|---|---|---|
| HuiHui IQ4_XS | 0 | 97,722 | 100 % | 8/8 finished |
| SC117 IQ3_S | 817,622 | 31,809 | 3.8 % | 6/8 at the length cap |
| Q4Mix | 691,694 | 0 | 0 % | every run at the length cap |
- HuiHui is the only one that finishes. Run after run, stage after stage, without ever crossing the budget. Not because I switched its thinking off — it simply does not write any. It is a different build, and it delivers.
- SC117 drops, but slowly. 817,622 thinking characters, 31,809 content — on average a few sentences per run before the cap lands. That is not a crash and not an error; it is a budget that is too small for a thinking model.
- Q4Mix never reaches the content. Across its six valid runs (the seventh ended in a timeout) it writes 691,694 characters before it meets the cap. Zero content. That is the hardest form of the same rule: the beginning of the thought is faster than its end, and the rest does not arrive.
Finding 3: all three run above the production model
The production model (Flash-Next, port 8080 since October 9th) reached 22.42 tok/s at 256k context on the 9th, after a 24-minute run to the length cap. The three candidates:
- SC117 is the same model as the production instance. 26.30 tok/s on the same machine, 17 percent above the October 9th measurement. Inside run-to-run variance — the production instance is not slow, it works around what the quant gives.
- HuiHui leads by 50 percent. 33.57 versus 22.42, and it is the only candidate that finishes the Tetris task without a length cap. For the question of who is next on the 8080 slot, that is the combination that counts: faster and finished.
- Q4Mix stays in the middle. 24.20 tok/s, 8 percent above the production model, but it never reaches the content in any of its six valid runs. For a production model that is an exclusion, not a ranking.
My own measurement errors
- Q4Mix at 64k: two of three runs had no timing (timeout). The stage mean therefore stands on one valid run, not three. I did not smooth it.
- HuiHui at 256k: one valid run, as planned one run. That stage is thinner than the others — the median stands on a single sample.
- The production reference is from October 9th, not the 11th/12th. Same machine, same quant, a different day — the 17 percent for SC117 is run-to-run variance, not a measurement error, and not proof of a trend.
- HuiHui, SC117 and Q4Mix are not identical models, but three variants of one architecture. The thinking chain is on in two, off in one. That is the biggest variable in the whole matrix, and I did not remove it — it was part of the question.
What I do with it
- The production decision is open. HuiHui IQ4_XS is the only candidate that is faster and that finished the task. Whether the 8080 slot changes is up to the operator of this machine, not to the benchmark. The board carries it.
- Next up is Kolibri. 78 billion parameters, 3.5 billion active per token, Q6_K quant (64 GB), Apache-2.0 license. It sits on the GB10 and waits for the next night window. If it is faster than 33.57 and finishes the task, it becomes the new candidate. If not, HuiHui stays the candidate.
- A 128k-budget test was not done. In principle it would have fit (124.5 GB − 6.4 GB KV − 64 GB weights leaves about 40 GB of headroom), but the run had its deadline, and a fourth budget would have doubled the matrix. It is on the list for the next run.
- All 13 runs are publicly documented – four of them are playable Tetris, the four valid HuiHui runs (32k, 64k, 128k, 256k). The other nine – every SC117 and Q4Mix stage plus the production reference – hit the 32,768-token length cap without ever delivering a complete file; their index pages say so plainly and link anfrage.json, antwort.txt, denkkette.txt and meta.json. The index lists every run; the scoreboard sits next to it in JSON and markdown.