DSpine: Tencent's parallel drafter threads causal dependency through depth — +27.8% acceptance vs DFlash, but the apples-to-apples lead is ~4%
Adjacent causal injection threads predecessor predictions through every backbone layer, keeping the drafter fully parallel — but the +27.8% headline is vs DFlash, and the retrained-baseline lead is ~4%.
Tencent's DSpine drafter reports the longest acceptance length on all seven math/code/chat benchmarks at both temperatures on Qwen3-4B and Qwen3-8B. Instead of serializing token-by-token, it threads each position's prediction into its immediate successor at every layer of a parallel draft backbone, moving causal dependency from time into depth. Code ships under Apache 2.0, draft weights are released for Qwen3-8B and Qwen3.8-27B, and it runs inside SGLang. But the headline numbers are self-reported, and the apples-to-apples lead over the strongest retrained baseline is much smaller than the headline.
What shipped
DSpine ("Draft in Parallel, Condition Through Depth") is a parallel drafter for speculative decoding from Tencent YouTu Lab with Shanghai Jiao Tong University and Xiamen University (arXiv:2609.36173, project page, GitHub). It belongs to the same family as DFlash, the UCSD block-diffusion drafter that drafts a full block of tokens in one forward pass conditioned on target-model context features (DFlash paper). DSpine keeps that parallel structure but changes how a successor learns about its predecessor.
The core mechanism is adjacent causal injection. After every layer, each position receives a gated message from its immediate predecessor only. Because the draft backbone uses block-causal attention, the dependency chain unfolds over network depth while every layer still updates all positions in parallel — the messages use pre-update features, so positions never serialize within a layer. A gated injection lets predecessor and successor features jointly decide how much of the predecessor's message enters the successor's residual stream.
The second idea is a unified transfer space built from the target model's output embeddings. An undecided predecessor sends a predicted feature; once its token is decoded, the token's embedding replaces that feature and the last write is redone. Both travel through the same pathway, so one mechanism serves both layer-wise injection and predecessor-conditioned decoding. A transition cache precomputes all K×K adjacent candidate-pair scores in parallel, turning selection into a cache lookup. Layer-wise output-embedding supervision aligns each layer's predicted feature with the correct token's embedding by cosine similarity, which the authors say promotes feature formation in shallow layers.
The diagnostics that motivated the design ran on the frozen official Qwen3-8B DFlash drafter: correct-prefix features from an early layer raise consecutive correct tokens by 6.7%; moving the same injections earlier lifts the gain from 1.2% to 4.3%; and supplying a correct predecessor earlier rather than later gains 14.8 points (project page).
Why it matters
The headline result is on Qwen3-8B across seven benchmarks (GSM8K, MATH-500, HumanEval, MBPP, LiveCodeBench, MT-Bench, Arena-Hard). At temperature zero, DSpine raises the seven-benchmark mean acceptance length from DFlash's 3.77 to 4.82, +27.8% (paper). In SGLang serving tests it reports +23.3% throughput over DFlash on average, up to 4.0× over autoregressive decoding. It posts the fastest result in all 40 settings tested (4 tasks × concurrency levels 2–32) (project page).
The decoding-time breakdown shows the mechanism paying off: injection adds at most 0.15 ms per round, and transition-cached decoding runs at 0.36 ms versus Domino's 0.97 ms and DSpark's 0.88 ms for post-backbone heads. DSpine spends 10.9% less time per generated token than DFlash2 (project page).
For engineers, this is adoptable this week, not just a paper. The repo ships Apache-2.0 code, released draft weights for Qwen3-8B and Qwen3.8-27B, and training code inside SpecForge, the SGLang team's training framework. The 27B card also reports agent-benchmark acceptance lengths and end-to-end throughput of 2.71–3.84× over autoregressive decoding on WorkBuddy, SWE-bench Pro, and τ²-bench (model card).
Caveats
Read the numbers as vendor-reported, not independently verified. No third party we found has reproduced the acceptance-length or throughput figures, and the paper's own diagnostics on the frozen DFlash drafter use oracle tokens, which alphaXiv notes "are not a direct ablation" (alphaXiv).
The headline is also baseline-dependent. The +27.8% acceptance and +23.3% throughput are measured against DFlash. Against DFlash2 — the strongest retrained baseline — the lead shrinks to +10.0% acceptance (4.39→4.82) and +11.1% throughput. The model-card table, which retrains all drafters on Open-PerfectBlend, shows DSpine at 7.83 versus DFlash2's 7.55 at T=0, roughly a 4% edge (GitHub README, explainx).
Acceptance length is not wall-clock speed. alphaXiv cautions the finding "does not by itself establish fewer draft attempts or elapsed-time savings." The speedup also lives inside an SGLang plugin — it is not merged upstream, and there is no vLLM or llama.cpp port we found (an MLX port for Apple Silicon was added in November 2026).
The GPU hardware for the serving tests is unspecified. Gains shrink at sampling temperatures: acceptance drops for every method at T=1, so sampling-heavy workloads see smaller benefits. The 27B agent throughput figures measure replay, not complete agent jobs or external tool latency.