Eight DGX Sparks vs one GB300 on DeepSeek-V4.1-Flash: Christopher Owen's spark-ds41f-1120 at TP8
Christopher Owen published spark-ds41f-1120 this morning, his DGX Spark engine for DeepSeek-V4.1-Flash, with a switched profile for eight nodes. We built it from his tag, put it on all eight of our Sparks at TP8, and ran it through the same battery as the lane we actually lean on: Garner McCloud's engine (our Pg62 recipe) on one DGX Station GB300. Same model, same checkpoint, same tests, same morning. This is what the two shapes of hardware do with the same 1M-context model.
In plain English
- What we compared. One DeepSeek-V4.1-Flash model held two ways: spread across eight DGX Sparks (each holding one eighth of every layer, talking over two switches) running Christopher Owen's new engine, or held by one DGX Station GB300 running Garner McCloud's engine. Same weights, same questions, same morning.
- The GB300 is faster at almost everything. One user gets 549 tokens per second instead of 183 (3.0×). Sixteen users together get 2,444 instead of 609–625 (about 4×). A 131K-token prompt is read at 43,790 tokens per second instead of 11,723 or 9,941 (3.7–4.4×). Finding three codes in a 1,000,000-token prompt takes 35.9 s instead of 90.4–108.0 s.
- Eight Sparks win two things. They keep about 2.5× as much context warm (28.5–29.9 million tokens of cache against 11.7 million). And with our scheduling on top of Owen's engine, a short chat that arrives while someone's 413K-token prompt is being read gets its first token in 0.549 s, against 1.283 s on the GB300.
- The trade. As Owen ships it, TP8 reads prompts in 32,768-token steps. That is the fastest prompt reading of any Spark arm in this campaign, and the worst wait for a short chat behind a long prompt: 3.905 s. Our smaller steps cut that to 0.549 s and give back some prompt-reading speed (11,723 → 9,941 tok/s at 131K).
- What we run now. Not TP8. Owen's engine serves guests on four Sparks (5–8); the other four are a test pod; the GB300 serves our own agents. TP8 was the campaign's best Spark result and comes back in about 2.5 minutes from kept containers.
- Bottom line: one GB300 out-runs eight Sparks on every throughput row; eight Sparks hold more context and, scheduled our way, answer small requests sooner.
What we compared
Owen's release now even runs DeepSeek-V4.1-Flash on a single Spark (alpha, 4.4 tok/s on prose by his count), but useful speed comes from splitting every layer across nodes. His 1120 release ships a switched eight-node profile (TP8) alongside the four-node one we run: his fork of vLLM with a 702-patch series, TileLang kernels for the GB10, sparknet's RoCE collectives, and DSpark speculative decoding with five drafts, on CUDA 13.5.37. He publishes source, not images; we built the image on one Spark in about 20 minutes, checked the vLLM tree hash matched his label (8fc99ca7), and copied it to the other seven. The only site changes are our node map, model path, port, two NCCL flags and thinking off by default.
The GB300 side is Garner McCloud's DeepSeek-V4.1 engine from dgx-station-recipes, under our serving policy as Pg62: vLLM v0.31.0, 1M context, 32 seats, with an RTX PRO 6000 Blackwell Max-Q beside the Station holding cold experts. Both sides serve the same DeepSeek checkpoint, 1017, HF revision 1bae0e10, with file hashes checked on every node.
Figure 1. Two ways to hold one model. Left: eight Sparks in two pods of four, one pod per CRS804 switch, the switches joined by a 400G link; rank 0 on Spark 5, ranks 4–7 on Sparks 1–4. Right: one GB300 Station with its RTX PRO 6000 sidecar running Pg62.
One asymmetry to keep in mind: the GB300 was benched as it was serving. Our own agents can send it traffic at any moment, so its sixteen-stream spread is wide (1,896–2,489 tok/s). The Spark arms had the eight nodes to themselves.
| arm | nodes | engine | scheduling shape |
|---|---|---|---|
| 1120 TP8 as shipped | all 8 Sparks | Owen's 1120 | his tp8-switched profile: 32 seats, 32,768-token batches, long-prefill threshold 32,576, late admission at layer 30, 25.5 GiB KV per node, Engram tables in GPU memory |
| 1120 TP8 + our scheduling | all 8 Sparks | Owen's 1120 | same, with 8,192-token batches, threshold 3,856, late admission at layer 20; his 25.5 GiB KV kept |
| GB300 Pg62 | 1 Station + sidecar | Garner McCloud's engine | as serving: 1M context, 32 seats, 11,696,582 KV tokens |
Speed
Figure 2. Speed, four panels with their own scales. The GB300 leads every panel; the two TP8 arms differ only on prompt reading, where the shipped 32K steps are faster.
| row | 1120 TP8 shipped | 1120 TP8 + our scheduling | GB300 Pg62 |
|---|---|---|---|
| One stream decode (tok/s) | 182.59 (180.83–182.94) | 182.87 (181.19–183.00) | 548.58 (533.66–566.12) |
| 16 streams, aggregate (tok/s) | 609.36 | 624.55 | 2,444.14 (1,896–2,489) |
| Read a 32K / 131K prompt (tok/s) | 11,296.8 / 11,722.5 | 9,749.7 / 9,941.1 | 45,667.8 / 43,789.5 |
| Read a 300K / 1M prompt (tok/s) | 11,639.5 / 11,034.0 | 9,836.8 / 9,412.6 | 41,400.4 / 28,279.9 |
| 1M needle | 3/3, 90.4 s | 3/3, 108.0 s | 3/3, 35.9 s |
| Short turn behind a cold 413K prompt (s) | 3.905 | 0.549 | 1.283 |
| Cached 68K turn behind a 413K prompt (s) | 3.606 | 1.804 | 0.611 |
| Agent: read 200K once (s) | 17.2 | 20.5 | 4.7 |
| Agent: 3 follow-up turns, TTFT (s) | 0.385 / 0.350 / 0.350 | 0.400 / 0.352 / 0.387 | 0.702 / 0.259 / 0.266 |
| qeval /75 | 72 | 72 | 71 |
| KV pool (tokens) | 28,462,214 | 29,920,256 | 11,696,582 |
| = full 1M contexts | 27.14× | 28.53× | 11.15× |
Per stream, the GB300 writes 548.58 tokens per second to TP8's 182.59 (3.00×). With sixteen streams, 2,444.14 against 609.36 as shipped and 624.55 with our scheduling (4.01× and 3.91×). Reading cold prompts, the gap is 4.04× at 32K and narrows to 2.56× at 1M against the shipped arm (45,668 vs 11,297; 28,280 vs 11,034); against our scheduling it is 4.68× to 3.00×. The 1M needle test, three codes planted in a 1,000,000-token prompt, finishes in 35.9 s on the GB300, 90.4 s on TP8 as shipped and 108.0 s with our scheduling, all three finding 3 of 3.
Per category the shape is the same everywhere: on one stream the GB300 writes code at 793.7 tok/s to TP8's 239.3, and narrative prose at 311.5 to 117.2. The Sparks are not slow by Spark standards; TP8 is 44.4% faster per stream than Owen's TP4 on the same engine (182.59 vs 126.43), the campaign's best Spark result. The GB300 is simply a different class of machine for this model.
Under load
Throughput is the easy half. The half that decides how a lane feels is what happens to a small request while a huge one is being read.
Figure 3. Time to first token for a request sent while a cold 413,000-token prompt is being read. Left: a short ~18-token turn. Right: a 68,000-token document already in cache plus a fresh 1,500-token question.
As shipped, TP8 is the worst arm of the whole campaign on the short turn: 3.905 s, against 1.283 s on the GB300. The cause is in the config, not the hardware. Owen's TP8 profile reads a long prompt in steps of up to 32,768 tokens (per-request long-prefill threshold 32,576), and a short request that arrives mid-step waits for the step to finish. Our scheduling, the same 8,192-token steps, 3,856-token long-prompt cap and layer-20 late admission we run on four Sparks, cuts that wait to 0.549 s on 1120 TP8, 2.34× faster than the GB300. The cost is prompt-reading speed, 11,723 → 9,941 tok/s at 131K.
The GB300 wins the cached case: a 68K document already in its prefix cache plus a new 1,500-token question gets its first token in 0.611 s while the 413K prompt is being read, against 1.804 s on TP8 with our scheduling (2.95×) and 3.606 s as shipped. On the agent pattern, reading a 200,000-token context once takes 4.7 s on the GB300, 17.2 s on TP8 as shipped and 20.5 s with our scheduling; the three follow-up turns are then close everywhere (0.702 / 0.259 / 0.266 s on the GB300; 0.400 / 0.352 / 0.387 s on TP8 with our scheduling).
Capacity
Figure 4. KV pool each server reports, in tokens and as full 1M-token contexts. These are reported capacities; we did not fill them.
Eight Sparks carry about 123 GiB each, and Owen's TP8 profile gives 25.5 GiB per node to the KV pool: 28,462,214 tokens as shipped (27.14 full 1M contexts), 29,920,256 with our scheduling (28.53×). The GB300's Pg62 pool is 11,696,582 tokens (11.15×). That is 2.43× to 2.56× more warm context on the Sparks, which is the one resource where eight small machines beat one large one outright.
Sixteen and thirty-two sessions
Added the same afternoon after @HomeLabAI asked about decode with 16 and 32 sessions. All three lanes allow 32 seats, so we took the guest lane down for twenty minutes and reran 16 and 32 sessions together on each: same prompt set, temperature 0, thinking off, three reps. The sixteen-session totals reproduced the morning run within 2%.
| Lane | 16 total tok/s | 32 total tok/s | 16 per session | 32 per session | First token at 32 (mean) |
|---|---|---|---|---|---|
| GB300 Pg62 | 2,475.36 | 3,637.21 | 210.11 | 149.70 | 0.207 s |
| 8 Sparks, TP8 as shipped | 623.49 | 788.52 | 47.86 | 30.23 | 0.695 s |
| 8 Sparks, TP8 + our scheduling | 623.98 | 792.40 | 47.99 | 30.32 | 0.702 s |
Figure 5. Sixteen and thirty-two sessions, measured the afternoon of November 20, 2026. Bars are sized per panel from the receipts.
Doubling the sessions buys the GB300 47% more total output. Each of its sessions drops from 210 to 150 tok/s, which is still faster than one session alone on eight Sparks (183). Eight Sparks gain 27% total, and each session drops from 48 to 30 tok/s. At 32 sessions the GB300 does 4.6× the total and 4.9× per session, up from 4.0× and 4.4× at 16. Our scheduling changes nothing here; it only matters while long prompts are being read. Spread across three reps at 32 sessions: GB300 3,584–3,711 tok/s total, Sparks 786–795.
What each is better at
Eight Sparks at TP8
- Warm context: 28.5–29.9M KV tokens against 11.7M, about 2.5×.
- Short-turn latency behind a long prompt, with our scheduling: 0.549 s against 1.283 s.
- Best prompt reading on Spark hardware, as shipped: 11,723 tok/s at 131K.
One GB300 Station
- Every throughput row: 3.00× per stream, 3.9–4.0× at sixteen streams, 4.6× at thirty-two, 2.6–4.7× reading prompts.
- The 1M needle: 35.9 s against 90.4–108.0 s.
- The cached-context turn behind a long prompt: 0.611 s against 1.804 s.
- Priming an agent session: a 200K context read in 4.7 s against 17.2–20.5 s.
- Only one box to keep up.
Gates
TP8 with our scheduling passed the same gates as every lane we promote: greedy output identical across 40 fixed prompts twice on one boot and again with 15 other streams running, and identical across two separate boots; 64 concurrent JSON and json_schema requests all valid with the server alive afterward; a DSML tool-call probe whose arguments contain DeepSeek's own closing tags, streaming and not. The image and reasoning_effort checks were run on the four-Spark lane that now serves guests, not on TP8.
Quality is the same within noise. Our 75-task qeval set scores 71 on the GB300 and 72 on both TP8 arms; the TP8 arms pass one JSON-escaping task the four-node and GB300 arms miss. One task is inside run-to-run noise, so we do not claim TP8 is smarter. Greedy, temperature 0, thinking off throughout.
1120 needed no overlay patches. It carries the two fixes sent to Owen on November 16 (the structured-output bitmask fix and the DSML-closer fix) in his own tree.
What runs now
TP8 is not what we serve. James chose 4+4: Owen's TP4 as shipped on Sparks 5–8 for the guest gateway, Sparks 1–4 kept free as a test pod, and the GB300 serving Pg62 for our own agents. The TP4 decision and its trade are the subject of the companion post. The TP8 containers are kept, not removed; a restart to ready took 150 s and 143 s today, so the full eight-node lane is about 2.5 minutes away when a test needs it. First boot of a new shape is longer because kernels compile: 566 s for TP8 as shipped.
Method
Every arm ran the same harness on the morning of November 20, 2026, between 07:21 and 09:26 CST: v41bench prompt set v1, eight categories, temperature 0, thinking off, three repetitions, tokens counted from the server's usage block.
- C1: one request at a time, per-stream decode tok/s, median of 3 (spread = min–max). C16: sixteen at once, aggregate tok/s. C32 (added that afternoon, with a fresh C16 alongside): thirty-two at once.
- Prefill: a cold prompt with a unique nonce at the start so nothing hits the cache; median of 3; tok/s at 32K, 131K, 300K and 1M tokens.
- 1M needle: three codes planted in a 1,000,000-token prompt; found/planted and seconds.
- Short turn behind long prompt: start a cold 413,000-token prompt, then send a ~18-token chat turn while it is being read; time to first token of the short turn, median of 3.
- Cached turn behind long prompt: a 68,000-token document already in the prefix cache plus a fresh 1,500-token question, sent while the 413K prompt is being read; time to first token.
- Agent turn: read a 200,000-token context once, then three follow-up turns each adding 1,500 tokens; time to first token per turn.
- qeval: our 75-task quality set (code, JSON, math, format); passed count.
Fabric: two MikroTik CRS804-4DDQ switches joined by one 400G cable; Sparks 1–4 and the GB300 on switch B, Sparks 5–8 on switch A; one 200G port per Spark (about 196 Gb/s measured RDMA), MTU 9000. A TP4 pod stays on one switch; TP8 crosses the 400G link. The fabric post has the measurements. Owen qualifies his shapes on a 64 KiB-page kernel with Memory Saver; we run the stock 4 KiB kernel, and his shipped sizes still fit (14.7 GiB free on the head node while serving his TP8 shape).
Not measured
- Power, or watts per token, on either side. Cost.
- Teacher-forced logprob equality between the two engines.
- Concurrency beyond sixteen streams; whether the reported KV pools can actually be filled.
- Any abliterated weights. The Hermes gauntlet.
- The GB300 was measured live, not restarted; its spreads include whatever our agents were doing.
Credits
Christopher Owen: spark-ds41f, the engine, kernels, sparknet collectives and the new eight-node switched profile every Spark number here runs on (repo, release). His own published figures are his, measured with his bench on his testbed; we quote none of them as a delta against ours. Garner McCloud: the DeepSeek-V4.1 engine on our GB300 lane. DeepSeek: the model. Local Inference Lab, TileLang, vLLM and NVIDIA for what both engines build on.