Owen's recipe, pre-release candidate-54: DeepSeek-V4.1-Flash on 4 GB10 boxes (TP4 ring)

How fast it runs

Long prompts: context steps (filler log first, task prompt last, 512 reply tokens)

Context step and prefill series. "Prefill at 32K" in the table above is the prefill series (a cold prompt of 32,768 token ids, 8 reply tokens, three runs). The 32K row here is a different measurement of a prompt of about the same size: a chat request with a filler log first and the task prompt last, 512 reply tokens, two runs each with the code and the prose prompt. Both divide the prompt tokens by the time to first token; the two numbers are not the same measurement.

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; long prompts (later supplementary run of 2026-11-12, same setup): 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. Measured 2026-11-12. Raw files: speed result · speed contract · log · long answer · speed result · speed contract · log.

What ran. Pre-release candidate-54 of Owen's spark-ds41f recipe (tag candidate-54, commit ed033551831fb4e8e1031647b4cd2f475f0208e5, published Nov 11, 2026), not Owen's standard release 1107, which stays Owen's default. Owen's release text for candidate-54 says: "Verified, not release-qualified: no release set, quality evals, AgentX or cold boots." The setup is the recipe's shape tp4-ring: DeepSeek-V4.1-Flash-1017 (revision 1bae0e10, FP8 with FP4 routed experts, as published) with its DSpark drafts (5 per step), served by vLLM (the local-inference-lab fork that the recipe pins: base 19f2c20e plus 672 patches, tree ad2dc11f) with TileLang kernels, tensor parallel 4 over 4 GB10 boxes in a cable ring, the one-shot ring all-reduce (transport oneshot-ring4), a context of 1,048,576 tokens, 16 slots (--max-num-seqs 16) and a batch of 16,384 tokens (shape values from releases/spark-ds41f-1107/cluster.json lines 224 and 227 to 230, inherited by candidate-54). The image is not Owen's: we built it ourselves from Owen's lock for candidate-54 (image tag spark-ds41f:candidate-54, our image ID sha256:ecfca830b946ad8ea350189ac72d94d56514cbbbbbf7af1e35c856a0f7f7c069; no published image was used), and started it with Owen's own tool, bin/spark, and a cluster config of ours that extends Owen's candidate-54 profile (the start command is in the Setup section below). Owen's own published numbers come from the image that Owen's receipts name with the ID d502217e; they are in the section "Owen's published numbers" below, labelled with release, date and method.

Where this run differs from Owen's setup (paths in this paragraph are relative to the repository root at tag candidate-54). (1) Kernel and page size: the stock kernel 7.0.0-1019-nvidia with 4 KiB pages and no memory saver, where the recipe asks for 7.0.0-1019-nvidia-64k with 64 KiB pages and dgx-spark-memory-saver 0.4.1 (releases/spark-ds41f-1107/cluster.json lines 74 to 78 for the kernel and the page size, docs/memory-profiles.md line 99 for the memory saver 0.4.1; the start tool printed its warning about this on all four boxes). (2) GPU clock: our boxes run with a standing cap of 2200 MHz; Owen writes that a healthy GB10 stays near 2,400 MHz in operation (docs/recovery.md line 176), and Owen's measurement files do not record the clock. (3) Weights: the workers read the 46 non-Engram shards of the checkpoint over a read-only network mount from the head box when the model loads; the two Engram shards (47 and 48) are local on every box; every weight file was checked against the Hugging Face file list. (4) The recipe's GLP file is left out (glp unset in our cluster config); only the stock model name is served. (5) The image is our own build (point above); the vLLM patch head 15833ed1 and the vLLM tree ad2dc11f match the ones named in Owen's release text. (6) NCCL_IB_GID_INDEX stays pinned to 3, as in the recipe. (7) Host: nothing was changed on the boxes for this run (no headless boot, no sysctl or NVMe changes) and fan control is off in our config (host.fan_control false); the management network is the wired 2.5 GbE link. (8) Sampling and thinking: temperature 1.0 and top_p 1.0, the recipe's generation defaults (releases/spark-ds41f-1107/cluster.json lines 19 and 20, equal to the model card as recorded on our card), no top_k, no min_p and no penalties, because the recipe names none; seed 42; thinking is off in every request of Speed v2 and of the six fixed quality lists (enable_thinking false per request), on only for the last quality test; Owen's server default is thinking on (docs/current-state.md line 292), and Owen's own test runs use thinking off. (9) The prompt cache is off for the tests (cache_prompt false, a different cache salt in every request). (10) The context, the slot count, the batch size and the KV cache of 10.5 GiB per rank (11,274,289,152 bytes) are the recipe's own values, unchanged.

