DFlash 2: Keep Drafting Parallel

Inference is de bottleneck van het tijdperk van AI-agents. Agents lezen, plannen en roepen tools aan, vaak gedurende uren of dagen. Ze consumeren tokens in een tempo dat chat-interfaces nooit hebben benaderd. Elk van die tokens vereist een volledige forward pass over het model. Bij Inco AI bouwen we de inference-stack die is geschaald naar de token-economie van morgen. Dit bericht is een eerste inkijkje.

Ons team bracht DFlash uit in januari; het draait nu in SGLang, vLLM, TensorRT-LLM en llama.cpp. NVIDIA mat hiermee tot 15× meer doorvoersnelheid (throughput) op Blackwell GPU's; Google rapporteerde 3× meer tokens per seconde op TPU's. Het productie-endpoint van CoreWeave voor Kimi K2.7 Code — de snelste voor dat model volgens Artificial Analysis — draait standaard op DFlash. Het ecosysteem bouwt er nu op voort: NVIDIA, Red Hat en Modal hebben allemaal DFlash-drafters gepubliceerd; Meta (Muse Glimmer), Poolside (Laguna), Xiaomi (MiMo-V2.5-Pro) en NVIDIA (Nemotron 3.5 Lightning) leveren officiële drafters mee met hun eigen modellen. Op Hugging Face zijn DFlash-modellen meer dan 3,5 miljoen keer gedownload (stand van zaken augustus 2026).

Speculatief decoderen is een kernonderdeel van de moderne inference-stack. Een klein draft-model raadt een blok tokens, en het target-model verifieert het hele blok in één forward pass. Goede gissingen zetten één pass om in meerdere tokens; slechte gissingen worden simpelweg weggegooid. Jarenlang bleef het draften echter autoregressief: één token per keer. DFlash maakte dit ook een one-pass proces: het volledige blok, elke positie, wordt parallel voorspeld.

DFlash 2 zet parallel draften een stap verder: meer dan 20% meer output per verificatie-pass, met ongeveer 1% extra cycle-latentie, waarbij de output aantoonbaar ongewijzigd blijft. In benchmarks loopt de winst op tot 16–25%. Met de vandaag uitgebrachte Qwen3.8-27B drafter levert SGLang een doorvoersnelheid die 2,7–3,4× hoger ligt dan bij autoregressief decoderen bij een batch-grootte van 1. Het onafhankelijk voorspellen van elke positie laat ruimte over op twee gebieden: het kiezen van de juiste tokens en het behouden van de nauwkeurigheid tot aan het einde van het blok. DFlash 2 herstelt beide zonder het one-pass ontwerp op te geven.

Direct Uitproberen

DFlash 2 draait reeds in de gangbare inference-engines: SGLang, vLLM, llama.cpp en oMLX.

SGLang

pip install "sglang[all] @ git+https://github.com/sgl-project/sglang.git#subdirectory=python"
python -m sglang.launch_server \
--model-path Qwen/Qwen3.8-27B \
--speculative-algorithm DFLASH \
--speculative-draft-model-path incoai/Qwen3.8-27B-DFlash2 \
--speculative-num-draft-tokens 8

vLLM

pip install -U "vllm @ git+https://github.com/vllm-project/vllm.git@refs/pull/52816/head"
vllm serve Qwen/Qwen3.8-27B \
--speculative-config '{
"method": "dflash",
"model": "incoai/Qwen3.8-27B-DFlash2",
"num_speculative_tokens": 7
}'

llama.cpp

git clone https://github.com/ggml-org/llama.cpp.git
cd llama.cpp
git fetch origin pull/27342/head:pr-27342
git switch pr-27342
# NVIDIA CUDA
cmake -B build -DCMAKE_BUILD_TYPE=Release -DGGML_CUDA=ON
cmake --build build -j
# Apple Silicon
cmake -B build -DCMAKE_BUILD_TYPE=Release -DGGML_METAL=ON
cmake --build build -j
./build/bin/llama-server \
-hf ggml-org/Qwen3.8-27B-GGUF:Q4_K_M \
-hfd incoai/Qwen3.8-27B-DFlash2-GGUF:Q4_K_M \
--spec-type draft-dflash \
--spec-draft-n-max 7

