Agent Upstart

Cool things people are building with agents — and practical help getting the most out of them.

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 replayLow effortHigh effort
SWE-bench Pro2.95x3.19x
WorkBuddy Code2.71x3.18x
WorkBuddy Web3.13x3.33x
WorkBuddy Office3.84x3.55x
τ²-bench3.20x2.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

Related playbooks

Sources

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