Three server starts, and which one each value comes from. Start 1 (up at 19:42 after 652 s): Speed v2 was stopped at its long-answer step by the load guard (a kernel thread, kcompactd0, above 25 % CPU for two samples in a row, up to 100 %, still after 3 repeats), so nothing of that run is used or in the register; then the five quality tests of the instruct profile ran on the same server (19:50 to 20:07, all five finished; four of their summary files report 0 errors, and the answer file of the long-text test has none with an error field); the Thinking test started at 20:07 and got its answers from a server that crashed: the kernel log of each of the four boxes shows a GPU error line, "NVRM: Xid ...: 43", at 20:08:03 on three boxes and at 20:08:16 on the fourth. That run of the Thinking test (30 requests, 45 seconds) is discarded: 29 of its 30 requests got HTTP 500 ("EngineCore encountered an issue") so that run says nothing about the model; it is not in the register and its raw files are not published. An open issue in Owen's repository (#1036) reports an Xid 43 on all ranks with release 1107. Start 2 (up at 20:23 after 653 s): Speed v2 (20:23 to 20:31) and the Thinking test again (20:31 to 20:40, valid). Start 3 (up at 20:54 after 649 s): only the long-prompt step (20:54 to 20:58), with one setting changed, VLLM_SSE_KEEPALIVE_INTERVAL_S=0, explained below. Every value on this page comes from exactly one of these runs: Decode, words per second, prefill at 2K, 8K and 32K, first token, acceptance, requests at once, long answer and long prompts at 16K, 32K and 64K come from the Speed v2 run of start 2 (raw folder speed-r3); long prompts at 128K come only from the run of start 3 (raw folder ctx128k-nosse-speed-r0); the five instruct quality tests come from start 1 (raw folder inst-r1); the Thinking test from start 2 (raw folder think-r4).

The 128K step, and the one forced deviation. In the Speed v2 run of start 2 the step with a prompt of 131,072 tokens failed: of its 4 requests, 2 ended after 1 output token without a usage report (the tool's wording: "decode code 1 of 2 runs valid: only 1 output tokens (< 256); decode prose 1 of 2 runs valid: only 1 output tokens (< 256); prefill/TTFT 2 of 4 requests valid: server did not return usage.prompt_tokens"), so this run has no 128K value for decode, prefill or first token; the register rows of that run carry the remark "CTX d131072 FAILED". The first token of all four requests came after 15.2 to 15.3 s. Our note from the run records the cause: with the default heartbeat of 15 s in candidate-54 (patch 0771, pull request 972 in Owen's repository), a streaming request whose first token takes longer than 15 s ends in an asyncio InvalidStateError at vllm/entrypoints/serve/utils/sse_keep_alive.py line 181, and the client gets 1 token and no usage. What the recorded streams show: in each of the four requests the server sent a keep-alive line (": keep-alive") at 15.2 s, before the first token, and the two requests that failed (code prompt run 1, prose prompt run 2) ended in HTTP 200 right after one single token ("#"), without a finish reason, a done marker or a usage report. The engine log of this start was not kept, so the error line itself is not in the raw files; the single requests are not published (see the notes on foreign load below). The patch file in Owen's checkout says that the heartbeat is on by default at 15.0 s and is switched off by VLLM_SSE_KEEPALIVE_INTERVAL_S=0. We therefore measured the long-prompt step once more on a third server start with exactly that one variable set; this is a forced deviation from the recipe, not a recipe setting, and the 128K values on this page (decode code 80.5, decode prose 77.9 tok/s, prefill 8,545 tok/s, first token 15.3 s; 4 of 4 requests valid, a prompt of exactly 131,072 tokens each, 512 reply tokens) come only from that run. The run of start 3 also measured 16K, 32K and 64K with the heartbeat off; those values are not used on this page, which shows 16K, 32K and 64K from start 2. Compared with start 2 they differ (change from start 2 to start 3, from the raw values) by +0.4 to +3.9 % for decode with the code prompt, -8.9 to -5.6 % with the prose prompt, -0.5 to -0.3 % for prefill and +0.3 to +0.6 % for first token. Both raw folders are linked below.

