Two models on the same box, the same day, the same harness. One decoded at 106.9 tokens a second. The other decoded at 29.8. Both are mixture-of-experts models quantized to 4-bit weights, both activate about three to four billion parameters per token, and both ran on kernels I had checked were the fast path. The gap is 3.6x, and no single fact I measured explains all of it.

I ran the round on 2026-08-31 to test a claim I kept reading in the DGX Spark community and had not seen measured under control: that small-active-parameter MoE models at 4-bit weights with speculative decoding are decisively the fastest class on a single GB10. A mixture-of-experts (MoE) model splits its feed-forward layers into many expert blocks and routes each token through only a few, so the model is large on disk but does a small model's worth of arithmetic per token. Active parameters are the ones actually read to produce one token; for the models here that is about 3 to 4 billion out of 26 to 35 billion total. NVFP4 is NVIDIA's 4-bit floating-point weight format, roughly half a byte per parameter, executed by dedicated FP4 kernels on Blackwell-class GPUs. Multi-token prediction (MTP) is a form of speculative decoding in which a small extra head drafts several next tokens and the main model verifies them in one pass, so one read of the weights can yield more than one accepted token.

The theory is plausible because a GB10 decodes at the speed it can read memory. The community-measured sustained bandwidth is about 220 GB/s. Reading three billion parameters at half a byte each is 1.5 to 2 GB per token, which caps a non-speculative decoder somewhere near 110 to 146 tokens a second. Fewer active parameters, fewer bytes per parameter, and more than one token per read are the three levers that move that ceiling.

The reason to measure rather than believe: the public figures for one of these checkpoints on this hardware spanned about 2.5x across sources, 86, 101 and 218 tokens a second, and most published Spark results are one machine, one operator, one run.

What I ran

All of it ran in one day on the second of my two Sparks, with production on the first untouched throughout. Four models. Qwen3.6-35B-A3B in NVFP4 with MTP drafting three tokens. Ornith 1.5 35B-A3B in NVFP4 with MTP drafting one. Qwen3-Coder-Next, an 80B MoE in FP8 with no speculative decoding. Gemma 4 26B-A4B in NVFP4 with no speculative decoding. Each ran a context ladder of 4K, 32K, 50K and 100K prompt tokens single-stream, a concurrency curve at 4K, and a tool-calling probe. Every cell was one discarded warm-up plus five measured runs, medians reported with ranges. Every model ran the full ladder twice with a fresh server restart between passes. 441 result rows (370 measured, 71 discarded warm-ups), zero request errors.

The verdict, on speed

On speed, the claim held for the four recipes I ran. The two 4-bit MoE models with MTP beat the FP8 80B MoE by 2.1x to 3.2x single-stream, and beat the 4-bit MoE without MTP by 2.8x to 3.8x, at every context length on both passes. Qwen3.6 decoded at 106.9 tokens a second at 4K and 91.7 at 100K; Ornith at 89.3 and 69.3; Qwen3-Coder-Next at 42.6 and 29.1; Gemma 4 at 29.8 and 24.7. Fifteen of the sixteen single-stream cells reproduced within plus or minus 2.6 percent across the restart. The sixteenth, Qwen3.6 at 100K, dropped 11 percent on the second pass with non-overlapping ranges. I flag it; I do not explain it.

MTP was the largest single lever I measured. On Qwen3.6 at 4K, turning it off dropped decode from 106.9 to 77.3 tokens a second on the benchmark's filler prompts, and from 102.9 to 78.1 on natural prose: a 32 percent gain in the natural-text cell. Those are medians of five sequential runs in one cell of one model. They support a range, not a confidence interval, and I would not generalize them without interleaved trials. They also do not explain why Gemma 4, with no MTP, decoded at 29.8 while Qwen3.6 with MTP switched off decoded at 77.3. Same weight format, similar active size, same box, both on the fast kernel path. That residual is the open question in this dataset.

