DSpine for Qwen3.8-27B

DSpine for Qwen3.8-27B

A five-layer draft model that guesses 16 tokens in parallel for Qwen3.8-27B, so the large model can check them together. Made for teams that serve that model.

Made by tencent on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: DSpine for Qwen3.8-27B is a small draft model from tencent that speeds up how a large model writes text. It guesses a block of 16 upcoming tokens in parallel, and Qwen3.8-27B then checks the guess. This checkpoint has five layers and an 8,192-token sliding window.

Who it suits: It suits teams that serve Qwen3.8-27B and care about how many drafted tokens the large model accepts. It also suits researchers who study parallel drafting.

Industry | Who uses it | How they use it | Example
AI infrastructure | Teams that host Qwen3.8-27B | Add it as the draft model beside the large model | A serving stack tested with SGLang 0.5.22
Research | People studying speculative decoding | Compare block drafting against the DFlash2 baseline | GSM8K runs at temperature 0 and temperature 1
Coding agents | Builders of code agents | Draft tokens for long agent traces | SWE-bench Pro and WorkBuddy Code replays
Office automation | Builders of office agents | Draft tokens for document and office tasks | WorkBuddy Office replays

You can skip it if you do not run Qwen3.8-27B, since this draft model is made for that one target.

Where to use it: It runs next to Qwen3.8-27B inside a model server.

• SGLang: the runtime the authors measured, on version 0.5.22 with FlashAttention 3
• Qwen3.8-27B serving setups, since the draft is built for that model
• Agent and coding workloads such as WorkBuddy, SWE-bench Pro and τ²-bench, which the authors replayed

Use case | Who | What they get back
Maths and code generation | Teams serving the large model | Longer accepted drafts, such as 7.20 on GSM8K against 5.69 for DFlash2
Agent sessions | Agent platform builders | Longer accepted drafts across WorkBuddy, SWE-bench Pro and τ²-bench
Chat | Teams serving general assistants | Longer accepted drafts on MT-Bench, 4.48 against 4.11

How to set it up: You pair this checkpoint with its target model in a server that supports the authors' setup.

You need:

• The Qwen3.8-27B model that this checkpoint drafts for
• An SGLang server, tested by the authors on version 0.5.22
• BF16 weights and FlashAttention 3
• Dynamic verification and ReplaySSM, both enabled in the authors' runs

1. Get Qwen3.8-27B, the model this checkpoint drafts for.
2. Download this DSpine checkpoint, which has block size 16.
3. Start SGLang in BF16 with FlashAttention 3, the setup the authors measured.
4. Turn on dynamic verification and ReplaySSM as in their DSpine runs. The DSpine GitHub project is where its code lives.

How to use it: You do not prompt this model yourself. It sits inside the server and drafts tokens while Qwen3.8-27B answers your requests. The authors used these sampling settings for their temperature runs:

temperature=1.0
top_p=0.95
top_k=20

Tool | What it does
SGLang | The runtime the authors used for their tests
DSpark | A reference for the dynamic verification used with DSpine
ReplaySSM | Enabled during the DSpine runs
DFlash2 | The official draft model with block size 8 that DSpine is compared with

Example: Run a maths question like those in GSM8K through a Qwen3.8-27B server that uses this draft model. With greedy decoding, the authors measured an acceptance length of 7.20, while DFlash2 reached 5.69.

For newcomers and experts: A large model writes one token at a time, which is slow. A draft model guesses several tokens ahead and the large model checks them together. Acceptance length counts how many drafted tokens it keeps. To try it, compare the same prompts with and without the draft model on your own server.

Under the hood, every layer hands the features it predicts for earlier tokens to the positions beside them. Causal links between tokens therefore travel through network depth, so a whole block of 16 can be drafted at once. The trade-off is that the numbers come from one runtime and one concurrency of 8.

The draft model reads the context so far
It drafts a block of 16 tokens in parallel
Qwen3.8-27B checks the drafted tokens
Accepted tokens are kept
Drafting restarts from the last kept token

Good to know:

• It works only as a draft for Qwen3.8-27B
• Five layers, block size 16, 8,192-token sliding window
• Tests used SGLang 0.5.22, BF16, FlashAttention 3 and concurrency 8
• General benchmarks ran at xhigh reasoning with at most 4,096 new tokens
• At low reasoning, WorkBuddy Code acceptance length rises from 4.19 to 5.08
• License: Apache 2.0

Title: Acceptance length at temperature 0
GSM8K DFlash2: 5.69
GSM8K DSpine: 7.20
MATH-500 DFlash2: 5.49
MATH-500 DSpine: 6.49
HumanEval DFlash2: 4.87
HumanEval DSpine: 5.71
MBPP DFlash2: 5.04
MBPP DSpine: 6.14

On Hugging Face, 10 November 2026

• Task: text generation
• Parameters: 2B
• Weights: about 4.1 GB in BF16; about 1 GB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 1,464
• Likes: 151
• License: apache-2.0
• Based on: Qwen/Qwen3.8-27B
• Quantized versions: 4
• Fine-tunes: 1
• Tags: safetensors, qwen3, dspine, speculative-decoding, draft-model, sglang, text-generation

Links

• Model: https://huggingface.co/tencent/Qwen3.8-27B-DSpine-b16
• Files: https://huggingface.co/tencent/Qwen3.8-27B-DSpine-b16/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download tencent/Qwen3.8-27B-DSpine-b16

Then follow the usage in its model card. Nothing in this kit runs by itself.