The headline 84.5 tok/s is the mean of the code prompt (89.1) and the prose prompt (79.9), medians of two runs each (the code runs gave 83.8 and 94.3, the prose runs 78.1 and 81.7 tok/s; spread (CV) 8.4 % and 3.2 %). The code prompt has 1,208 tokens and the prose prompt 1,282 and 1,284 tokens; every reply is 512 tokens long and ends at the limit. Drafts were accepted at a rate of 25.3 % (1,201 of 4,744 drafted tokens, mean accepted length 2.42 tokens; counted from the engine's counters over the four decode runs).

Requests at once. The server has 16 slots, so the levels 1, 2, 4 and 8 at once are all below the slot count and run in parallel. All requests carry the same prompt (the prose prompt), 512 tokens each, two rounds per level. The total is 72.1, 110.0, 153.2 and 210.0 tok/s with 1, 2, 4 and 8 requests, and the speed of each request is 72.1, 57.7, 39.6 and 27.3 tok/s. The level of 16 at once, the server's slot count, was not measured.

Prefill and long prompts. The prefill series uses prompts of exactly 2,048, 8,192 and 32,768 tokens, three runs each (prefill 4,551, 7,384 and 8,643 tok/s); the long-prompt steps use prompts of exactly 16K, 32K, 64K and 128K tokens (a filler log first, the task prompt last), 2 runs each with the code and the prose prompt, 512 reply tokens. Prefill is the prompt tokens divided by the time to first token of the same request; the 128K step needs 15.3 s to the first token. "Prefill at 32K" and the 32K step of the long-prompt table are two different measurements of a prompt of about the same size: the prefill series sends raw token ids with no chat template and 8 reply tokens, three runs (a cold prompt, 8,643 tok/s); the context step is a chat request, a filler log first and the code or the prose task prompt last, with 512 reply tokens, two runs each, median of the four requests (8,349 tok/s). The two numbers are not the same measurement and are not mixed on this page; the context steps are shown only in the long-prompt table. Long answer test: one reply that ended by itself (finish reason stop) after 5,859 tokens in 47.8 s.

Foreign load. The load guard of the speed test (any other process above 25 % of a core for two samples in a row) threw away and repeated 2 of 38 steps of this run: decode with the code prompt (run 2) and the prefill at 32K (run 1), each once, because the kernel thread kcompactd0 (memory compaction) went to 100 % CPU; both repeats ran clean and are the values used. The same thread stopped the run of start 1, as told above. We did not isolate the cause; our boxes run 4 KiB pages (point 1 above). The cache check of the tool found no cached tokens in any of the 61 requests that it checked; for 2 requests it could not check, because the failed 128K requests returned no usage. Not published: the guard's sample file, the quiet-check tables and the single requests of the speed runs.

Server start. The server answered after 652 s (start 1), 653 s (start 2) and 649 s (start 3). The weights are read over a network mount here (point 3 above); Owen's receipts give boot times of 105.3 s (gate) and 111.5 and 113.6 s (screens) for candidate-54 (receipts/final/tp4-ring/README.md lines 45 and 46). This is not a speed test, and we did not isolate what the difference comes from.

Owen's published numbers

These are the figures Owen published in the spark-ds41f repository for the same recipe on the same shape (four GB10 boxes in a ring, tensor parallel 4). They are shown as published, with label, date and source, and were not measured by us. Owen's method differs from our speed test (last paragraph), so they are shown for reference and not as a comparison, unless a line says so. Source paths are relative to experiments/2026-10-26-spark-ds41f-candidate/ at tag candidate-54, except the paths starting with manifests/ or README.md, which are relative to the repository root at tag 1107.

candidate-54, screen of 11 Nov 2026, two boots (servebench 0.1.0, suite screen v1). Sixteen streams in a closed loop (60 s warm-up, 300 s window, 256 fixed prompts of 15 to 29 tokens, 256 output tokens each, temperature 0, thinking off): 270.2 and 269.6 tok/s total output, mean 269.9 tok/s (the figure Owen states), time to first token p50 0.41 s. Cold prefill on real source text (1 output token, 3 repeats): 8,689 and 8,712 tok/s at 32K, 8,849 and 8,859 tok/s at 256K. Sources: candidate-54/receipts/references/candidate-54-0799-tp4-ring-screen{,-again}/c16.json:46 (output; :474 time to first token), candidate-54/receipts/references/candidate-54-0799-tp4-ring-screen{,-again}/prefill.json:27 (32K), :42 (256K).

Owen's own changes for candidate-54 against the recorded 1107 screen of 9 Nov 2026, as Owen states them (mean over both boots of each build, margin in brackets): 16-stream output +1.74% (0.94%), prefill 32K +2.10% (2.49%, in Owen's words "the same"), prefill 256K +7.35% (0.50%), engine decode grid -4.94% step time (0.30%). The 1107 screen itself: 265.2 and 265.3 tok/s at 16 streams, prefill 8,500 and 8,544 tok/s at 32K, 8,228 and 8,268 tok/s at 256K (two boots, same suite). Sources: candidate-54/receipts/final/tp4-ring/lab/candidate-54-0799-screen-tp4-table.txt:3-7 and candidate-54/pre-release-notes.md:81-84 (changes); candidate-50/receipts/references/spark-ds41f-1107-tp4-ring-screen{,-again}/c16.json:46, candidate-50/receipts/references/spark-ds41f-1107-tp4-ring-screen{,-again}/prefill.json:27 (32K), :42 (256K) (1107 screen).

