@@ -391,8 +391,9 @@ explicit flags take precedence.
 | `--prefill-chunk-size N` | Most prompt tokens processed in one prefill step, a multiple of 64. A larger chunk reaches a long prompt's first token sooner; while it runs, other active requests wait for their next token. Command line only. | The recipe's chunk |
 | `--mixed-prefill` | Capture mixed prompt/decode graphs alongside separate graphs. Supported by Qwen with concurrency of at least two, with or without speculation. Command line only; existing packages retain their captured catalog. | Disabled |
 | `--expert-scale-compression [MODE]` | Losslessly compress routed-expert scales: DeepSeek V4.1 backbone and DSpark MXFP4 scales, or Step-5 NVFP4 scales including BF16 experts converted to W4A16. `csf` is a compressed scale encoding expanded during execution. Estimated resident GPU weight savings are 3% for DeepSeek V4.1 and 6% for Step-5; actual savings depend on encoded scales. A bare flag selects `csf`; `native` disables compression. Retain compressed scales and share expansion scratch across serial layers. | Recipe default: `csf` for DeepSeek V4.1, native otherwise |
+| `--speculative-method {mtp,dflash2}` | Select the recipe's learned proposal method. Flash Next defaults to MTP and also supports its pinned DFlash2 checkpoint; Qwen3.8 dense uses DFlash2. Overrides `[models."MODEL"] speculative_method`, then `[defaults] speculative_method`. The selection is recorded in preparation and rebuild metadata; native serving replays the exported graphs. | Recipe declaration |
 | `--no-mtp` | Disable multi-token speculation: load no draft model, keep no verification rows, and decode one token per step. | Speculation on |
-| `--draft-head-quantization {nvfp4,mxfp8}` | Prepare a separate proposal vocabulary head while retaining target-head precision. NVFP4 supports DeepSeek V4/V4.1; MXFP8 supports DeepSeek V4.1. Qwen3.8 dense supports both when the source checkpoint head is BF16, including `qwen3.8-27b-qad`; the packed NVIDIA head cannot be converted through this option. This does not quantize the draft body. | Checkpoint precision |
+| `--draft-head-quantization {nvfp4,mxfp8}` | Prepare a separate proposal vocabulary head while retaining target-head precision. NVFP4 supports DeepSeek V4/V4.1; MXFP8 supports DeepSeek V4.1. Qwen3.8 dense supports both when the source checkpoint head is BF16, including `qwen3.8-27b-qad`; the packed NVIDIA head cannot be converted through this option. Flash Next supports both with `--speculative-method dflash2` and a BF16 target vocabulary head. This does not quantize the draft body. | Checkpoint precision |
 | `--mtp-draft-tokens N` | Most draft tokens verified in one round; see `MODEL --help` for its limit. Verification capacities cover counts from 0 through `N` within the speculative token capacity. Each complete speculative program records its actual proposal depth independently of target width and aggregate rows. Prefix selection uses measured complete-program cost and completed acceptance or confidence. Zero retains draft state with width-one execution; `--no-mtp` excludes draft weights and state. | Recipe declaration |
 | `--speculative-token-capacity N` | Maximum physical target-token rows in wider speculative graphs; width one covers every request bucket. Applies to every speculative recipe. | 128 except Gemma 4, which derives it from concurrency and draft depth (6 at its defaults) |
 | `--speculative-graph-budget N` | Maximum packed round graphs to capture, independently of physical target-token rows. Excludes mandatory width-one and ordinary graphs; requires packed adaptive learned speculation at positive draft depth. Must cover both physical-row endpoints for every eligible request bucket. | 64 for packed recipes |
@@ -408,8 +409,9 @@ explicit flags take precedence.
 | `--compile-workers N` | CPU compiler process budget per host, divided among local preparation ranks and bounded by available RAM and device memory. Applies to b12x kernel compilation and complete-forward compilation. Overrides `[preparation] compile_workers`. | Automatic |
 | `--tuning-gpus LIST` | Local kernel-tuning GPUs. Start with the serving GPU list, then append complete replicas of that TP group on matching hardware. Serving TP size stays fixed. Command line only; cannot be combined with multi-host `--ranks`. | Serving GPUs |
 | `--no-compile` | Development only: capture graphs without compiling forwards. A recipe never sets it. | off |