oMLX

Download en installeer de prebuilt oMLX met DFlash 2-ondersteuning. Om Qwen3.8-27B met DFlash 2 te draaien:

1. Open de oMLX Model Downloader en download:

• mlx-community/Qwen3.8-27B-4bit
• incoai/Qwen3.8-27B-DFlash2

1. Open de Model Manager en bewerk mlx-community/Qwen3.8-27B-4bit. Configureer DFlash met de volgende instellingen:

• DFlash: enabled
• Draft model: incoai/Qwen3.8-27B-DFlash2
• Draft quantization: enabled
• Runtime block size: 5
• Verify mode: dflash

1. Sla de instellingen op en laad het target-model.

De Juiste Tokens zijn Al Aanwezig

DFlash voorspelt elke positie onafhankelijk en parallel. Elke keuze is op zichzelf plausibel. Toch is er niets dat ze op elkaar afstemt, en een incoherent blok wordt bij verificatie afgebroken. Recente methoden zoals Domino en DSpark kopen coherentie met sequentiële heads die de volledige-vocabulaire distributie van elke positie herschrijven.

Is die kostbare autoregressieve correctie werkelijk nodig? Nee. Het bewijs ligt al in de kandidaatlijsten van DFlash. Neem de eerste positie: de topkeuze van DFlash is in 85,4% van de gevallen correct, maar de juiste token bevindt zich in de top 16 kandidaten in 99,5% van de gevallen. Zelfs wanneer de topkeuze fout is, staat de juiste token meestal op de lijst.

Tabel 1. Recall@1 en Recall@16 per draft-positie (Vijf-laags Qwen3-4B DFlash op GSM8K).

Metriek	0	1	2	3	4	5	6	Acceptatielengte
Recall@1	85.4%	80.3%	79.4%	78.3%	77.5%	75.9%	72.9%	4.27
Recall@16	99.5%	97.3%	94.8%	92.6%	90.8%	89.4%	87.8%	6.79

Opmerking: De acceptatielengte is inclusief het volgende token van de verifieerder.

Een 'orakel' dat altijd de juiste kandidaat uit de top 16 kiest, zou de acceptatielengte verhogen van 4,27 naar 6,79. Dat gat is pure selectieruimte. We hoeven alleen het juiste pad door de kandidaten te selecteren.

(Figuur 1 beschrijft de selector in één cyclus: waar DFlash alleen vaak stottert door dezelfde woorden te kiezen, traceert de selector van DFlash 2 een coherent pad waardoor het hele blok overleeft.)

Een Lichtgewicht Pad-selector

Coherentie is grotendeels lokaal: de passing van een kandidaat hangt voornamelijk af van het token vlak ervoor. Het scoren van naburige paren zou dus voldoende moeten zijn. DFlash 2 bewaart de top 16 kandidaten per positie en scoort elk aangrenzend paar: voor voorganger $a$ en huidige kandidaat $b$:

$$St(a,b) = Ut(b) + \langle A(a) \odot H(h_t), B(b) \rangle$$

De score bestaat uit twee delen. Ten eerste is $Ut(b)$ de eigen logit van DFlash: hoezeer de drafter $b$ op zichzelf al leuk vond. Ten tweede wordt gekeken hoe goed $b$ volgt op $a$: $A$ en $B$ geven elk token een compacte 256-dimensionale embedding, en deze twee embeddings worden gematcht onder een context-gate $H(ht)$ die bepaalt welke delen van de match tellen. In essentie is dit een low-rank bilinear attention over aangrenzende kandidaten.