The amendment, and its correction

The amendment came out of the day and got corrected two days later. "Engine" here means the serving stack: the vLLM build, its kernels, and its launch flags. Four things happened on the day that had nothing to do with model class. The stock vLLM container failed to load these MoE NVFP4 checkpoints at all, with a missing scale-tensor error, per the upstream runbook I was replicating; every SparkBench golden number for them runs on a community-built image. Older vLLM builds load the same weights and then run them in emulation at a reported one token a second, so every launch in my round checked the server log for the FP4 kernel dispatch before a single measurement counted. Gemma 4's public "with MTP" figure of 54.9 tokens a second, from an issue thread on the community image's repository, did not appear on the NVIDIA checkpoint the way I launched it: the checkpoint ships no MTP head and vLLM says so when asked. A public external drafter exists; with it I later measured 47.9 on 2026-09-03, still short of 54.9. And Gemma 4's public tool-calling failure was a missing parser flag; with the right parser named, it passed 5 of 5 on both days.

Then the correction. On the day, I noted that Qwen3-Coder-Next measured 42 percent faster on the new image than the 30.0 I had recorded for the same weights a month earlier, and wrote it up as evidence that the engine matters as much as the class. That was an association across different days, harnesses and prompts, and I labelled it that way. That earlier round had already measured 42.8 on the old engine before an instance-drift event dropped it to 30.0. Two days later I ran the controlled version: same box, same day, same prompts, prefix cache off, old image against new, five runs each with ranges under 0.4 tokens a second. The old image was faster, 47.4 against 42.3 tokens a second at 4K. The 42 percent claim is withdrawn. What survives is narrower: the engine decides whether you get the class's speed at all, and two of the four items above are upstream reports, not things I demonstrated. It does not follow that a newer engine is a faster engine.

The caveats, in plain words

This was a throughput round. It says nothing about output quality, and the quality round that followed two days later says the opposite of what the speed suggests: under gates I had pre-registered after the speed numbers were in but before any quality run, none of the fast models passed, and my slower incumbent stayed in every lane.

My numbers do not compare to the public SparkBench figures I set out to replicate. Their metric puts prompt processing and queueing time in the denominator of a multi-turn session; mine measures decode alone. Run under their definition on my own serving, Qwen3.6 reads 97 tokens a second at 4K and 14.5 at 100K, not 106.9 and 91.7. The "long-context cliff" I thought I had failed to reproduce was two metrics being compared, and the comparison should not have been made.

The kernel check classified every row's launch log as the FP4 fast path and found no emulation marker on any launch; the FP8 model has no FP4 path, so its label is nominal. The check does not certify that the kernels were the best available, and each recipe chose its own MoE backend, so the cross-model comparison inherits those choices. It also does not make the serving images trustworthy: both come from personal GitHub accounts, not NVIDIA's registry, and a production lane would need re-serving on a vetted image.

The benchmark's fill prompts are repetitive template sentences over a small vocabulary, which speculative decoding likes. A natural-prose control put the inflation from that at about 4 percent, and Ornith was faster on natural text than on filler. Power and temperature are as the GPU exporter reported them, not wall-calibrated.

What it changes for one box

If you have one GB10-class box and want the fastest local decode, start the shortlist where these four recipes point: a MoE with a few billion active parameters, 4-bit weights, and a draft head the checkpoint ships or a public drafter the recipe names. Then choose the engine that runs that checkpoint's kernels, and read the server log to prove it did, because the failure mode is silent and about a hundred times slower. Expect around 100 tokens a second single-stream at 4K on the best of these, and, on the hybrid-attention models, decode that drops 14 to 23 percent from 4K to 100K tokens of context.

Do not promote on speed. Run your own tasks through the model first, with the output budget and the response format your consumer actually needs. A model that decodes at 107 tokens a second and cannot hold a JSON contract is a fast way to make work for yourself.