+| `--force-moe-decode-a16` / `--no-force-moe-decode-a16` | Prepare Qwen3.8 Flash NVFP4 target routed experts as one packed weight owner: decode and speculative verification use W4A16 at every token-row count, and separate prefill graphs use calibrated A4. Requires SM120/121, checkpoint activation scales, and rank-local expert intermediate width divisible by 64 (TP1/2). Mixed prefill and other recipes/precisions reject the flag. Shared experts and stored A16 MTP experts retain their precision. Overrides `[preparation] force_moe_decode_a16`; the resolved value is recorded in the plan and package rebuild metadata. | off |
 | `--native-dense-activations` | Replace dense projection `auto` precision with b12x `quantized`: A8 for FP8 weights and A4 for FP4 weights. Explicit recipe precision and routed MoE precision are retained. NVFP4 requires a checkpoint activation global scale; unsupported native paths fail preparation. | Recipe precision |
-| `--online-mxfp8` | Store eligible BF16 projections as MXFP8 while loading. Kimi K3 converts KDA projections, MLA latent/gate, query and output projections, shared experts, MoE latent down/up projections, and DSpark context, outputs and MLPs; batched MLA key/value projections retain BF16. Qwen3.8 dense converts target attention/MLP projections and DFlash2 context, attention and MLP projections. Existing packed weights, normalization, convolutions, selectors and target vocabulary weights retain their precision. Recipes that name no such projections reject it. | Checkpoint precision |
+| `--online-mxfp8` | Store eligible BF16 projections as MXFP8 while loading. Kimi K3 converts KDA projections, MLA latent/gate, query and output projections, shared experts, MoE latent down/up projections, and DSpark context, outputs and MLPs; batched MLA key/value projections retain BF16. Qwen3.8 dense converts target attention/MLP projections and DFlash2 context, attention and MLP projections. Flash Next with `--speculative-method dflash2` converts only DFlash2 projections; target precision is retained. Existing packed weights, normalization, convolutions, selectors and target vocabulary weights retain their precision. Recipes that name no such projections reject it. | Checkpoint precision |
 | `--language-model-only` | Prepare no vision encoder and serve text only, as vLLM's flag of the same name; requests with images are rejected and the encoder's weights, scratch, and graphs become KV pages. Recipes without a separable encoder reject it. | The recipe's image support |
 
 Speculative token capacity and packed graph budget also accept configuration-file
@@ -1145,8 +1147,10 @@ api_key = ""                      # Empty: no authentication.
 [defaults]
 model = "qwen3.8-flash"
 max_concurrency = 4
+# speculative_method = "mtp"      # Flash Next also supports dflash2.
 
 [preparation]
+# force_moe_decode_a16 = false    # Qwen Flash NVFP4: A16 decode/verify, calibrated A4 prefill.
 # compile_workers = 24           # Optional CPU process budget per host.
 # autotune_effort = "default"     # off, default, audit.
 # collective_tuning = "static"    # static, runtime; omitted uses the recipe default.
 
@@ -440,6 +440,31 @@ rectangular: the default catalog covers five drafts per request through batch 16
 and three drafts at batch 32. Already exported packages retain their captured
 capacities.
 
