Mia's 2-Spark recipe, version 1104: GLM-5.3-Flash

How fast it runs

Long prompts

Method: code+prose; 2 run(s) each; 512 tokens; 1 warm-up(s); median; context steps: prompts of exactly 16K, 32K, 64K and 128K tokens (a filler log first, the code or prose task prompt last), 2 runs per step, 512 output tokens; decode = tokens after the first / time after the first token; prefill = prompt tokens / time to first token of the same request, median over its requests; requests at once: C1,C2,C4,C8 at once; 2 rounds each; 512 tokens per request; prose prompt; total = all tokens / wall time, per request = tokens / end-to-end time; median over the rounds. Measured 2026-11-04. Raw files: speed result · speed contract · log · long answer.

Requests at once: the server has 8 slots (from the author's recipe). The speed test ran with Mia's recipe, version 1104 (MiaAI-Lab/GLM-5.3-Flash-DGX-Sparks-1104). I ran the file tree of her commit 0049d7c of 4 Nov 2026, which is commit 3f44ec2 on GitHub since she rewrote the history that day (the two trees differ only in one planning file). Her main branch had moved on by the time I started the build (commit ff29b0d adds a patch for four boxes and files for a four-box ring; according to her notes nothing changes for two boxes); I kept the 105-patch tree that her README names for the pair (image built from that tree, tag d3acd712b31c). TensorFold's native engine (commit f350cd3e, Zig 0.17.0) with her 105 patches, tensor parallel over two boxes (CX7 RDMA, 109.2 and 109.3 Gb/s on the two links before the run), DFlash2 drafts and vision on as the recipe sets them, a context window of 1,048,576 tokens and 8 requests at once (PARALLEL=8 in the local.sh of her served pair, README lines 155 and 156; the script default is 4; the recorded command below cites line 160 and 73 to 79, which are the line numbers of her later commit ff29b0d, not of the tree I ran). Her worker-weights check wants a marker file with the revision of her pin (76c0b517); my copy of the weights is snapshot 078455ff, whose weight and configuration files have the same hashes as her pin (only the model card differs), so I wrote that marker on both boxes. Nothing in her settings was lowered. Sampling is the model card's, the same with thinking on and off: temperature 1.0, top_p 0.95; seed 42; the request flag for no thinking; no cached tokens in the 61 requests that were checked. The headline 40.58 tok/s is the mean of the code prompt (42.44) and the prose prompt (38.71), medians of two runs each (spread 3.4 % and 0.9 %). Drafts were accepted at a rate of 58.0 % (1,143 of 1,971). The server has 8 slots, so the four concurrency levels (1, 2, 4 and 8 at once) are all inside its slot count. Mia's README lists decode numbers for prose at temperature 0.7 with thinking on (47.8 tok/s for one request, 87.3 tok/s for four), measured with sparkDash on this pair. Speed v2 uses other prompts, temperature 1.0 and thinking off, so the numbers are not comparable. The recorded command below says that Mia's own decode numbers were reproduced separately with her method; that separate run is not shown on this page. At the start of the first session the server reported a prompt cache of 1.2 GiB on each of the two ranks (1.3 GiB in the later sparkDash and LiveCodeBench sessions); Mia's README names 3.6 GiB. On my boxes less memory was available at the start (about 113 GiB, 16.5 GiB left after the 9.5 GiB reserve in the first session), and I changed no system setting. Cached tokens were 0 in the requests I checked; a multi-turn chat that reuses earlier turns is not measured here. The load guard (a sample every half second) saw other processes together above 25 % CPU in 76 of 7,285 samples, up to 112 %, including the samples of the two tries that it threw away; it throws a try away and repeats it when a single process uses more than 25 % CPU in two samples in a row. It threw away two tries of the long single run (32,768 tokens) and repeated it: the first because of a scheduled "apt update" on the box, the second because of a log query I ran myself on the box; the third try is the one that counts, and no other step had to be repeated. The ten-second quiet check named a firmware query as the busiest other process (100 %).

python3 speed2.py --base-url http://127.0.0.1:32851/v1 --label glm-mia-1104-0411-speed-r0 --prompts $BENCH/repos/rigmark-v2/prompts-v2.json --output $RUN/glm-mia-1104-0411-speed-r0/glm-mia-1104-0411-speed-r0/speed2 --contract $RUN/glm-mia-1104-0411-speed-r0/glm-mia-1104-0411-speed-r0/speed2/speed-contract.json --parts decode,prefill,conc,l1,ctx --prefill-depths 2048,8192,32768 --prompt-ids code,prose --runs 2 --max-tokens 512 --warmups 1 --prefill-runs 3 --conc-levels 1,2,4,8 --conc-rounds 2 --conc-max-tokens 512 --conc-prompt prose --ctx-depths 16384,32768,65536,131072 --ctx-runs 2 --ctx-max-tokens 512 --tokenizer-json $HOME/models/glm53-mia-4bpw-1104/tokenizer.json --tokenizer-python $HOME/not published --sampling {"temperature": 1.0, "top_p": 0.95} --sampling-source Checkpoint generation_config.json:9-10 (temperature 1.0, top_p 0.95; Mia-AiLab/GLM-5.3-Flash-EXL3-4bpw-TensorFold @078455ff = pin 76c0b517 weights, copy $HOME/models/glm53-mia-4bpw-1104/generation_config.json); Mia's 1104 README names no separate sampling profile. Mia's own official decode numbers use T=0.7 with thinking ON (README.md:59) and are reproduced separately (mia_method.py, own column, never mixed). Speed v2 runs with thinking off (enable_thinking false per request), think part with thinking on. --model GLM-5.3-Flash --no-cache-prompt --server-log $RUN/server-A.log --engine-version-file $RUN/engine-version.txt --server-slots 8 --server-slots-source MiaAI-Lab/GLM-5.3-Flash-DGX-Sparks-1104@0049d7c scripts/local.sh PARALLEL=8 ('The served pair's local.sh sets PORT=8888, PARALLEL=8, CONTEXT=auto' README.md:160; performance table README.md:73-79 '8 streams'; scripts/config.sh:136 default 4, 'auto: up to 8'); rank 0 start log shows '8 at once' --server-ctx 1048576 --server-ctx-source card GB10 box 3-glm53-flash-tf-zig-1104-2x-mia field ctx

How well it answers

Thinking off, except the last test. Seed 42. Sampling from the model card. A cut-off answer counts as wrong. Measured: MMLU-Pro 2026-11-04; GPQA Diamond 2026-11-04; IFEval 2026-11-04; LiveCodeBench 2026-11-05; Long text 8K 2026-11-04; Long text 32K 2026-11-04; GPQA 30, thinking on 2026-11-04.

Note from the run: MMLU-Pro and GPQA Diamond ran with an answer limit of 1,024 tokens (my usual limit for these two tests is 48; the card of this setup sets 1,024, which is the limit Mia's sparkDash uses for MMLU); same questions, seed 42, first-letter extraction. 1 of 400 MMLU-Pro answers and 1 of 198 GPQA Diamond answers were still cut off at that limit and count as wrong. 10 of 200 IFEval answers were cut off at their limit of 4,096 tokens, 24 of 80 long-text answers at their limit of 128 tokens and 4 of 30 GPQA answers with thinking at the limit of 16,384 tokens; these count as wrong too. 16 of 40 LiveCodeBench answers were cut off at their limit of 32,768 tokens and count as wrong (none of them passed; job glm-mia-1104-0411-lcb, run after the other tests). The questions of each test ran 8 at a time, the slot count of the recipe's server (same questions, limits and seed for every question). Sampling: temperature 1.0, top_p 0.95 (the model card). Speed v2, MMLU-Pro, GPQA Diamond, IFEval, the long-text tests and GPQA with thinking ran one after the other on 4 Nov 2026 on one freshly started server; LiveCodeBench, sparkDash and the memory test each ran in their own session on a freshly started server. These quality tests have no foreign-load guard; their sampling files list the busiest other process every 10 seconds: in the four instruction tests one sample was above 25 % CPU (48 %, a firmware query), in the thinking test three samples were (up to 100 %: a short python command of unknown origin, a package-manager dry run and the firmware query), and in LiveCodeBench ten samples were (up to 98 %: package-manager checks and the firmware query; two more samples at the end came from the test's own code runner). The answers file of MMLU-Pro is not published: the site's filter for power units flagged physics values in the model's reasoning text (they are not power readings). The row was counted from the complete file. The answers files of LiveCodeBench are not published: the site's filter for power settings flagged a program variable named power in the model's code (it is not a power reading). The row was counted from the complete results file. These are my own tests, and no other run of this setup is mixed into the numbers on this page. I did not look for the reason why 10 of the 200 IFEval answers ran to the 4,096-token limit.

bash tools/quality2/measure_all.sh tools/quality2/cards/glm53-flash-tf-zig-1104-2x-mia.json --parts mmlupro --job glm-mia-1104-0411

bash tools/quality2/measure_all.sh tools/quality2/cards/glm53-flash-tf-zig-1104-2x-mia.json --parts gpqa --job glm-mia-1104-0411

bash tools/quality2/measure_all.sh tools/quality2/cards/glm53-flash-tf-zig-1104-2x-mia.json --parts ifeval --job glm-mia-1104-0411

bash tools/quality2/measure_all.sh tools/quality2/cards/glm53-flash-tf-zig-1104-2x-mia.json --parts lcb --job glm-mia-1104-0411-lcb

bash tools/quality2/measure_all.sh tools/quality2/cards/glm53-flash-tf-zig-1104-2x-mia.json --parts ruler --job glm-mia-1104-0411

bash tools/quality2/measure_all.sh tools/quality2/cards/glm53-flash-tf-zig-1104-2x-mia.json --parts ruler --job glm-mia-1104-0411

bash tools/quality2/measure_all.sh tools/quality2/cards/glm53-flash-tf-zig-1104-2x-mia.json --parts think --job glm-mia-1104-0411

How much context fits

Memory test. The recipe fixes the context (1,048,576 tokens), so the server is started once with the recipe's own command and reserves its memory up front. Then, for each size (4K, 8K, 16K ... up to the largest size tested), one prompt that fills about 95 % of that size is sent, and the model must answer. The largest size that answered counts; it is the highest size tested, not a limit of the setup. Decode speed at that size was not measured. Peak memory is, on each of the two boxes, the rise of used memory (MemTotal - MemAvailable) over the idle value before the step; the table and the number show the highest of the two boxes. Unified memory, so GPU and CPU share it. Measured 2026-11-04. Raw files: result of every step · log · contract.

Note from the run: fit memory per node, highest rise over idle: box-3 102.0 GiB, box-4 100.6 GiB The recipe fixes the context (1,048,576 tokens, 8 requests at once), so the server is started once with the author's command and reserves its memory up front. Every size from 4K to 128K was sent as a prompt of about 95 % of the size and answered. The largest size tested is 131,072 tokens, the highest size in my list, not a limit of the setup: the window is 1,048,576. Decode speed at these sizes is not measured here (the memory test returns no timings; the speed section has decode and prefill at 16K to 128K). The memory number is the rise of used memory over the idle value (unified memory, so GPU and CPU share it). The number shown (101.78 GiB) is the rise on the first box at the largest size; the highest rise at any size was 102.04 GiB on the first and 100.60 GiB on the second box. Most of it is the model and the reserved cache, which the server takes at its start.

bash tools/quality2/measure_all.sh tools/quality2/cards/glm53-flash-tf-zig-1104-2x-mia.json --parts fit --job glm-mia-1104-0411-fit

Also made this possible

• ModelZ.ai (GLM-5.3-Flash)Hugging Face @Zai_org GitHub Website
• Draft model (DFlash2, revision bf582e4e)Inco AI@inco_ai Hugging Face GitHub Website
• Engine (TensorFold, commit f350cd3e)Ash Hart@ashxhart GitHub Hugging Face Website
• EXL3 formatturboderp@turboderp_ Hugging Face GitHub

Run it yourself

What you need and how to start it, step by step. The results below come from exactly this setup.

What you need

Hardware

2x NVIDIA GB10 boxes linked by CX7 RDMA (109.2 and 109.3 Gb/s on the two links, measured before the run): 1x Gigabyte AI TOP ATOM and 1x Lenovo ThinkStation PGX. Both run driver 580.178.04 and kernel 7.0.0-1019-nvidia, GPU clock capped at 2200 MHz.

Model

Mia GLM-5.3-Flash EXL3 4bpw (rev 078455ff = weights of pin 76c0b517) + incoai DFlash2 (rev bf582e4e)

Draft model (DFlash2, revision bf582e4e)

huggingface.co/incoai/GLM-5.3-Flash-DFlash2

Engine

TensorFold's native engine (commit f350cd3e) with 105 patches, tensor parallel on 2 GB10 boxes, EXL3 4 bpw with DFlash2 drafts — the program that loads the model and answers requests · github.com/ashhart/TensorFold

Recipe (version 1104, commit 3f44ec2) and EXL3 quant

github.com/MiaAI-Lab/GLM-5.3-Flash-DGX-Sparks-1104 by Mia (MiaAI-Lab)

Steps

1. Get the recipe, the engine and the model files from the list above.

2. Start the server with this command. It loads the model into memory. When the model has loaded, the server waits for requests on port 8888.

   Copy

   ./start.sh in glm53-mia-1104 on box-3 via scripts-agent/spark-2x-glm-1104.sh start (scripts/local.sh: \
     WORKER=me@127.0.0.1, \
     PORT=8888, \
     PARALLEL=8, \
     CONTEXT=auto, \
     KV=fp8, \
     DENSE=q8, \
     HEAD=q8, \
     ABSORB_MMA=1, \
     HOST_CACHE_GIB=0, \
     MEMORY_RESERVE_GIB=9.5, \
     MODEL_SOURCE=local, \
     WORKER_WEIGHTS=check); head box-3 rank 0, worker box-4 rank 1

   The file names are the ones we used. Run the command in the folder that holds them, or put the full path in front of each name.

TensorFold native Zig engine f350cd3e (ashhart/TensorFold, Zig 0.17.0, NCCL 2.30.7) + 105 patches of Mia's recipe 1104, TP=2, DFlash2 drafts (4 bit), image tensorfold-glm53-spark:d3acd712b31c; ./start.sh in $HOME/glm53-mia-1104 on box-3 via scripts-agent/spark-2x-glm-1104.sh start (scripts/local.sh: WORKER=me@127.0.0.1, PORT=8888, PARALLEL=8, CONTEXT=auto, KV=fp8, DENSE=q8, HEAD=q8, ABSORB_MMA=1, HOST_CACHE_GIB=0, MEMORY_RESERVE_GIB=9.5, MODEL_SOURCE=local, WORKER_WEIGHTS=check); head box-3 rank 0, worker box-4 rank 1

Mia's own benchmark, run unchanged

This is Mia's own benchmark tool (commit 21a3511), run unchanged. It has its own section on this page, and it is never mixed with my numbers. A cut-off answer counts as wrong here, so a value can differ from sparkDash's own screen.

Seed 1234 applies to the two quality tests; decode, prefill and tool eval send no seed. The benchmark client ran on a separate machine that is never part of the measured group. Measured 2026-11-04. Version 2.50.0, commit 21a3511.

QA. Quality QA, 150 items, seed 1234, temperature 0, thinking off, 4 requests at once (Mia's default). An answer cut off at the token limit counts as wrong. ± is the 95 % margin (Wilson).

MMLU. Quality MMLU, 285 items (5 for each of 57 subjects, 4 answers), seed 1234, temperature 0, thinking off. An answer cut off at the token limit counts as wrong. ± is the 95 % margin (Wilson).

Decode. Decode bench, 1 request at once, 400 tokens, prompt type structured, temperature 0, thinking off. No seed is sent.

Prefill. Prefill bench at 4K, 8K, 16K and 32K tokens. sparkDash skips a size that does not fit into the context. No seed is sent.

Tool Eval Quick. Tool Eval Quick: tool-eval-bench (SeraphimSerapis, commit c61319b), 15 core scenarios (--short), --no-think, --timeout 120. Score 0 to 100. No seed is sent.

Note from the run: sparkDash runs its own tests (its own QA and MMLU questions at temperature 0, thinking off, a cut-off answer counts as wrong; 7 of the 150 QA answers and 0 of the 285 MMLU answers were cut off), so its decode and prefill values are not comparable with Speed v2 above: its decode test uses a structured prompt, Speed v2 a code and a prose prompt. Mia's README numbers come from sparkDash too, but with temperature 0.7 and thinking on; as I run it, sparkDash sends temperature 0 and thinking off, so I cannot reproduce them with it. Speed v2 and Quality v2 stay in their own columns; no sparkDash number is mixed into them. The sparkDash client ran on another machine and was never part of the measured group.

python3 tools/quality2/sparkdash_client.py tools/quality2/cards/glm53-flash-tf-zig-1104-2x-mia.json <box> --client <client machine> --job glm-mia-1104-0411-sd --out $RUN

tool-eval-bench --base-url http://127.0.0.1:<port> --model GLM-5.3-Flash --short --no-think --timeout 120 --json-file $BENCH/sparkdash-client/runs/glm-mia-1104-0411-sd-sparkdash-r0/tooleval/result.json --no-live