Single stream (c1): Owen's screen has no c1 step on this build ("not measured on this image", candidate-54/pre-release-notes.md:80). Owen's c1 decision check of 11 Nov 2026 (4 boots, 30 s warm-up and a 150 s window instead of the suite's 300 s, 256 fixed prompts, 256 output tokens, temperature 0, thinking off) gave 80.65, 80.55, 80.61 and 80.65 tok/s, with a time to first token p50 of about 113 ms (candidate-54/receipts/final/tp4-ring/lab/candidate-54-c1-decisions-tp4-table.txt:1-4). Owen describes these checks as "a different workload from the screens'" (candidate-54/README.md:330-332).

Eight streams (c8): not measured with servebench on this build. Owen's gate check with distinct prompts (4 samples, 256 output tokens, a different method) gave 271.1 / 200.7 / 154.2 tok/s at 16 / 8 / 4 streams (candidate-54/receipts/final/tp4-ring/lab/candidate-54-gate-final-tp4-table.txt:5-7; candidate-54/receipts/final/tp4-ring/README.md:21).

For reference, Owen's release run of 1107 (7 Nov 2026; a different build, not the one on this page; suites release v3, single-stream v1 and sampled v1, closed loops of 300 s): c1 82.6, c8 207.4, c16 272.9 tok/s at temperature 0; with temperature 1.0 and top_p 1.0 (Owen's sampled suite) c16 268.3, c8 203.8, c1 80.0 tok/s; cold prefill 8,508 tok/s at 32K, 8,657 at 131K, 8,261 at 262K. Sources: manifests/suites/2026-11-07-spark-ds41f-1107-tp4/c16.json:46, c8.json:46, prefill.json:27, :42, :57; manifests/suites/2026-11-07-spark-ds41f-1107-tp4-single-stream/c1.json:46; manifests/suites/2026-11-07-spark-ds41f-1107-tp4-sampled/{c16,c8,c1}.json:49; README.md lines 353-364. Where two of Owen's texts give different figures for the same run, this page uses the value in the run file.