Het scoren blijft volledig parallel. Elk aangrenzend paar op elke positie wordt in één keer gescoord, zonder extra backbone- of LM-head pass. De enige sequentiële handeling is de uiteindelijke wandeling over de vooraf berekende scores: beginnend bij het laatste geverifieerde token volgt een greedy aanpak de beste opvolger per stap.

Tabel 2. Acceptatielengte met path selection alleen (geen convolutie), voor vijf-laags Qwen3-4B op GSM8K.

Methode	Params	Latentie	T = 0	T = 1
DFlash	—	—	4.27	3.78
+ DSpark correctie	+77.8M	+9.6%	4.49	4.08
+ path selection (ons)	+2.0M	+0.6%	4.61	4.25

De selector verbetert DFlash met 0,34 tokens bij $T=0$ en 0,47 bij $T=1$. Het verslaat de DSpark-correctie in beide instellingen met ongeveer 40× minder parameters en 16× lagere latentie-overhead. Kiezen is goedkoper dan voorspellen.

Suffix Decay is een Lokaal Probleem

We merkten ook op dat zowel de recall-rijen als die van het orakel dalen richting het einde van het blok. Zelfs bij perfecte selectie daalt de nauwkeurigheid van 99,5% bij de eerste positie naar 87,8% bij de laatste. Geen enkele selector kan dit oplossen, omdat de kandidaten zelf opraken. We noemen dit suffix decay, en het is een backbone-probleem.

Een vermoeden is capaciteit: een backbone van vijf lagen is mogelijk te klein om afhankelijkheden over het hele blok te bewaren. Als dat klopt, zou meer diepte vooral helpen bij latere posities. Dat is inderdaad het geval. Modellen van 3, 5 en 15 lagen zijn bijna identiek bij de eerste positie, maar lopen uiteen naarmate het blok vordert. Echter, extra diepte is onselectief: tien extra attention-blokken voegen overal capaciteit toe, ook waar dat niet nodig is, wat de efficiëntie van DFlash tenietdoet.

(Figuur 2 en de bijbehorende tabel tonen de Recall@1 op GSM8K. DFlash 15L presteert het best aan het einde van het blok, maar met 3× zoveel parameters.)

We wilden een gerichte oplossing. Analyse van de attention in DFlash laat zien dat deze twee taken heeft: de context vóór het blok lezen en de afhankelijkheden binnen het blok modelleren. Maar de aandacht voor dat laatste neemt af: het aandeel van het blok in de attention daalt van 30% in laag 1 naar 8% in laag 5. We hebben deze taken daarom gesplitst: een speciale module neemt het werk binnen het blok over, zodat de attention zich kan blijven richten op de context.

Een Lichtgewicht Lokale Convolutie

Het werk binnen het blok is van korte afstand: een blok beslaat slechts 4 tot 16 tokens. De meest natuurlijke operator hiervoor is een korte convolutie: twee taps, één op de huidige positie en één op de positie ervoor, met gewichten die zich aanpassen aan de inhoud.

We voegen deze two-tap dynamic depthwise convolution in vóór en ná elke attention- en feed-forward sublaag:

$$\operatorname{Conv}{k}(x)t = k{t,0} \odot xt + k{t,1} \odot x{t-1}$$

Elke coëfficiënt combineert een geleerde basis-kernel met een kleine correctie berekend uit de huidige hidden state. De eerste positie leest de representatie van het laatste geverifieerde token, en elke volgende positie leest zijn voorganger. Informatie verspreidt zich over het blok terwijl alle posities nog steeds parallel rekenen.

Met slechts 16,5M extra parameters (3%) komt de vijf-laags DFlash met convolutie dicht in de buurt van de 15-laags DFlash, wat suffix decay aanzienlijk vermindert. De convoluties voegen 0,7% toe aan de cycle-latentie, terwijl tien extra Transformer-lagen 15,2% toevoegen.

