Mia's 2-Spark recipe, version of 9 Nov 2026: DeepSeek-V4.1-Flash-1017

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-09. Raw files: speed result · speed contract · log · long answer.

Requests at once: the server has 4 slots (from the author's recipe). C8 exceeds the slots: the extra requests wait in the queue, and they were measured anyway. The speed test ran on 9 Nov 2026 (22:20 to 22:36 CET, 15.7 minutes) with Mia's recipe at commit c7f2b85 (MiaAI-Lab/DeepSeek-v4.1-Flash-1017-2x-DGX-Sparks, the head of main on 9 Nov 2026, merged at 15:41 UTC): TensorFold's native Zig engine as the recipe pins it (Bertholomus AI's branch deepseek-v41-zig, commit fbbc971) with the recipe's engine patches, in the container image the recipe's own scripts build (tag exl3-tp2-8a98ae503d85). No image of this commit's pins is published (scripts/config.sh, line 107: 'None is published yet'), so the image was built on the head DGX Spark on 9 Nov 2026 with the build command of the recipe's prepare.sh and copied to the other box, and the image ID is the same on both. The checkpoint is Mia-AiLab/DeepSeek-V4.1-Flash-1017-EXL3-EAQ-v1-2.9-bpw at revision 45ee5d0f, with the DSpark drafts of the checkpoint on and Engram's tables on local disk on both boxes (README line 41). Everything else is the recipe's default: 4 streams, the model card's sampling (temperature 1.0, top_p 0.95, top_k 20). Only the setup values of the recipe's local.sh differ from her start command: the context 524,288 (her measurement condition, README line 27; her default is 1,048,576) and the local paths, without NFS (her 'no NFS at all' mode, docs/requirements.md, line 59). Seed 42; the request flag for no thinking; no cached tokens (the tool's cache check found no cached prompt token in any of the 61 requests it examined).

The quality tests and the memory test ran later on the same two boxes with the same image and the same start (the image ID in the records of the speed, quality and thinking runs is the same): the quality tests on 9 Nov 2026 straight after the speed test, the memory test and the thinking test on 10 Nov 2026; they are described in their own notes below. Each test was run once and is not repeated here.

The headline 66.1 tok/s is the mean of the code prompt (66.5) and the prose prompt (65.7), medians of two runs each. The spread of the code runs is 7.4 % (the two runs gave 63.0 and 70.0 tok/s) and the spread of the prose runs 0.3 %. Drafts were accepted at a rate of 57.0 % (1,191 of 2,088 drafted tokens, 2.4 accepted tokens per round of drafting). With several requests at once the server's 4 streams are the limit: C1, C2 and C4 run inside them, and the 4 extra requests of C8 wait in the queue (measured anyway, the note above names it). The context rows go from 16K to 128K tokens (prompts of exactly that many tokens), well inside the window of 524,288; sizes above 128K are not measured in the speed test.

Mia's README gives numbers from her own tool (sparkDash; decode with real prose and code prompts at temperature 0, thinking off; prefill from 4K to 256K tokens; README lines 26 to 39). My protocol uses other prompts (with a system prompt), other sampling, a fixed seed and its own counting, so the two sets of numbers are not comparable and are not set side by side here; both sets are public. I also ran her tool on this version; those results are not on this page.

The first trial start of this version on 9 Nov 2026 (before the series, without any measurement) hung while loading the weights on the head DGX Spark: the box's kernel log showed an out-of-memory message from the GPU driver, and a watchdog service restarted the box after about 3 minutes (not my action). I do not know the cause. After the restart, the starts that followed, including the ones for the tests on this page, ran without a problem.

Other processes: the load guard watched the whole speed test (38 steps, none thrown away and repeated); the busiest other process was 6.0 % of one core at most (the tool 'top' in two steps, a network service in one). Not published: the 126 per-request records of the test (the requests folder). Held back by the site's filter: the server logs, the quiet logs, the file ruhe.csv with the per-10-seconds samples (they carry GPU readings), the guard's samples (guard-samples.jsonl), its error file and the page l1.html of the long-answer test, which loads a script from the internet; the answer text l1-output.txt is published. In the published speed records, that network service is named 'network service'.

python3 speed2.py --base-url http://127.0.0.1:39589/v1 --label mia-ds41-s3s4-0911-speed-r0 --prompts $BENCH/repos/rigmark-v2/prompts-v2.json --output $RUN/mia-ds41-s3s4-0911-speed-r0/mia-ds41-s3s4-0911-speed-r0/speed2 --contract $RUN/mia-ds41-s3s4-0911-speed-r0/mia-ds41-s3s4-0911-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/hf-ds1017/hub/models--Mia-AiLab--DeepSeek-V4.1-Flash-1017-EXL3-EAQ-v1-2.9-bpw/snapshots/45ee5d0fd106c94a3d77f721e09cbb2f50e5a16b/tokenizer.json --tokenizer-python $HOME/not published --sampling {"temperature": 1.0, "top_p": 0.95, "top_k": 20} --sampling-source Same setting for thinking and non-thinking (no separate profile): Mia's recipe server defaults scripts/config.sh:148-150 @c7f2b85 (TEMPERATURE 1.0, TOP_P 0.95, TOP_K 20; 'the family's measured sampling, BertholomusAI two-node launch'; a request's own values win), and the EAQ model card Mia-AiLab/DeepSeek-V4.1-Flash-1017-EXL3-EAQ-v1-2.9-bpw @45ee5d0f README.md:141 ('Official sampling from the base card: temperature 1.0, top_p 0.95'). Note: the 1017 base card deepseek-ai/DeepSeek-V4.1-Flash-1017 README.md:77-84 recommends top_p 1.0; Mia's recipe uses 0.95; kept at 0.95 as in Mia's recipe (decision of 19 Oct). Speed v2 and quality v2 run with thinking off (enable_thinking false per request). --model DeepSeek-V4.1-Flash-1017 --no-cache-prompt --server-log $RUN/server-A.log --engine-version-file $RUN/engine-version.txt --server-slots 4 --server-slots-source MiaAI-Lab/DeepSeek-v4.1-Flash-1017-2x-DGX-Sparks@c7f2b85 scripts/config.sh:132 (PARALLEL=4, requests at once = the engine's streams TF_DS_STREAMS); README.md:101 (PARALLEL 4, 'the family was measured at 4') --server-ctx 524288 --server-ctx-source card GB10 box 3-ds1017-exl3-eaq-2.9bpw-2x-rc7f2b85 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-09; GPQA Diamond 2026-11-09; IFEval 2026-11-09; LiveCodeBench 2026-11-09; Long text 8K 2026-11-09; Long text 32K 2026-11-09; GPQA 30, thinking on 2026-11-10.

Note from the run: MMLU-Pro (400 questions), GPQA Diamond (198), IFEval (200), LiveCodeBench (40 tasks) and RULER at 8K and 32K tokens (40 tasks each) ran on 9 Nov 2026 (22:48 to 23:51 CET) with thinking off and the sampling of the recipe and the model card (temperature 1.0, top-p 0.95, top-k 20), seed 42, on the same two DGX Sparks and with the same image and start as the speed test of that evening. Four requests ran at once (the server's 4 streams, the recipe's default; each question is its own request with the same limits and seed). MMLU-Pro and GPQA Diamond ran with an answer limit of 48 tokens (letter only), IFEval with 4,096 tokens, LiveCodeBench with 32,768 tokens, RULER with 128 tokens. Without thinking the model answers a multiple-choice question with a letter at once (median 2 tokens) or starts with an explanation: 47 of 400 MMLU-Pro answers and 61 of 198 GPQA answers were cut off at the 48-token limit and count as wrong. None of the IFEval answers, but 4 LiveCodeBench answers and 3 RULER answers (all at 8K) were cut off at their limit and count as wrong; in all, 115 answers of these five parts were cut off. RULER by task at 8K and 32K: multi-key retrieval 10 of 10 and 10 of 10; common-word extraction 7 of 10 and 10 of 10; multi-hop question answering 9 of 10 and 4 of 10; variable tracking 1 of 10 and 1 of 10. The thinking test (GPQA 30) ran on 10 Nov 2026 (17:10 to 17:30 CET) with the same card, image and start, with thinking on and a limit of 16,384 tokens: 4 of the 30 answers were cut off at the limit and count as wrong (median 2,128 tokens and 66.6 s per question, with 4 questions running at once). No request ended in an error (the error count in the summaries of all tests is 0, and all 80 RULER answers are in the answers file). My MMLU-Pro and GPQA answers are the same as in my run of 20 Oct 2026 on Mia's earlier version of the recipe (commit e65785cd, checkpoint revision 6d54be4f, which no longer resolves on the Hub): for all 400 MMLU-Pro and all 198 GPQA questions the answer text, the thinking text and the correct flag are equal. The other tests were not compared answer by answer. These quality tests have no foreign-load guard. Their sampling files (not published, see the speed notes) list the busiest other process every 10 seconds: during MMLU-Pro, GPQA, IFEval, LiveCodeBench and RULER (371 samples) it was at most 100.0 % of one core, and 7 samples were above 25 %: a simulated package upgrade (94.7 %, once), the network card's firmware query tool mstflint (66.6, 71.7, 69.2 and 47.8 % in four samples within 60 seconds, about 3 minutes into the run) and the code sandbox of the LiveCodeBench test (100.0 % and 99.5 %, two samples in a row); during the thinking test (118 samples) it was at most 31.2 %, once, a status query of the other box over ssh. The quiet logs before and after each part (not published) list no foreign problems. GPQA Diamond: the original is gated and no Hugging Face token was available, so the public mirror fingertap/GPQA-Diamond (198 rows) was used. Mia's model card for this checkpoint gives fidelity against the original weights (KL and top-1 agreement), not task scores, so these are my own task tests. Not published (the site's filter holds these back): IFEval's answers file (ifeval.jsonl; a word in one task text is read as a machine name), the LiveCodeBench answers and generations (lcb.jsonl, lcb.gen.jsonl; program code with a variable named 'power' is read as a power setting), and the server logs, the quiet logs and sampling files named above; the summaries of all tests, the answers files of MMLU-Pro, GPQA, RULER and the thinking test, and the logs are published. These are my own tests, and no other quality run of this setup is mixed into the numbers on this page.