+`ignition export qwen3.8-flash --speculative-method dflash2` selects
+[`incoai/Qwen3.8-Flash-Next-DFlash2`](https://huggingface.co/incoai/Qwen3.8-Flash-Next-DFlash2)
+at revision `a22a1744e85c17364dcc54a6a420af7135d4c7f6` instead of the checkpoint's
+MTP module. Draft proposals use an eight-token block and up to seven verified
+drafts; the default remains five drafts and 128 target-token rows. The target
+captures completed zero-based layers 5, 15, 25, 35, and 45 after averaging its four
+hyperconnection streams. Five independent draft attention layers retain the last
+2,048 accepted target positions. These rings are included in continuation
+snapshots and restored with the target's GDN, QSA, PLE, and position state.
+Mixed prefill is rejected; separate prefill and verification graphs retain the
+same target arithmetic. `--online-mxfp8` converts the draft's eligible BF16
+projections, and `--draft-head-quantization nvfp4` or `mxfp8` prepares a separate
+proposal vocabulary head. Target weights retain checkpoint precision.
+
+`ignition export qwen3.8-flash --force-moe-decode-a16` prepares the NVFP4 target
+routed experts as one packed W4A16 weight owner. Decode and speculative
+verification use A16 at every row count; separate prefill graphs use calibrated
+A4 from the checkpoint activation scales. The option requires SM120/121 and
+rank-local intermediate width divisible by 64 (TP1/2); mixed prefill is rejected
+because its prompt and decode rows share one expert call. Shared experts and MTP
+retain their declared precision. `[preparation] force_moe_decode_a16 = true`
+sets the default, and `--no-force-moe-decode-a16` overrides it. Preparation records
+the resolved option in the plan and rebuild metadata; compatible weight reuse
+requires the packed layouts and activation scales prepared for that option.
+
 `ignition export qwen3.8-flash --gpus 0,1 --shard-hyperconnections` partitions
 the 320-wide hyperconnection bottleneck across ranks, including target and MTP
 final mixers. Each rank loads its down-projection rows and up-projection columns;
 
@@ -112,6 +112,8 @@ message RebuildManifest {
   string collective_tuning = 25;
   // Preparation-only offline geometry and runtime profile recommendations.
   string collective_ladder_json = 26;
+  // Preparation-only routed W4A16 decode/verification with calibrated A4 prefill.
+  bool force_moe_decode_a16 = 27;
 }
 message RebuildSpeculation {
   uint32 draft_tokens = 1;
@@ -126,6 +128,8 @@ message RebuildSpeculation {
   optional uint64 graph_budget = 10;
   // Preparation arithmetic and communication choice; serving replays captured graphs.
   bool vocabulary_parallel_sampling = 11;
+  // Preparation-only learned proposal method; serving replays captured graphs.
+  string method = 12;
 }
 // Views of retained prepared weight storage, with no additional payload copies.
 // Names are paths in the recipe's weight objects, not original checkpoint keys.
 
@@ -161,6 +161,8 @@ def _preparation_arguments(running, *, model_default="defaults.model"):
     speculative = running.add_argument_group("speculative decoding",
         "MTP flags configure speculative decoding, including DSpark and DFlash.\n"
         "Recipe defaults and limits: ignition export MODEL --help.")
+    speculative.add_argument("--speculative-method", choices=("mtp", "dflash2"),
+                          help="learned proposal method; supported choices and the default depend on MODEL")
     speculative.add_argument("--no-mtp", action="store_true",
                           help="disable multi-token speculation: load no draft model and decode one token"
                                " per step; cannot accompany other speculation flags")
@@ -179,13 +181,16 @@ def _preparation_arguments(running, *, model_default="defaults.model"):
                                " excludes mandatory width-one and ordinary graphs. Requires packed adaptive"
                                " learned speculation (default: see MODEL --help)")
     advanced = running.add_argument_group("advanced options")
+    advanced.add_argument("--force-moe-decode-a16", action=argparse.BooleanOptionalAction, default=None,
+                          help="use W4A16 target routed experts for decode and verification, with calibrated A4 prefill;"
+                               " requires Qwen3.8 Flash NVFP4 on SM120/121 and separate prefill graphs")
     advanced.add_argument("--native-dense-activations", action="store_true",
                           help="use quantized activations instead of auto precision for dense projections:"
                                " A8 for FP8 weights and A4 for FP4 weights; explicit recipe precision is retained")
     advanced.add_argument("--draft-head-quantization", choices=("nvfp4", "mxfp8"),
                           help="prepare a separate quantized vocabulary head for learned draft proposals;"
                                " target verification retains its precision (NVFP4: DeepSeek V4/V4.1;"
-                               " MXFP8: DeepSeek V4.1; both: Qwen3.8 dense with a BF16 checkpoint head;"
+                               " MXFP8: DeepSeek V4.1; both: Qwen3.8 dense and Flash Next DFlash2 with a BF16 checkpoint head;"
                                " default: checkpoint precision)")
     advanced.add_argument("--markov-head-quantization", choices=("nvfp4", "fp8"),
                           help="prepare the draft Markov transition projection as NVFP4"
@@ -235,7 +240,7 @@ def _preparation_arguments(running, *, model_default="defaults.model"):
                           help="store the recipe's eligible BF16 projections as MXFP8 while loading"
                                " (Kimi K3 KDA, MLA except batched key/value, shared"
                                " experts, MoE latent projections, and DSpark draft context, outputs and MLPs;"
-                               " Qwen3.8 dense target attention/MLPs and DFlash2 context, attention and MLPs;"
+                               " Qwen3.8 dense target attention/MLPs and DFlash2 context, attention and MLPs; Flash Next DFlash2 projections;"
                                " default: checkpoint precision)")
     advanced.add_argument("--language-model-only", action="store_true",
                           help="prepare no vision encoder and reject images; its weights and scratch become KV"
 
@@ -150,6 +150,7 @@ def run(args):
         compile_workers=args.compile_workers, tuning_gpus=args.tuning_gpus,
         autotune_effort=args.autotune_effort, collective_tuning=args.collective_tuning, collective_ladder=args.collective_ladder,
         lock_gpu_clocks=args.lock_gpu_clocks, native_dense_activations=args.native_dense_activations,
+        force_moe_decode_a16=args.force_moe_decode_a16,
         shard_hyperconnections=args.shard_hyperconnections, joint_tuning=args.joint_tuning,
         image_concurrency=args.image_concurrency, mixed_prefill=args.mixed_prefill,
         prompt_logprobs=args.prompt_logprobs, expert_scale_compression=args.expert_scale_compression,
@@ -221,7 +222,7 @@ def _measure(model, plan, configuration, settings, progress, *, compile_forwards
         "requested_max_concurrency": plan.concurrency, "prepared_request_capacity": max(settings.batches),
         "preparation": {key: preparation[key] for key in (
             "tensor_parallel", "prefill_chunk", "stream_overlap", "context_parallel",
-            "native_dense_activations", "autotune_effort", "collective_tuning", "collective_ladder", "compile_workers",
+            "native_dense_activations", "force_moe_decode_a16", "autotune_effort", "collective_tuning", "collective_ladder", "compile_workers",
             "speculative_token_capacity", "speculation", "expert_scale_compression", "mla_compute_mode",
             "online_mxfp8", "language_model_only")}}
 
 
@@ -21,20 +21,21 @@
     "publishing": {"signing_key": str, "namespace": str, "official_source": str},
     "server": {"host": str, "port": int, "api_key": str, "thinking_token_budget": int},
     "defaults": {"model": str, "max_concurrency": int, "image_concurrency": int,
-                 "speculative_token_capacity": int, "speculative_graph_budget": int},
+                 "speculative_token_capacity": int, "speculative_graph_budget": int, "speculative_method": str},
     "memory": {"reserve": str},
-    "preparation": {"compile_workers": int, "autotune_effort": str, "collective_tuning": str, "checkpoint_token_file": str},
+    "preparation": {"compile_workers": int, "autotune_effort": str, "collective_tuning": str, "checkpoint_token_file": str, "force_moe_decode_a16": bool},
     "prefix_cache": {"memory": str, "disk_limit": str, "drain_on_shutdown": str, "max_age": str},
     "paths": {"hub_cache": str, "kernel_cache": str, "package_cache": str, "export_staging": str,
               "prefix_cache": str, "cuda": str},
 }
 _MODEL_KEYS = {"max_concurrency": int, "image_concurrency": int,
-               "speculative_token_capacity": int, "speculative_graph_budget": int}
+               "speculative_token_capacity": int, "speculative_graph_budget": int, "speculative_method": str}
 # Empty prefix-cache values leave the decision to Flare, which derives them from the host.
 _BUILT_IN = {
     "server.host": "127.0.0.1", "server.port": 8000, "server.api_key": "",
     "server.thinking_token_budget": None,
     "memory.reserve": "0",
+    "preparation.force_moe_decode_a16": False,
     "preparation.compile_workers": 0,
     "preparation.autotune_effort": "default",
     "preparation.collective_tuning": None,
@@ -176,10 +177,12 @@ def write_initial(self, model: str, max_concurrency: int) -> None:
             f'# model = "{model}"',
             f"# max_concurrency = {max_concurrency}",
             '# image_concurrency = 4          # active image requests; bounded by max_concurrency',
+            '# speculative_method = "mtp"    # proposal method; Qwen Flash also supports dflash2',
             '# speculative_token_capacity = 8  # wider target graphs require batch * width within this limit',
             '# speculative_graph_budget = 64  # packed round graphs; excludes width-one and ordinary graphs',
             "", "[preparation]",
             '# compile_workers = 24           # CPU processes per host; default: automatic, bounded by memory',
+            '# force_moe_decode_a16 = false   # Qwen Flash NVFP4 decode/verify A16, calibrated A4 prefill',
             '# autotune_effort = "default"    # off, default, audit',
             '# collective_tuning = "static"  # static, runtime; omitted uses recipe default',
             "", "[memory]",
 
@@ -39,4 +39,5 @@ def speculation(settings, *, brief: bool = False) -> str:
     precision = " · " + ", ".join(heads) if heads else ""
     if brief:
         return depth + selection + precision + parallel
-    return f"{depth} per round · MTP module" + selection + precision + parallel
+    source = "DFlash2" if settings.method == "dflash2" else "MTP module"
+    return f"{depth} per round · {source}" + selection + precision + parallel
@@ -42,6 +42,8 @@ def recipe_help(model=None):
     speculation = recipe.speculation
     if speculation is not None:
         lines.extend((
+            *([] if speculation.method is None else [
+                f"  --speculative-method: {', '.join(dict.fromkeys((speculation.method, *recipe.speculative_methods)))}; default {speculation.method}"]),
             f"  --mtp-draft-tokens: 0..{recipe.max_draft_tokens}; default {speculation.draft_tokens}",
             f"  Verification: {'adaptive' if speculation.adaptive else 'fixed width'} by default;"
             " --no-mtp excludes draft weights and state.",