Skip to content

DFlash 2 vs EAGLE-3 vs MTP

Canonical comparison of the three speculative-decoding draft paths you can actually deploy in 2026: the DFlash 2 block-diffusion drafter (topic folder), the EAGLE-3 external autoregressive drafter, and native multi-token prediction (MTP) modules shipped with the model. Verification is identical across all three — the entire difference is in how tokens get drafted.

TL;DR

DFlash 2 EAGLE-3 Native MTP
What it is External block-diffusion drafter + candidate path selector + two-tap dynamic convolutions External autoregressive drafter conditioned on target features at its input Multi-token prediction module shipped inside the target model
Drafting Whole block (K=8-16) in one forward pass; draft cost nearly flat in K One token per forward pass; draft cost grows linearly with K One token per forward pass (e.g. Qwen3.8: built-in 7-token serial draft)
Target conditioning KV injection of target hidden states into every draft layer Target features at the drafter input only (fades with depth) Trained jointly with the model
Acceptance (best measured mean) 5.97 (Qwen3.5-4B, 5-task mean) 4.2-4.3 on comparable 4B-class rigs (5-layer drafter) 4.54 (same Qwen3.5-4B rig); 4.28 (Qwen3.8-27B)
Speedup @ batch 1 2.67-3.43x (H200, Qwen3.8-27B) 2.1-2.2x (LMSYS rig); 1.30x on TPU v5p out-of-box (K=2) 1.96-2.59x (H200, Qwen3.8-27B)
Speedup @ concurrency 32 1.01-1.45x Not published on comparable rigs 0.77-1.04x — can fall below baseline
Coverage 2 DFlash 2 drafters; ~20 DFlash v1 drafters across Qwen/Gemma/Kimi/gpt-oss/Llama/MiniMax/GLM Widest community-checkpoint ecosystem Every model that ships an MTP head
Extra artifact to trust Drafter checkpoint (new orgs) + possibly PR-ref engine builds Community drafter checkpoint None — part of the model
Best for Max speedup at interactive concurrency where a drafter exists Broad model coverage with mature mainline engine support Zero-effort baseline; models without external drafters

Layer Mapping

Forcing the three into explicit layers resolves most confusion: MTP and EAGLE-3 both draft serially and differ in who trained the drafter and what it sees; DFlash 2 changes the drafting execution model itself.

flowchart TB
    subgraph DRAFTLAYER["Draft layer (the actual difference)"]
        direction LR
        MTP["Native MTP module<br/>in-model weights, serial K tokens<br/>trained with the target"]
        EAGLE["EAGLE-3 drafter<br/>1-5 layers, serial<br/>target features at input"]
        DF2["DFlash 2 drafter (2B, 5 layers)<br/>one pass, whole block<br/>KV injection + selector + conv"]
    end

    subgraph RUNTIME["Runtime layer"]
        ENG["SGLang (Spec V2 overlap) / vLLM (Speculators, tpu-inference) /<br/>TensorRT-LLM / llama.cpp / ollama / oMLX"]
    end

    subgraph VERIFY["Verification layer (identical for all three)"]
        TV["Target LLM forward pass over draft block"]
        RS["Rejection sampling -> target distribution, lossless"]
        TV --> RS
    end

    MTP --> ENG
    EAGLE -->|"target features at input"| ENG
    DF2 -->|"target hidden states -> draft KV cache"| ENG
    ENG --> TV

Architecture Comparison

Native MTP

The model's own extra prediction head(s), trained jointly with the target (Qwen3.8 ships a seven-token MTP path; Gemma 4 and DeepSeek-V4 ship MTP modules per LMSYS). Drafting is autoregressive — the head proposes tokens one at a time — so per-cycle draft cost grows with the speculation depth. Zero extra artifacts: the drafter is part of the model release, which makes it the only path with no supply-chain addition — but also the performance floor (see the TL;DR and Rig 1 below for its acceptance and high-concurrency numbers).

EAGLE-3

The mature external-drafter design (arXiv:2503.01840): a small autoregressive transformer drafts sequentially, conditioned on the target model's feature forecasts at the drafter's input. That conditioning fades with drafter depth, so practical drafters are shallow (1 layer typical; 5-layer variants appear in ablations), and out-of-the-box speculation depths are small (K=2 on the TPU benchmark) because draft cost is linear in K. Strengths are ecosystem, not peak numbers: the widest set of community checkpoints, years of mainline engine support, and well-understood behavior (measured results in Rigs 3 and 4 below).

DFlash 2

External drafter, different execution model: a block-diffusion backbone predicts every position of the block in one non-causal forward pass, conditioned by injecting target hidden states through its own KV projection into every draft layer — the injection keeps deep drafters accurate, which input-only conditioning cannot. DFlash 2 adds a pairwise candidate path selector and two-tap dynamic convolutions to fix the two measured loss modes of parallel drafting (incoherent picks and suffix decay) at ~1.3% combined cycle latency; component-level detail lives in DFlash 2 architecture. Draft cost is nearly flat in block size, which is why it exploits K-flat verification on datacenter hardware. Measured acceptance means: 5.97 (Qwen3.5-4B) and 4.80 (Qwen3.8-27B) — ahead of MTP and DSpark on every task, and +1.05 tokens over DFlash v1.

Measured Head-to-Heads (by rig)