bash tools/quality2/measure_all.sh tools/quality2/cards/ds1017-exl3-eaq-2.9bpw-2x-rc7f2b85.json --parts mmlupro --job mia-ds41-s3s4-0911-quali

bash tools/quality2/measure_all.sh tools/quality2/cards/ds1017-exl3-eaq-2.9bpw-2x-rc7f2b85.json --parts gpqa --job mia-ds41-s3s4-0911-quali

bash tools/quality2/measure_all.sh tools/quality2/cards/ds1017-exl3-eaq-2.9bpw-2x-rc7f2b85.json --parts ifeval --job mia-ds41-s3s4-0911-quali

bash tools/quality2/measure_all.sh tools/quality2/cards/ds1017-exl3-eaq-2.9bpw-2x-rc7f2b85.json --parts lcb --job mia-ds41-s3s4-0911-quali

bash tools/quality2/measure_all.sh tools/quality2/cards/ds1017-exl3-eaq-2.9bpw-2x-rc7f2b85.json --parts ruler --job mia-ds41-s3s4-0911-quali

bash tools/quality2/measure_all.sh tools/quality2/cards/ds1017-exl3-eaq-2.9bpw-2x-rc7f2b85.json --parts ruler --job mia-ds41-s3s4-0911-quali

bash tools/quality2/measure_all.sh tools/quality2/cards/ds1017-exl3-eaq-2.9bpw-2x-rc7f2b85.json --parts think --job mia-ds41-s3s4-1011-think