Alles Samengevoegd

In de onderstaande vergelijking zijn de selector en de convolutie gecombineerd.

Tabel 3. Gemiddelde acceptatielengte per request voor Qwen3.5-4B.

Dataset	MTP	DFlash	DSpark	DFlash 2
GSM8K	4.78	4.99	5.69	6.20
MATH-500	5.04	5.42	6.20	6.76
HumanEval	4.84	5.43	5.80	6.28
MBPP	4.16	4.49	4.96	5.41
MT-Bench	3.90	4.26	4.77	5.20
Gemiddelde	4.54	4.92	5.49	5.97

DFlash 2 voert in elke benchmark. Gemiddeld wint het 1,05 tokens ten opzichte van DFlash (21%) en 0,48 ten opzichte van DSpark. Deze upgrade blijft goedkoop: de selector en de convolutie samen voegen slechts 1,3% toe aan de cycle-latentie.

Op MATH-500 is de winst per positie zichtbaar: DFlash 2 blijft stabiel rond de 86% tot de laatste positie, terwijl alle baselines aan het einde van het blok 6 tot 9 punten lager eindigen.

Twee Drafters, Vandaag Beschikbaar

We brengen vandaag twee DFlash 2 drafters uit: één voor Qwen3.8-27B en één voor Meta's Muse Glimmer.

Tabel 4. Qwen3.8-27B gemiddelde acceptatielengte per request.

Dataset	MTP	DSpark	DFlash 2
GSM8K	5.02	4.36	5.46
MATH-500	4.72	3.92	5.28
HumanEval	3.91	3.30	4.39
MBPP	3.99	3.51	4.79
MT-Bench	3.74	3.01	4.10
Gemiddelde	4.28	3.62	4.80

Tabel 5. Muse Glimmer gemiddelde acceptatielengte per request.

Dataset	DFlash	DSpark	DFlash 2
GSM8K	5.43	5.45	6.57
MATH-500	5.39	5.01	6.56
HumanEval	4.11	4.33	5.66
MBPP	3.74	4.02	5.30
MT-Bench	3.52	3.59	4.42
Gemiddelde	4.44	4.48	5.70

De marges zijn groot: bij beide modellen ligt DFlash 2 gemiddeld meer dan een volledig token voor op DSpark. Het verslaat ook de officiële drafters (MTP op Qwen3.8-27B en DFlash op Muse Glimmer). Dit vertaalt zich naar een doorvoersnelheid van 2,7–3,4× ten opzichte van autoregressief decoderen op Qwen3.8-27B, en 3,1–4,6× op Muse Glimmer.

Conclusie

Een agent schrijft in een middag wat een chatbot in een maand schrijft, en decoding zit achter elk van die tokens. DFlash 2 decodeert bijna 3× zo snel als autoregressief decoderen, met ongeveer een derde van de compute per token, bij exact dezelfde output.

In zeven maanden is DFlash gegroeid van een paper naar een industriestandaard met meer dan 3,5 miljoen downloads. Binnen hetzelfde ontwerp decodeert DFlash 2 nu één volledig token meer per pass, zonder extra kosten. Dit is slechts één onderdeel van de serving-stack.

Inference is nog lang niet bij zijn absolute minimum. Bij Inco AI bouwen we aan een end-to-end serving-stack om dat minimum verder te verlagen. DFlash 2 is het eerste onderdeel.

***

Bronvermelding

Citeer dit bericht als: @misc{inco2026dflash2, title = {{DFlash 2: Keep Drafting Parallel}}, author = {{Inco AI}}, year = {2026}, month = {August}, url = {https://inco.ai/blog/dflash2/}}

Voetnoten

1. Modal's "Speculation Is All You Need" wijst erop dat speculatief decoderen de optimalisatie is die het meeste uitmaakt voor low-latency serving. We zijn grote fans van hun werk en waarderen hun steun en discussies sinds de release van DFlash.