Rig honesty matters here: no single published table contains all three methods on one rig. These are the four rigs with direct comparisons; treat cross-rig rows as indicative, not equal.

Rig 1 — H200, Qwen3.8-27B, block 8 (Inco blog + HF model card; MTP and DFlash 2, no EAGLE-3):

Concurrency MTP DFlash 2
1 1.96-2.59x 2.67-3.43x
8 1.74-2.19x 2.27-2.85x
32 0.77-1.04x 1.01-1.45x

Acceptance (mean of 5 tasks): MTP 4.28, DFlash 2 4.80.

Rig 2 — LMSYS Qwen3-4B-class, 5-layer drafters (EAGLE-3 vs DFlash v1):

Task EAGLE-3: acceptance / speedup DFlash: acceptance / speedup
GSM8K 4.2 / 2.1x 4.2 / 3.3x
HumanEval 4.3 / 2.2x 4.0 / 3.2x
MT-Bench 3.1 / 1.4x 3.0 / 2.2x

Same acceptance, ~1.5x the speedup — the win is drafting cost, not guess quality. With DFlash 2's selector+conv (Qwen3.5-4B rig), acceptance rises to 5.97 vs MTP's 4.54 on the same task set.

Rig 3 — TPU v5p, Llama-3.1-8B (UCSD/Google; out-of-box checkpoints, K=10 vs K=2): DFlash 2.29x vs EAGLE-3 1.30x end-to-end serving speedup.

Rig 4 — NVIDIA Blackwell, Speed-Bench, interactivity-matched (DFlash v1): avg interactivity speedup gpt-oss-120b: DFlash 2.3x vs EAGLE-3 1.7x; Llama-3.1-8B: 2.8x vs 2.2x. At 500-600 tok/s/user, DFlash delivers >15x AR throughput on 8x B300 — 1.5x higher than EAGLE-3 at the same point.

Caveat

Published EAGLE-3 comparisons are against DFlash v1, not DFlash 2. Since DFlash 2 strictly improves v1 (+1.05 tokens acceptance, same design), the v1-vs-EAGLE-3 gap is a floor for DFlash 2 — but no same-rig DFlash 2 vs EAGLE-3 table exists yet (TBD, watch for third-party replications).

Decision Matrix

Dimension DFlash 2 EAGLE-3 Native MTP
Architecture Block-diffusion, one pass, KV-injection conditioning Autoregressive, input-only conditioning, shallow In-model autoregressive head
Performance Highest acceptance + speedup at batch 1-32 Mid acceptance; speedup capped by serial drafting Mid acceptance; degrades below baseline at high concurrency
Operations Config swap; best on SGLang Spec V2; some engines on PR refs Config swap; fully mainline everywhere Zero config; enabled by default path
Cost +2B BF16 drafter resident; +1.3% cycle latency Small shallow drafter No extra artifact (weights ship with model)
Security New drafter orgs; PR-ref builds to pin; lossless output Mature checkpoint ecosystem; lossless output No new artifact; lossless output
Ecosystem 2 launch drafters; ~20 v1 family; NeMo training recipe Widest checkpoint coverage; years of engine support Every MTP-shipping model
Lock-in Risk Drafter per target; training code pending (Issue #1) Low — open algorithm, many checkpoints None within a model; changes per model family

Weighted Decision Matrix

Scenario scored: you serve a model that has a published DFlash-family drafter; interactive-heavy traffic (batch 1-8) on GPU. Scale 1-5, weights sum to 100%.

Criterion Weight DFlash 2 EAGLE-3 MTP
Speedup at batch 1-8 25% 5 3 3
Behavior at concurrency 32 15% 3 2 1
Drafter availability (this scenario) 15% 5 4 3
Engine support maturity 15% 4 5 5
Rollout effort 10% 4 5 5
Memory/overhead 10% 3 4 5
Maturity / supply-chain risk 10% 3 4 5
Weighted total (max 5.00) 3.80 3.70 3.45

The margin between DFlash 2 and EAGLE-3 is maturity vs peak: DFlash 2 wins every measured performance row but concedes points on engine mainline status and ecosystem age. Flip the availability row (no DFlash drafter for your model: 5 -> 1) and EAGLE-3 wins outright at 3.70 vs 2.90 — which is exactly the fallback rule below.

Verdict

  • Primary — DFlash 2 when a published drafter exists for your exact target model and traffic is interactive (batch 1-32): it leads acceptance and throughput on every published rig, is lossless, and migration is a config swap on SGLang/vLLM. Benchmark at your real concurrency before rollout — gains compress toward 1x by concurrency 32 (Rig 1).
  • Fallback — EAGLE-3 when no DFlash-family drafter exists for your model (its checkpoint ecosystem is the widest), or when you require fully mainline engine builds with no PR-ref pinning. Expect mid-2x speedups at low concurrency rather than ~3x.
  • Baseline — native MTP as the zero-effort default and the A/B floor for any speculation rollout: it ships with the model, adds no artifact, but is the slowest of the three at batch 1 and measured below 1x at high concurrency (Rig 1) — do not assume it is free under load.
  • Output quality is never the trade-off here: verification is the shared lossless layer (above), so an output audit valid under autoregressive decoding stays valid under all three.

Sources

All URLs verified HTTP 200 on 2026-08-28.