How much context fits

Memory test. The recipe fixes the context (524,288 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-10. Raw files: result of every step · log · contract.

Note from the run: fit memory per node, highest rise over idle: box-3 108.7 GiB, box-4 107.0 GiB. In this test the server was started once, with the recipe's context setting at 524,288 tokens (Mia's measurement condition; the recipe fixes the context, so there is no knob to turn per size; four streams, drafts on, the same start as in the speed and quality tests). Then one prompt of about 95 % of each size (4K, 8K, 16K, 32K, 64K and 128K) was sent, and the model had to answer with at most 96 tokens. All six sizes loaded and were answered: at 4K, 16K, 64K and 128K the model finished by itself (finish reason stop), at 8K and 32K the answer ended at the test's 96-token limit (finish reason length), which this test counts as answered. The list of sizes ends at 128K (124,518 tokens in the largest prompt), so this is the largest size tested, not the largest size the setup can load: the recipe runs at a context of 524,288 and the model's window is 1,048,576. The memory number is the rise of the head DGX Spark's used memory over its idle value before the server start (the GB10 has one pool of memory for CPU and GPU, so the number includes the model weights and the desktop and services that were running): the highest rise was 108.71 GiB (116.7 GB) with the 128K prompt on the head box; the worker box peaked at 106.97 GiB. The head box's idle value was 8.97 GiB, the worker's 9.19 GiB. Because it is the rise of the whole machine, other programs that used or released memory at the same time are inside the number. This engine reports no timings for this memory test, so the decode speed and first-token columns are empty (the speed test above measures prompts up to 128K). Mia's documentation names the free memory of her own head box under load (docs/requirements.md and docs/measurements.md); it measures another thing than this rise over idle, so I do not set the numbers side by side. The server log of this test is not published (the site's filter holds it back); the test's own log, its output and its contract are published.

bash tools/quality2/measure_all.sh tools/quality2/cards/ds1017-exl3-eaq-2.9bpw-2x-rc7f2b85.json --parts fit --job dsv41-mia-c7f2b85-fit-1010

How it plays the Gauntlet

One solo race, season seed 21, one attempt, no help.

Game rank as of Nov 9, 2026. The rank is the order of the Gauntlet finish times in this memory class. Race page and raw files.

The race ran the recipe named on its race page, with the sampling and answer limit of its lane config. The engine build of the race is not recorded in the race files.

Result (result.json) Race log (log.jsonl) Model answers (io.jsonl) System prompt Exact command Verify output Model config Race page

Also made this possible

• ModelDeepSeekHugging Face @deepseek_ai GitHub Website
• Engine (TensorFold)Ash Hart@ashxhart GitHub Hugging Face Website
• DeepSeek-V4.1 support in TensorFold (the engine branch the recipe builds, commit fbbc971)Bertholomus AI@bertholomusai GitHub Hugging Face
• EXL3 formatturboderp@turboderp_ GitHub Hugging Face

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 (about 109 Gb/s): 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 DeepSeek-V4.1-Flash-1017 EXL3 EAQ v1 2.9bpw (rev 45ee5d0f) + checkpoint DSpark drafts

Engine

TensorFold, tensor parallel on 2 GB10 boxes, EXL3 EAQ 2.9 bpw with DSpark drafts (recipe commit c7f2b85 of 9 Nov 2026) — the program that loads the model and answers requests · github.com/ashhart/TensorFold

Recipe and EXL3 quant (EAQ 2.9 bpw), commit c7f2b85

github.com/MiaAI-Lab/DeepSeek-v4.1-Flash-1017-2x-DGX-Sparks by Mia (MiaAI-Lab)

Steps

1. Get the recipe and the engine from the list above. The list has no direct download link for the model file itself. The base model is huggingface.co/deepseek-ai/DeepSeek-V4.1-Flash-1017.

2. Start the server with this command in the recipe folder. It loads the model into memory.

   Copy

   PATH=$HOME/.local/bin HF_HUB_OFFLINE=1 ./start.sh

   We used the recipe at commit c7f2b85. Our run started it on the first DGX Spark (head); the second DGX Spark ran the worker. How the recipe starts the two DGX Sparks: see the README of the recipe, github.com/MiaAI-Lab/DeepSeek-v4.1-Flash-1017-2x-DGX-Sparks.

TensorFold native (Zig 0.17.0), TP=2, DSpark speculative drafts (DRAFTS=1), in image tensorfold-dsv41:exl3-tp2-8a98ae503d85 (TF_REF fbbc971 (BertholomusAI, branch deepseek-v41-zig) + the recipe's 53 engine patches zig/patches 0001-0068 and 2 inputs patches @c7f2b85 (list: zig/patches/README.md), among them 0005 prefill interleave 250 ms, 0008 pool window, 0010 RDMA idle nap, 0049 first-draft depth, 0066 load prefetch (TF_DS_LOAD_PREFETCH on), 0068 RDMA proxy CPUs (off unless set); CHANGELOG.md Unreleased @c7f2b85); PREPARE=0 PATH=$HOME/.local/bin HF_HUB_OFFLINE=1 ./start.sh ($HOME/dsv41-mia-0911/recipe @c7f2b85, scripts/local.sh: CONTEXT=524288, no NFS; head box-3 rank 0, worker box-4 rank 1; via mia-2x-rc7f2b85.sh start)