In Owen's release text for candidate-54 ("Known issues", candidate-54/pre-release-notes.md:98 and :101): "Verified, not release-qualified: no release set, quality evals, AgentX or cold boots." and "c1 paired decode against 1107 is not measured on the rebuilt image; the earlier build's was the same as 1107's (about 82 tok/s, cross-session)."

How these relate to our numbers: our speed test uses two fixed prompts of about 1,200 tokens (code and prose), 512 output tokens, temperature 1.0 and top_p 1.0 (the recipe's generation defaults), thinking off, median of two runs; concurrency starts 1, 2, 4 and 8 identical requests together; prefill and context steps use a synthetic filler text at exact lengths. Owen's servebench uses closed loops over 256 different one-sentence prompts, 256 output tokens, temperature 0, and real source text for prefill. Single stream and eight streams: different method, not comparable. Sixteen streams, 256K prefill and the engine grid: not measured by us. Prefill 32K: the formula is the same (prompt tokens over time to first token, cold cache) but the text and the request differ, so also different method, not comparable. Prefill 128K: Owen has no candidate-54 value at 131K. Time to first token: Owen's prompts are 15 to 29 tokens, ours about 1,200, so not comparable.

python3 speed2.py --base-url http://127.0.0.1:45979/v1 --label quality-v2-261112-box-3-ds1017-owen-c54-native-fp8fp4-tp4-ring-4x-site-speed-r3 --prompts $BENCH/repos/<speed-test-tool>/prompts-v2.json --output $RUN/quality-v2-261112-box-3-ds1017-owen-c54-native-fp8fp4-tp4-ring-4x-site-speed-r3/quality-v2-261112-box-3-ds1017-owen-c54-native-fp8fp4-tp4-ring-4x-site-speed-r3/speed2 --contract $RUN/quality-v2-261112-box-3-ds1017-owen-c54-native-fp8fp4-tp4-ring-4x-site-speed-r3/quality-v2-261112-box-3-ds1017-owen-c54-native-fp8fp4-tp4-ring-4x-site-speed-r3/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/ds41f-hub/hub/models--deepseek-ai--DeepSeek-V4.1-Flash-1017/snapshots/1bae0e1088993b9b82de08f59de5be5a34e42170/tokenizer.json --tokenizer-python $HOME/not published --sampling {"temperature": 1.0, "top_p": 1.0} --sampling-source releases/spark-ds41f-1107/cluster.json:19-20 generation_defaults (temperature 1.0, top_p 1.0), inherited by candidate-54 (experiments/2026-10-26-spark-ds41f-candidate/candidate-54/tp4.json extends it); equal to the model card; a request's own values win. Speed v2 runs thinking off. --model deepseek-v4.1-flash --no-cache-prompt --server-log $RUN/server-A.log --engine-version-file $RUN/engine-version.txt --server-slots 16 --server-slots-source christopherowen/spark-ds41f@ed033551 (tag candidate-54) releases/spark-ds41f-1107/cluster.json:228 shapes.tp4-ring.sizing.max_num_seqs (16); candidate-54 tp4.json does not change it --server-ctx 1048576 --server-ctx-source card GB10 box 3-ds1017-owen-c54-native-fp8fp4-tp4-ring-4x-site field ctx

# Long prompts: supplementary run of 2026-11-12 (raw folder ctx128k-nosse-speed-r0-ctx)
python3 speed2.py --base-url http://127.0.0.1:36413/v1 --label ctx128k-261112-box-3-ds1017-owen-c54-native-fp8fp4-tp4-ring-4x-site-ctx128k-nosse-speed-r0 --prompts $BENCH/repos/<speed-test-tool>/prompts-v2.json --output $RUN/ctx128k-261112-box-3-ds1017-owen-c54-native-fp8fp4-tp4-ring-4x-site-ctx128k-nosse-speed-r0/ctx128k-261112-box-3-ds1017-owen-c54-native-fp8fp4-tp4-ring-4x-site-ctx128k-nosse-speed-r0/speed2 --contract $RUN/ctx128k-261112-box-3-ds1017-owen-c54-native-fp8fp4-tp4-ring-4x-site-ctx128k-nosse-speed-r0/ctx128k-261112-box-3-ds1017-owen-c54-native-fp8fp4-tp4-ring-4x-site-ctx128k-nosse-speed-r0/speed2/speed-contract.json --parts 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/ds41f-hub/hub/models--deepseek-ai--DeepSeek-V4.1-Flash-1017/snapshots/1bae0e1088993b9b82de08f59de5be5a34e42170/tokenizer.json --tokenizer-python $HOME/not published --sampling {"temperature": 1.0, "top_p": 1.0} --sampling-source releases/spark-ds41f-1107/cluster.json:19-20 generation_defaults (temperature 1.0, top_p 1.0), inherited by candidate-54 (experiments/2026-10-26-spark-ds41f-candidate/candidate-54/tp4.json extends it); equal to the model card; a request's own values win. Speed v2 runs thinking off. --model deepseek-v4.1-flash --no-cache-prompt --server-log $RUN/server-A.log --engine-version-file $RUN/engine-version.txt --server-slots 16 --server-slots-source christopherowen/spark-ds41f@ed033551 (tag candidate-54) releases/spark-ds41f-1107/cluster.json:228 shapes.tp4-ring.sizing.max_num_seqs (16); candidate-54 tp4.json does not change it --server-ctx 1048576 --server-ctx-source card GB10 box 3-ds1017-owen-c54-native-fp8fp4-tp4-ring-4x-site-ctx128k-nosse field ctx --supplement-of quality-v2-261112-box-3-ds1017-owen-c54-native-fp8fp4-tp4-ring-4x-site-speed-r3

How well it answers

Pre-release candidate-54, not Owen's standard release 1107. Six fixed lists with thinking off and one test with thinking on (the last row), raw numbers with their 95 % margins, no overall score. The five instruct tests ran on server start 1, the Thinking test on server start 2 after a GPU error ended its first attempt (see the notes below and the Speed section).

Thinking off, except the last test. Seed 42. Sampling from the model card. A cut-off answer counts as wrong. Measured 2026-11-12.

Note from the run: What the numbers are. Only raw numbers with their margins; there is no overall score. Six fixed lists ran with thinking off (MMLU-Pro with 400 questions, GPQA Diamond with 198, IFEval with 200, LiveCodeBench with 40, long-text tests (RULER-lite) at 8K and 32K with 40 each), 16 requests at a time (the recipe's 16 slots), temperature 1.0, top_p 1.0, seed 42. The last test, GPQA with 30 questions, ran with thinking on and is a test of its own: a cap of 16,384 tokens, 16 requests at a time.

Where they ran. The five instruct tests ran on server start 1 (19:50 to 20:07), before the GPU error of 20:08 that crashed the server during the Thinking test (see the Speed section). Four of the five summary files report 0 errors; the long-text summary has no error counter, and its answer file has 80 answers, none with an error field. The kernel log extracts show the GPU error line at 20:08, after these tests had finished. The Thinking test of this page ran on server start 2 (20:31 to 20:40). Its first run, on the crashed server, is discarded and is not in the register.

Cut-off answers count as wrong. The two knowledge tests give each answer 48 tokens: 59 of the 400 MMLU-Pro answers and 56 of the 198 GPQA answers were cut off at that limit and count as wrong (115 of the 918 requests of the instruct tests, 12.5 %; IFEval, LiveCodeBench and the long-text tests had none). In the Thinking test, 4 of 30 answers were cut off at the cap of 16,384 tokens and count as wrong; the median answer took 2,273.5 tokens and 109.2 s with 16 requests at a time.

Not published: the answer files of MMLU-Pro (mmlupro.jsonl) and of LiveCodeBench (lcb.jsonl and lcb.gen.jsonl). The publication check of this site holds back a file when an answer text in it looks like a hardware reading (here a unit in a physics question and a variable name in the code of a solution); the files themselves are unchanged, and the summary files of both tests are linked in the table. The answer files of GPQA, IFEval, the long-text tests and the Thinking test are published.

bash tools/quality2/measure_all.sh tools/quality2/cards/ds1017-owen-c54-native-fp8fp4-tp4-ring-4x-site.json --parts mmlupro --job quality-v2-261112-box-3-ds1017-owen-c54-native-fp8fp4-tp4-ring-4x-site

bash tools/quality2/measure_all.sh tools/quality2/cards/ds1017-owen-c54-native-fp8fp4-tp4-ring-4x-site.json --parts gpqa --job quality-v2-261112-box-3-ds1017-owen-c54-native-fp8fp4-tp4-ring-4x-site

bash tools/quality2/measure_all.sh tools/quality2/cards/ds1017-owen-c54-native-fp8fp4-tp4-ring-4x-site.json --parts ifeval --job quality-v2-261112-box-3-ds1017-owen-c54-native-fp8fp4-tp4-ring-4x-site

bash tools/quality2/measure_all.sh tools/quality2/cards/ds1017-owen-c54-native-fp8fp4-tp4-ring-4x-site.json --parts lcb --job quality-v2-261112-box-3-ds1017-owen-c54-native-fp8fp4-tp4-ring-4x-site

bash tools/quality2/measure_all.sh tools/quality2/cards/ds1017-owen-c54-native-fp8fp4-tp4-ring-4x-site.json --parts ruler --job quality-v2-261112-box-3-ds1017-owen-c54-native-fp8fp4-tp4-ring-4x-site

bash tools/quality2/measure_all.sh tools/quality2/cards/ds1017-owen-c54-native-fp8fp4-tp4-ring-4x-site.json --parts ruler --job quality-v2-261112-box-3-ds1017-owen-c54-native-fp8fp4-tp4-ring-4x-site

bash tools/quality2/measure_all.sh tools/quality2/cards/ds1017-owen-c54-native-fp8fp4-tp4-ring-4x-site.json --parts think --job quality-v2-261112-box-3-ds1017-owen-c54-native-fp8fp4-tp4-ring-4x-site

Also made this possible

• Model (DeepSeek-V4.1-Flash-1017, revision 1bae0e10)DeepSeek@deepseek_ai Hugging Face GitHub Website
• Engine base pinned by the recipe (vLLM, local-inference-lab fork, base 19f2c20e plus 672 patches, tree ad2dc11f)Llocal-inference-labGitHub

Exact command

What you need and how to start it, step by step. The results below come from this setup; the 128K long-prompt step comes from a separate start with one forced deviation, named below the steps.

What you need

Hardware

4x NVIDIA DGX Spark class boxes (GB10), tensor parallel 4 over a switchless CX7 cable ring (two paths per neighbour, 109.25 to 109.35 Gb/s per path, measured before the second and the third server start; the check before the first start passed and its table was not kept): two ASUS Ascent GX10, one Gigabyte AI TOP ATOM (head box, rank 0) and one Lenovo ThinkStation PGX. All four boxes run driver 580.178.04 and the stock kernel 7.0.0-1019-nvidia with 4 KiB pages and no memory saver; GPU clock capped at 2200 MHz

Model

deepseek-ai DeepSeek-V4.1-Flash-1017 (rev 1bae0e10, FP8 block-32 ue8m0 + FP4 routed experts as published) + checkpoint DSpark drafts

Model (DeepSeek-V4.1-Flash-1017, revision 1bae0e10)

huggingface.co/deepseek-ai/DeepSeek-V4.1-Flash-1017

Engine

Pre-release candidate-54 of Owen's spark-ds41f recipe, not Owen's standard release 1107; DeepSeek-V4.1-Flash-1017 with DSpark drafts, vLLM with TileLang kernels, tensor parallel on 4 GB10 boxes in a cable ring; image built by us from Owen's lock for candidate-54 — the program that loads the model and answers requests · github.com/local-inference-lab/vllm

Recipe: spark-ds41f, PRE-RELEASE candidate-54 (tag, commit ed033551, Nov 11, 2026), not the standard release 1107

github.com/christopherowen/spark-ds41f by Christopher Owen

Steps

1. Get the recipe, the engine and the model files from the list above. The cluster config named in the next step is ours and is not published.

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

   Copy

   cd <spark-ds41f checkout at tag candidate-54 (commit ed033551) plus our cluster config> && bin/spark \
     --cluster-config <our cluster config> cluster start \
     --replace \
     --apply
   (our cluster config extends experiments/2026-10-26-spark-ds41f-candidate/candidate-54/tp4.json, which extends releases/spark-ds41f-1107/cluster.json shape tp4-ring; it sets our model path (DeepSeek-V4.1-Flash-1017, revision 1bae0e10), our host home folder, host.fan_control false, the head address and our deployment repository, and unsets glp. The tool starts one vLLM process per box: head box = rank 0, then ranks 1 to 3 around the ring; vllm serve <model snapshot> \
     --tensor-parallel-size 4 \
     --nnodes 4 \
     --max-model-len 1048576 \
     --max-num-seqs 16 \
     --max-num-batched-tokens 16384 \
     --speculative-config dspark 5 ... as set by the recipe; image tag spark-ds41f:candidate-54, built by us from Owen's lock)
   
   The long-prompt step at 128K, supplementary run (server start 3): the same command with a cluster config that adds one environment variable to ours: VLLM_SSE_KEEPALIVE_INTERVAL_S=0 (SSE keep-alive heartbeats off). A forced deviation from the recipe, explained in the Speed section.

Owen spark-ds41f PRE-RELEASE candidate-54 (not Owen's standard release spark-ds41f-1107, which stays Owen's default): vLLM (local-inference-lab fork, base 19f2c20e + 672 patches, tree ad2dc11f; image built by us from Owen's lock) + TileLang kernels, TP=4 over 4 nodes (mp backend), DSpark 5 drafts (CopyDrafter), one-shot ring all-reduce (sparknet, NCCL 2.30.7), Engram tables on local NVMe; cd <spark-ds41f checkout at tag candidate-54 (commit ed033551) plus our cluster config> && bin/spark --cluster-config <our cluster config> cluster start --replace --apply
(our cluster config extends experiments/2026-10-26-spark-ds41f-candidate/candidate-54/tp4.json, which extends releases/spark-ds41f-1107/cluster.json shape tp4-ring; it sets our model path (DeepSeek-V4.1-Flash-1017, revision 1bae0e10), our host home folder, host.fan_control false, the head address and our deployment repository, and unsets glp. The tool starts one vLLM process per box: head box = rank 0, then ranks 1 to 3 around the ring; vllm serve <model snapshot> --tensor-parallel-size 4 --nnodes 4 --max-model-len 1048576 --max-num-seqs 16 --max-num-batched-tokens 16384 --speculative-config dspark 5 ... as set by the recipe; image tag spark-ds41f:candidate-54, built by us from Owen's lock)

The long-prompt step at 128K, supplementary run (server start 3): the same command with a cluster config that adds one environment variable to ours: VLLM_SSE_KEEPALIVE_INTERVAL_S=0 (SSE keep-alive heartbeats off). A forced deviation from the recipe, explained in the Speed section.