Playbooks · Coding tasks
DSpine makes Qwen3.8-27B 3.19x faster
Written November 8, 2026
Tencent open-sourced DSpine, a parallel draft model for Qwen3.8-27B, claiming 3.19x throughput on SWE-bench Pro replay. The claim, and the catch.
What it is
DSpine is a five-layer draft model for Qwen3.8-27B, published by Tencent on Hugging Face. It generates draft tokens in parallel: each layer passes predicted predecessor features to adjacent positions, carrying causal dependencies through network depth. It uses a block size of 16 and an 8,192-token sliding window, and it is released under Apache 2.0.
A draft model is not a model you chat with. It proposes tokens ahead of time, and the target model — here Qwen3.8-27B — accepts or rejects them. When most drafts are accepted, the pair runs much faster than the target model alone. When most are rejected, the draft work is wasted and the speedup shrinks. That is the whole catch, and it is why the headline number needs its conditions attached.
The 3.19x claim, with its conditions
The model card reports end-to-end throughput from a concurrent replay, measured in tokens per second, with speedup stated against plain autoregressive decoding. The setup is SGLang 0.5.22, BF16, FlashAttention 3, concurrency 8, with 16 draft blocks for DSpine against 8 for the official DFlash2 draft model. The headline figure is the SWE-bench Pro replay at high reasoning effort: 791.30 tokens per second against 248.17 for autoregressive decoding, or 3.19x. At low reasoning effort the same benchmark reads 713.41 against 241.86, or 2.95x.
| Benchmark replay | Low effort | High effort |
|---|---|---|
| SWE-bench Pro | 2.95x | 3.19x |
| WorkBuddy Code | 2.71x | 3.18x |
| WorkBuddy Web | 3.13x | 3.33x |
| WorkBuddy Office | 3.84x | 3.55x |
| τ²-bench | 3.20x | 2.87x |
Every figure above is Tencent-reported, from the model card, on Tencent's replay setup. No independent run sits behind any of them. The spread matters: the speedup is 2.71x on one replay and 3.84x on another, so 3.19x is one benchmark's result, not a general speedup for the model.
The acceptance lengths tell the same story in a different unit. On SWE-bench Pro, DSpine averages 4.99 accepted tokens per step at low effort and 4.77 at high effort, against 4.19 and 4.00 for DFlash2. Longer accepted drafts are what turn into throughput. On your own workload, the acceptance length is the number to watch: if it falls well below 4, expect a speedup well below the card's figures.
How to try it
The checkpoint is tencent/Qwen3.8-27B-DSpine-b16 on Hugging Face, and the code lives in the Tencent/DSpine repository. Install it with git clone https://github.com/Tencent/DSpine.git followed by pip install -e . in the cloned directory. Then serve the pair with SGLang:
sglang serve \
--model-path Qwen/Qwen3.8-27B \
--speculative-algorithm DSPINE \
--speculative-draft-model-path /path/to/Qwen3.8-27B-DSpine-b16 \
--speculative-num-draft-tokens 16 \
--dtype bfloat16
The command above is shortened from the model card's full example, which also sets the attention backends, the context length, and the concurrency. Use the card's full command for a real run. The target model is Qwen3.8-27B itself, so this only helps if you already run that model: the Foundry Local setup for Qwen3.8-27B is the local path this accelerates, and DFlash2 — the draft mechanism DSpine is measured against — is the speculative decoding stack in that piece.
What it can't do
DSpine cannot speed up a model it was not built for. It drafts for Qwen3.8-27B, and the card gives no basis for using it with anything else. It cannot beat its acceptance rate: a workload whose drafts the target model mostly rejects will see little of the card's speedup, and the 8,192-token sliding window bounds how much draft context it carries. It also does not change what Qwen3.8-27B knows or how well it codes. The model card's general-benchmark acceptance lengths — 7.20 on GSM8K, 6.49 on MATH-500, 5.71 on HumanEval at greedy decoding — are about draft acceptance, not about the target model's scores, and they should not be read as capability gains.
Limits
- No local run sits behind this page: the machine used for it has no GPU capable of serving Qwen3.8-27B, so no speedup was measured here and no acceptance rate was recorded on a real workload.
- Every throughput and acceptance figure is Tencent-reported, from one replay setup: SGLang 0.5.22, BF16, FlashAttention 3, concurrency 8. A different serving stack, a different concurrency, or a different workload will give different numbers.
- The model card does not state a parameter count or a download size in its text, so neither is stated here.
Related playbooks
- Foundry Local runs Qwen3.8-27B on your GPU
- Claude Code 2.1.328 makes auto mode the cloud default
- BotPsy 0.8B: an agent model that fits on-device
- Copilot retires six more models on December 14
Sources
- tencent/Qwen3.8-27B-DSpine-b16 — Hugging Face — the draft-model mechanism, the block size and sliding window, the throughput and acceptance tables, the install and serve commands, and the Apache 2.0 licence
- Tencent/DSpine — GitHub — the draft-model code the Hugging Face checkpoint points to
Back to: Coding playbooks hub · Also: Foundry Local runs Qwen3.8-27B on your GPU · MAI-Code-1.1-Flash: local coding on RTX Spark · Model specs: context, tools, and cutoffs in one table