From a3c6646c6f4cb56ce14747b5c09426033106e372 Mon Sep 17 00:00:00 2001
From: functionstackx <47992694+functionstackx@users.noreply.github.com>
Date: Sun, 1 Nov 2026 08:05:06 +0000
Subject: [PATCH 01/14] feat(speedbench): collect GLM-5.3-Flash natural MTP
 acceptance

---
 .github/workflows/speedbench-al.yml           |  17 +-
 .../speedbench/glm53flash_fp8_b300_sglang.sh  |  29 ++
 inferencex-e2e/configs/runners.yaml           |   1 +
 inferencex-e2e/infx/bench/__main__.py         |   1 +
 inferencex-e2e/infx/bench/speedbench_al.py    | 303 ++++++++++++++++++
 .../infx/tests/bench/test_speedbench_al.py    |  95 ++++++
 6 files changed, 441 insertions(+), 5 deletions(-)
 create mode 100644 inferencex-e2e/benchmarks/single_node/speedbench/glm53flash_fp8_b300_sglang.sh
 create mode 100644 inferencex-e2e/infx/bench/speedbench_al.py
 create mode 100644 inferencex-e2e/infx/tests/bench/test_speedbench_al.py

diff --git a/.github/workflows/speedbench-al.yml b/.github/workflows/speedbench-al.yml
index e036c0c98c..16936d196d 100644
--- a/.github/workflows/speedbench-al.yml
+++ b/.github/workflows/speedbench-al.yml
@@ -19,13 +19,19 @@ on: # zizmor: ignore[concurrency-limits]
         type: string
         default: 'dsv4'
       framework:
-        description: "Serving framework; selects the <model-prefix>_fp4_b300_<framework>[_<collector-variant>].sh collector"
+        description: "Serving framework; selects the <model-prefix>_<precision>_b300_<framework>[_<collector-variant>].sh collector"
         required: false
         type: choice
         options: [vllm, sglang]
         default: 'vllm'
+      precision:
+        description: "Checkpoint precision; selects the collector and queue metadata"
+        required: false
+        type: choice
+        options: [fp4, fp8, bf16]
+        default: 'fp4'
       collector-variant:
-        description: "Collector variant suffix; non-empty selects <model-prefix>_fp4_b300_<framework>_<collector-variant>.sh (e.g. probabilistic_sample_method_block_rejection_sample_method)"
+        description: "Collector variant suffix; non-empty selects <model-prefix>_<precision>_b300_<framework>_<collector-variant>.sh"
         required: false
         type: string
         default: ''
@@ -97,7 +103,7 @@ env:
   HF_HUB_CACHE: '/mnt/hf_hub_cache/'
   MODEL: ${{ inputs.model }}
   MODEL_PREFIX: ${{ inputs.model-prefix }}
-  PRECISION: fp4
+  PRECISION: ${{ inputs.precision }}
   FRAMEWORK: ${{ inputs.framework }}
   EXP_NAME: ${{ inputs.model-prefix }}_speedbench
   IMAGE: ${{ inputs.image }}
@@ -155,11 +161,12 @@ jobs:
             --arg runner "$RUNNER" \
             --arg model_prefix "$MODEL_PREFIX" \
             --arg framework "$FRAMEWORK" \
+            --arg precision "$PRECISION" \
             '[{
               runner: $runner,
               framework: $framework,
               "model-prefix": $model_prefix,
-              precision: "fp4",
+              precision: $precision,
               "spec-decoding": "mtp"
             }]')
           scored=$(printf '%s' "$entry" |
@@ -250,7 +257,7 @@ jobs:
         run: |
           if [[ -f inferencex-e2e/configs/runners.yaml ]]; then cd inferencex-e2e; fi
           collector_dir=benchmarks/single_node/speedbench
-          collector="${MODEL_PREFIX}_fp4_b300_${FRAMEWORK}"
+          collector="${MODEL_PREFIX}_${PRECISION}_b300_${FRAMEWORK}"
           if [[ -n "$COLLECTOR_VARIANT" ]]; then
             collector+="_${COLLECTOR_VARIANT}"
           fi
diff --git a/inferencex-e2e/benchmarks/single_node/speedbench/glm53flash_fp8_b300_sglang.sh b/inferencex-e2e/benchmarks/single_node/speedbench/glm53flash_fp8_b300_sglang.sh
new file mode 100644
index 0000000000..7439d60583
--- /dev/null
+++ b/inferencex-e2e/benchmarks/single_node/speedbench/glm53flash_fp8_b300_sglang.sh
@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+set -eo pipefail
+repo_root="$(cd "$(dirname "$0")/../../.." && pwd)"
+source "$repo_root/benchmarks/check_env.sh"
+check_env_vars \
+    CATEGORY CHAT_TEMPLATE_KWARGS_ON EP_SIZE IMAGE MODEL MODEL_PATH MTP_LIST \
+    OUT_YAML PORT SPEEDBENCH_OUTPUT_LEN THINKING_MODES TP
+
+export PYTHONPATH="$repo_root${PYTHONPATH:+:$PYTHONPATH}"
+exec python3 -m infx.bench speedbench-al \
+    --concurrency 32 \
+    --temperature 1.0 \
+    --top-p 0.95 \
+    -- \
+    --tp-size "$TP" --ep-size "$EP_SIZE" \
+    --trust-remote-code \
+    --mem-fraction-static 0.80 \
+    --context-length 32768 \
+    --chunked-prefill-size 8192 \
+    --max-prefill-tokens 8192 \
+    --max-running-requests 32 \
+    --cuda-graph-max-bs 32 \
+    --kv-cache-dtype fp8_e4m3 \
+    --dsa-prefill-backend trtllm \
+    --dsa-decode-backend trtllm \
+    --moe-runner-backend flashinfer_trtllm \
+    --reasoning-parser glm45 \
+    --tool-call-parser glm47 \
+    --disable-radix-cache
diff --git a/inferencex-e2e/configs/runners.yaml b/inferencex-e2e/configs/runners.yaml
index c54e232edb..ff16164590 100644
--- a/inferencex-e2e/configs/runners.yaml
+++ b/inferencex-e2e/configs/runners.yaml
@@ -521,6 +521,7 @@ clusters:
         GLM-5.2-FP8: {root: scratch, dir: GLM-5.2-FP8}
         GLM-5.2-NVFP4: {root: scratch, dir: GLM-5.2-NVFP4}
         GLM-5.3-NVFP4: {root: scratch, dir: GLM-5.3-NVFP4}
+        GLM-5.3-Flash: {root: data-models, dir: GLM-5.3-Flash}
         Kimi-K3: {root: scratch, dir: Kimi-K3}
         MiniMax-M3: {root: scratch, dir: MiniMax-M3}
         MiniMax-M3-MXFP8: {root: scratch, dir: MiniMax-M3-MXFP8}
diff --git a/inferencex-e2e/infx/bench/__main__.py b/inferencex-e2e/infx/bench/__main__.py
index cb33a7ea8e..6ef5583aa1 100644
--- a/inferencex-e2e/infx/bench/__main__.py
+++ b/inferencex-e2e/infx/bench/__main__.py
@@ -13,6 +13,7 @@
     "fixed-seq": "infx.bench.fixed_seq",
     "agentic": "infx.bench.agentic.run",
     "eval": "infx.bench.eval",
+    "speedbench-al": "infx.bench.speedbench_al",
 }
 
 
diff --git a/inferencex-e2e/infx/bench/speedbench_al.py b/inferencex-e2e/infx/bench/speedbench_al.py
new file mode 100644
index 0000000000..7dd1c0acdd
--- /dev/null
+++ b/inferencex-e2e/infx/bench/speedbench_al.py
@@ -0,0 +1,303 @@
+from __future__ import annotations
+
+import argparse
+import contextlib
+import hashlib
+import importlib.metadata
+import json
+import math
+import os
+import signal
+import socket
+import subprocess
+import sys
+import tempfile
+import urllib.request
+from collections.abc import Mapping, Sequence
+from pathlib import Path
+
+from infx.bench import env, proc, server
+
+PREPARE_URL = (
+    "https://raw.githubusercontent.com/NVIDIA-NeMo/Skills/"
+    "bcf059af55c20a89f797724598f9908d126153e6/"
+    "nemo_skills/dataset/speed-bench/prepare.py"
+)
+
+
+def levels(value: str) -> list[int]:
+    parsed = [env.parse_positive_int("MTP_LIST", item) for item in value.split()]
+    if not parsed or len(parsed) != len(set(parsed)):
+        raise env.InputError("MTP_LIST must contain distinct positive integers")
+    return parsed
+
+
+def select_category(source: Path, destination: Path, category: str) -> int:
+    count = 0
+    with source.open(encoding="utf-8") as rows, destination.open("w", encoding="utf-8") as out:
+        for line in rows:
+            row = json.loads(line)
+            if row.get("category") != category:
+                continue
+            messages = row["messages"]
+            # SGLang's loader consumes only the first user turn; reject lossy conversion.
+            if (
+                len(messages) != 1
+                or messages[0]["role"] != "user"
+                or not isinstance(messages[0]["content"], str)
+                or not messages[0]["content"]
+            ):
+                raise env.BenchError("SPEED-Bench row must contain exactly one nonempty user turn")
+            out.write(json.dumps({"turns": [messages[0]["content"]]}) + "\n")
+            count += 1
+    if count == 0:
+        raise env.BenchError(f"No SPEED-Bench rows for category {category!r}")
+    return count
+
+
+def read_acceptance(path: Path, *, expected: int, mtp: int) -> float:
+    rows = [json.loads(line) for line in path.read_text(encoding="utf-8").splitlines() if line]
+    if len(rows) != 1:
+        raise env.BenchError(f"Expected one benchmark result in {path}, got {len(rows)}")
+    result = rows[0]
+    if result.get("completed") != expected or result.get("total_output_tokens", 0) <= 0:
+        raise env.BenchError(f"Incomplete SPEED-Bench result: {result.get('completed')}/{expected}")
+    value = result.get("accept_length")
+    if (
+        isinstance(value, bool)
+        or not isinstance(value, (int, float))
+        or not math.isfinite(value)
+        or not 1 <= value <= mtp + 1
+    ):
+        raise env.BenchError(f"Invalid acceptance length for MTP={mtp}: {value!r}")
+    return float(value)
+
+
+def prepare_dataset(directory: Path, category: str) -> tuple[Path, int]:
+    constraints = directory / "constraints.txt"
+    constraints.write_text(
+        "".join(
+            f"{name}=={importlib.metadata.version(name)}\n"
+            for name in ("huggingface-hub", "transformers", "tokenizers")
+        ),
+        encoding="utf-8",
+    )
+    run(
+        [
+            sys.executable,
+            "-m",
+            "pip",
+            "install",
+            "-q",
+            "-c",
+            str(constraints),
+            "datasets",
+            "tiktoken",
+        ]
+    )
+    prepare = directory / "prepare.py"
+    with urllib.request.urlopen(PREPARE_URL, timeout=60) as response:
+        prepare.write_bytes(response.read())
+    run([sys.executable, str(prepare), "--config", "qualitative", "--output_dir", str(directory)])
+    selected = directory / "selected.jsonl"
+    return selected, select_category(directory / "qualitative.jsonl", selected, category)
+
+
+def run(command: Sequence[str]) -> None:
+    code = proc.call(command)
+    if code:
+        raise env.BenchError(f"Command exited with status {code}: {command[0]}")
+
+
+def free_port(requested: int) -> int:
+    with socket.socket() as sock:
+        try:
+            sock.bind(("127.0.0.1", requested))
+        except OSError:
+            sock.bind(("127.0.0.1", 0))
+        return int(sock.getsockname()[1])
+
+
+def stop(child: subprocess.Popen[bytes]) -> None:
+    with contextlib.suppress(ProcessLookupError):
+        os.killpg(child.pid, signal.SIGTERM)
+    try:
+        child.wait(timeout=30)
+    except subprocess.TimeoutExpired:
+        pass
+    finally:
+        # The launcher can exit before its GPU workers.
+        with contextlib.suppress(ProcessLookupError):
+            os.killpg(child.pid, signal.SIGKILL)
+        child.wait()
+
+
+def collect_cell(
+    *,
+    model_path: str,
+    mtp: int,
+    port: int,
+    dataset: Path,
+    count: int,
+    output_len: int,
+    results: Path,
+    args: argparse.Namespace,
+) -> float:
+    command = [
+        sys.executable,
+        "-m",
+        "sglang.launch_server",
+        "--model-path",
+        model_path,
+        "--host",
+        "127.0.0.1",
+        "--port",
+        str(port),
+        *args.server_args,
+        "--speculative-algorithm",
+        "EAGLE",
+        "--speculative-num-steps",
+        str(mtp),
+        "--speculative-eagle-topk",
+        "1",
+        "--speculative-num-draft-tokens",
+        str(mtp + 1),
+    ]
+    log = results / f"server_on_mtp{mtp}.log"
+    result = results / f"speedbench_on_mtp{mtp}.jsonl"
+    result.unlink(missing_ok=True)
+    proc.echo(command)
+    with log.open("wb") as sink:
+        child = subprocess.Popen(
+            command, stdout=sink, stderr=subprocess.STDOUT, start_new_session=True
+        )
+        try:
+            server.wait_ready(f"http://127.0.0.1:{port}/health", pid=child.pid, log=log)
+            run(
+                [
+                    sys.executable,
+                    "-m",
+                    "sglang.bench_serving",
+                    "--backend",
+                    "sglang",
+                    "--host",
+                    "127.0.0.1",
+                    "--port",
+                    str(port),
+                    "--model",
+                    model_path,
+                    "--dataset-name",
+                    "speed-bench",
+                    "--dataset-path",
+                    str(dataset),
+                    "--speed-bench-output-len",
+                    str(output_len),
+                    "--num-prompts",
+                    str(count),
+                    "--max-concurrency",
+                    str(args.concurrency),
+                    "--temperature",
+                    str(args.temperature),
+                    "--top-p",
+                    str(args.top_p),
+                    # No warmup generations may contaminate server-wide acceptance counters.
+                    "--warmup-requests",
+                    "0",
+                    "--seed",
+                    "42",
+                    "--disable-ignore-eos",
+                    "--output-file",
+                    str(result),
+                    "--output-details",
+                ]
+            )
+            return read_acceptance(result, expected=count, mtp=mtp)
+        finally:
+            stop(child)
+
+
+def write_matrix(path: Path, model: str, values: Mapping[int, float], metadata: Path) -> None:
+    text = f"# Collection provenance: {metadata.name}\n{json.dumps(model.rsplit('/', 1)[-1].lower())}:\n"
+    text += "  thinking_on:\n"
+    text += "".join(f"    {level}: {value:.6f}\n" for level, value in values.items())
+    path.write_text(text, encoding="utf-8")
+
+
+def main(argv: list[str]) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--concurrency", type=int, required=True)
+    parser.add_argument("--temperature", type=float, required=True)
+    parser.add_argument("--top-p", type=float, required=True)
+    parser.add_argument("server_args", nargs=argparse.REMAINDER)
+    args = parser.parse_args(argv)
+    if args.server_args[:1] == ["--"]:
+        args.server_args = args.server_args[1:]
+    if args.concurrency < 1 or not args.temperature > 0 or not 0 < args.top_p <= 1:
+        raise env.InputError("Invalid concurrency or sampling parameters")
+    inputs = env.require(
+        "CATEGORY",
+        "CHAT_TEMPLATE_KWARGS_ON",
+        "IMAGE",
+        "MODEL",
+        "MODEL_PATH",
+        "MTP_LIST",
+        "OUT_YAML",
+        "PORT",
+        "SPEEDBENCH_OUTPUT_LEN",
+        "THINKING_MODES",
+    )
+    # The upstream SPEED-Bench loader cannot forward chat-template kwargs.
+    if inputs["THINKING_MODES"] != "on" or json.loads(inputs["CHAT_TEMPLATE_KWARGS_ON"]) != {}:
+        raise env.InputError(
+            "SGLang SPEED-Bench requires THINKING_MODES=on and CHAT_TEMPLATE_KWARGS_ON={}"
+        )
+    mtp_levels = levels(inputs["MTP_LIST"])
+    output_len = env.positive_int("SPEEDBENCH_OUTPUT_LEN")
+    requested_port = env.positive_int("PORT")
+    model = Path(inputs["MODEL_PATH"])
+    if not (model / "config.json").is_file():
+        raise env.BenchError(
+            f"Staged checkpoint missing: {model / 'config.json'}; no download attempted"
+        )
+    out = Path(inputs["OUT_YAML"])
+    out.unlink(missing_ok=True)
+    results = out.parent / "speedbench_results"
+    results.mkdir(exist_ok=True)
+    metadata = results / "speedbench_provenance.json"
+    with tempfile.TemporaryDirectory(prefix="infx-speedbench-") as temp:
+        dataset, count = prepare_dataset(Path(temp), inputs["CATEGORY"])
+        provenance = {
+            "inputs": inputs,
+            "server_args": args.server_args,
+            "concurrency": args.concurrency,
+            "temperature": args.temperature,
+            "top_p": args.top_p,
+            "thinking": "chat template default; reasoning_effort=max for GLM-5.3-Flash",
+            "draft": "embedded MTP, upstream checkpoint-default precision",
+            "verification": "standard (no block or synthetic acceptance flags)",
+            "prepare_url": PREPARE_URL,
+            "num_prompts": count,
+            "dataset_sha256": hashlib.sha256(dataset.read_bytes()).hexdigest(),
+            "config_sha256": hashlib.sha256((model / "config.json").read_bytes()).hexdigest(),
+            "sglang_version": importlib.metadata.version("sglang"),
+            "complete": False,
+        }
+        metadata.write_text(json.dumps(provenance, indent=2) + "\n", encoding="utf-8")
+        values: dict[int, float] = {}
+        for mtp in mtp_levels:
+            print(f"Collecting thinking=on MTP={mtp}, {count} prompts", flush=True)
+            values[mtp] = collect_cell(
+                model_path=str(model),
+                mtp=mtp,
+                port=free_port(requested_port),
+                dataset=dataset,
+                count=count,
+                output_len=output_len,
+                results=results,
+                args=args,
+            )
+            write_matrix(out, inputs["MODEL"], values, metadata)
+            print(f"MTP={mtp}: AL={values[mtp]:.6f}", flush=True)
+        provenance["complete"] = True
+        metadata.write_text(json.dumps(provenance, indent=2) + "\n", encoding="utf-8")
+    return 0
diff --git a/inferencex-e2e/infx/tests/bench/test_speedbench_al.py b/inferencex-e2e/infx/tests/bench/test_speedbench_al.py
new file mode 100644
index 0000000000..a1afcd8a75
--- /dev/null
+++ b/inferencex-e2e/infx/tests/bench/test_speedbench_al.py
@@ -0,0 +1,95 @@
+import json
+
+import pytest
+import yaml
+
+from infx.bench.env import BenchError, InputError
+from infx.bench.speedbench_al import levels, read_acceptance, select_category, write_matrix
+
+
+def test_select_category_preserves_all_matching_prompts(tmp_path):
+    source = tmp_path / "source.jsonl"
+    source.write_text(
+        "\n".join(
+            json.dumps(
+                {
+                    "category": category,
+                    "messages": [{"role": "user", "content": content}],
+                }
+            )
+            for category, content in [("coding", "one"), ("math", "two"), ("coding", "three")]
+        )
+    )
+    destination = tmp_path / "selected.jsonl"
+    assert select_category(source, destination, "coding") == 2
+    assert [json.loads(row) for row in destination.read_text().splitlines()] == [
+        {"turns": ["one"]},
+        {"turns": ["three"]},
+    ]
+    with pytest.raises(BenchError, match="No SPEED-Bench"):
+        select_category(source, destination, "missing")
+
+
+@pytest.mark.parametrize(
+    "messages",
+    [
+        [],
+        [{"role": "system", "content": "instruction"}, {"role": "user", "content": "question"}],
+        [{"role": "user", "content": ""}],
+        [{"role": "user", "content": ["multimodal"]}],
+    ],
+)
+def test_select_category_rejects_lossy_conversion(tmp_path, messages):
+    source = tmp_path / "source.jsonl"
+    source.write_text(json.dumps({"category": "coding", "messages": messages}))
+    with pytest.raises(BenchError, match="exactly one"):
+        select_category(source, tmp_path / "selected.jsonl", "coding")
+
+
+def test_acceptance_and_matrix(tmp_path):
+    result = tmp_path / "result.jsonl"
+    result.write_text(
+        json.dumps({"completed": 20, "total_output_tokens": 100, "accept_length": 2.3456789})
+    )
+    value = read_acceptance(result, expected=20, mtp=3)
+    matrix = tmp_path / "matrix.yaml"
+    write_matrix(matrix, "zai-org/GLM-5.3-Flash", {3: value}, tmp_path / "provenance.json")
+    assert yaml.safe_load(matrix.read_text()) == {"glm-5.3-flash": {"thinking_on": {3: 2.345679}}}
+
+
+@pytest.mark.parametrize(
+    "updates",
+    [
+        {"completed": 19},
+        {"total_output_tokens": 0},
+        {"accept_length": None},
+        {"accept_length": "N/A"},
+        {"accept_length": float("nan")},
+        {"accept_length": float("inf")},
+        {"accept_length": True},
+        {"accept_length": 0.99},
+        {"accept_length": 4.01},
+    ],
+)
+def test_reject_incomplete_or_invalid_measurements(tmp_path, updates):
+    result = tmp_path / "result.jsonl"
+    result.write_text(
+        json.dumps({"completed": 20, "total_output_tokens": 100, "accept_length": 2.5} | updates)
+    )
+    with pytest.raises(BenchError):
+        read_acceptance(result, expected=20, mtp=3)
+
+
+@pytest.mark.parametrize("content", ["", "{}\n{}\n"])
+def test_reject_missing_or_stale_results(tmp_path, content):
+    result = tmp_path / "result.jsonl"
+    result.write_text(content)
+    with pytest.raises(BenchError, match="Expected one"):
+        read_acceptance(result, expected=20, mtp=3)
+
+
+def test_levels():
+    assert levels("1 3 8") == [1, 3, 8]
+    for invalid in ("", "1 1", "0", "-1", "a"):
+        with pytest.raises(InputError):
+            levels(invalid)

From 8ea3013a89b3f5fdd4de7c58c31d484ec948798c Mon Sep 17 00:00:00 2001
From: functionstackx <47992694+functionstackx@users.noreply.github.com>
Date: Sun, 1 Nov 2026 08:09:31 +0000
Subject: [PATCH 02/14] fix(speedbench): use vLLM B300 for GLM-5.3-Flash
 collection

---
 .../speedbench/glm53flash_fp8_b300_sglang.sh  |  29 -----
 .../speedbench/glm53flash_fp8_b300_vllm.sh    |  27 +++++
 inferencex-e2e/infx/bench/speedbench_al.py    | 100 +++++++++++-------
 .../infx/tests/bench/test_speedbench_al.py    |  48 ++++++---
 4 files changed, 122 insertions(+), 82 deletions(-)
 delete mode 100644 inferencex-e2e/benchmarks/single_node/speedbench/glm53flash_fp8_b300_sglang.sh
 create mode 100644 inferencex-e2e/benchmarks/single_node/speedbench/glm53flash_fp8_b300_vllm.sh

diff --git a/inferencex-e2e/benchmarks/single_node/speedbench/glm53flash_fp8_b300_sglang.sh b/inferencex-e2e/benchmarks/single_node/speedbench/glm53flash_fp8_b300_sglang.sh
deleted file mode 100644
index 7439d60583..0000000000
--- a/inferencex-e2e/benchmarks/single_node/speedbench/glm53flash_fp8_b300_sglang.sh
+++ /dev/null
@@ -1,29 +0,0 @@
-#!/usr/bin/env bash
-set -eo pipefail
-repo_root="$(cd "$(dirname "$0")/../../.." && pwd)"
-source "$repo_root/benchmarks/check_env.sh"
-check_env_vars \
-    CATEGORY CHAT_TEMPLATE_KWARGS_ON EP_SIZE IMAGE MODEL MODEL_PATH MTP_LIST \
-    OUT_YAML PORT SPEEDBENCH_OUTPUT_LEN THINKING_MODES TP
-
-export PYTHONPATH="$repo_root${PYTHONPATH:+:$PYTHONPATH}"
-exec python3 -m infx.bench speedbench-al \
-    --concurrency 32 \
-    --temperature 1.0 \
-    --top-p 0.95 \
-    -- \
-    --tp-size "$TP" --ep-size "$EP_SIZE" \
-    --trust-remote-code \
-    --mem-fraction-static 0.80 \
-    --context-length 32768 \
-    --chunked-prefill-size 8192 \
-    --max-prefill-tokens 8192 \
-    --max-running-requests 32 \
-    --cuda-graph-max-bs 32 \
-    --kv-cache-dtype fp8_e4m3 \
-    --dsa-prefill-backend trtllm \
-    --dsa-decode-backend trtllm \
-    --moe-runner-backend flashinfer_trtllm \
-    --reasoning-parser glm45 \
-    --tool-call-parser glm47 \
-    --disable-radix-cache
diff --git a/inferencex-e2e/benchmarks/single_node/speedbench/glm53flash_fp8_b300_vllm.sh b/inferencex-e2e/benchmarks/single_node/speedbench/glm53flash_fp8_b300_vllm.sh
new file mode 100644
index 0000000000..088c65a168
--- /dev/null
+++ b/inferencex-e2e/benchmarks/single_node/speedbench/glm53flash_fp8_b300_vllm.sh
@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+set -eo pipefail
+repo_root="$(cd "$(dirname "$0")/../../.." && pwd)"
+source "$repo_root/benchmarks/check_env.sh"
+check_env_vars \
+    CATEGORY CHAT_TEMPLATE_KWARGS_ON IMAGE MODEL MODEL_PATH MTP_LIST \
+    OUT_YAML PORT SPEEDBENCH_OUTPUT_LEN THINKING_MODES TP
+
+export PYTHONPATH="$repo_root${PYTHONPATH:+:$PYTHONPATH}"
+export VLLM_ENGINE_READY_TIMEOUT_S=3600
+export VLLM_USE_RUST_FRONTEND=0
+exec python3 -m infx.bench speedbench-al \
+    --concurrency 1 \
+    --temperature 1.0 \
+    --top-p 0.95 \
+    -- \
+    --tensor-parallel-size "$TP" --data-parallel-size 1 \
+    --trust-remote-code \
+    --gpu-memory-utilization 0.80 \
+    --max-model-len 32768 \
+    --max-num-batched-tokens 8192 \
+    --max-num-seqs 32 \
+    --kv-cache-dtype fp8 \
+    --tokenizer-mode auto \
+    --reasoning-parser glm47 \
+    --chat-template-content-format string \
+    --no-enable-prefix-caching
diff --git a/inferencex-e2e/infx/bench/speedbench_al.py b/inferencex-e2e/infx/bench/speedbench_al.py
index 7dd1c0acdd..e1dd7dff41 100644
--- a/inferencex-e2e/infx/bench/speedbench_al.py
+++ b/inferencex-e2e/infx/bench/speedbench_al.py
@@ -40,7 +40,7 @@ def select_category(source: Path, destination: Path, category: str) -> int:
             if row.get("category") != category:
                 continue
             messages = row["messages"]
-            # SGLang's loader consumes only the first user turn; reject lossy conversion.
+            # Coding collection is single-turn; do not silently flatten conversations.
             if (
                 len(messages) != 1
                 or messages[0]["role"] != "user"
@@ -48,7 +48,7 @@ def select_category(source: Path, destination: Path, category: str) -> int:
                 or not messages[0]["content"]
             ):
                 raise env.BenchError("SPEED-Bench row must contain exactly one nonempty user turn")
-            out.write(json.dumps({"turns": [messages[0]["content"]]}) + "\n")
+            out.write(json.dumps(row) + "\n")
             count += 1
     if count == 0:
         raise env.BenchError(f"No SPEED-Bench rows for category {category!r}")
@@ -56,13 +56,17 @@ def select_category(source: Path, destination: Path, category: str) -> int:
 
 
 def read_acceptance(path: Path, *, expected: int, mtp: int) -> float:
-    rows = [json.loads(line) for line in path.read_text(encoding="utf-8").splitlines() if line]
-    if len(rows) != 1:
-        raise env.BenchError(f"Expected one benchmark result in {path}, got {len(rows)}")
-    result = rows[0]
-    if result.get("completed") != expected or result.get("total_output_tokens", 0) <= 0:
+    try:
+        result = json.loads(path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError as error:
+        raise env.BenchError(f"Expected one benchmark result in {path}") from error
+    if (
+        result.get("completed") != expected
+        or result.get("failed", 0) != 0
+        or result.get("total_output_tokens", 0) <= 0
+    ):
         raise env.BenchError(f"Incomplete SPEED-Bench result: {result.get('completed')}/{expected}")
-    value = result.get("accept_length")
+    value = result.get("spec_decode_acceptance_length")
     if (
         isinstance(value, bool)
         or not isinstance(value, (int, float))
@@ -70,6 +74,16 @@ def read_acceptance(path: Path, *, expected: int, mtp: int) -> float:
         or not 1 <= value <= mtp + 1
     ):
         raise env.BenchError(f"Invalid acceptance length for MTP={mtp}: {value!r}")
+    drafts = result.get("spec_decode_num_drafts")
+    accepted = result.get("spec_decode_accepted_tokens")
+    if (
+        type(drafts) is not int
+        or drafts <= 0
+        or type(accepted) is not int
+        or not 0 <= accepted <= mtp * drafts
+        or not math.isclose(value, 1 + accepted / drafts, rel_tol=1e-9)
+    ):
+        raise env.BenchError("Missing or inconsistent speculative decoding counter deltas")
     return float(value)
 
 
@@ -100,7 +114,10 @@ def prepare_dataset(directory: Path, category: str) -> tuple[Path, int]:
         prepare.write_bytes(response.read())
     run([sys.executable, str(prepare), "--config", "qualitative", "--output_dir", str(directory)])
     selected = directory / "selected.jsonl"
-    return selected, select_category(directory / "qualitative.jsonl", selected, category)
+    dataset = directory / "qualitative.jsonl"
+    count = select_category(dataset, selected, category)
+    selected.replace(dataset)
+    return dataset, count
 
 
 def run(command: Sequence[str]) -> None:
@@ -144,27 +161,19 @@ def collect_cell(
     args: argparse.Namespace,
 ) -> float:
     command = [
-        sys.executable,
-        "-m",
-        "sglang.launch_server",
-        "--model-path",
+        "vllm",
+        "serve",
         model_path,
         "--host",
         "127.0.0.1",
         "--port",
         str(port),
         *args.server_args,
-        "--speculative-algorithm",
-        "EAGLE",
-        "--speculative-num-steps",
-        str(mtp),
-        "--speculative-eagle-topk",
-        "1",
-        "--speculative-num-draft-tokens",
-        str(mtp + 1),
+        "--speculative-config",
+        json.dumps({"method": "mtp", "num_speculative_tokens": mtp}),
     ]
     log = results / f"server_on_mtp{mtp}.log"
-    result = results / f"speedbench_on_mtp{mtp}.jsonl"
+    result = results / f"speedbench_on_mtp{mtp}.json"
     result.unlink(missing_ok=True)
     proc.echo(command)
     with log.open("wb") as sink:
@@ -175,11 +184,11 @@ def collect_cell(
             server.wait_ready(f"http://127.0.0.1:{port}/health", pid=child.pid, log=log)
             run(
                 [
-                    sys.executable,
-                    "-m",
-                    "sglang.bench_serving",
+                    "vllm",
+                    "bench",
+                    "serve",
                     "--backend",
-                    "sglang",
+                    "vllm",
                     "--host",
                     "127.0.0.1",
                     "--port",
@@ -187,28 +196,35 @@ def collect_cell(
                     "--model",
                     model_path,
                     "--dataset-name",
-                    "speed-bench",
+                    "speed_bench",
                     "--dataset-path",
-                    str(dataset),
+                    str(dataset.parent),
                     "--speed-bench-output-len",
                     str(output_len),
                     "--num-prompts",
-                    str(count),
+                    "-1",
                     "--max-concurrency",
                     str(args.concurrency),
                     "--temperature",
                     str(args.temperature),
                     "--top-p",
                     str(args.top_p),
-                    # No warmup generations may contaminate server-wide acceptance counters.
-                    "--warmup-requests",
+                    "--chat-template-kwargs",
+                    os.environ["CHAT_TEMPLATE_KWARGS_ON"],
+                    "--trust-remote-code",
+                    # vLLM records counter deltas around the formal request window.
+                    "--num-warmups",
+                    "0",
+                    "--ready-check-timeout-sec",
                     "0",
                     "--seed",
                     "42",
-                    "--disable-ignore-eos",
-                    "--output-file",
-                    str(result),
-                    "--output-details",
+                    "--save-result",
+                    "--save-detailed",
+                    "--result-dir",
+                    str(results),
+                    "--result-filename",
+                    result.name,
                 ]
             )
             return read_acceptance(result, expected=count, mtp=mtp)
@@ -246,10 +262,13 @@ def main(argv: list[str]) -> int:
         "SPEEDBENCH_OUTPUT_LEN",
         "THINKING_MODES",
     )
-    # The upstream SPEED-Bench loader cannot forward chat-template kwargs.
-    if inputs["THINKING_MODES"] != "on" or json.loads(inputs["CHAT_TEMPLATE_KWARGS_ON"]) != {}:
+    # GLM-5.3-Flash always thinks; enable_thinking=false does not disable it.
+    if inputs["THINKING_MODES"] != "on" or json.loads(inputs["CHAT_TEMPLATE_KWARGS_ON"]) not in (
+        {},
+        {"reasoning_effort": "max"},
+    ):
         raise env.InputError(
-            "SGLang SPEED-Bench requires THINKING_MODES=on and CHAT_TEMPLATE_KWARGS_ON={}"
+            "GLM-5.3-Flash collection requires THINKING_MODES=on and max reasoning effort"
         )
     mtp_levels = levels(inputs["MTP_LIST"])
     output_len = env.positive_int("SPEEDBENCH_OUTPUT_LEN")
@@ -272,14 +291,15 @@ def main(argv: list[str]) -> int:
             "concurrency": args.concurrency,
             "temperature": args.temperature,
             "top_p": args.top_p,
-            "thinking": "chat template default; reasoning_effort=max for GLM-5.3-Flash",
+            "thinking": "reasoning_effort=max for GLM-5.3-Flash",
             "draft": "embedded MTP, upstream checkpoint-default precision",
             "verification": "standard (no block or synthetic acceptance flags)",
             "prepare_url": PREPARE_URL,
             "num_prompts": count,
             "dataset_sha256": hashlib.sha256(dataset.read_bytes()).hexdigest(),
             "config_sha256": hashlib.sha256((model / "config.json").read_bytes()).hexdigest(),
-            "sglang_version": importlib.metadata.version("sglang"),
+            "vllm_version": importlib.metadata.version("vllm"),
+            "frontend": os.environ.get("VLLM_USE_RUST_FRONTEND"),
             "complete": False,
         }
         metadata.write_text(json.dumps(provenance, indent=2) + "\n", encoding="utf-8")
diff --git a/inferencex-e2e/infx/tests/bench/test_speedbench_al.py b/inferencex-e2e/infx/tests/bench/test_speedbench_al.py
index a1afcd8a75..1d868ddeea 100644
--- a/inferencex-e2e/infx/tests/bench/test_speedbench_al.py
+++ b/inferencex-e2e/infx/tests/bench/test_speedbench_al.py
@@ -23,8 +23,8 @@ def test_select_category_preserves_all_matching_prompts(tmp_path):
     destination = tmp_path / "selected.jsonl"
     assert select_category(source, destination, "coding") == 2
     assert [json.loads(row) for row in destination.read_text().splitlines()] == [
-        {"turns": ["one"]},
-        {"turns": ["three"]},
+        {"category": "coding", "messages": [{"role": "user", "content": "one"}]},
+        {"category": "coding", "messages": [{"role": "user", "content": "three"}]},
     ]
     with pytest.raises(BenchError, match="No SPEED-Bench"):
         select_category(source, destination, "missing")
@@ -47,9 +47,17 @@ def test_select_category_rejects_lossy_conversion(tmp_path, messages):
 
 
 def test_acceptance_and_matrix(tmp_path):
-    result = tmp_path / "result.jsonl"
+    result = tmp_path / "result.json"
     result.write_text(
-        json.dumps({"completed": 20, "total_output_tokens": 100, "accept_length": 2.3456789})
+        json.dumps(
+            {
+                "completed": 20,
+                "total_output_tokens": 100,
+                "spec_decode_acceptance_length": 2.3456789,
+                "spec_decode_num_drafts": 10000000,
+                "spec_decode_accepted_tokens": 13456789,
+            }
+        )
     )
     value = read_acceptance(result, expected=20, mtp=3)
     matrix = tmp_path / "matrix.yaml"
@@ -62,19 +70,33 @@ def test_acceptance_and_matrix(tmp_path):
     [
         {"completed": 19},
         {"total_output_tokens": 0},
-        {"accept_length": None},
-        {"accept_length": "N/A"},
-        {"accept_length": float("nan")},
-        {"accept_length": float("inf")},
-        {"accept_length": True},
-        {"accept_length": 0.99},
-        {"accept_length": 4.01},
+        {"failed": 1},
+        {"spec_decode_acceptance_length": None},
+        {"spec_decode_acceptance_length": "N/A"},
+        {"spec_decode_acceptance_length": float("nan")},
+        {"spec_decode_acceptance_length": float("inf")},
+        {"spec_decode_acceptance_length": True},
+        {"spec_decode_acceptance_length": 0.99},
+        {"spec_decode_acceptance_length": 4.01},
+        {"spec_decode_num_drafts": 0},
+        {"spec_decode_num_drafts": None},
+        {"spec_decode_accepted_tokens": -1},
+        {"spec_decode_accepted_tokens": 301},
     ],
 )
 def test_reject_incomplete_or_invalid_measurements(tmp_path, updates):
-    result = tmp_path / "result.jsonl"
+    result = tmp_path / "result.json"
     result.write_text(
-        json.dumps({"completed": 20, "total_output_tokens": 100, "accept_length": 2.5} | updates)
+        json.dumps(
+            {
+                "completed": 20,
+                "total_output_tokens": 100,
+                "spec_decode_acceptance_length": 2.5,
+                "spec_decode_num_drafts": 200,
+                "spec_decode_accepted_tokens": 300,
+            }
+            | updates
+        )
     )
     with pytest.raises(BenchError):
         read_acceptance(result, expected=20, mtp=3)

From 7e8ca71fa27bc2a70324b9fe978f8deefed8c332 Mon Sep 17 00:00:00 2001
From: functionstackx <47992694+functionstackx@users.noreply.github.com>
Date: Sun, 1 Nov 2026 08:20:48 +0000
Subject: [PATCH 03/14] fix(speedbench): preserve multi-turn rows and drain GPU
 workers

---
 inferencex-e2e/infx/bench/speedbench_al.py    | 29 ++++++++++++--
 .../infx/tests/bench/test_speedbench_al.py    | 38 ++++++++++++++++++-
 2 files changed, 62 insertions(+), 5 deletions(-)

diff --git a/inferencex-e2e/infx/bench/speedbench_al.py b/inferencex-e2e/infx/bench/speedbench_al.py
index e1dd7dff41..291fe9eed6 100644
--- a/inferencex-e2e/infx/bench/speedbench_al.py
+++ b/inferencex-e2e/infx/bench/speedbench_al.py
@@ -12,6 +12,7 @@
 import subprocess
 import sys
 import tempfile
+import time
 import urllib.request
 from collections.abc import Mapping, Sequence
 from pathlib import Path
@@ -40,14 +41,14 @@ def select_category(source: Path, destination: Path, category: str) -> int:
             if row.get("category") != category:
                 continue
             messages = row["messages"]
-            # Coding collection is single-turn; do not silently flatten conversations.
+            # vLLM samples the first turn of each row, including multi-turn rows.
             if (
-                len(messages) != 1
+                not messages
                 or messages[0]["role"] != "user"
                 or not isinstance(messages[0]["content"], str)
                 or not messages[0]["content"]
             ):
-                raise env.BenchError("SPEED-Bench row must contain exactly one nonempty user turn")
+                raise env.BenchError("SPEED-Bench row must start with a nonempty text user turn")
             out.write(json.dumps(row) + "\n")
             count += 1
     if count == 0:
@@ -147,6 +148,24 @@ def stop(child: subprocess.Popen[bytes]) -> None:
         with contextlib.suppress(ProcessLookupError):
             os.killpg(child.pid, signal.SIGKILL)
         child.wait()
+    wait_gpu_idle()
+
+
+def wait_gpu_idle() -> None:
+    # Reaping the launcher does not wait for TP workers to release their CUDA contexts.
+    deadline = time.monotonic() + 120
+    while True:
+        output = subprocess.check_output(
+            ["nvidia-smi", "--query-gpu=memory.used", "--format=csv,noheader,nounits"],
+            text=True,
+            timeout=10,
+        )
+        used = [int(line.strip()) for line in output.splitlines() if line.strip()]
+        if used and max(used) < 2000:
+            return
+        if time.monotonic() >= deadline:
+            raise env.BenchError(f"GPU memory did not drain after server shutdown: {used} MiB")
+        time.sleep(3)
 
 
 def collect_cell(
@@ -296,6 +315,10 @@ def main(argv: list[str]) -> int:
             "verification": "standard (no block or synthetic acceptance flags)",
             "prepare_url": PREPARE_URL,
             "num_prompts": count,
+            "prompt_selection": "upstream vLLM SPEED-Bench: first user turn of each category row",
+            "rows_with_followup_turns": sum(
+                len(json.loads(line)["messages"]) > 1 for line in dataset.read_text().splitlines()
+            ),
             "dataset_sha256": hashlib.sha256(dataset.read_bytes()).hexdigest(),
             "config_sha256": hashlib.sha256((model / "config.json").read_bytes()).hexdigest(),
             "vllm_version": importlib.metadata.version("vllm"),
diff --git a/inferencex-e2e/infx/tests/bench/test_speedbench_al.py b/inferencex-e2e/infx/tests/bench/test_speedbench_al.py
index 1d868ddeea..e1a8279550 100644
--- a/inferencex-e2e/infx/tests/bench/test_speedbench_al.py
+++ b/inferencex-e2e/infx/tests/bench/test_speedbench_al.py
@@ -3,6 +3,7 @@
 import pytest
 import yaml
 
+from infx.bench import speedbench_al
 from infx.bench.env import BenchError, InputError
 from infx.bench.speedbench_al import levels, read_acceptance, select_category, write_matrix
 
@@ -39,13 +40,46 @@ def test_select_category_preserves_all_matching_prompts(tmp_path):
         [{"role": "user", "content": ["multimodal"]}],
     ],
 )
-def test_select_category_rejects_lossy_conversion(tmp_path, messages):
+def test_select_category_rejects_invalid_first_turn(tmp_path, messages):
     source = tmp_path / "source.jsonl"
     source.write_text(json.dumps({"category": "coding", "messages": messages}))
-    with pytest.raises(BenchError, match="exactly one"):
+    with pytest.raises(BenchError, match="start with"):
         select_category(source, tmp_path / "selected.jsonl", "coding")
 
 
+def test_select_category_preserves_multiturn_rows_for_native_vllm_loader(tmp_path):
+    source = tmp_path / "source.jsonl"
+    row = {
+        "category": "coding",
+        "messages": [
+            {"role": "user", "content": "Write a parser"},
+            {"role": "user", "content": "Add error handling"},
+        ],
+    }
+    source.write_text(json.dumps(row))
+    destination = tmp_path / "selected.jsonl"
+    assert select_category(source, destination, "coding") == 1
+    assert json.loads(destination.read_text()) == row
+
+
+def test_wait_gpu_idle_waits_for_workers(monkeypatch):
+    readings = iter(["15000\n16000\n", "1000\n1900\n"])
+    monkeypatch.setattr(speedbench_al.subprocess, "check_output", lambda *a, **kw: next(readings))
+    waits = []
+    monkeypatch.setattr(speedbench_al.time, "sleep", waits.append)
+    speedbench_al.wait_gpu_idle()
+    assert waits == [3]
+
+
+@pytest.mark.parametrize("output", ["", "3000\n4000\n"])
+def test_wait_gpu_idle_fails_closed(monkeypatch, output):
+    monkeypatch.setattr(speedbench_al.subprocess, "check_output", lambda *a, **kw: output)
+    clock = iter([0, 121])
+    monkeypatch.setattr(speedbench_al.time, "monotonic", lambda: next(clock))
+    with pytest.raises(BenchError, match="did not drain"):
+        speedbench_al.wait_gpu_idle()
+
+
 def test_acceptance_and_matrix(tmp_path):
     result = tmp_path / "result.json"
     result.write_text(

From 48627c4a3b8157789edff95972247e39716aacc2 Mon Sep 17 00:00:00 2001
From: functionstackx <47992694+functionstackx@users.noreply.github.com>
Date: Sun, 1 Nov 2026 11:05:02 +0000
Subject: [PATCH 04/14] feat(golden-al): commit measured GLM-5.3-Flash MTP
 curve

---
 .../golden_al_distribution/glm5.3flash_mtp.yaml     | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 inferencex-e2e/infx/golden_al_distribution/glm5.3flash_mtp.yaml

diff --git a/inferencex-e2e/infx/golden_al_distribution/glm5.3flash_mtp.yaml b/inferencex-e2e/infx/golden_al_distribution/glm5.3flash_mtp.yaml
new file mode 100644
index 0000000000..8216550753
--- /dev/null
+++ b/inferencex-e2e/infx/golden_al_distribution/glm5.3flash_mtp.yaml
@@ -0,0 +1,13 @@
+# Source GitHub Actions run: https://github.com/SemiAnalysisAI/InferenceX/actions/runs/41288481245
+# SPEED-Bench coding, 80 first-user-turn prompts, concurrency 1, max reasoning effort.
+# vLLM B300 TP8, temperature 1.0, top_p 0.95, natural EOS, output cap 4096.
+glm-5.3-flash:
+  thinking_on:
+    1: 1.858382
+    2: 2.518506
+    3: 3.004589
+    4: 3.349344
+    5: 3.603536
+    6: 3.790803
+    7: 3.925358
+    8: 3.992497

From 12eea95ef965295bd2dc0baf0cbb06f018a486fd Mon Sep 17 00:00:00 2001
From: functionstackx <47992694+functionstackx@users.noreply.github.com>
Date: Sun, 1 Nov 2026 11:09:10 +0000
Subject: [PATCH 05/14] fix(ci): allow authorized sweeps on stacked pull
 requests

---
 .github/workflows/README.md     | 2 +-
 .github/workflows/run-sweep.yml | 2 --
 2 files changed, 1 insertion(+), 3 deletions(-)

diff --git a/.github/workflows/README.md b/.github/workflows/README.md
index 1822672c27..a3b9d45166 100644
--- a/.github/workflows/README.md
+++ b/.github/workflows/README.md
@@ -162,7 +162,7 @@ test-config --config-keys dsr1-fp8-h200-sglang --evals-only --all-evals --config
 
 ## PR Sweep Labels
 
-`run-sweep.yml` sweeps only same-repository PRs that change
+`run-sweep.yml` sweeps only same-repository PRs, including stacked PRs, that change
 `inferencex-e2e/perf-changelog.yaml`, using the appended entries as the matrix.
 Apply exactly one primary label, normally `full-sweep-fail-fast`.
 Fork PRs use the [trusted dispatch](#trusted-external-fork-sweep-dispatch-poc).
diff --git a/.github/workflows/run-sweep.yml b/.github/workflows/run-sweep.yml
index 19f6d4d2c6..03842620bf 100644
--- a/.github/workflows/run-sweep.yml
+++ b/.github/workflows/run-sweep.yml
@@ -18,8 +18,6 @@ concurrency:
 
 on:
     pull_request:
-        branches:
-            - main
         types:
             - synchronize
             - labeled

From d49bdf1d416b420b4a3b45e029b75955c3fce53f Mon Sep 17 00:00:00 2001
From: functionstackx <47992694+functionstackx@users.noreply.github.com>
Date: Sun, 1 Nov 2026 11:10:32 +0000
Subject: [PATCH 06/14] fix(bench): preserve golden acceptance precision in
 native overrides

---
 .../infx/srt_slurm/synthetic_acceptance.py    |  8 ++---
 .../srt_slurm/test_synthetic_acceptance.py    | 36 +++++++++++++++++++
 2 files changed, 40 insertions(+), 4 deletions(-)

diff --git a/inferencex-e2e/infx/srt_slurm/synthetic_acceptance.py b/inferencex-e2e/infx/srt_slurm/synthetic_acceptance.py
index e7da9b72bb..7ae0f9f9ae 100644
--- a/inferencex-e2e/infx/srt_slurm/synthetic_acceptance.py
+++ b/inferencex-e2e/infx/srt_slurm/synthetic_acceptance.py
@@ -248,16 +248,16 @@ def build_overrides(
         elif worker_engine == "atom":
             key = "spec-decode-acceptance-length"
             if worker_al is not None and worker_spec:
-                overrides += ["--set", f"{prefix}.args.{key}={worker_al:g}"]
+                overrides += ["--set", f"{prefix}.args.{key}={worker_al:.15g}"]
             elif key in (role.get("args") or {}):
                 overrides += ["--unset", f"{prefix}.args.{key}"]
         elif worker_al is not None and worker_spec:
             values = (
-                (f"{worker_al:g}", "match-expected", "real-draft-token")
+                (f"{worker_al:.15g}", "match-expected", "real-draft-token")
                 if engine == "sglang"
-                else (f"{worker_al:g}", "match-expected")
+                else (f"{worker_al:.15g}", "match-expected")
                 if engine == "tilert"
-                else (f"{worker_al - 1:g}",)
+                else (f"{worker_al - 1:.15g}",)
             )
             for key, value in zip(variables, values, strict=True):
                 overrides += ["--set", f"{prefix}.env.{key}={json.dumps(value)}"]
diff --git a/inferencex-e2e/infx/tests/srt_slurm/test_synthetic_acceptance.py b/inferencex-e2e/infx/tests/srt_slurm/test_synthetic_acceptance.py
index e687fc922c..0a309f4047 100644
--- a/inferencex-e2e/infx/tests/srt_slurm/test_synthetic_acceptance.py
+++ b/inferencex-e2e/infx/tests/srt_slurm/test_synthetic_acceptance.py
@@ -762,6 +762,42 @@ def test_sglang_abbreviated_algorithm_selects_golden(
     }
 
 
+@pytest.mark.parametrize(
+    ("engine", "args", "key", "expected"),
+    [
+        (
+            "sglang",
+            {"speculative-algorithm": "EAGLE", "speculative-num-steps": 3},
+            "SGLANG_SIMULATE_ACC_LEN",
+            "3.603536",
+        ),
+        (
+            "tilert",
+            {"with-mtp": True, "num-mtp": 3},
+            "TILERT_SIMULATE_ACC_LEN",
+            "3.603536",
+        ),
+        (
+            "trt",
+            {"speculative_config": {"decoding_type": "mtp", "max_draft_len": 3}},
+            "TLLM_SPEC_DECODE_FORCE_NUM_ACCEPTED_TOKENS",
+            "2.603536",
+        ),
+    ],
+)
+def test_precise_golden_length_survives_native_overrides(
+    golden_dir: Path, engine: str, args: dict[str, Any], key: str, expected: str
+) -> None:
+    (golden_dir / "dsv4_mtp.yaml").write_text(
+        yaml.safe_dump({"deepseek-v4-pro": {"thinking_on": {3: 3.603536}}})
+    )
+    recipe = {"roles": {"decode": {"args": args}}}
+    result = apply_native(
+        recipe, build_overrides(recipe, engine, ENV, golden_dir=golden_dir)
+    )
+    assert result["roles"]["decode"]["env"][key] == expected
+
+
 def test_sglang_conflicting_algorithm_aliases_fail(golden_dir: Path) -> None:
     recipe = {
         "roles": {

From 32d6423628e59003178b35404ddd985e08ed90ee Mon Sep 17 00:00:00 2001
From: functionstackx <47992694+functionstackx@users.noreply.github.com>
Date: Sun, 1 Nov 2026 11:14:57 +0000
Subject: [PATCH 07/14] feat(bench): add native GLM-5.3-Flash FP8 GB300 AgentX
 lane

---
 .../sglang/gb300-fp8-mtp/agentic.yaml         | 51 +++++++++++++++++++
 inferencex-e2e/configs/nvidia-master.yaml     | 15 +++++-
 inferencex-e2e/configs/runners.yaml           |  1 +
 inferencex-e2e/docs/MODELS.md                 |  2 +
 4 files changed, 68 insertions(+), 1 deletion(-)
 create mode 100644 inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/glm5.3flash/sglang/gb300-fp8-mtp/agentic.yaml

diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/glm5.3flash/sglang/gb300-fp8-mtp/agentic.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/glm5.3flash/sglang/gb300-fp8-mtp/agentic.yaml
new file mode 100644
index 0000000000..52d703fd43
--- /dev/null
+++ b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/glm5.3flash/sglang/gb300-fp8-mtp/agentic.yaml
@@ -0,0 +1,51 @@
+schema: 2
+name: glm5.3flash-fp8-gb300-sglang-agentic-mtp
+resources:
+  gpu_type: gb300
+  gpus_per_node: 4
+slurm:
+  time_limit: '4:00:00'
+frontend:
+  type: sglang
+  enable_multiple_frontends: false
+observability:
+  enabled: false
+  tachometer:
+    enabled: false
+engine: sglang
+roles:
+  agg:
+    nodes: 1
+    workers: 1
+    gpus: 4
+    args:
+      served-model-name: zai-org/GLM-5.3-Flash
+      trust-remote-code: true
+      tensor-parallel-size: 4
+      expert-parallel-size: 1
+      context-length: 1048576
+      dsa-prefill-backend: trtllm
+      dsa-decode-backend: trtllm
+      kv-cache-dtype: fp8_e4m3
+      moe-runner-backend: flashinfer_trtllm
+      speculative-algorithm: EAGLE
+      speculative-num-steps: 5
+      speculative-eagle-topk: 1
+      speculative-num-draft-tokens: 6
+      reasoning-parser: auto
+      tool-call-parser: auto
+      watchdog-timeout: 3600
+      enable-metrics: true
+    env:
+      PYTHONNOUSERSITE: '1'
+      PYTHONUNBUFFERED: '1'
+      HF_HUB_OFFLINE: '1'
+      SGLANG_TIMEOUT_KEEP_ALIVE: '900'
+health_check:
+  max_attempts: 1440
+  interval_seconds: 5
+benchmark:
+  env:
+    TOKENIZER: /model
+    AIPERF_HTTP_TCP_USER_TIMEOUT: '900000'
+    AIPERF_REQUIRED_SERVER_METRIC_PREFIX: 'sglang:'
diff --git a/inferencex-e2e/configs/nvidia-master.yaml b/inferencex-e2e/configs/nvidia-master.yaml
index ca18213d0c..bbb6d3fed4 100644
--- a/inferencex-e2e/configs/nvidia-master.yaml
+++ b/inferencex-e2e/configs/nvidia-master.yaml
@@ -8820,6 +8820,20 @@ kimik3-fp4-gb200-dynamo-vllm-agentic-dspark-mooncake-dcp16-disagg:
           dp-attn: false
         decode: { num-worker: 1, tp: 16, dcp-size: 16, ep: 1, dp-attn: false }
 
+glm5.3flash-fp8-gb300-sglang-agentic-mtp:
+  image: lmsysorg/sglang:v0.5.22-cu130@sha256:e3a4f06001a29542fc4a8638536d9ffc5eb9c9942b08603c09b19a56eae4a1ae
+  model: zai-org/GLM-5.3-Flash
+  model-prefix: glm5.3flash
+  runner: cluster:gb300-nv
+  precision: fp8
+  framework: sglang
+  multinode: false
+  srt-recipe-dir: glm5.3flash/sglang/gb300-fp8-mtp
+  scenarios:
+    agentic-coding:
+    - search-space:
+      - { tp: 4, ep: 1, spec-decoding: mtp, kv-offloading: none, conc-list: [1, 2, 4, 8, 12, 16, 24, 32, 48, 64], srt-recipe: agentic.yaml }
+
 glm5.3-fp4-b300-sglang-agentic-mtp:
   image: lmsysorg/sglang:v0.5.20-cu130@sha256:b27fce60bc5494c118c4910702812bcfa8cee67abcdd1ff8b0902f21647552f4
   model: nvidia/GLM-5.3-NVFP4
@@ -9071,4 +9085,3 @@ minimaxm31flash-fp4-gb300-dynamo-vllm-agentic-dspark-disagg:
         srt-recipe: disagg-mooncake.yaml:override_3p4d16
         prefill: { num-worker: 6, tp: 2, ep: 2, dp-attn: true }
         decode: { num-worker: 1, tp: 16, ep: 16, dp-attn: true }
-
diff --git a/inferencex-e2e/configs/runners.yaml b/inferencex-e2e/configs/runners.yaml
index ff16164590..564ae8d930 100644
--- a/inferencex-e2e/configs/runners.yaml
+++ b/inferencex-e2e/configs/runners.yaml
@@ -634,6 +634,7 @@ clusters:
         DeepSeek-R1-0528: {root: scratch, dir: DeepSeek-R1-0528}
         DeepSeek-R1-0528-NVFP4-v2: {root: scratch, dir: DeepSeek-R1-0528-NVFP4-v2}
         GLM-5.2-NVFP4: {root: scratch, dir: GLM-5.2-NVFP4}
+        GLM-5.3-Flash: {root: data-models, dir: GLM-5.3-Flash}
         Kimi-K3: {root: scratch, dir: Kimi-K3}
         MiniMax-M3.1-Flash: {root: data-models, dir: MiniMax-M3.1-Flash}
         Muse-Spark-Open-816B-A42B-NVFP4: {root: data-models, dir: Muse-Spark-Open-816B-A42B-NVFP4}
diff --git a/inferencex-e2e/docs/MODELS.md b/inferencex-e2e/docs/MODELS.md
index e0a6d55d7b..afa4031486 100644
--- a/inferencex-e2e/docs/MODELS.md
+++ b/inferencex-e2e/docs/MODELS.md
@@ -98,6 +98,7 @@ The table also records both the agreed plan-of-record (PoR) draft-model mapping
 |---|---|---|---|---|
 | Kimi-K3 (`kimik3`) | native/upstream vLLM engine | `Inferact/Kimi-K3-DSpark` | None | Additional non-vLLM/SGLang engines under the ordering guideline and exceptions above |
 | GLM-5.2 (`glm5.2`) | native/upstream SGLang engine | native MTP | None | Additional non-vLLM/SGLang engines under the ordering guideline and exceptions above |
+| GLM-5.3-Flash (`glm5.3flash`) | native/upstream SGLang engine | native MTP | None | Additional non-vLLM/SGLang engines under the ordering guideline and exceptions above |
 | Qwen3.5-397B-A17B (`qwen3.5`) | native/upstream SGLang engine | native MTP | None | Additional non-vLLM/SGLang engines under the ordering guideline and exceptions above |
 | Qwen3.8-Flash-Next (`qwen3.8next`) | native/upstream SGLang engine | TBD | native MTP (built-in 4B multi-step module; golden AL collector: [`qwen3.8next_fp4_b300_vllm.sh`](../benchmarks/single_node/speedbench/qwen3.8next_fp4_b300_vllm.sh)) | Additional non-vLLM/SGLang engines under the ordering guideline and exceptions above |
 
@@ -124,6 +125,7 @@ Other offloading tiers, including NVMe KV cache offloading, are outside the init
 
 | Model architecture class | Prefix | Date added | Active scenarios | Deprecated scenarios |
 |---|---|---|---|---|
+| GLM-5.3-Flash | `glm5.3flash` | 2026-11-01 | Agentic coding (native SGLang FP8 on GB300, embedded MTP; golden AL curve `glm5.3flash_mtp.yaml`) | |
 | MiniMax-M3.1-Flash | `minimaxm31flash` | 2026-10-23 | Agentic coding (vLLM DSpark; golden AL curve `minimaxm31flash_dspark.yaml`) | |
 | Muse Spark Open 816B-A42B | `musespark` | 2026-10-15 | Agentic coding (SGLang and GB300 TensorRT-LLM with DFlash2 draft `RadixArk/Muse-Spark-Open-DFlash2`; golden AL curve `musespark_dflash.yaml`) | |
 | DeepSeek-V4.1-Flash | `dsv41flash` | 2026-09-10 | Agentic coding (vLLM: DSpark, Engram UVA offload; SGLang: DSpark arms added per SKU from 2026-09-17; ATOM: MI355X TP2/TP4 DSpark added 2026-09-23, removed in #3463, restored on srt-slurm 2026-09-30; GPU validation pending) | |

From 505ac3a89485ce9a82458c160122c366f94573ba Mon Sep 17 00:00:00 2001
From: functionstackx <47992694+functionstackx@users.noreply.github.com>
Date: Sun, 1 Nov 2026 11:15:38 +0000
Subject: [PATCH 08/14] chore(bench): register GLM-5.3-Flash FP8 GB300 sweep

---
 inferencex-e2e/perf-changelog.yaml | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/inferencex-e2e/perf-changelog.yaml b/inferencex-e2e/perf-changelog.yaml
index 88ea87392c..51fbda91ac 100644
--- a/inferencex-e2e/perf-changelog.yaml
+++ b/inferencex-e2e/perf-changelog.yaml
@@ -11769,3 +11769,11 @@
     - "6 DEP2 prefill workers with a DEP8 decode at conc 280-400 or a DEP16 decode at conc 300; MegaMoE, DSpark block 7 with fp8 draft KV, Dynamo KV router with fastokens for prefill and least-loaded routing across decode DP ranks."
     - "Prefill: shortest-prefill-first, chunk 8192, mem-fraction-static 0.85, HiCache 200 GB per rank write_back."
   pr-link: https://github.com/SemiAnalysisAI/InferenceX/pull/4686
+
+- config-keys:
+    - glm5.3flash-fp8-gb300-sglang-agentic-mtp
+  scenario-type: [agentic-coding]
+  description:
+    - "Add native SGLang GLM-5.3-Flash FP8 AgentX on GB300 with the official ARM64-capable v0.5.22-cu130 image, TP4/EP1, TRT-LLM DSA, FP8 E4M3 KV cache, and embedded EAGLE MTP 5/1/6."
+    - "Run the full AgentX corpus and 1048576-token context at concurrency 1, 2, 4, 8, 12, 16, 24, 32, 48, and 64 with shared measured golden acceptance and canonical real evals."
+  pr-link: https://github.com/SemiAnalysisAI/InferenceX/pull/4715

From 86f215a33bfc8b4326d6c3900ec18bd8d5c9d6c5 Mon Sep 17 00:00:00 2001
From: functionstackx <47992694+functionstackx@users.noreply.github.com>
Date: Sun, 1 Nov 2026 11:22:19 +0000
Subject: [PATCH 09/14] fix(ci): preserve canary gates after skipped reuse
 checks

---
 .github/workflows/run-sweep.yml | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/run-sweep.yml b/.github/workflows/run-sweep.yml
index 03842620bf..acf9c1995c 100644
--- a/.github/workflows/run-sweep.yml
+++ b/.github/workflows/run-sweep.yml
@@ -316,6 +316,7 @@ jobs:
         name: canary-select
         needs: setup
         if: >-
+            !cancelled() && needs.setup.result == 'success' &&
             (
               contains(github.event.pull_request.labels.*.name, 'full-sweep-enabled') ||
               contains(github.event.pull_request.labels.*.name, 'full-sweep-fail-fast')
@@ -366,7 +367,7 @@ jobs:
 
     canary-sweep:
         needs: canary-select
-        if: ${{ needs.canary-select.outputs.canary-config != '' && needs.canary-select.outputs.canary-config != '[]' }}
+        if: ${{ !cancelled() && needs.canary-select.result == 'success' && needs.canary-select.outputs.canary-config != '' && needs.canary-select.outputs.canary-config != '[]' }}
         uses: $/.github/workflows/benchmark-tmpl.yml
         name: canary /
         strategy:
@@ -390,7 +391,7 @@ jobs:
 
     canary-multi-node-sweep:
         needs: canary-select
-        if: ${{ needs.canary-select.outputs.multi-node-canary-config != '' && needs.canary-select.outputs.multi-node-canary-config != '[]' }}
+        if: ${{ !cancelled() && needs.canary-select.result == 'success' && needs.canary-select.outputs.multi-node-canary-config != '' && needs.canary-select.outputs.multi-node-canary-config != '[]' }}
         uses: $/.github/workflows/benchmark-multinode-tmpl.yml
         name: multi-node canary /
         strategy:

From c611580c42f9f8975d260d1a0a567c38e188d7d8 Mon Sep 17 00:00:00 2001
From: functionstackx <47992694+functionstackx@users.noreply.github.com>
Date: Sun, 1 Nov 2026 12:45:34 +0000
Subject: [PATCH 10/14] fix(bench): use canonical Flash tokenizer ID for AgentX

---
 .../glm5.3flash/sglang/gb300-fp8-mtp/agentic.yaml                | 1 -
 1 file changed, 1 deletion(-)

diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/glm5.3flash/sglang/gb300-fp8-mtp/agentic.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/glm5.3flash/sglang/gb300-fp8-mtp/agentic.yaml
index 52d703fd43..7f4253b855 100644
--- a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/glm5.3flash/sglang/gb300-fp8-mtp/agentic.yaml
+++ b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/glm5.3flash/sglang/gb300-fp8-mtp/agentic.yaml
@@ -46,6 +46,5 @@ health_check:
   interval_seconds: 5
 benchmark:
   env:
-    TOKENIZER: /model
     AIPERF_HTTP_TCP_USER_TIMEOUT: '900000'
     AIPERF_REQUIRED_SERVER_METRIC_PREFIX: 'sglang:'

From ecb4205af236dca66ae63b5c9af0538b123878f9 Mon Sep 17 00:00:00 2001
From: Oseltamivir <58582368+Oseltamivir@users.noreply.github.com>
Date: Thu, 5 Nov 2026 19:46:45 +0800
Subject: [PATCH 11/14] feat(bench): add GLM-5.3-Flash FP8 and NVFP4 AgentX on
 GB300

Single-node SGLang v0.5.22 TP4 MTP 5/1/6 lanes for FP8 and NVFP4 using
the SGLang cookbook GB300 recipe: GPU-resident KV at low concurrency and
an auto-sized HiCache host tier (host memory fraction 0.90) at high
concurrency.
---
 .github/AGENT_OPERATIONS.md                   |   12 +-
 .github/actions/classify-priority/action.yml  |  174 +
 .github/codeowner-signoff-verify-prompt.md    |    8 +-
 .github/workflows/README.md                   |   18 +-
 .github/workflows/al-gate-prompts.yml         |  104 +
 .../workflows/benchmark-multinode-tmpl.yml    |   14 +
 .github/workflows/benchmark-tmpl.yml          |   14 +
 .github/workflows/collect-evals.yml           |    6 +
 .github/workflows/e2e-tests.yml               |   44 +-
 .github/workflows/profile.yml                 |   12 +-
 .github/workflows/run-sweep.yml               |  111 +-
 .github/workflows/speedbench-al.yml           |   36 +-
 AGENTS.md                                     |    1 +
 collectivex/bench/ep_backend.py               |    9 +
 collectivex/bench/ep_deepep_v2.py             |   99 +-
 collectivex/bench/ep_flashinfer.py            |    4 -
 collectivex/bench/ep_legacy_ll.py             |  102 +-
 collectivex/bench/ep_mori.py                  |    5 +-
 collectivex/bench/ep_nccl.py                  |    6 -
 collectivex/bench/ep_uccl.py                  |   69 +-
 collectivex/configs/platform_config.json      |    3 +-
 collectivex/tests/test_backends.py            |  373 +-
 collectivex/tests/test_deepep_v2_contract.py  |   47 +
 collectivex/tests/test_nccl_ep_contract.py    |  308 +-
 .../multi_node/srt-slurm-recipes/RECIPES.md   |   44 +-
 .../configs/kimik3-atom-dspark-draft.sh       |   13 -
 .../configs/kimik3-b300-mooncake.sh           |   36 -
 .../configs/kimik3-dspark-config-compat.sh    |   49 -
 .../configs/tokenspeed-nightly.sh             |   15 +
 .../gb300-fp4/agentx/disagg-variants.yaml     |    2 -
 .../b300-fp4/agentx/agg-tp4-variants.yaml     |    2 +-
 .../vllm/b200-fp4/agentx/agg-variants.yaml    |  201 -
 .../agg-dcp16-dspark4-maxseq2-mooncake.yaml   |  147 -
 .../agentx/agg-dcp16-nospec-mooncake.yaml     |  143 -
 .../gb200-fp4/agentx/agg-tp8pp2-variants.yaml |  173 -
 .../vllm/gb200-fp4/agentx/agg-variants.yaml   |  205 -
 .../gb200-fp4/agentx/disagg-variants.yaml     |  268 --
 .../agentx/agg-megakernel-variants.yaml       |   89 -
 .../gb300-fp4/agentx/disagg-tp8-dep16.yaml    |  218 -
 .../gb300-fp4/agentx/disagg-variants.yaml     |  367 --
 .../agentx/agg-tp16dp2ep32-latency.yaml       |   79 -
 .../agentx/agg-tp8dp4ep32-balanced.yaml       |   80 -
 .../agentx/agg-tp8dp4ep32-vllm-simple.yaml    |   81 -
 .../mi355x-fp4/agentx/disagg-variants.yaml    |  212 -
 .../sglang/gb300-fp4/agentx/agg-variants.yaml |  216 +
 .../gb300-fp4/agentx/disagg-variants.yaml     |   16 +-
 .../8k1k/mtp/1p1d-tp4-tp4-c1.yaml             |  155 -
 .../8k1k/mtp/1p1d-tp4-tp4-c4.yaml             |  155 -
 .../8k1k/mtp/1p1d-tp4-tp4-c8.yaml             |  155 -
 .../8k1k/mtp/2p2d-tp2-tp2-c512.yaml           |  158 -
 .../8k1k/mtp/2p3d-tp2-tp2-c768.yaml           |  154 -
 .../8k1k/mtp/3p5d-tp4-tp4-c128.yaml           |  155 -
 .../8k1k/mtp/7p1d-dep4-dep16-c5120.yaml       |  165 -
 .../8k1k/mtp/7p1d-dep4-dep16-c8192.yaml       |  165 -
 .../8k1k/mtp/7p4d-dep4-dep4-c12288.yaml       |  178 -
 ...sagg-1p1d-p-tp4-d-tp4-b128-c1x2x8-mtp.yaml |  130 -
 ...tp8-ep8-d-tp8-ep8-b1024-c32x48x80-mtp.yaml |  142 -
 .../8k1k/disagg-1p1d-tp4-tp4-stp.yaml         |  110 -
 ...4-dp4-d-tp16-ep16-dp16-b1024-c480-mtp.yaml |  157 -
 .../8k1k/disagg-4p1d-dep4-dep16-stp.yaml      |  146 -
 ...4-dp4-d-tp16-ep16-dp16-b1024-c768-mtp.yaml |  157 -
 ...-dp4-d-tp16-ep16-dp16-b1024-c1280-mtp.yaml |  157 -
 ...-dp4-d-tp16-ep16-dp16-b2048-c1344-mtp.yaml |  157 -
 .../8k1k/disagg-8p1d-dep4-dep16-stp.yaml      |  155 -
 ...d-tp16-ep16-dp16-b2048-c1920x2304-mtp.yaml |  157 -
 ...p4-d-tp4-b128-c1x4x8x16x32x64x256-stp.yaml |  157 -
 ...-dp4-d-tp16-ep16-dp16-b4096-c2048-stp.yaml |  157 -
 ...-dp4-d-tp16-ep16-dp16-b5120-c5120-stp.yaml |  155 -
 ...-dp4-d-tp16-ep16-dp16-b5120-c5120-stp.yaml |  155 -
 ...agg-1p1d-p-tp4-d-tp4-b1024-c1x2x8-mtp.yaml |  130 -
 ...tp8-ep8-d-tp8-ep8-b1024-c32x48x80-mtp.yaml |  142 -
 .../8k1k/disagg-1p1d-tp4-tp4-stp.yaml         |  110 -
 ...4-dp4-d-tp16-ep16-dp16-b1024-c480-mtp.yaml |  158 -
 .../8k1k/disagg-4p1d-dep4-dep16-stp.yaml      |  145 -
 ...4-dp4-d-tp16-ep16-dp16-b1024-c768-mtp.yaml |  158 -
 ...-dp4-d-tp16-ep16-dp16-b1024-c1280-mtp.yaml |  158 -
 ...-dp4-d-tp16-ep16-dp16-b2048-c1344-mtp.yaml |  158 -
 .../8k1k/disagg-8p1d-dep4-dep16-stp.yaml      |  154 -
 ...d-tp16-ep16-dp16-b2048-c1920x2304-mtp.yaml |  158 -
 .../mi355x-fp4/8k1k/disagg-1p1d-tp8.yaml      |  100 -
 .../8k1k/disagg-1p1d-p-tp4-d-tp8.yaml         |  105 -
 .../gb300-fp4/8k1k/disagg-mtp-variants.yaml   |  796 ----
 .../gb300-fp4/8k1k/disagg-stp-variants.yaml   |  681 ---
 .../benchmarks/multi_node/srt_eval.sh         |    5 +
 .../speedbench/dsv4_fp4_b300_vllm.sh          |   13 +-
 .../speedbench/dsv4dspark_fp4_b300_vllm.sh    |   23 +-
 ...le_method_block_rejection_sample_method.sh |    4 +
 .../speedbench/glm5.3_fp4_b300_sglang.sh      |  203 +
 .../speedbench/glm52_fp4_b300_vllm.sh         |   11 +-
 .../speedbench/glm53flash_fp8_b300_vllm.sh    |   27 -
 .../speedbench/kimik3.1_fp4_b300_sglang.sh    |  276 ++
 .../speedbench/kimik3_fp4_b300_vllm.sh        |   19 +-
 ...4_b300_vllm_probabilistic_sample_method.sh |    4 +
 ...le_method_block_rejection_sample_method.sh |   11 +-
 .../minimaxm31flash_fp4_b300_vllm.sh          |   11 +-
 .../speedbench/minimaxm3_fp4_b300_vllm.sh     |   23 +-
 ..._vllm_gqa_block_rejection_sample_method.sh |    5 +
 .../speedbench/musespark_fp4_b300_sglang.sh   |   11 +-
 .../speedbench/qwen3.5_fp4_b300_vllm.sh       |   11 +-
 .../speedbench/qwen3.8next_fp4_b300_vllm.sh   |   11 +-
 .../atom/mi355x-fp4-mtp/agentic.yaml          |    2 +-
 .../sglang/gb300-fp4-mtp/agentic.yaml         |   34 +-
 .../vllm/mi355x-fp4-mtp/agentic.yaml          |   20 +-
 .../glm5.2/sglang/mi355x-fp4-mtp/agentic.yaml |   61 +
 .../glm5.3/sglang/b300-fp4-mtp/agentic.yaml   |    2 +-
 .../sglang/gb300-fp4-mtp/agentic.yaml         |   71 +
 .../sglang/gb300-fp8-mtp/agentic.yaml         |  112 +-
 .../kimik3.1/sglang/b300-fp4-mtp/agentic.yaml |  230 +
 .../sglang/mi355x-fp4-mtp/agentic.yaml        |  193 +
 .../kimik3.1/vllm/b300-fp4-mtp/agentic.yaml   |  182 +
 .../kimik3/atom/mi355x-fp4-mtp/agentic.yaml   |  217 -
 .../kimik3/vllm/b300-fp4-mtp/agentic.yaml     |  233 -
 .../kimik3/vllm/mi355x-fp4-mtp/agentic.yaml   |  323 --
 .../b300-fp4-mtp/agentic-tp2-spf-extra.yaml   |  117 +
 .../b300-fp4-mtp/agentic-tp4-spf-extra.yaml   |   95 +
 .../sglang/mi355x-fp4-mtp/agentic.yaml        |   30 +-
 .../vllm/gb300-fp4-mtp/agentic.yaml           |  129 +-
 .../vllm/h100-fp4-mtp/agentic.yaml            |    2 +-
 .../vllm/h200-fp4-mtp/agentic.yaml            |    2 +-
 .../vllm/mi355x-fp4/agentic.yaml              |   38 +-
 .../sglang/b300-fp4-mtp/agentic.yaml          |  133 +-
 .../sglang/gb300-fp4-mtp/agentic.yaml         |   79 +-
 .../qwen3.5/atom/mi355x-fp4/8k1k.yaml         |   40 -
 .../qwen3.5/atom/mi355x-fp8-mtp/8k1k.yaml     |   43 -
 .../qwen3.5/atom/mi355x-fp8/8k1k.yaml         |   47 -
 .../qwen3.5/sglang/b200-fp4-mtp/8k1k.yaml     |   82 -
 .../qwen3.5/sglang/b200-fp4/8k1k.yaml         |   59 -
 .../qwen3.5/sglang/b200-fp8-mtp/8k1k.yaml     |   68 -
 .../qwen3.5/sglang/b200-fp8/8k1k.yaml         |   64 -
 .../qwen3.5/sglang/b300-fp4-mtp/8k1k.yaml     |   77 -
 .../qwen3.5/sglang/b300-fp4/8k1k.yaml         |   73 -
 .../qwen3.5/sglang/b300-fp8-mtp/8k1k.yaml     |   60 -
 .../qwen3.5/sglang/b300-fp8/8k1k.yaml         |   55 -
 .../qwen3.5/sglang/h100-fp8-mtp/8k1k.yaml     |   56 -
 .../qwen3.5/sglang/h100-fp8/8k1k.yaml         |   63 -
 .../qwen3.5/sglang/h200-fp8-mtp/8k1k.yaml     |   55 -
 .../qwen3.5/sglang/h200-fp8/8k1k.yaml         |   50 -
 .../qwen3.5/sglang/mi300x-fp8/8k1k.yaml       |   43 -
 .../qwen3.5/sglang/mi325x-fp8-mtp/8k1k.yaml   |   47 -
 .../qwen3.5/sglang/mi325x-fp8/8k1k.yaml       |   43 -
 .../qwen3.5/sglang/mi355x-fp4-mtp/8k1k.yaml   |   62 -
 .../qwen3.5/sglang/mi355x-fp4/8k1k.yaml       |   58 -
 .../qwen3.5/sglang/mi355x-fp8-mtp/8k1k.yaml   |   54 -
 .../qwen3.5/sglang/mi355x-fp8/8k1k.yaml       |   50 -
 .../qwen3.5/trtllm/b200-fp4-mtp/8k1k.yaml     |  141 -
 .../qwen3.5/trtllm/b200-fp4/8k1k.yaml         |  156 -
 .../sglang/b300-fp4-mtp/agentic.yaml          |  208 +-
 .../sglang/mi355x-fp4-mtp/agentic.yaml        |   45 +-
 .../benchmarks/single_node/srt_eval.sh        |    5 +
 inferencex-e2e/benchmarks/srt_al_gate.sh      |   12 +
 inferencex-e2e/configs/CONFIGS.md             |   21 +-
 inferencex-e2e/configs/amd-master.yaml        |  537 +--
 inferencex-e2e/configs/ci-priority.yaml       |    2 +-
 inferencex-e2e/configs/nvidia-master.yaml     | 3744 ++++-------------
 inferencex-e2e/configs/runners.yaml           |   28 +-
 .../configs/srt-recipes/telemetry-dcgm.yaml   |    6 +-
 .../configs/srt-recipes/telemetry-native.yaml |    2 -
 inferencex-e2e/docs/MODELS.md                 |   41 +-
 inferencex-e2e/docs/PRINCIPLES.md             |    3 +-
 inferencex-e2e/docs/agentx-standalone.md      |    8 +-
 inferencex-e2e/infx/bench/__main__.py         |    2 +-
 inferencex-e2e/infx/bench/agentic/replay.py   |   15 +-
 .../infx/bench/agentic/requirements.txt       |    2 +-
 inferencex-e2e/infx/bench/agentic/venv.py     |    5 +
 inferencex-e2e/infx/bench/al_gate.py          |  247 ++
 inferencex-e2e/infx/bench/fixed_seq.py        |    2 +-
 inferencex-e2e/infx/bench/speedbench.py       |   89 +
 inferencex-e2e/infx/bench/speedbench_al.py    |  346 --
 .../infx/bench_serving/encoding_dsv41.py      |  548 +++
 inferencex-e2e/infx/clusters/slurm.py         |   36 +-
 inferencex-e2e/infx/evals/EVALS.md            |   50 +-
 .../infx/golden_al_distribution/README.md     |  102 +-
 .../infx/golden_al_distribution/README_zh.md  |   99 +-
 .../infx/golden_al_distribution/__init__.py   |    8 +-
 .../infx/golden_al_distribution/__main__.py   |   15 +-
 .../infx/golden_al_distribution/curves.py     |   72 +-
 ...spark__native__probabilistic-default.yaml} |   11 +-
 ...v4-pro__mtp__native__default-default.yaml} |   14 +-
 ..._dspark__native__probabilistic-block.yaml} |   12 +-
 ....2-fp8__mtp__native__default-default.yaml} |   11 +-
 ...3-flash__mtp__native__default-default.yaml |   26 +
 ...3-nvfp4__mtp__native__default-default.yaml |   19 +
 .../golden_al_distribution/glm5.3_mtp.yaml    |   19 -
 .../glm5.3flash_mtp.yaml                      |   13 -
 .../golden_al_distribution/identities.yaml    |  233 +
 .../infx/golden_al_distribution/identity.py   |  285 ++
 ...i-k3.1-dflash2-preview__default-block.yaml |   28 +
 ...o-dspark-preview__probabilistic-block.yaml |   28 +
 ...ark__kimi-k3-dspark__default-default.yaml} |   11 +-
 ..._kimi-k3-dspark__probabilistic-block.yaml} |   11 +-
 ...kimi-k3-dspark__probabilistic-default.yaml |   41 +
 ..._dspark__native__probabilistic-block.yaml} |    9 +-
 ..._minimax-m3-eagle3-gqa__default-block.yaml |   42 +
 ...nimax-m3-eagle3-gqa__default-default.yaml} |   14 +-
 ...__minimax-m3-eagle3__default-default.yaml} |   14 +-
 ...-spark-open-dflash2__default-default.yaml} |    9 +-
 ...-nvfp4__mtp__native__default-default.yaml} |   14 +-
 ...xt-fp8__mtp__native__default-default.yaml} |   11 +-
 inferencex-e2e/infx/launch/artifacts.py       |   27 +-
 .../infx/launch/drivers/srt/__init__.py       |   49 +-
 .../infx/launch/drivers/srt/checkout.py       |   12 +-
 .../infx/launch/drivers/srt/collect.py        |   21 +-
 .../infx/launch/drivers/srt/config.py         |   88 +-
 .../infx/launch/drivers/srt/lanes.py          |    6 +-
 .../infx/launch/drivers/srt/models.py         |    1 -
 .../infx/launch/drivers/srt/power.py          |  121 +-
 .../infx/launch/drivers/srt/submit.py         |   68 +-
 inferencex-e2e/infx/launch/event.py           |    3 +
 inferencex-e2e/infx/launch/policy.py          |    2 +-
 inferencex-e2e/infx/launch/request.py         |    1 +
 inferencex-e2e/infx/matrix/fingerprint.py     |    6 +-
 inferencex-e2e/infx/matrix/generate.py        |   19 +-
 inferencex-e2e/infx/matrix/validation.py      |   23 +
 .../infx/results/agentic/__init__.py          |    3 +-
 .../infx/results/agentic/backends/__init__.py |    2 +
 .../results/agentic/backends/tokenspeed.py    |   27 +
 .../infx/results/agentic/power_adapter.py     |    4 +
 .../infx/results/agentic/spec_decode.py       |  101 +
 inferencex-e2e/infx/results/fixed_sequence.py |    1 +
 inferencex-e2e/infx/results/metadata.py       |    6 +
 inferencex-e2e/infx/results/power/__init__.py |   38 +-
 inferencex-e2e/infx/results/power/audit.py    |   39 +-
 inferencex-e2e/infx/results/power/common.py   |   40 +-
 inferencex-e2e/infx/results/power/cpu_side.py |  334 ++
 .../infx/results/power/multinode.py           |  189 +-
 inferencex-e2e/infx/srt_slurm/al_gate.py      |  193 +
 inferencex-e2e/infx/srt_slurm/generate.py     |   87 +-
 inferencex-e2e/infx/srt_slurm/single_node.py  |   28 +-
 .../infx/srt_slurm/spec_identity.py           |  222 +
 .../infx/srt_slurm/synthetic_acceptance.py    |  132 +-
 inferencex-e2e/infx/srt_slurm/workload.py     |  166 +-
 inferencex-e2e/infx/tests/bench/conftest.py   |   10 +-
 .../infx/tests/bench/test_al_gate.py          |  305 ++
 .../infx/tests/bench/test_fixed_seq.py        |    3 +-
 .../infx/tests/bench/test_speedbench.py       |   95 +
 .../infx/tests/bench/test_speedbench_al.py    |  151 -
 .../test_golden_al_distribution.py            |  127 +-
 .../test_spec_identity.py                     |  178 +
 .../infx/tests/launch/fake_slurm.py           |    7 +-
 .../tests/launch/test_launch_artifacts.py     |   66 +
 .../infx/tests/launch/test_launch_policy.py   |  115 +-
 .../tests/launch/test_srt_collect_staging.py  |    2 +-
 .../infx/tests/launch/test_srt_config.py      |  106 +-
 .../infx/tests/launch/test_srt_driver.py      |  248 +-
 .../matrix/test_generate_sweep_configs.py     |   50 +
 .../infx/tests/matrix/test_validation.py      |   15 +
 .../results/agentic/test_power_adapter.py     |    2 +-
 .../agentic/test_process_agentic_result.py    |   43 +
 .../tests/results/agentic/test_spec_decode.py |  125 +
 .../results/power/test_aggregate_power.py     |    1 +
 .../power/test_aggregate_power_multinode.py   |  335 ++
 .../infx/tests/srt_slurm/test_al_gate_plan.py |  219 +
 .../infx/tests/srt_slurm/test_generate.py     |  112 +-
 .../tests/srt_slurm/test_setup_scripts.py     |   21 +
 .../tests/srt_slurm/test_srt_single_node.py   |   37 +
 .../srt_slurm/test_synthetic_acceptance.py    |  210 +-
 .../infx/tests/srt_slurm/test_workload.py     |   59 +-
 .../infx/tests/workflows/test_ci_priority.py  |   24 -
 .../workflows/test_find_reusable_sweep_run.py |    2 +-
 .../tests/workflows/test_launch_layout.py     |    4 +-
 .../infx/tests/workflows/test_pr_checklist.py |   44 +
 .../tests/workflows/test_signoff_facts.py     |    4 +-
 inferencex-e2e/infx/workflows/ci_priority.py  |    8 +
 inferencex-e2e/infx/workflows/pr_checklist.py |   42 +
 .../infx/workflows/signoff_facts.py           |   16 +-
 inferencex-e2e/perf-changelog.yaml            |  283 +-
 .../runners/srt-slurm/hooks/common.sh         |   10 +-
 .../srt-slurm/hooks/mi355x-amds/setup.sh      |    6 +-
 inferencex-e2e/utils/srt-slurm                |    2 +-
 operatorx/perf-changelog.yaml                 |    9 +
 operatorx/testlists/moe_small.json            |   15 -
 271 files changed, 10977 insertions(+), 16807 deletions(-)
 create mode 100644 .github/actions/classify-priority/action.yml
 create mode 100644 .github/workflows/al-gate-prompts.yml
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/configs/kimik3-atom-dspark-draft.sh
 delete mode 100755 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/configs/kimik3-b300-mooncake.sh
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/configs/kimik3-dspark-config-compat.sh
 create mode 100755 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/configs/tokenspeed-nightly.sh
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/b200-fp4/agentx/agg-variants.yaml
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/gb200-fp4/agentx/agg-dcp16-dspark4-maxseq2-mooncake.yaml
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/gb200-fp4/agentx/agg-dcp16-nospec-mooncake.yaml
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/gb200-fp4/agentx/agg-tp8pp2-variants.yaml
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/gb200-fp4/agentx/agg-variants.yaml
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/gb200-fp4/agentx/disagg-variants.yaml
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/gb300-fp4/agentx/agg-megakernel-variants.yaml
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/gb300-fp4/agentx/disagg-tp8-dep16.yaml
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/gb300-fp4/agentx/disagg-variants.yaml
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/h200-fp4/agentx/agg-tp16dp2ep32-latency.yaml
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/h200-fp4/agentx/agg-tp8dp4ep32-balanced.yaml
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/h200-fp4/agentx/agg-tp8dp4ep32-vllm-simple.yaml
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/mi355x-fp4/agentx/disagg-variants.yaml
 create mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/minimaxm31flash/sglang/gb300-fp4/agentx/agg-variants.yaml
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp4-v2/8k1k/mtp/1p1d-tp4-tp4-c1.yaml
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp4-v2/8k1k/mtp/1p1d-tp4-tp4-c4.yaml
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp4-v2/8k1k/mtp/1p1d-tp4-tp4-c8.yaml
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp4-v2/8k1k/mtp/2p2d-tp2-tp2-c512.yaml
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp4-v2/8k1k/mtp/2p3d-tp2-tp2-c768.yaml
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp4-v2/8k1k/mtp/3p5d-tp4-tp4-c128.yaml
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp4-v2/8k1k/mtp/7p1d-dep4-dep16-c5120.yaml
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp4-v2/8k1k/mtp/7p1d-dep4-dep16-c8192.yaml
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp4-v2/8k1k/mtp/7p4d-dep4-dep4-c12288.yaml
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp8/8k1k/disagg-1p1d-p-tp4-d-tp4-b128-c1x2x8-mtp.yaml
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp8/8k1k/disagg-1p1d-p-tp8-ep8-d-tp8-ep8-b1024-c32x48x80-mtp.yaml
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp8/8k1k/disagg-1p1d-tp4-tp4-stp.yaml
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp8/8k1k/disagg-3p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b1024-c480-mtp.yaml
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp8/8k1k/disagg-4p1d-dep4-dep16-stp.yaml
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp8/8k1k/disagg-4p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b1024-c768-mtp.yaml
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp8/8k1k/disagg-6p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b1024-c1280-mtp.yaml
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp8/8k1k/disagg-7p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b2048-c1344-mtp.yaml
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp8/8k1k/disagg-8p1d-dep4-dep16-stp.yaml
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp8/8k1k/disagg-8p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b2048-c1920x2304-mtp.yaml
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp4/8k1k/disagg-1p1d-p-tp4-d-tp4-b128-c1x4x8x16x32x64x256-stp.yaml
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp4/8k1k/disagg-5p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b4096-c2048-stp.yaml
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp4/8k1k/disagg-6p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b5120-c5120-stp.yaml
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp4/8k1k/disagg-7p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b5120-c5120-stp.yaml
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp8/8k1k/disagg-1p1d-p-tp4-d-tp4-b1024-c1x2x8-mtp.yaml
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp8/8k1k/disagg-1p1d-p-tp8-ep8-d-tp8-ep8-b1024-c32x48x80-mtp.yaml
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp8/8k1k/disagg-1p1d-tp4-tp4-stp.yaml
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp8/8k1k/disagg-3p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b1024-c480-mtp.yaml
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp8/8k1k/disagg-4p1d-dep4-dep16-stp.yaml
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp8/8k1k/disagg-4p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b1024-c768-mtp.yaml
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp8/8k1k/disagg-6p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b1024-c1280-mtp.yaml
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp8/8k1k/disagg-7p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b2048-c1344-mtp.yaml
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp8/8k1k/disagg-8p1d-dep4-dep16-stp.yaml
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp8/8k1k/disagg-8p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b2048-c1920x2304-mtp.yaml
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/mi355x-fp4/8k1k/disagg-1p1d-tp8.yaml
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/mi355x-fp8/8k1k/disagg-1p1d-p-tp4-d-tp8.yaml
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/trtllm/gb300-fp4/8k1k/disagg-mtp-variants.yaml
 delete mode 100644 inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/trtllm/gb300-fp4/8k1k/disagg-stp-variants.yaml
 create mode 100755 inferencex-e2e/benchmarks/single_node/speedbench/dsv4dspark_fp4_b300_vllm_probabilistic_sample_method_block_rejection_sample_method.sh
 create mode 100755 inferencex-e2e/benchmarks/single_node/speedbench/glm5.3_fp4_b300_sglang.sh
 delete mode 100644 inferencex-e2e/benchmarks/single_node/speedbench/glm53flash_fp8_b300_vllm.sh
 create mode 100755 inferencex-e2e/benchmarks/single_node/speedbench/kimik3.1_fp4_b300_sglang.sh
 create mode 100755 inferencex-e2e/benchmarks/single_node/speedbench/kimik3_fp4_b300_vllm_probabilistic_sample_method.sh
 create mode 100755 inferencex-e2e/benchmarks/single_node/speedbench/minimaxm3_fp4_b300_vllm_gqa_block_rejection_sample_method.sh
 create mode 100644 inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/glm5.3flash/sglang/gb300-fp4-mtp/agentic.yaml
 create mode 100644 inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/kimik3.1/sglang/b300-fp4-mtp/agentic.yaml
 create mode 100644 inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/kimik3.1/sglang/mi355x-fp4-mtp/agentic.yaml
 create mode 100644 inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/kimik3.1/vllm/b300-fp4-mtp/agentic.yaml
 delete mode 100644 inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/kimik3/atom/mi355x-fp4-mtp/agentic.yaml
 delete mode 100644 inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/kimik3/vllm/b300-fp4-mtp/agentic.yaml
 delete mode 100644 inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/kimik3/vllm/mi355x-fp4-mtp/agentic.yaml
 create mode 100644 inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/minimaxm31flash/sglang/b300-fp4-mtp/agentic-tp2-spf-extra.yaml
 create mode 100644 inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/minimaxm31flash/sglang/b300-fp4-mtp/agentic-tp4-spf-extra.yaml
 delete mode 100644 inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/atom/mi355x-fp4/8k1k.yaml
 delete mode 100644 inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/atom/mi355x-fp8-mtp/8k1k.yaml
 delete mode 100644 inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/atom/mi355x-fp8/8k1k.yaml
 delete mode 100644 inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/b200-fp4-mtp/8k1k.yaml
 delete mode 100644 inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/b200-fp4/8k1k.yaml
 delete mode 100644 inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/b200-fp8-mtp/8k1k.yaml
 delete mode 100644 inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/b200-fp8/8k1k.yaml
 delete mode 100644 inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/b300-fp4-mtp/8k1k.yaml
 delete mode 100644 inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/b300-fp4/8k1k.yaml
 delete mode 100644 inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/b300-fp8-mtp/8k1k.yaml
 delete mode 100644 inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/b300-fp8/8k1k.yaml
 delete mode 100644 inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/h100-fp8-mtp/8k1k.yaml
 delete mode 100644 inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/h100-fp8/8k1k.yaml
 delete mode 100644 inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/h200-fp8-mtp/8k1k.yaml
 delete mode 100644 inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/h200-fp8/8k1k.yaml
 delete mode 100644 inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/mi300x-fp8/8k1k.yaml
 delete mode 100644 inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/mi325x-fp8-mtp/8k1k.yaml
 delete mode 100644 inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/mi325x-fp8/8k1k.yaml
 delete mode 100644 inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/mi355x-fp4-mtp/8k1k.yaml
 delete mode 100644 inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/mi355x-fp4/8k1k.yaml
 delete mode 100644 inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/mi355x-fp8-mtp/8k1k.yaml
 delete mode 100644 inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/mi355x-fp8/8k1k.yaml
 delete mode 100644 inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/trtllm/b200-fp4-mtp/8k1k.yaml
 delete mode 100644 inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/trtllm/b200-fp4/8k1k.yaml
 create mode 100644 inferencex-e2e/benchmarks/srt_al_gate.sh
 create mode 100644 inferencex-e2e/infx/bench/al_gate.py
 create mode 100644 inferencex-e2e/infx/bench/speedbench.py
 delete mode 100644 inferencex-e2e/infx/bench/speedbench_al.py
 create mode 100644 inferencex-e2e/infx/bench_serving/encoding_dsv41.py
 rename inferencex-e2e/infx/golden_al_distribution/{dsv4-pro-0813-dspark.yaml => deepseek-v4-pro-0813__dspark__native__probabilistic-default.yaml} (62%)
 rename inferencex-e2e/infx/golden_al_distribution/{dsv4_mtp.yaml => deepseek-v4-pro__mtp__native__default-default.yaml} (57%)
 rename inferencex-e2e/infx/golden_al_distribution/{dsv41flash_dspark.yaml => deepseek-v4.1-flash__dspark__native__probabilistic-block.yaml} (68%)
 rename inferencex-e2e/infx/golden_al_distribution/{glm5.2_mtp.yaml => glm-5.2-fp8__mtp__native__default-default.yaml} (61%)
 create mode 100644 inferencex-e2e/infx/golden_al_distribution/glm-5.3-flash__mtp__native__default-default.yaml
 create mode 100644 inferencex-e2e/infx/golden_al_distribution/glm-5.3-nvfp4__mtp__native__default-default.yaml
 delete mode 100644 inferencex-e2e/infx/golden_al_distribution/glm5.3_mtp.yaml
 delete mode 100644 inferencex-e2e/infx/golden_al_distribution/glm5.3flash_mtp.yaml
 create mode 100644 inferencex-e2e/infx/golden_al_distribution/identities.yaml
 create mode 100644 inferencex-e2e/infx/golden_al_distribution/identity.py
 create mode 100644 inferencex-e2e/infx/golden_al_distribution/kimi-k3.1-pro__dflash__kimi-k3.1-dflash2-preview__default-block.yaml
 create mode 100644 inferencex-e2e/infx/golden_al_distribution/kimi-k3.1-pro__dspark__kimi-k3.1-pro-dspark-preview__probabilistic-block.yaml
 rename inferencex-e2e/infx/golden_al_distribution/{kimik3_dspark.yaml => kimi-k3__dspark__kimi-k3-dspark__default-default.yaml} (59%)
 rename inferencex-e2e/infx/golden_al_distribution/{kimik3_dspark_probabilistic_sample_method_block_rejection_sample_method.yaml => kimi-k3__dspark__kimi-k3-dspark__probabilistic-block.yaml} (65%)
 create mode 100644 inferencex-e2e/infx/golden_al_distribution/kimi-k3__dspark__kimi-k3-dspark__probabilistic-default.yaml
 rename inferencex-e2e/infx/golden_al_distribution/{minimaxm31flash_dspark.yaml => minimax-m3.1-flash__dspark__native__probabilistic-block.yaml} (71%)
 create mode 100644 inferencex-e2e/infx/golden_al_distribution/minimax-m3__eagle3__minimax-m3-eagle3-gqa__default-block.yaml
 rename inferencex-e2e/infx/golden_al_distribution/{minimaxm3_eagle3_gqa.yaml => minimax-m3__eagle3__minimax-m3-eagle3-gqa__default-default.yaml} (57%)
 rename inferencex-e2e/infx/golden_al_distribution/{minimaxm3_eagle3.yaml => minimax-m3__eagle3__minimax-m3-eagle3__default-default.yaml} (57%)
 rename inferencex-e2e/infx/golden_al_distribution/{musespark_dflash.yaml => muse-spark-open-816b-a42b-nvfp4__dflash__muse-spark-open-dflash2__default-default.yaml} (74%)
 rename inferencex-e2e/infx/golden_al_distribution/{qwen3.5_mtp.yaml => qwen3.5-397b-a17b-nvfp4__mtp__native__default-default.yaml} (57%)
 rename inferencex-e2e/infx/golden_al_distribution/{qwen3.8next_mtp.yaml => qwen3.8-flash-next-fp8__mtp__native__default-default.yaml} (62%)
 create mode 100644 inferencex-e2e/infx/results/agentic/backends/tokenspeed.py
 create mode 100644 inferencex-e2e/infx/results/agentic/spec_decode.py
 create mode 100644 inferencex-e2e/infx/results/power/cpu_side.py
 create mode 100644 inferencex-e2e/infx/srt_slurm/al_gate.py
 create mode 100644 inferencex-e2e/infx/srt_slurm/spec_identity.py
 create mode 100644 inferencex-e2e/infx/tests/bench/test_al_gate.py
 create mode 100644 inferencex-e2e/infx/tests/bench/test_speedbench.py
 delete mode 100644 inferencex-e2e/infx/tests/bench/test_speedbench_al.py
 create mode 100644 inferencex-e2e/infx/tests/golden_al_distribution/test_spec_identity.py
 create mode 100644 inferencex-e2e/infx/tests/results/agentic/test_spec_decode.py
 create mode 100644 inferencex-e2e/infx/tests/srt_slurm/test_al_gate_plan.py
 create mode 100644 inferencex-e2e/infx/tests/workflows/test_pr_checklist.py
 create mode 100644 inferencex-e2e/infx/workflows/pr_checklist.py

diff --git a/.github/AGENT_OPERATIONS.md b/.github/AGENT_OPERATIONS.md
index 69f653c531..6a5cf1ce93 100644
--- a/.github/AGENT_OPERATIONS.md
+++ b/.github/AGENT_OPERATIONS.md
@@ -70,13 +70,21 @@ Eval selection, the `--no-evals` / `--evals-only` / `--all-evals` flags, and cha
 
 ## Power telemetry
 
-Multinode srt-slurm results, and single-node fixed-sequence and AgentX results with a retained native telemetry package, may include `power_valid`, `avg_power_w`, `avg_total_gpu_power_w`, `total_gpu_energy_j`, and joules per query/input/output/total token. Invalid telemetry records `power_valid: 0` without energy metrics and fails only with `REQUIRE_POWER=1`.
+Multinode srt-slurm results, and single-node fixed-sequence and AgentX results with a retained native telemetry package, may include `power_valid`, `avg_power_w`, `avg_total_gpu_power_w`, `total_gpu_energy_j`, and joules per query/input/output/total token. Invalid telemetry records `power_valid: 0` without energy metrics and fails only with `REQUIRE_POWER=1`, or always on AgentX lanes whose launcher validates power.
 
 Multinode disaggregated results add `prefill_gpu_energy_j`, `decode_gpu_energy_j`, `prefill_avg_power_w`, `decode_avg_power_w`, `prefill_joules_per_input_token`, and `decode_joules_per_output_token`. Role energy covers the full formal benchmark window, not kernel-level phases, and the role watts are that energy divided by the same window and by the role's GPU count.
 
+A multinode master row with `cpu-power: true` beside `power: true` adds srt-slurm's CPU leg; every multinode benchmark point on a cluster that declares a CPU exporter binds the leg, and `cpu-power: true` makes it expected. The binder merges `telemetry.cpu_power_exporter` into the bound recipe from the cluster's `srt-slurm.cpu-power-exporter` record in `inferencex-e2e/configs/runners.yaml` (ACPI on `gb200-nv` and `gb300-nv`, RAPL on the AMD clusters), the same way it merges the GPU telemetry block, so recipe fragments and `additional-settings` never carry it; `make setup` pins the exporter release from `CPU_POWER_EXPORTER_RELEASE` in `infx/launch/drivers/srt/checkout.py` for jobs that bind it, and the workflow exports `CPU_POWER=1` once for both the launcher and the result processor.
+
+The package then carries `power/cpu/samples.csv` in srt-slurm's wide format (one row per scrape, host, and Grace socket; two sockets per worker host in the manifest topology), and the aggregate adds `cpu_power_valid`, `avg_cpu_socket_power_w`, `avg_total_cpu_power_w`, and `total_cpu_energy_j` from the `CPU<n>:cpuSidePowerUsageW` series, plus `avg_total_cpu_rail_power_w` / `total_cpu_rail_energy_j` (ACPI `CPU Power Socket N`, cores only) and `avg_total_cpu_sysio_power_w` / `total_cpu_sysio_energy_j` (ACPI `SysIO Power Socket N`), each pair only when every socket reports that rail without gaps. The meters nest ([NVIDIA Grace power guide](https://docs.nvidia.com/dccpu/grace-perf-tuning-guide/power-thermals.html)): `Grace Power Socket N` is the whole socket (CPU rail, SysIO rail, LPDDR5X, and regulator loss) and the two rails are a breakdown inside it, so never add them to or subtract them from the total; a GB300 socket reads about 97 W while its rails sum to about 55 W. The DRAM rail is blank on the CI NVL72 firmware. srt-slurm v2.59.0+ writes NVML superchip module power as `module_w` (CPU samples schema v3) when its exporter can load NVML (the aarch64 glibc build, srt-slurm #609), and the aggregate then publishes `avg_total_module_power_w` / `total_module_energy_j` under the same every-socket, gap-free rule; the module includes both GPUs, so never add it to the CPU or GPU totals. Every series is integrated over the bound formal GPU window with the GPU leg's trapezoid, boundary interpolation, and 3.0 s gap limit; the sidecar's `cpu` block, mirrored as `power_audit.cpu`, records `sensor_kind: grace_socket`, `source`, socket and row counts, and reason codes. A valid GPU leg also publishes `workers[]`: one entry per worker per host (`role`, the manifest's `worker_idx`, `hosts` holding that one host, `num_gpus`, `avg_power_w`), so a worker spanning trays repeats its index once per host and can be modeled per tray; it is omitted when a GPU belongs to two workers.
+
+A native single-node fixed-sequence row with `cpu-power: true` adds the same leg. Single-node rows have no `power` field because their native points always measure GPU power; eval-only and acceptance-gate jobs bind no CPU exporter. RAPL clusters (`mi300x-amd`, `mi325x-amd`, `mi355x-amds`) read each AMD EPYC package as `CPU<n>:packagePowerUsageW` and publish the three headline CPU keys with `sensor_kind: rapl_package` and no rail keys. RAPL `energy_uj` counters are root-only, so a job that binds a RAPL exporter adds a host-setup command that gives the job user each top-level counter and a teardown that returns them to root. A failed grant only warns, so the CPU leg is then judged by the verdict below; a cancelled job skips teardown, and a failed restore shows up only in the job's `logs/host_teardown_<node>.out`.
+
+The CPU verdict is independent of `power_valid`: a failed leg records `cpu_power_valid: 0` with no CPU keys and leaves every GPU field unchanged. It fails the job only when power is required (`REQUIRE_POWER=1`, or on AgentX lanes whose launcher validates power, except multinode points whose row omits `power`) and the row set `cpu-power`; missing CPU artifacts are then a verdict (`cpu_artifacts_missing`) rather than silence. Other reason codes: `cpu_samples_missing`, `cpu_samples_header_mismatch`, `cpu_samples_malformed`, `cpu_socket_count_mismatch` (also when a host reports only the DCGM CPU rail), `cpu_sample_gap_exceeded`, `cpu_window_not_bracketed`, `cpu_window_unavailable`, and the shared `non_finite_power_metric`.
+
 Every power result, valid or invalid, carries `power_metric_schema_version`. Version 2 defines each unprefixed `joules_per_*` field as whole-deployment GPU-board energy over the named denominator; role-scoped energy uses the explicit `prefill_*` / `decode_*` keys. Rows without the field predate the whole-deployment switch and their unprefixed joules are not comparable across topologies.
 
-A multinode master row with `power: true` enables official energy collection through the shared telemetry fragment; native single-node throughput and AgentX jobs enable telemetry through their bound recipe. Native single-node jobs inherit the exporter image, labels and metrics from the cluster's `default_gpu_exporter` in `inferencex-e2e/configs/runners.yaml`: DCGM on NVIDIA, the `kind: custom` AMD device-metrics-exporter on AMD. Multi-node power rows keep their shared DCGM telemetry block. Eval-only jobs omit collection. The Git submodule pointer at `inferencex-e2e/utils/srt-slurm` is the source of truth for every srt-slurm job, including TileRT. CI derives `POWER_PRODUCER_SHA` from the launcher stamp. The aggregate-power and AgentX power tests validate telemetry and provenance. These local tests do not prove hardware power collection. Eligible `dynamo-sglang` dcgm-power lanes are validated.
+A multinode master row with `power: true` enables official energy collection through the shared telemetry fragment. Every multinode benchmark point on a cluster with a GPU exporter measures GPU power, and CPU power where the cluster declares a CPU exporter, whether or not its row sets `power`; invalid telemetry then records `power_valid: 0` and keeps the result, while `power: true` keeps invalid AgentX power fatal. Native single-node throughput and AgentX jobs enable telemetry through their bound recipe. Native single-node jobs inherit the exporter image, labels and metrics from the cluster's `default_gpu_exporter` in `inferencex-e2e/configs/runners.yaml`: DCGM on NVIDIA, the `kind: custom` AMD device-metrics-exporter on AMD. Multi-node points take the shared DCGM telemetry block on a cluster with `power-exporter-port` and the cluster's `default_gpu_exporter` elsewhere. Eval-only jobs omit collection. The Git submodule pointer at `inferencex-e2e/utils/srt-slurm` is the source of truth for every srt-slurm job, including TileRT. CI derives `POWER_PRODUCER_SHA` from the launcher stamp. The aggregate-power and AgentX power tests validate telemetry and provenance. These local tests do not prove hardware power collection. Eligible `dynamo-sglang` dcgm-power lanes are validated.
 
 Power audit artifacts are named `power_audit_<result>` and contain the `power_validation*.json` sidecars plus, for native telemetry jobs, `LOGS/power/` (`samples.csv` v3 with `temperature_c`, `manifest.json`, `windows/`). They are uploaded even when validation fails.
 
diff --git a/.github/actions/classify-priority/action.yml b/.github/actions/classify-priority/action.yml
new file mode 100644
index 0000000000..4fee106105
--- /dev/null
+++ b/.github/actions/classify-priority/action.yml
@@ -0,0 +1,174 @@
+name: Classify CI priority criteria
+description: >-
+    Classify an unmerged diff into CI priority criteria. Emits no criteria when
+    head is already on the default branch, and falls back to patchwork when
+    classification fails.
+
+inputs:
+    head-ref:
+        description: Revision under test
+        required: true
+    base-ref:
+        description: Diff base; empty uses the merge base with the default branch
+        required: false
+        default: ""
+    scope:
+        description: "full returns every criterion; patchwork returns only the patchwork verdict"
+        required: false
+        default: full
+    pr-number:
+        description: Pull request whose description decides checklist-complete; empty never returns it
+        required: false
+        default: ""
+    anthropic-api-key:
+        description: Anthropic API key for the classifier
+        required: true
+    github-token:
+        description: GitHub token for claude-code-action and reading the PR description
+        required: true
+
+outputs:
+    criteria:
+        description: JSON array for ci_priority --criteria-json, or empty for unscoped scoring
+        value: ${{ steps.normalize.outputs.criteria }}
+
+runs:
+    using: composite
+    steps:
+        - name: Resolve classification range
+          id: range
+          shell: bash
+          env:
+              HEAD_REF: ${{ inputs.head-ref }}
+              BASE_REF: ${{ inputs.base-ref }}
+              SCOPE: ${{ inputs.scope }}
+              DEFAULT_BRANCH: ${{ github.event.repository.default_branch }}
+          run: |
+              if [ "$SCOPE" != "full" ] && [ "$SCOPE" != "patchwork" ]; then
+                  echo "::error::scope must be full or patchwork, got '$SCOPE'" >&2
+                  exit 1
+              fi
+              head=$(git rev-parse --verify "${HEAD_REF}^{commit}")
+              base="$BASE_REF"
+              if [ -z "$base" ]; then
+                  if [ "$(git rev-parse --is-shallow-repository)" = "true" ] ||
+                     ! git rev-parse --verify -q "origin/${DEFAULT_BRANCH}" >/dev/null; then
+                      echo "::error::classify-priority needs a full-history checkout (fetch-depth: 0) with origin/${DEFAULT_BRANCH}" >&2
+                      exit 1
+                  fi
+                  if git merge-base --is-ancestor "$head" "origin/${DEFAULT_BRANCH}"; then
+                      echo "Head $head is already on ${DEFAULT_BRANCH}; skipping priority classification."
+                      exit 0
+                  fi
+                  base=$(git merge-base "$head" "origin/${DEFAULT_BRANCH}")
+              fi
+              {
+                  echo "base=$base"
+                  echo "head=$head"
+              } >> "$GITHUB_OUTPUT"
+
+        - name: Load supported criteria
+          id: schema
+          if: steps.range.outputs.head != ''
+          shell: bash
+          env:
+              E2E_ROOT: ${{ github.action_path }}/../../../inferencex-e2e
+          run: |
+              criteria=$(env PYTHONPATH="$E2E_ROOT" \
+                uv run --no-project --exclude-newer PT12H --python 3.12 --with pyyaml \
+                python -P -m infx.workflows.ci_priority \
+                --policy "$E2E_ROOT/configs/ci-priority.yaml" --list-criteria)
+              schema=$(jq -c 'map(select(. != "checklist-complete")) | {type:"object",properties:{criteria:{type:"array",items:{type:"string",enum:.},uniqueItems:true},reason:{type:"string"}},required:["criteria","reason"]}' <<<"$criteria")
+              echo "json=$schema" >> "$GITHUB_OUTPUT"
+
+        - name: Check PR checklist
+          id: checklist
+          if: steps.range.outputs.head != '' && inputs.pr-number != ''
+          continue-on-error: true
+          shell: bash
+          env:
+              GH_TOKEN: ${{ inputs.github-token }}
+              PR_NUMBER: ${{ inputs.pr-number }}
+              E2E_ROOT: ${{ github.action_path }}/../../../inferencex-e2e
+          run: |
+              complete=$(gh api "repos/${GITHUB_REPOSITORY}/pulls/${PR_NUMBER}" --jq '.body // ""' |
+                env PYTHONPATH="$E2E_ROOT" uv run --no-project --exclude-newer PT12H --python 3.12 \
+                python -P -m infx.workflows.pr_checklist)
+              echo "complete=$complete" >> "$GITHUB_OUTPUT"
+
+        - name: Install Claude Code 2.1.282
+          id: claude_cli
+          if: steps.range.outputs.head != ''
+          shell: bash
+          run: | # zizmor: ignore[adhoc-packages] Claude CLI and its native packages are pinned to 2.1.282
+              npm install --prefix "$RUNNER_TEMP/claude-code" --no-audit --no-fund @anthropic-ai/claude-code@2.1.282
+              claude_cli="$RUNNER_TEMP/claude-code/node_modules/.bin/claude"
+              test "$("$claude_cli" --version)" = "2.1.282 (Claude Code)"
+              echo "path=$claude_cli" >> "$GITHUB_OUTPUT"
+
+        - name: Classify priority criteria
+          id: classify
+          if: steps.range.outputs.head != ''
+          continue-on-error: true
+          uses: anthropics/claude-code-action@9171db3e57d6a3140a37ddc2ba92788584e0ead6 # v1.0.234
+          with:
+              path_to_claude_code_executable: ${{ steps.claude_cli.outputs.path }}
+              github_token: ${{ inputs.github-token }}
+              anthropic_api_key: ${{ inputs.anthropic-api-key }}
+              track_progress: false
+              settings: |
+                  {"fastMode": true}
+              claude_args: |
+                  --model 'claude-opus-5-5'
+                  --effort low
+                  --max-turns 8
+                  --allowedTools "Read,Glob,Grep,Bash(git diff:*)"
+                  --json-schema '${{ steps.schema.outputs.json }}'
+              prompt: |
+                  Inspect the diff `git diff ${{ steps.range.outputs.base }}...${{ steps.range.outputs.head }}`.
+
+                  Return every matching priority criterion:
+
+                  - multi-node: separate prefill and decode workers
+                  - agentic: agentic-coding or AgentX workload
+                  - eval-only: evaluation without throughput measurement
+                  - fp4: FP4 precision
+                  - mtp, draft_model: speculative decoding method
+                  - sglang, vllm, dynamo-sglang, dynamo-vllm: runtime framework
+                  - model criterion: the config model-prefix itself (minimaxm31flash, not minimaxm3)
+                  - patchwork: modified upstream engine or runtime source
+
+                  Patchwork includes patch files, git apply, source mutation,
+                  monkey-patching, local engine builds, forks, or images
+                  containing unmerged engine changes.
+
+                  Return a concise reason grounded in the diff.
+
+        - name: Normalize priority classification
+          id: normalize
+          if: always() && steps.range.outputs.head != ''
+          shell: bash
+          env:
+              OUTPUT: ${{ steps.classify.outputs.structured_output || '{}' }}
+              SCOPE: ${{ inputs.scope }}
+              CHECKLIST_COMPLETE: ${{ steps.checklist.outputs.complete }}
+          run: |
+              if jq -e 'type == "object" and (.criteria | type == "array")' \
+                >/dev/null <<<"$OUTPUT"; then
+                  criteria=$(jq -c '.criteria' <<<"$OUTPUT")
+              else
+                  criteria='["patchwork"]'
+              fi
+              criteria=$(jq -c 'map(select(. != "checklist-complete"))' <<<"$criteria")
+              if [ "$CHECKLIST_COMPLETE" = "true" ]; then
+                  criteria=$(jq -c '. + ["checklist-complete"]' <<<"$criteria")
+              fi
+              if [ "$SCOPE" = "patchwork" ]; then
+                  if jq -e 'index("patchwork")' >/dev/null <<<"$criteria"; then
+                      criteria='["patchwork"]'
+                  else
+                      criteria=''
+                  fi
+              fi
+              echo "criteria=$criteria" >> "$GITHUB_OUTPUT"
+              echo "Priority criteria: ${criteria:-<unscoped>}"
diff --git a/.github/codeowner-signoff-verify-prompt.md b/.github/codeowner-signoff-verify-prompt.md
index 868c764afe..fecab0f8ba 100644
--- a/.github/codeowner-signoff-verify-prompt.md
+++ b/.github/codeowner-signoff-verify-prompt.md
@@ -559,10 +559,14 @@ Verify BOTH:
   Name the config/script and line.
 - (b) AL VALUE MATCHES THE GOLDEN CURVE. Read the committed golden AL YAML for the
   model in `inferencex-e2e/infx/golden_al_distribution/` on the default-branch checkout. Examples include
-  `qwen3.5_mtp.yaml` and `minimaxm3_eagle3.yaml`. Confirm the pinned AL equals the golden value for that
+  `qwen3.5-397b-a17b-nvfp4__mtp__native__default-default.yaml` and `minimax-m3__eagle3__minimax-m3-eagle3__default-default.yaml`. Confirm the pinned AL equals the golden value for that
   model, thinking mode, and the config's `num_speculative_tokens` / MTP level (e.g.
   qwen3.5 thinking_on with 3 speculative tokens -> 3.39; `signoff_facts golden-al` returns
-  the expected value and setting). For TRT-LLM configs, compare
+  the expected value and setting; pass the generation role's verifier, as `identities.yaml` may select on it:
+  `--verify block` for vLLM `rejection_sample_method: block` or `synthetic` and SGLang
+  `speculative-use-block-verification`, `--verify relaxed` for TRT-LLM
+  `use_relaxed_acceptance_for_thinking`, `--verify standard` for vLLM, SGLang and TRT-LLM roles
+  that set none, and no `--verify` for ATOM and TileRT). For TRT-LLM configs, compare
   the pinned `TLLM_SPEC_DECODE_FORCE_NUM_ACCEPTED_TOKENS` value PLUS 1 against the
   golden AL (the env var excludes the bonus token). A submission may choose any
   supported draft length, but it may NOT substitute a different acceptance target.
diff --git a/.github/workflows/README.md b/.github/workflows/README.md
index a3b9d45166..befe37537b 100644
--- a/.github/workflows/README.md
+++ b/.github/workflows/README.md
@@ -162,7 +162,7 @@ test-config --config-keys dsr1-fp8-h200-sglang --evals-only --all-evals --config
 
 ## PR Sweep Labels
 
-`run-sweep.yml` sweeps only same-repository PRs, including stacked PRs, that change
+`run-sweep.yml` sweeps only same-repository PRs that change
 `inferencex-e2e/perf-changelog.yaml`, using the appended entries as the matrix.
 Apply exactly one primary label, normally `full-sweep-fail-fast`.
 Fork PRs use the [trusted dispatch](#trusted-external-fork-sweep-dispatch-poc).
@@ -186,8 +186,16 @@ Labels authorize same-repository sweeps on draft or ready PRs. Marking ready
 does not dispatch a sweep. Changing a recognized primary or modifier label
 cancels the active sweep; another starts only if a primary label remains.
 To retrigger an already-labeled PR, remove and reapply its primary label.
-Merge conflicts block sweeps. Queue priority comes from the PR diff and
-review state, not priority labels.
+Merge conflicts block sweeps. Queue priority comes from the PR diff and the
+PR description's checklist, not priority labels. A PR gets a small bonus when
+every item under its `Checklist` heading is checked, except conditional items
+("If ...", "Before merging ...") that do not apply yet. The checklist is read
+when the sweep starts, so later edits count from the next sweep. Trusted
+external sweeps classify the approved PR diff the same way. Manual
+`e2e-tests.yml` and `profile.yml` dispatches of a revision not yet on `main`
+classify its diff from the merge
+base only for patchwork, so engine-patching branches still run last. Klaud runs
+and revisions already on `main` keep unclassified scoring.
 
 The canary is the lowest-concurrency non-eval candidate among single-node
 fixed-sequence 1k/1k, 8k/1k, or AgentX entries, falling back to multi-node AgentX.
@@ -197,6 +205,10 @@ cancels siblings within each matrix family, not every independent family.
 Find the first actual failure before treating a cancelled run as a flake.
 Manual `e2e-tests.yml` has no canary and defaults `fail-fast` to false.
 
+## Speculative acceptance gate
+
+AgentX throughput forces speculative acceptance to the committed golden acceptance length (AL). The acceptance gate, milestone M1 of [#1651](https://github.com/SemiAnalysisAI/InferenceX/issues/1651), measures each agentic speculative eval's real AL on the eval's own server, in the same Slurm job, before the eval runs. `run-sweep.yml` and `e2e-tests.yml` call [`al-gate-prompts.yml`](al-gate-prompts.yml) for the SPEED-Bench prompts before their agentic eval jobs, and `collect-evals.yml` tabulates the verdicts. The gate is report-only: a verdict, a skipped gate or a failed measurement never fails the eval or the run. See [the speculative acceptance gate](../../inferencex-e2e/infx/evals/EVALS.md#speculative-acceptance-gate) for how it is planned, run, and skipped.
+
 ## Changelog Conflict Recovery
 
 Run from `inferencex-e2e/`. After fetching and merging `origin/main`, if the
diff --git a/.github/workflows/al-gate-prompts.yml b/.github/workflows/al-gate-prompts.yml
new file mode 100644
index 0000000000..86b72ecc35
--- /dev/null
+++ b/.github/workflows/al-gate-prompts.yml
@@ -0,0 +1,104 @@
+name: AL Gate Prompts Cache
+
+# Prepares the 80 SPEED-Bench coding prompts that agentic speculative evals replay before their
+# eval, on the same server (inferencex-e2e/infx/evals/EVALS.md#speculative-acceptance-gate).
+# Pushes to main and the weekly schedule keep the cache warm; sweeps call it with upload: true
+# to hand the prompts to their eval jobs. Report-only: callers' evals run without the gate if it
+# fails, and the gate records why.
+
+on:
+  push:
+    branches:
+      - main
+    paths:
+      - inferencex-e2e/infx/bench/speedbench.py
+      - .github/workflows/al-gate-prompts.yml
+  schedule:
+    - cron: '41 5 * * 1'
+  workflow_dispatch:
+  workflow_call:
+    inputs:
+      upload:
+        description: "Upload the prompts as the al_gate_dataset artifact"
+        type: boolean
+        default: false
+    secrets:
+      INFERENCEX_OFFICIAL_RO_HF_TOKEN:
+        required: false
+
+permissions:
+  contents: read
+
+jobs:
+  warm:
+    name: warm
+    runs-on: ubuntu-latest
+    # A sweep's evals wait for this job: a stall ends it and they run without the gate.
+    timeout-minutes: ${{ inputs.upload && 30 || 360 }}
+    continue-on-error: ${{ inputs.upload == true }}
+    # Cache warming runs one at a time; a sweep's call prepares its own prompts on a miss.
+    concurrency:
+      group: ${{ inputs.upload && format('al-gate-prompts-{0}-{1}', github.run_id, github.run_attempt) || 'al-gate-prompts' }}
+      cancel-in-progress: false
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        continue-on-error: ${{ inputs.upload == true }} # A sweep's evals run without the gate.
+        with:
+          persist-credentials: false
+
+      - name: Restore cached prompts
+        continue-on-error: ${{ inputs.upload == true }} # A sweep's evals run without the gate.
+        id: cached
+        uses: actions/cache/restore@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
+        with:
+          path: ${{ runner.temp }}/al_gate_dataset
+          key: al-gate-speedbench-${{ hashFiles('inferencex-e2e/infx/bench/speedbench.py') }}
+          lookup-only: ${{ !inputs.upload }}
+
+      - name: Free hosted-runner disk for SPEED-Bench
+        continue-on-error: ${{ inputs.upload == true }} # A sweep's evals run without the gate.
+        if: ${{ steps.cached.outputs.cache-hit != 'true' }}
+        run: |
+          # The pinned resolver materializes about 35 GB of coding source datasets.
+          # These preinstalled SDKs are unused by this hosted Python-only job.
+          sudo rm -rf -- /usr/local/lib/android /usr/share/dotnet /opt/ghc \
+            /usr/local/.ghcup /usr/local/swift /opt/hostedtoolcache/CodeQL
+          df -h / /mnt
+
+      - uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+        continue-on-error: ${{ inputs.upload == true }} # A sweep's evals run without the gate.
+        if: ${{ steps.cached.outputs.cache-hit != 'true' }}
+        with:
+          enable-cache: false
+
+      - name: Prepare gate prompts
+        continue-on-error: ${{ inputs.upload == true }} # A sweep's evals run without the gate.
+        id: prepare
+        if: ${{ steps.cached.outputs.cache-hit != 'true' }}
+        env:
+          # Read-only Hugging Face credential; it only lifts anonymous Hub rate limits.
+          HF_TOKEN: ${{ secrets.INFERENCEX_OFFICIAL_RO_HF_TOKEN }} # zizmor: ignore[secrets-outside-env]
+          HF_HOME: /mnt/al-gate-hf-home # The ~35 GB of SPEED-Bench sources exceed the root disk's free space.
+        run: |
+          cd "$GITHUB_WORKSPACE/inferencex-e2e"
+          sudo install -d -o "$(id -u)" -g "$(id -g)" "$HF_HOME"
+          uv run --no-project --exclude-newer 2026-10-27T00:00:00Z --python 3.12 \
+            --with datasets --with numpy --with pandas --with tiktoken \
+            python -m infx.bench.speedbench --output-dir "$RUNNER_TEMP/al_gate_dataset"
+
+      - name: Cache gate prompts
+        continue-on-error: ${{ inputs.upload == true }} # A sweep's evals run without the gate.
+        if: ${{ steps.prepare.outcome == 'success' }}
+        uses: actions/cache/save@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
+        with:
+          path: ${{ runner.temp }}/al_gate_dataset
+          key: al-gate-speedbench-${{ hashFiles('inferencex-e2e/infx/bench/speedbench.py') }}
+
+      - name: Upload gate prompts
+        continue-on-error: ${{ inputs.upload == true }} # A sweep's evals run without the gate.
+        if: ${{ inputs.upload }}
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: al_gate_dataset
+          path: ${{ runner.temp }}/al_gate_dataset/speedbench_coding.jsonl
+          if-no-files-found: error
diff --git a/.github/workflows/benchmark-multinode-tmpl.yml b/.github/workflows/benchmark-multinode-tmpl.yml
index 9f61b9ecd7..fa011ff0ca 100644
--- a/.github/workflows/benchmark-multinode-tmpl.yml
+++ b/.github/workflows/benchmark-multinode-tmpl.yml
@@ -143,6 +143,8 @@ env:
   EVAL_CONC: ${{ inputs.eval-conc }}
   EVAL_LIMIT: ${{ inputs.eval-limit }}
   POWER: ${{ fromJSON(inputs.config).power && '1' || '0' }}
+  CPU_POWER: ${{ fromJSON(inputs.config)['cpu-power'] && '1' || '0' }}
+  AL_GATE_DATASET: ${{ inputs.eval-only && inputs.scenario-type == 'agentic-coding' && 'al_gate_dataset/speedbench_coding.jsonl' || '' }}
   REQUIRE_POWER: ${{ inputs.require-power && '1' || '0' }}
   POWER_PRODUCER_SHA: ${{ inputs.power-producer-sha }}
   SCENARIO_TYPE: ${{ inputs.scenario-type }}
@@ -289,6 +291,14 @@ jobs:
         run: &launcher-cleanup |
           "$INFERENCEX_LAUNCH_PYTHON" -P -m infx.launch cleanup
 
+      - name: Download acceptance gate prompts
+        if: ${{ inputs.eval-only && inputs.scenario-type == 'agentic-coding' && env.SPEC_DECODING != 'none' }}
+        continue-on-error: true # Without them the eval runs alone and the gate records why.
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        with:
+          name: al_gate_dataset
+          path: ${{ github.workspace }}/inferencex-e2e/al_gate_dataset
+
       - name: Launch multi-node job script
         env:
           PREFILL_ADDITIONAL_SETTINGS: ${{ toJSON(fromJSON(inputs.config).prefill.additional-settings) }}
@@ -537,6 +547,7 @@ jobs:
           path: |
             ${{ env.INFERENCEX_E2E_ROOT }}/meta_env.json
             ${{ env.INFERENCEX_E2E_ROOT }}/results*.json
+            ${{ env.INFERENCEX_E2E_ROOT }}/al_gate_*.json
             ${{ env.INFERENCEX_E2E_ROOT }}/*_report.json
             ${{ env.INFERENCEX_E2E_ROOT }}/*_results.jsonl
             ${{ env.INFERENCEX_E2E_ROOT }}/sample*.jsonl
@@ -562,6 +573,7 @@ jobs:
           path: |
             ${{ env.INFERENCEX_E2E_ROOT }}/meta_env.json
             ${{ env.INFERENCEX_E2E_ROOT }}/results*.json
+            ${{ env.INFERENCEX_E2E_ROOT }}/al_gate_*.json
             ${{ env.INFERENCEX_E2E_ROOT }}/*_report.json
             ${{ env.INFERENCEX_E2E_ROOT }}/*_results.jsonl
             ${{ env.INFERENCEX_E2E_ROOT }}/sample*.jsonl
@@ -585,6 +597,7 @@ jobs:
           path: |
             ${{ env.INFERENCEX_E2E_ROOT }}/meta_env.json
             ${{ env.INFERENCEX_E2E_ROOT }}/results*.json
+            ${{ env.INFERENCEX_E2E_ROOT }}/al_gate_*.json
             ${{ env.INFERENCEX_E2E_ROOT }}/*_report.json
             ${{ env.INFERENCEX_E2E_ROOT }}/*_results.jsonl
             ${{ env.INFERENCEX_E2E_ROOT }}/sample*.jsonl
@@ -611,6 +624,7 @@ jobs:
           if [[ -f inferencex-e2e/configs/runners.yaml ]]; then cd inferencex-e2e; fi
           rm -f meta_env.json || true
           rm -f results*.json || true
+          rm -f al_gate_*.json || true
           rm -f -- ./*_report.json || true
           rm -f -- ./*_results.jsonl || true
           rm -f -- ./*_artifacts.tar.gz || true
diff --git a/.github/workflows/benchmark-tmpl.yml b/.github/workflows/benchmark-tmpl.yml
index adb39e1962..5b8d8bf862 100644
--- a/.github/workflows/benchmark-tmpl.yml
+++ b/.github/workflows/benchmark-tmpl.yml
@@ -98,6 +98,7 @@ env:
   SALLOC_TIME_LIMIT: '480'
   IS_MULTINODE: 'false'
   REQUIRE_POWER: ${{ inputs.require-power && '1' || '0' }}
+  CPU_POWER: ${{ fromJSON(inputs.config)['cpu-power'] && '1' || '0' }}
   RANDOM_RANGE_RATIO: 0.8
   HF_TOKEN: ${{ secrets.INFERENCEX_OFFICIAL_RO_HF_TOKEN }}
   HF_HUB_CACHE: '/mnt/hf_hub_cache/'
@@ -137,6 +138,7 @@ env:
   DURATION: ${{ inputs.duration }}
   AIPERF_EXPERIMENTAL_FAST: ${{ inputs.agentx-fast && '1' || '0' }}
   EVAL_LIMIT: ${{ inputs.eval-limit }}
+  AL_GATE_DATASET: ${{ inputs.eval-only && inputs.scenario-type == 'agentic-coding' && 'al_gate_dataset/speedbench_coding.jsonl' || '' }}
   AIPERF_FAILED_REQUEST_THRESHOLD: '0.10'
   RESULT_DIR: /workspace/results
   PYTHONDONTWRITEBYTECODE: '1'
@@ -257,6 +259,14 @@ jobs:
         run: &launcher-cleanup |
           "$INFERENCEX_LAUNCH_PYTHON" -P -m infx.launch cleanup
 
+      - name: Download acceptance gate prompts
+        if: ${{ inputs.eval-only && inputs.scenario-type == 'agentic-coding' && env.SPEC_DECODING != 'none' }}
+        continue-on-error: true # Without them the eval runs alone and the gate records why.
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        with:
+          name: al_gate_dataset
+          path: ${{ github.workspace }}/inferencex-e2e/al_gate_dataset
+
       - name: Launch job script
         env:
           RUNNER_NAME: ${{ runner.name }}
@@ -500,6 +510,7 @@ jobs:
           path: |
             ${{ env.INFERENCEX_E2E_ROOT }}/meta_env.json
             ${{ env.INFERENCEX_E2E_ROOT }}/results*.json
+            ${{ env.INFERENCEX_E2E_ROOT }}/al_gate_*.json
             ${{ env.INFERENCEX_E2E_ROOT }}/*_report.json
             ${{ env.INFERENCEX_E2E_ROOT }}/*_results.jsonl
             ${{ env.INFERENCEX_E2E_ROOT }}/*_artifacts.tar.gz
@@ -521,6 +532,7 @@ jobs:
           path: |
             ${{ env.INFERENCEX_E2E_ROOT }}/meta_env.json
             ${{ env.INFERENCEX_E2E_ROOT }}/results*.json
+            ${{ env.INFERENCEX_E2E_ROOT }}/al_gate_*.json
             ${{ env.INFERENCEX_E2E_ROOT }}/*_report.json
             ${{ env.INFERENCEX_E2E_ROOT }}/*_results.jsonl
             ${{ env.INFERENCEX_E2E_ROOT }}/*_artifacts.tar.gz
@@ -544,6 +556,7 @@ jobs:
           path: |
             ${{ env.INFERENCEX_E2E_ROOT }}/meta_env.json
             ${{ env.INFERENCEX_E2E_ROOT }}/results*.json
+            ${{ env.INFERENCEX_E2E_ROOT }}/al_gate_*.json
             ${{ env.INFERENCEX_E2E_ROOT }}/*_report.json
             ${{ env.INFERENCEX_E2E_ROOT }}/*_results.jsonl
             ${{ env.INFERENCEX_E2E_ROOT }}/*_artifacts.tar.gz
@@ -570,6 +583,7 @@ jobs:
           if [[ -f inferencex-e2e/configs/runners.yaml ]]; then cd inferencex-e2e; fi
           rm -f meta_env.json || true
           rm -f results*.json || true
+          rm -f al_gate_*.json || true
           rm -f -- ./*_report.json || true
           rm -f -- ./*_results.jsonl || true
           rm -f sample*.jsonl || true
diff --git a/.github/workflows/collect-evals.yml b/.github/workflows/collect-evals.yml
index 3b3512a64c..9e2c284c43 100644
--- a/.github/workflows/collect-evals.yml
+++ b/.github/workflows/collect-evals.yml
@@ -58,6 +58,12 @@ jobs:
           uv run --project "$INFERENCEX_PYTHON_PROJECT" --locked --extra results \
             python -m infx.results.collect_eval_results eval_results/ "${RESULT_PREFIX}" >> $GITHUB_STEP_SUMMARY
 
+      - name: Summarize acceptance gates
+        continue-on-error: true # Report-only.
+        run: |
+          uv run --project "$INFERENCEX_PYTHON_PROJECT" --locked \
+            python -m infx.srt_slurm.al_gate summarize eval_results/ >> "$GITHUB_STEP_SUMMARY"
+
       - name: Upload aggregated evals
         uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
         with:
diff --git a/.github/workflows/e2e-tests.yml b/.github/workflows/e2e-tests.yml
index e80395e5f3..22fb27f796 100644
--- a/.github/workflows/e2e-tests.yml
+++ b/.github/workflows/e2e-tests.yml
@@ -99,6 +99,8 @@ on: # zizmor: ignore[concurrency-limits]
         secrets:
           INFERENCEX_OFFICIAL_RO_HF_TOKEN:
             required: true
+          ANTHROPIC_API_KEY:
+            required: false
         inputs:
             generate-cli-command:
                 description: "Command passed to generate matrix script"
@@ -196,6 +198,9 @@ jobs:
     get-jobs:
         name: get-jobs
         runs-on: ubuntu-latest
+        permissions:
+            contents: read
+            pull-requests: read # Read the external PR description for checklist-complete.
         outputs:
             benchmark-ref: ${{ steps.checkout-ref.outputs.commit || steps.checkout-default.outputs.commit }}
             tooling-ref: ${{ steps.tooling.outputs.result }}
@@ -223,6 +228,7 @@ jobs:
               uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
               with:
                 ref: ${{ github.sha }}
+                fetch-depth: 0
                 persist-credentials: false
             - name: Resolve workflow tooling
               id: tooling
@@ -249,6 +255,17 @@ jobs:
                 persist-credentials: false
 
             - uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+            - name: Classify priority criteria
+              id: priority-criteria
+              if: vars.PRIORITY_SCHEDULER_ENABLED == 'true' && !inputs.klaud-run
+              uses: $/.github/actions/classify-priority
+              with:
+                  base-ref: ${{ inputs.changelog-base-ref }}
+                  head-ref: ${{ inputs.changelog-head-ref || 'HEAD' }}
+                  scope: ${{ inputs.changelog-head-ref != '' && 'full' || 'patchwork' }}
+                  pr-number: ${{ inputs.source-pr-number }}
+                  anthropic-api-key: ${{ secrets.ANTHROPIC_API_KEY }} # zizmor: ignore[secrets-outside-env]
+                  github-token: ${{ github.token }}
             - id: get-jobs
               env:
                   GENERATE_COMMAND: ${{ inputs.generate-cli-command || github.event.inputs.generate-cli-command }}
@@ -257,6 +274,7 @@ jobs:
                   TRIM_CONC: ${{ inputs.trim-conc }}
                   ALL_EVALS: ${{ inputs.all-evals }}
                   EVALS_ONLY: ${{ inputs.evals-only }}
+                  PRIORITY_CRITERIA: ${{ steps.priority-criteria.outputs.criteria }}
               run: |
                   if [[ -f inferencex-e2e/configs/runners.yaml ]]; then cd inferencex-e2e; fi
                   MEASURED_ROOT="$PWD"
@@ -322,7 +340,8 @@ jobs:
                       python -P -m infx.workflows.ci_priority \
                       --policy "${PRIORITY_ROOT}/configs/ci-priority.yaml" \
                       --event-name "${GITHUB_EVENT_NAME}" \
-                      --queue-namespace "${GITHUB_RUN_ID}:${GITHUB_RUN_ATTEMPT}:${family}"
+                      --queue-namespace "${GITHUB_RUN_ID}:${GITHUB_RUN_ATTEMPT}:${family}" \
+                      --criteria-json "$PRIORITY_CRITERIA"
                   }
                   AGENTIC=$(echo "$CONFIG_JSON" | python3 -c "import sys,json; d=json.load(sys.stdin); print(json.dumps([x for x in d if x.get('scenario-type') == 'agentic-coding' and 'prefill' not in x and not x.get('eval-only', False)]))" | score_matrix agentic)
                   AGENTIC_EVAL=$(echo "$CONFIG_JSON" | python3 -c "import sys,json; d=json.load(sys.stdin); print(json.dumps([x for x in d if x.get('scenario-type') == 'agentic-coding' and 'prefill' not in x and x.get('run-eval', False)]))" | score_matrix agentic-eval)
@@ -465,9 +484,24 @@ jobs:
             ref: ${{ needs.get-jobs.outputs.benchmark-ref }}
             test-name: ${{ inputs.test-name }}
 
-    test-sweep-agentic-evals:
+    # Prompts for the report-only acceptance gate that agentic speculative evals run before their eval.
+    al-gate-prompts:
         needs: get-jobs
-        if: ${{ needs.get-jobs.outputs.agentic-eval-config != '' && needs.get-jobs.outputs.agentic-eval-config != '[]' }}
+        if: >-
+            ${{
+              (needs.get-jobs.outputs.agentic-eval-config != '' && needs.get-jobs.outputs.agentic-eval-config != '[]') ||
+              (needs.get-jobs.outputs.multi-node-agentic-eval-config != '' && needs.get-jobs.outputs.multi-node-agentic-eval-config != '[]')
+            }}
+        uses: $/.github/workflows/al-gate-prompts.yml
+        secrets:
+            INFERENCEX_OFFICIAL_RO_HF_TOKEN: ${{ secrets.INFERENCEX_OFFICIAL_RO_HF_TOKEN }}
+        with:
+            upload: true
+
+    test-sweep-agentic-evals:
+        needs: [get-jobs, al-gate-prompts]
+        # The acceptance gate is report-only: the evals run whether or not its prompts were prepared.
+        if: ${{ !cancelled() && needs.get-jobs.result == 'success' && needs.get-jobs.outputs.agentic-eval-config != '' && needs.get-jobs.outputs.agentic-eval-config != '[]' }}
         uses: $/.github/workflows/benchmark-tmpl.yml
         name: agentic eval /
         strategy:
@@ -524,8 +558,8 @@ jobs:
             test-name: ${{ inputs.test-name }}
 
     test-sweep-multi-node-agentic-evals:
-        needs: get-jobs
-        if: ${{ needs.get-jobs.outputs.multi-node-agentic-eval-config != '' && needs.get-jobs.outputs.multi-node-agentic-eval-config != '[]' }}
+        needs: [get-jobs, al-gate-prompts]
+        if: ${{ !cancelled() && needs.get-jobs.result == 'success' && needs.get-jobs.outputs.multi-node-agentic-eval-config != '' && needs.get-jobs.outputs.multi-node-agentic-eval-config != '[]' }}
         uses: $/.github/workflows/benchmark-multinode-tmpl.yml
         name: multi-node agentic eval /
         strategy:
diff --git a/.github/workflows/profile.yml b/.github/workflows/profile.yml
index ce9feb53bb..55bb372554 100644
--- a/.github/workflows/profile.yml
+++ b/.github/workflows/profile.yml
@@ -65,6 +65,7 @@ jobs:
         uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
         with:
           ref: ${{ inputs.ref || github.sha }}
+          fetch-depth: 0
           persist-credentials: false
       - name: Checkout priority scheduler tooling
         if: ${{ inputs.ref && inputs.ref != '' }}
@@ -75,6 +76,15 @@ jobs:
           persist-credentials: false
 
       - uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+      - name: Classify priority criteria
+        id: priority-criteria
+        if: vars.PRIORITY_SCHEDULER_ENABLED == 'true' && !inputs.moe-debug
+        uses: $/.github/actions/classify-priority
+        with:
+          head-ref: HEAD
+          scope: patchwork
+          anthropic-api-key: ${{ secrets.ANTHROPIC_API_KEY }} # zizmor: ignore[secrets-outside-env]
+          github-token: ${{ github.token }}
       - id: gen
         name: Generate matrix via script
         run: |
@@ -113,7 +123,7 @@ jobs:
           echo "raw=$CONFIG_JSON" >> "$GITHUB_OUTPUT"
 
         env:
-          PRIORITY_CRITERIA: ${{ inputs.moe-debug && '["patchwork"]' || '' }}
+          PRIORITY_CRITERIA: ${{ inputs.moe-debug && '["patchwork"]' || steps.priority-criteria.outputs.criteria || '' }}
           INPUTS_CONFIG_FILE: ${{ inputs.config-file }}
           INPUTS_CONFIG_KEY: ${{ inputs.config-key }}
           INPUTS_CONC: ${{ inputs.conc }}
diff --git a/.github/workflows/run-sweep.yml b/.github/workflows/run-sweep.yml
index acf9c1995c..6bad8a4c09 100644
--- a/.github/workflows/run-sweep.yml
+++ b/.github/workflows/run-sweep.yml
@@ -18,6 +18,8 @@ concurrency:
 
 on:
     pull_request:
+        branches:
+            - main
         types:
             - synchronize
             - labeled
@@ -191,6 +193,8 @@ jobs:
         outputs:
             tooling-ref: ${{ steps.tooling.outputs.result }}
             search-space-config: ${{ steps.setup.outputs.search-space-config }}
+            # Empty when the priority scheduler is disabled, as for setup's own scoring.
+            priority-criteria: ${{ steps.priority-criteria.outputs.criteria }}
         steps:
             - name: Checkout code
               id: checkout
@@ -216,67 +220,16 @@ jobs:
                       ]).write();
                       return data.sha;
             - uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
-            - name: Install Claude Code 2.1.282
-              id: claude_cli
-              if: vars.PRIORITY_SCHEDULER_ENABLED == 'true'
-              run: | # zizmor: ignore[adhoc-packages] Claude CLI and its native packages are pinned to 2.1.282
-                npm install --prefix "$RUNNER_TEMP/claude-code" --no-audit --no-fund @anthropic-ai/claude-code@2.1.282
-                claude_cli="$RUNNER_TEMP/claude-code/node_modules/.bin/claude"
-                test "$("$claude_cli" --version)" = "2.1.282 (Claude Code)"
-                echo "path=$claude_cli" >> "$GITHUB_OUTPUT"
             - name: Classify priority criteria
-              id: classify
+              id: priority-criteria
               if: vars.PRIORITY_SCHEDULER_ENABLED == 'true'
-              continue-on-error: true
-              uses: anthropics/claude-code-action@9171db3e57d6a3140a37ddc2ba92788584e0ead6 # v1.0.234
+              uses: $/.github/actions/classify-priority
               with:
-                  path_to_claude_code_executable: ${{ steps.claude_cli.outputs.path }}
-                  github_token: ${{ github.token }}
-                  anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }} # zizmor: ignore[secrets-outside-env]
-                  track_progress: false
-                  settings: |
-                      {"fastMode": true}
-                  claude_args: |
-                      --model 'claude-opus-5-5'
-                      --effort low
-                      --max-turns 8
-                      --allowedTools "Read,Glob,Grep,Bash(git diff:*)"
-                      --json-schema '{"type":"object","properties":{"criteria":{"type":"array","items":{"type":"string","enum":["multi-node","agentic","eval-only","fp4","mtp","draft_model","sglang","vllm","dynamo-sglang","dynamo-vllm","musespark","dsv41flash","kimik3","glm5.3","glm5.2","dsv4","minimaxm31flash","minimaxm3","qwen3.5","qwen3.8next","dsr1","checklist-complete","patchwork"]},"uniqueItems":true},"reason":{"type":"string"}},"required":["criteria","reason"]}'
-                  prompt: |
-                      Inspect this pull request's diff against its base branch.
-
-                      Return every matching priority criterion:
-
-                      - multi-node: separate prefill and decode workers
-                      - agentic: agentic-coding or AgentX workload
-                      - eval-only: evaluation without throughput measurement
-                      - fp4: FP4 precision
-                      - mtp, draft_model: speculative decoding method
-                      - sglang, vllm, dynamo-sglang, dynamo-vllm: runtime framework
-                      - model criterion: the config model-prefix itself (minimaxm31flash, not minimaxm3)
-                      - checklist-complete: PR checklist is satisfied
-                      - patchwork: modified upstream engine or runtime source
-
-                      Patchwork includes patch files, git apply, source mutation,
-                      monkey-patching, local engine builds, forks, or images
-                      containing unmerged engine changes.
-
-                      Return a concise reason grounded in the diff.
-
-            - name: Normalize priority classification
-              id: priority-criteria
-              if: vars.PRIORITY_SCHEDULER_ENABLED == 'true' && always()
-              env:
-                  OUTPUT: ${{ steps.classify.outputs.structured_output || '{}' }}
-              run: |
-                  if jq -e 'type == "object" and (.criteria | type == "array")' \
-                    >/dev/null <<<"$OUTPUT"; then
-                      criteria=$(jq -c '.criteria' <<<"$OUTPUT")
-                  else
-                      criteria='["patchwork"]'
-                  fi
-                  echo "criteria=$criteria" >> "$GITHUB_OUTPUT"
-                  echo "Priority criteria: $criteria"
+                  base-ref: origin/${{ github.base_ref }}
+                  head-ref: ${{ github.event.pull_request.head.sha }}
+                  pr-number: ${{ github.event.pull_request.number }}
+                  anthropic-api-key: ${{ secrets.ANTHROPIC_API_KEY }} # zizmor: ignore[secrets-outside-env]
+                  github-token: ${{ github.token }}
 
             - id: setup
               env:
@@ -316,11 +269,14 @@ jobs:
         name: canary-select
         needs: setup
         if: >-
-            !cancelled() && needs.setup.result == 'success' &&
-            (
-              contains(github.event.pull_request.labels.*.name, 'full-sweep-enabled') ||
-              contains(github.event.pull_request.labels.*.name, 'full-sweep-fail-fast')
-            )
+            ${{
+              !cancelled() &&
+              needs.setup.result == 'success' &&
+              (
+                contains(github.event.pull_request.labels.*.name, 'full-sweep-enabled') ||
+                contains(github.event.pull_request.labels.*.name, 'full-sweep-fail-fast')
+              )
+            }}
         runs-on: ubuntu-latest
         outputs:
             canary-config: ${{ steps.pick.outputs.canary-config }}
@@ -385,6 +341,7 @@ jobs:
             queue-token: ${{ matrix.config['queue-token'] }}
             dp-attn: ${{ matrix.config.dp-attn }}
             run-eval: false
+            require-power: ${{ matrix.config['require-power'] == true }}
             scenario-type: ${{ matrix.config['scenario-type'] || 'fixed-seq-len' }}
             duration: ${{ matrix.config.duration || '3600' }}
             agentx-fast: ${{ contains(github.event.pull_request.labels.*.name, 'agentx-fast') }}
@@ -412,9 +369,29 @@ jobs:
             conc: ${{ matrix.config.conc[0] }}
             duration: ${{ matrix.config.duration }}
             run-eval: false
+            require-power: ${{ matrix.config['require-power'] == true }}
             scenario-type: agentic-coding
             agentx-fast: ${{ contains(github.event.pull_request.labels.*.name, 'agentx-fast') }}
 
+    # Prompts for the report-only acceptance gate that agentic speculative evals run before their
+    # eval, on the same server (inferencex-e2e/infx/evals/EVALS.md#speculative-acceptance-gate).
+    al-gate-prompts:
+        needs: setup
+        if: >-
+            ${{
+              !cancelled() &&
+              needs.setup.result == 'success' &&
+              (
+                (toJson(fromJson(needs.setup.outputs.search-space-config).agentic_evals) != '[]' && toJson(fromJson(needs.setup.outputs.search-space-config).agentic_evals) != 'null') ||
+                (toJson(fromJson(needs.setup.outputs.search-space-config).multinode_agentic_evals) != '[]' && toJson(fromJson(needs.setup.outputs.search-space-config).multinode_agentic_evals) != 'null')
+              )
+            }}
+        uses: $/.github/workflows/al-gate-prompts.yml
+        secrets:
+            INFERENCEX_OFFICIAL_RO_HF_TOKEN: ${{ secrets.INFERENCEX_OFFICIAL_RO_HF_TOKEN }}
+        with:
+            upload: true
+
     sweep-multi-node-1k1k:
         needs: [setup, canary-select, canary-sweep, canary-multi-node-sweep]
         if: >-
@@ -544,6 +521,7 @@ jobs:
             dp-attn: ${{ matrix.config.dp-attn }}
             duration: ${{ matrix.config.duration }}
             run-eval: false
+            require-power: ${{ matrix.config['require-power'] == true }}
             scenario-type: agentic-coding
             agentx-fast: ${{ contains(github.event.pull_request.labels.*.name, 'agentx-fast') }}
 
@@ -578,6 +556,7 @@ jobs:
             conc: ${{ matrix.config.conc[0] }}
             duration: ${{ matrix.config.duration }}
             run-eval: false
+            require-power: ${{ matrix.config['require-power'] == true }}
             scenario-type: agentic-coding
             agentx-fast: ${{ contains(github.event.pull_request.labels.*.name, 'agentx-fast') }}
 
@@ -614,7 +593,8 @@ jobs:
             eval-only: true
 
     sweep-agentic-evals:
-        needs: [setup, canary-select, canary-sweep, canary-multi-node-sweep]
+        # The acceptance gate is report-only: the evals run whether or not its prompts were prepared.
+        needs: [setup, canary-select, canary-sweep, canary-multi-node-sweep, al-gate-prompts]
         if: >-
             ${{
               !cancelled() &&
@@ -682,7 +662,8 @@ jobs:
             eval-conc: ${{ (matrix.config['eval-framework'] || 'lm-eval') == 'lm-eval' && matrix.config['eval-all-concs'] && join(matrix.config.conc, ' ') || matrix.config['eval-conc'] }}
 
     sweep-multi-node-agentic-evals:
-        needs: [setup, canary-select, canary-sweep, canary-multi-node-sweep]
+        # The acceptance gate is report-only: the evals run whether or not its prompts were prepared.
+        needs: [setup, canary-select, canary-sweep, canary-multi-node-sweep, al-gate-prompts]
         if: >-
             ${{
               !cancelled() &&
diff --git a/.github/workflows/speedbench-al.yml b/.github/workflows/speedbench-al.yml
index 16936d196d..ca0b0f3a36 100644
--- a/.github/workflows/speedbench-al.yml
+++ b/.github/workflows/speedbench-al.yml
@@ -19,19 +19,13 @@ on: # zizmor: ignore[concurrency-limits]
         type: string
         default: 'dsv4'
       framework:
-        description: "Serving framework; selects the <model-prefix>_<precision>_b300_<framework>[_<collector-variant>].sh collector"
+        description: "Serving framework; selects the <model-prefix>_fp4_b300_<framework>[_<collector-variant>].sh collector"
         required: false
         type: choice
         options: [vllm, sglang]
         default: 'vllm'
-      precision:
-        description: "Checkpoint precision; selects the collector and queue metadata"
-        required: false
-        type: choice
-        options: [fp4, fp8, bf16]
-        default: 'fp4'
       collector-variant:
-        description: "Collector variant suffix; non-empty selects <model-prefix>_<precision>_b300_<framework>_<collector-variant>.sh"
+        description: "Collector variant suffix; non-empty selects <model-prefix>_fp4_b300_<framework>_<collector-variant>.sh (e.g. probabilistic_sample_method_block_rejection_sample_method)"
         required: false
         type: string
         default: ''
@@ -76,7 +70,7 @@ on: # zizmor: ignore[concurrency-limits]
         type: boolean
         default: false
       golden-curve:
-        description: "Golden curve file stem that open-pr writes, e.g. dsv4_mtp or kimik3_dspark (required with open-pr)"
+        description: "Golden curve file stem that open-pr writes, e.g. deepseek-v4-pro__mtp__native__default-default or kimi-k3__dspark__kimi-k3-dspark__default-default (required with open-pr)"
         required: false
         type: string
         default: ''
@@ -103,7 +97,7 @@ env:
   HF_HUB_CACHE: '/mnt/hf_hub_cache/'
   MODEL: ${{ inputs.model }}
   MODEL_PREFIX: ${{ inputs.model-prefix }}
-  PRECISION: ${{ inputs.precision }}
+  PRECISION: fp4
   FRAMEWORK: ${{ inputs.framework }}
   EXP_NAME: ${{ inputs.model-prefix }}_speedbench
   IMAGE: ${{ inputs.image }}
@@ -134,8 +128,8 @@ jobs:
         env:
           GOLDEN_CURVE: ${{ inputs.golden-curve }}
         run: |
-          if [[ ! "$GOLDEN_CURVE" =~ ^[a-z0-9_.-]+$ ]]; then
-            echo "::error::open-pr needs golden-curve, a curve file stem such as dsv4_mtp (got '$GOLDEN_CURVE')." >&2
+          if [[ ! "$GOLDEN_CURVE" =~ ^[a-z0-9_.-]+$ || "$GOLDEN_CURVE" == identities ]]; then
+            echo "::error::open-pr needs golden-curve, a curve file stem such as deepseek-v4-pro__mtp__native__default-default (got '$GOLDEN_CURVE')." >&2
             exit 1
           fi
       - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
@@ -161,12 +155,11 @@ jobs:
             --arg runner "$RUNNER" \
             --arg model_prefix "$MODEL_PREFIX" \
             --arg framework "$FRAMEWORK" \
-            --arg precision "$PRECISION" \
             '[{
               runner: $runner,
               framework: $framework,
               "model-prefix": $model_prefix,
-              precision: $precision,
+              precision: "fp4",
               "spec-decoding": "mtp"
             }]')
           scored=$(printf '%s' "$entry" |
@@ -257,7 +250,7 @@ jobs:
         run: |
           if [[ -f inferencex-e2e/configs/runners.yaml ]]; then cd inferencex-e2e; fi
           collector_dir=benchmarks/single_node/speedbench
-          collector="${MODEL_PREFIX}_${PRECISION}_b300_${FRAMEWORK}"
+          collector="${MODEL_PREFIX}_fp4_b300_${FRAMEWORK}"
           if [[ -n "$COLLECTOR_VARIANT" ]]; then
             collector+="_${COLLECTOR_VARIANT}"
           fi
@@ -314,6 +307,10 @@ jobs:
             echo "AL collection failed: speedbench-reference-al.yaml not produced." >&2
             exit 1
           fi
+          if ! grep -qE '^ +[0-9]+: [0-9]' speedbench-reference-al.yaml; then
+            echo "AL collection failed: no cell was measured (every value is N/A)." >&2
+            exit 1
+          fi
           echo "### SpeedBench AL matrix" >> "$GITHUB_STEP_SUMMARY"
           echo '```yaml' >> "$GITHUB_STEP_SUMMARY"
           cat speedbench-reference-al.yaml >> "$GITHUB_STEP_SUMMARY"
@@ -339,9 +336,14 @@ jobs:
           check_env_vars GOLDEN_CURVE INFERENCEX_LAUNCH_PYTHON BENCH_SCRIPT_OVERRIDE
           run_url="${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY}/actions/runs/${GITHUB_RUN_ID}"
           curve_file="infx/golden_al_distribution/${GOLDEN_CURVE}.yaml"
+          collection=""
+          if [[ -f "$curve_file" ]]; then
+            collection=$(PYTHONPATH="$PWD" "$INFERENCEX_LAUNCH_PYTHON" -P -c 'import sys, yaml; from infx.golden_al_distribution import load_curve; c = load_curve(sys.argv[1]).collection; print(yaml.safe_dump({"collection": c}, sort_keys=False) if c else "", end="")' "$GOLDEN_CURVE")
+          fi
           {
-            echo "# Source GitHub Actions run: ${run_url}"
+            echo "source_run: ${run_url}"
             cat speedbench-reference-al.yaml
+            if [[ -n "$collection" ]]; then printf '\n%s\n' "$collection"; fi
           } > "$curve_file"
           PYTHONPATH="$PWD" "$INFERENCEX_LAUNCH_PYTHON" -P -m infx.golden_al_distribution show "$GOLDEN_CURVE"
 
@@ -358,7 +360,7 @@ jobs:
           git -c credential.helper= -c 'credential.helper=!gh auth git-credential' push -u origin "$BRANCH"
           gh pr create \
             --title "Update golden AL curve ${GOLDEN_CURVE} (auto)" \
-            --body "Auto-generated by the SpeedBench AL Collection workflow (${run_url}). Curve: \`${curve_file}\`, collector: \`${BENCH_SCRIPT_OVERRIDE}\`, model: \`${MODEL}\`, category: \`${CATEGORY}\`, MTP: \`${MTP_LIST}\`, thinking: \`${THINKING_MODES}\`, output_len: \`${SPEEDBENCH_OUTPUT_LEN}\`. Review the measured values against the checklist in infx/golden_al_distribution/README.md before merging. A new curve also needs its row in that README's curve table." \
+            --body "Auto-generated by the SpeedBench AL Collection workflow (${run_url}). Curve: \`${curve_file}\`, collector: \`${BENCH_SCRIPT_OVERRIDE}\`, model: \`${MODEL}\`, category: \`${CATEGORY}\`, MTP: \`${MTP_LIST}\`, thinking: \`${THINKING_MODES}\`, output_len: \`${SPEEDBENCH_OUTPUT_LEN}\`. Review the measured values against the checklist in infx/golden_al_distribution/README.md before merging. The curve keeps its previous \`collection\` block; confirm it still matches the collector's client settings, and add one for a new curve. A new curve also needs its row in that README's curve table and its identity in identities.yaml, named as the README's naming rule says." \
             --base main \
             --head "$BRANCH"
 
diff --git a/AGENTS.md b/AGENTS.md
index 4afbc6acb0..a02a1f1563 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -96,6 +96,7 @@ Run the focused test path first. Use `--extra workflows` for GitHub integrations
 - Launch only through `python -m infx.launch`; add no shell launchers. Cluster facts go in the cluster's `clusters:` record, workload rules in named policy tables; drivers never branch on a cluster id. Retiring a cluster removes its label, record, and policy rows in one PR.
 - srt-slurm host-setup hooks only check or prepare hosts: they never run benchmarks, tune engines, patch containers, or hide failures.
 - Never hard-code synthetic acceptance lengths; the srt driver picks measured values from `infx/golden_al_distribution/` ([details](inferencex-e2e/infx/golden_al_distribution/README.md#using-golden-curves-in-srt-slurm-runs)).
+- Agentic speculative evals also run the report-only [speculative acceptance gate](inferencex-e2e/infx/evals/EVALS.md#speculative-acceptance-gate) on the eval's own server. New golden curves need a `collection` block with the SPEED-Bench client settings they were measured with.
 
 ## Deprecating benchmark configs
 
diff --git a/collectivex/bench/ep_backend.py b/collectivex/bench/ep_backend.py
index 5ffc774cbf..abe248abb4 100644
--- a/collectivex/bench/ep_backend.py
+++ b/collectivex/bench/ep_backend.py
@@ -149,6 +149,9 @@ class EPBackend(abc.ABC):
     dispatch_scale_bytes_per_copy = 0
     # (eager quantize, dequantize) of an adopted blockwise FP8 codec; see `_enable_fp8`.
     _fp8_codec = None
+    # Whether this run dispatches FP8; set from args.precision in __init__ (the class default
+    # covers partial adapters that tests build without __init__).
+    _fp8 = False
     # The low-latency dispatch quantises FP8 in-kernel from BF16, so its caller-side quantize only
     # models those bits for the oracle. False where low-latency is caller-prequantized like normal.
     ll_quantizes_in_kernel = True
@@ -307,6 +310,12 @@ def __init__(self, args, rank, world_size, local_rank, device):
             raise ValueError(
                 f"{self.name} does not support precision {self.precision!r}"
             )
+        self._fp8 = self.precision == "fp8"
+        self.experts_per_rank = args.experts // world_size
+        # Every adapter's FP8 stage() dequantizes the received (fp8, scale) payload to the BF16
+        # combine input -- real device work, and so a separately-timed component -- while its BF16
+        # stage() is a pointer hand-off.
+        self.stage_device_work = self._fp8
 
     @staticmethod
     def init_process_group(dist, rank, world_size, device):
diff --git a/collectivex/bench/ep_deepep_v2.py b/collectivex/bench/ep_deepep_v2.py
index 99be7845a5..2ef3be2f9a 100644
--- a/collectivex/bench/ep_deepep_v2.py
+++ b/collectivex/bench/ep_deepep_v2.py
@@ -6,7 +6,6 @@
 import inspect
 import os
 import sys
-import types
 from importlib import metadata
 from pathlib import Path
 
@@ -47,7 +46,8 @@
 # Low-latency receive sizing, deliberately two numbers: _LL_BUFFER_CAP sizes the pre-allocated
 # receive (and so the transport footprint and fp8 dequant volume), _LL_LADDER_CAP bounds which
 # token counts are measured. Equal today, but kept separate so the ladder can be clamped around a
-# kernel defect at one rung without moving the footprint (see `create_buffer`).
+# kernel defect at one rung without moving the footprint (see `_create_ll_buffer`). The adapter
+# carries them as LL_BUFFER_CAP and LL_LADDER_CAP.
 _LL_BUFFER_CAP = 256
 _LL_LADDER_CAP = 256
 assert _LL_LADDER_CAP <= _LL_BUFFER_CAP <= 511, (
@@ -141,6 +141,12 @@ class DeepEPV2Backend(LegacyBufferLL, EPBackend):
     CUDA_GRAPH_MODES = ("normal", "low-latency")
     # vLLM's low-latency send/receive split (see LegacyBufferLL).
     ll_recv_hook = True
+    # LL pre-allocates a fixed [num_local_experts, cap * num_ranks, hidden] receive buffer, so the
+    # ladder cap is a hard per-rank dispatch-slot bound; the harness clamps the ladder to it and
+    # records any dropped point in the artifact. Clamping LL_LADDER_CAP is the containment lever if
+    # a kernel defect reds the top rung (check the DeepEP pin first).
+    LL_LADDER_CAP = _LL_LADDER_CAP
+    LL_BUFFER_CAP = _LL_BUFFER_CAP
     # The num_sms the timed dispatch passes: 0 hands the count to DeepEP's model, as vLLM does;
     # create_buffer overrides it where the registry sets rdma_gbs.
     _dispatch_num_sms = 0
@@ -156,12 +162,8 @@ def __init__(self, args, rank, world_size, local_rank, device):
         # Buffer); base SUPPORTED_MODES enforces the allowed set.
         super().__init__(args, rank, world_size, local_rank, device)
         self.group = dist.group.WORLD
-        self._fp8 = self.precision == "fp8"
-        # FP8 dispatch dequantizes the received (e4m3fn, per-128-block FP32 scale) payload
-        # back to the BF16 combine sends, which is real device work and so a separately-
-        # timed component. (Normal mode quantizes inside the timed dispatch; low-latency casts
-        # inside the dispatch kernel — either way the dequant lands in stage().)
-        self.stage_device_work = self._fp8
+        # Under FP8, normal mode quantizes inside the timed dispatch and low-latency casts inside
+        # the dispatch kernel; either way the dequant lands in stage() (stage_device_work).
         if self._fp8:
             # Resolve the pinned cast pair once (lazily, so a BF16-only run never imports
             # deep_ep.utils.math) so the timed stage() does no module lookup in the
@@ -207,31 +209,9 @@ def _dispatch_capacity(self, tokens):
         """
         return min(self.max_tokens, 1 << max(0, int(tokens) - 1).bit_length())
 
-    def buffer_cap(self, args):
-        if self.mode == "low-latency":
-            # LL pre-allocates a fixed [num_local_experts, cap * num_ranks, hidden] receive
-            # buffer, so the cap is a hard per-rank dispatch-slot bound; the harness clamps the
-            # ladder to it and records any dropped point in the artifact. Clamping here is the
-            # containment lever if a kernel defect reds the top rung (check the DeepEP pin first).
-            return _LL_LADDER_CAP
-        return None
-
-    def create_buffer(self, spec):
+    def _normal_create_buffer(self, spec):
         args, world_size = self.args, self.world_size
         self.max_tokens = spec.max_tokens_per_rank
-        if self.mode == "low-latency":
-            # Size the LL buffer from the fixed cap, not from the clamped ladder: the receive
-            # footprint sets both the transport's memory traffic and the fp8 dequant volume
-            # (`_ll_recv_bf16` converts the whole padded receive), so following the ladder would
-            # shift every retained rung and break comparability with the published series.
-            if spec.max_tokens_per_rank > _LL_BUFFER_CAP:
-                raise RuntimeError(
-                    f"low-latency ladder maximum {spec.max_tokens_per_rank} exceeds the LL "
-                    f"buffer cap {_LL_BUFFER_CAP}"
-                )
-            self.max_tokens = _LL_BUFFER_CAP
-            self._create_ll_buffer(spec)
-            return
         _require_runtime()
         jit_root = Path(os.environ["EP_JIT_CACHE_DIR"])
         # Hybrid exactly where vLLM's VLLM_DEEPEP_V2_ALLOW_HYBRID_MODE=1 autoselects it: DeepEP
@@ -331,19 +311,14 @@ def _create_ll_buffer(self, spec):
         buffer and forces IBGDA even for single-node EP8, so there is no NVLink-only
         fallback. `allow_nvlink_for_low_latency_mode` lets NVLink carry intranode
         traffic alongside IBGDA; it does not remove the IBGDA requirement.
+
+        The buffer is sized from LL_BUFFER_CAP, not from the clamped ladder: the receive footprint
+        sets both the transport's memory traffic and the fp8 dequant volume (`_ll_recv_bf16`
+        converts the whole padded receive), so following the ladder would shift every retained
+        rung and break comparability with the published series.
         """
-        args, world_size = self.args, self.world_size
-        assert args.experts % world_size == 0, (
-            "low-latency EP requires num_experts divisible by the EP size"
-        )
-        self.num_local_experts = args.experts // world_size
-        if not hasattr(deep_ep.Buffer, "low_latency_dispatch"):
-            raise RuntimeError(
-                "invalid DeepEP LL runtime: deep_ep.Buffer.low_latency_dispatch is absent"
-            )
-        num_rdma_bytes = deep_ep.Buffer.get_low_latency_rdma_size_hint(
-            self.max_tokens, args.hidden, world_size, args.experts
-        )
+        args = self.args
+        num_rdma_bytes = self._ll_geometry(spec, deep_ep.Buffer, "DeepEP")
         kwargs = {}
         # On an MNNVL rack the scale-up fabric is NVLink across trays, but the legacy Buffer
         # defaults `allow_mnnvl=False` and a False there self-sets NVSHMEM_DISABLE_MNNVL, so
@@ -378,9 +353,9 @@ def _topk_idx_dtype(self):
         # DeepEP V2's kernels key routing indices on deep_ep.topk_idx_t, not int64.
         return deep_ep.topk_idx_t
 
-    def dispatch(self, p):
-        if self.mode == "low-latency":
-            return self._ll_dispatch(p)
+    # ---- normal-mode transport (LegacyBufferLL routes by mode; low-latency lives there) ----
+
+    def _normal_dispatch(self, p):
         # Quantise here, not in make_problem: production runs one fused bf16->fp8 kernel per
         # forward pass immediately before this collective, so the timed window must contain it.
         dispatch_x = self._quant(p.dispatch_x) if self._fp8 else p.dispatch_x
@@ -397,20 +372,9 @@ def dispatch(self, p):
             do_cpu_sync=False,
             do_expand=False,
         )
-        return types.SimpleNamespace(
-            recv_x=recv_x,
-            recv_topk_idx=recv_topk_idx,
-            recv_topk_weights=recv_topk_weights,
-            handle=handle,
-        )
+        return self._normal_handle(recv_x, recv_topk_idx, recv_topk_weights, handle)
 
-    def stage(self, p, h):
-        if self.mode == "low-latency":
-            # The timed combine sends the padded per-expert receive back as BF16 (dequant
-            # under FP8). Value correctness is exercised by the oracle's combine_transformed
-            # path; this only has to move the right shape for timing.
-            h.combine_input = self._ll_recv_bf16(h.recv_x)
-            return
+    def _normal_stage(self, p, h):
         if self._fp8:
             # Dequantize the received (fp8, scale) tuple to the BF16 combine sends. Without the
             # host sync that is the whole worst-case plane: combine requires its input to match
@@ -420,10 +384,7 @@ def stage(self, p, h):
             # BF16: the received buffer is already the semantic payload to combine.
             h.combine_input = h.recv_x
 
-    def combine(self, p, h):
-        if self.mode == "low-latency":
-            # The kernel applies topk_weights internally (weighted).
-            return self._ll_combine(p, h, h.combine_input)
+    def _normal_combine(self, p, h):
         # SM and QP counts default as in vLLM: the dispatch handle's SMs, DeepEP's QP model.
         combined_x, _, _ = self.buffer.combine(
             h.combine_input,
@@ -432,9 +393,7 @@ def combine(self, p, h):
         )
         return combined_x
 
-    def inspect_dispatch(self, p, h):
-        if self.mode == "low-latency":
-            return self._ll_inspect_dispatch(p, h)
+    def _normal_inspect_dispatch(self, p, h):
         count = self.recv_tokens(h)
         if self._fp8:
             # Dequantize the sliced (fp8, scale) recv tuple so the payload the oracle
@@ -447,9 +406,7 @@ def inspect_dispatch(self, p, h):
             self.args.experts // self.world_size,
         )
 
-    def combine_transformed(self, p, h, transformed):
-        if self.mode == "low-latency":
-            return self._ll_combine_transformed(p, h, transformed)
+    def _normal_combine_transformed(self, p, h, transformed):
         # Combine always sends BF16. Under FP8, recv_x is an (fp8, scale) tuple, so the
         # BF16 combine buffer is shaped from the fp8 payload rather than zeros_like it.
         if self._fp8:
@@ -464,7 +421,5 @@ def combine_transformed(self, p, h, transformed):
         )
         return combined
 
-    def recv_tokens(self, h):
-        if self.mode == "low-latency":
-            return int(h.recv_count.sum().item())
+    def _normal_recv_tokens(self, h):
         return int(h.handle.psum_num_recv_tokens_per_scaleup_rank[-1].item())
diff --git a/collectivex/bench/ep_flashinfer.py b/collectivex/bench/ep_flashinfer.py
index dafae987ca..cdbf6d9788 100644
--- a/collectivex/bench/ep_flashinfer.py
+++ b/collectivex/bench/ep_flashinfer.py
@@ -134,18 +134,14 @@ def cuda_graph_supported(self) -> bool:
 
     def __init__(self, args, rank, world_size, local_rank, device):
         super().__init__(args, rank, world_size, local_rank, device)
-        self._fp8 = self.precision == "fp8"
         if self._fp8:
             # The codec, bytes and block size of deepep-v2/uccl-ep, so the same label.
             self._enable_fp8("fp8-e4m3fn", _blockwise_cast_to_fp8, _blockwise_cast_back)
-        # BF16 stage() is a pointer hand-off, so only the FP8 dequant is device work to hoist.
-        self.stage_device_work = self._fp8
         self._a2a = None
         self._max_tokens = None
         self._workspace_sizing = {}
         # Which of vLLM's two combine calls this wheel takes; resolved in create_buffer.
         self._combine_takes_output = False
-        self.experts_per_rank = args.experts // world_size
 
     # ---- setup -------------------------------------------------------------------------------
 
diff --git a/collectivex/bench/ep_legacy_ll.py b/collectivex/bench/ep_legacy_ll.py
index 80bf67bf12..34e044cf94 100644
--- a/collectivex/bench/ep_legacy_ll.py
+++ b/collectivex/bench/ep_legacy_ll.py
@@ -105,10 +105,13 @@ def _ll_dequant_static(fp8, scales):
 
 
 class LegacyBufferLL:
-    """Mixin (listed before EPBackend) for the legacy `Buffer` low-latency kernels. The adapter
-    keeps the mode branches of its timed methods inline and calls these `_ll_*` pieces; it provides
-    `_fp8`, `buffer` (from its `_create_ll_buffer`), `max_tokens` and `num_local_experts`, and calls
-    `_enable_ll` from `__init__`."""
+    """Mixin (listed before EPBackend) for the legacy `Buffer` low-latency kernels. It owns the
+    transport contract's public methods and routes each by mode: low-latency to the shared `_ll_*`
+    pieces here, normal to the adapter's `_normal_*` methods (`_normal_create_buffer`,
+    `_normal_dispatch`, `_normal_stage`, `_normal_combine`, `_normal_inspect_dispatch`,
+    `_normal_combine_transformed`, `_normal_recv_tokens`). The adapter builds its low-latency
+    `buffer` in `_create_ll_buffer` (sized by `_ll_geometry`) and calls `_enable_ll` from
+    `__init__`."""
 
     # vLLM's default (non-DBO) path issues each collective as a send kernel plus a receive hook
     # (deepep_ll.py: dispatch always passes return_recv_hook=True; finalize_async, the path the
@@ -118,6 +121,9 @@ class LegacyBufferLL:
     # `_ll_combine` for dispatch and combine to share the contract.
     ll_recv_hook = False
     _ll_ue8m0 = False
+    # Per-rank slots the low-latency receive is pre-allocated with; None sizes it at the ladder cap
+    # (LL_LADDER_CAP). An adapter that keeps the two apart sets it (see deepep-v2).
+    LL_BUFFER_CAP: "int | None" = None
 
     def _enable_ll(self, kernel_generation):
         # A distinct kernel family whose combine multiplies by the gate at the source (weighted),
@@ -153,6 +159,91 @@ def implementation_details(self):
             })
         return details
 
+    # ---- transport contract, routed by mode ----------------------------------------------
+
+    def create_buffer(self, spec):
+        if self.mode == "low-latency":
+            return self._create_ll_buffer(spec)
+        return self._normal_create_buffer(spec)
+
+    def dispatch(self, p):
+        if self.mode == "low-latency":
+            return self._ll_dispatch(p)
+        return self._normal_dispatch(p)
+
+    def stage(self, p, h):
+        if self.mode == "low-latency":
+            # The timed combine sends the padded per-expert receive back as BF16 (dequant under
+            # FP8). Value correctness is exercised by the oracle's combine_transformed path; this
+            # only has to move the right shape for timing.
+            h.combine_input = self._ll_recv_bf16(h.recv_x)
+            return
+        self._normal_stage(p, h)
+
+    def combine(self, p, h):
+        if self.mode == "low-latency":
+            # The kernel applies topk_weights internally (weighted).
+            return self._ll_combine(p, h, h.combine_input)
+        return self._normal_combine(p, h)
+
+    def inspect_dispatch(self, p, h):
+        if self.mode == "low-latency":
+            return self._expert_major_view(h, self._ll_recv_bf16(h.recv_x), h.recv_count)
+        return self._normal_inspect_dispatch(p, h)
+
+    def combine_transformed(self, p, h, transformed):
+        if self.mode == "low-latency":
+            return self._ll_combine_transformed(p, h, transformed)
+        return self._normal_combine_transformed(p, h, transformed)
+
+    def recv_tokens(self, h):
+        if self.mode == "low-latency":
+            return int(h.recv_count.sum().item())
+        return self._normal_recv_tokens(h)
+
+    @staticmethod
+    def _normal_handle(recv_x, recv_topk_idx, recv_topk_weights, handle):
+        """The per-call handle a normal-mode dispatch returns."""
+        return types.SimpleNamespace(
+            recv_x=recv_x,
+            recv_topk_idx=recv_topk_idx,
+            recv_topk_weights=recv_topk_weights,
+            handle=handle,
+        )
+
+    # ---- shared low-latency pieces --------------------------------------------------------
+
+    def _ll_geometry(self, spec, buffer_cls, label):
+        """Fix the low-latency receive geometry and return the Buffer's RDMA byte count.
+
+        The receive is pre-allocated at a fixed per-rank slot count (LL_BUFFER_CAP, else the ladder
+        cap) and never follows the ladder, so a partial ladder runs the same receive plane as the
+        full one; a ladder that does not fit fails closed. Sets `max_tokens` and
+        `num_local_experts` (LL requires the QP-per-rank count to equal the latter).
+        """
+        args, world_size = self.args, self.world_size
+        cap = self.LL_BUFFER_CAP if self.LL_BUFFER_CAP is not None else self.LL_LADDER_CAP
+        if spec.max_tokens_per_rank > cap:
+            raise RuntimeError(
+                f"low-latency ladder maximum {spec.max_tokens_per_rank} exceeds the LL "
+                f"buffer cap {cap}"
+            )
+        assert args.experts % world_size == 0, (
+            "low-latency EP requires num_experts divisible by the EP size"
+        )
+        self.max_tokens = cap
+        self.num_local_experts = args.experts // world_size
+        if not hasattr(buffer_cls, "low_latency_dispatch") or not hasattr(
+            buffer_cls, "get_low_latency_rdma_size_hint"
+        ):
+            raise RuntimeError(
+                f"invalid {label} LL runtime: Buffer.low_latency_dispatch / "
+                "get_low_latency_rdma_size_hint absent"
+            )
+        return buffer_cls.get_low_latency_rdma_size_hint(
+            self.max_tokens, args.hidden, world_size, args.experts
+        )
+
     def _ll_recv_bf16(self, recv_x):
         """The padded per-expert receive as BF16 `[num_local_experts, cap*num_ranks, hidden]`.
 
@@ -206,9 +297,6 @@ def _ll_combine(self, p, h, x):
             hook()
         return combined_x[: p.T]
 
-    def _ll_inspect_dispatch(self, p, h):
-        return self._expert_major_view(h, self._ll_recv_bf16(h.recv_x), h.recv_count)
-
     def _ll_combine_transformed(self, p, h, transformed):
         """Scatter the oracle-transformed rows back into a zeroed padded combine buffer at the
         exact `(expert, slot)` coordinates inspect_dispatch read them from, then run the weighted
diff --git a/collectivex/bench/ep_mori.py b/collectivex/bench/ep_mori.py
index 9d331e9a9f..d354e18e1c 100644
--- a/collectivex/bench/ep_mori.py
+++ b/collectivex/bench/ep_mori.py
@@ -126,8 +126,6 @@ def library_version(self) -> str:
 
     def __init__(self, args, rank, world_size, local_rank, device):
         super().__init__(args, rank, world_size, local_rank, device)
-        self._fp8 = self.precision == "fp8"
-        self.experts_per_rank = args.experts // world_size
         arch = _gfx_arch(device)
         scale_out = args.scope == "scale-out"
         if self.mode == "low-latency":
@@ -159,8 +157,7 @@ def __init__(self, args, rank, world_size, local_rank, device):
             )
             self._enable_fp8(label, *blockwise_fp8_codec(self._fp8_dtype, fp8_max))
         # External-input kernels consume the dispatch output directly, so stage has no copy of its
-        # own; under FP8 it dequantizes the received payload with its scales.
-        self.stage_device_work = self._fp8
+        # own; under FP8 it dequantizes the received payload with its scales (stage_device_work).
         self._library_config = {}
 
     def create_buffer(self, spec):
diff --git a/collectivex/bench/ep_nccl.py b/collectivex/bench/ep_nccl.py
index 6d31ff2b55..23abe5fa07 100644
--- a/collectivex/bench/ep_nccl.py
+++ b/collectivex/bench/ep_nccl.py
@@ -192,14 +192,11 @@ def __init__(self, args, rank, world_size, local_rank, device):
         # fails (error 5); present -> device_api_support=True and HT+LL groups create.
         os.environ.setdefault("NCCL_CUMEM_ENABLE", "1")
         self.group = dist.group.WORLD
-        self.experts_per_rank = args.experts // world_size
         self.num_local_experts = self.experts_per_rank
         self._internode = world_size > int(args.scale_up_domain)
         self._ll = self.mode == "low-latency"
-        self._fp8 = getattr(self, "precision", "bf16") == "fp8"
         if self._fp8 and not self._ll:
             raise ValueError("NCCL EP FP8 is enabled for low-latency mode only")
-        self.stage_device_work = self._fp8
         # LL layout: rank-major (TensorRT-LLM's NCCL EP contract, the default) or expert-major
         # (DeepEP LL's contract, as vLLM/SGLang decode consume it). Both are native LL layouts.
         layout = os.environ.get("COLLX_NCCL_LL_LAYOUT", "rank-major")
@@ -359,8 +356,6 @@ def _comm_config():
     def create_buffer(self, spec):
         """Bootstrap the communicator, create the EP group sized from the ladder maximum, and
         allocate the persistent receive/combine buffers reused across every ladder shape."""
-        # Unit tests construct a deliberately partial adapter without __init__.
-        self._fp8 = getattr(self, "_fp8", False)
         # Token capacity is the largest step the ladder runs. LL follows TensorRT-LLM, which sizes
         # its one NcclEP group to min(max_num_tokens, moe_max_num_tokens) (nccl_ep.py:98-103) and
         # rejects any step above it (124-129): the smallest such engine serving every rung has
@@ -526,7 +521,6 @@ def _ensure_handle(self, p):
         the oracle passes), never inside a timed window. Re-entering with the already-bound
         problem returns immediately without a collective or a sync.
         """
-        self._fp8 = getattr(self, "_fp8", False)
         cached = getattr(p, "_nccl", None)
         if cached is not None:
             if self._bound is not cached:
diff --git a/collectivex/bench/ep_uccl.py b/collectivex/bench/ep_uccl.py
index f05151079f..b84125b9ed 100644
--- a/collectivex/bench/ep_uccl.py
+++ b/collectivex/bench/ep_uccl.py
@@ -37,7 +37,6 @@
 import json
 import os
 import sys
-import types
 from importlib import metadata
 from pathlib import Path
 
@@ -178,14 +177,9 @@ def cuda_graph_supported(self) -> bool:
     def __init__(self, args, rank, world_size, local_rank, device):
         super().__init__(args, rank, world_size, local_rank, device)
         self.group = dist.group.WORLD
-        self.experts_per_rank = args.experts // world_size
         self._internode = world_size > int(args.scale_up_domain)
-        self._fp8 = self.precision == "fp8"
         self.library_version = _library_version()
         self._library_config = {}
-        # FP8 dispatch dequantizes the received (e4m3, per-128-block scale) payload back to the
-        # BF16 combine sends — real device work, hence a separately-timed stage component.
-        self.stage_device_work = self._fp8
         if self._fp8:
             fnuz = _fp8_e4m3_dtype() == torch.float8_e4m3fnuz
             quantize = per_token_cast_to_fp8
@@ -204,10 +198,7 @@ def __init__(self, args, rank, world_size, local_rank, device):
 
     # ---- buffer construction ---------------------------------------------------------------
 
-    def create_buffer(self, spec):
-        if self.mode == "low-latency":
-            self._create_ll_buffer(spec)
-            return
+    def _normal_create_buffer(self, spec):
         self.max_tokens = spec.max_tokens_per_rank
         # vLLM's deepep_ht resolves both configs from the EP size alone, on Buffer.num_sms left at
         # UCCL's default: one 20-SM budget at EP8 and EP16, on CUDA and HIP alike (the default is
@@ -260,29 +251,9 @@ def _create_ll_buffer(self, spec):
         same receive plane as the full one. It does NOT force the proxy path: `is_intranode` is
         passed below, so at EP8 UCCL leaves the proxies stopped and the kernel takes its IPC branch.
         """
-        args, world_size = self.args, self.world_size
-        assert args.experts % world_size == 0, (
-            "low-latency EP requires num_experts divisible by the EP size"
-        )
-        if spec.max_tokens_per_rank > self.LL_LADDER_CAP:
-            raise RuntimeError(
-                f"low-latency ladder maximum {spec.max_tokens_per_rank} exceeds the LL "
-                f"buffer cap {self.LL_LADDER_CAP}"
-            )
-        self.max_tokens = self.LL_LADDER_CAP
-        self.num_local_experts = args.experts // world_size
+        num_rdma_bytes = self._ll_geometry(spec, Buffer, "UCCL-EP")
         # LL requires the QP-per-rank count to equal the number of local experts.
         num_qps_per_rank = self.num_local_experts
-        if not hasattr(Buffer, "low_latency_dispatch") or not hasattr(
-            Buffer, "get_low_latency_rdma_size_hint"
-        ):
-            raise RuntimeError(
-                "invalid UCCL-EP LL runtime: Buffer.low_latency_dispatch / "
-                "get_low_latency_rdma_size_hint absent"
-            )
-        num_rdma_bytes = Buffer.get_low_latency_rdma_size_hint(
-            self.max_tokens, args.hidden, world_size, args.experts
-        )
         # vLLM also passes enable_shrink=False, which this pin's Buffer does not accept (UCCL #1043
         # adds it); False is UCCL's behaviour either way.
         self.buffer = Buffer(
@@ -314,11 +285,9 @@ def implementation_details(self) -> dict:
         # On top of the shared low-latency keys (ep_legacy_ll), which name the same values the same.
         return {**super().implementation_details(), **self._library_config}
 
-    # ---- transport contract (the shared low-latency pieces live in ep_legacy_ll) ---------
+    # ---- normal-mode transport (LegacyBufferLL routes by mode; low-latency lives there) ----
 
-    def dispatch(self, p):
-        if self.mode == "low-latency":
-            return self._ll_dispatch(p)
+    def _normal_dispatch(self, p):
         # Legacy normal dispatch, as vLLM's deepep_ht prepare runs it: compute the layout, then
         # scatter tokens to their experts. num_tokens_per_rdma_rank is None intranode (EP8) and
         # populated internode (EP16); pass it through so the same call serves both scopes.
@@ -339,27 +308,15 @@ def dispatch(self, p):
             config=self.dispatch_config,
             async_finish=False,
         )
-        return types.SimpleNamespace(
-            recv_x=recv_x,
-            recv_topk_idx=recv_topk_idx,
-            recv_topk_weights=recv_topk_weights,
-            handle=handle,
-        )
+        return self._normal_handle(recv_x, recv_topk_idx, recv_topk_weights, handle)
 
-    def stage(self, p, h):
-        if self.mode == "low-latency":
-            # The timed combine sends the padded per-expert receive back as BF16 (dequant under
-            # FP8). Value correctness is exercised by the oracle's combine_transformed path.
-            h.combine_input = self._ll_recv_bf16(h.recv_x)
-            return
+    def _normal_stage(self, p, h):
         if self._fp8:
             h.combine_input = per_token_cast_back(h.recv_x[0], h.recv_x[1])
         else:
             h.combine_input = h.recv_x
 
-    def combine(self, p, h):
-        if self.mode == "low-latency":
-            return self._ll_combine(p, h, h.combine_input)
+    def _normal_combine(self, p, h):
         # Normal combine is the activation-only unweighted rank-sum: topk_weights are intentionally
         # NOT passed so the kernel sums the per-token expert aggregates across ranks without
         # applying the gate (matches combine_weight_semantics and the two-level oracle).
@@ -373,9 +330,7 @@ def combine(self, p, h):
 
     # ---- correctness-oracle views ----------------------------------------------------------
 
-    def inspect_dispatch(self, p, h):
-        if self.mode == "low-latency":
-            return self._ll_inspect_dispatch(p, h)
+    def _normal_inspect_dispatch(self, p, h):
         # Legacy normal recv: recv_x is [num_recv, hidden] (each received token once) and
         # recv_topk_idx/recv_topk_weights are [num_recv, topk] — the oracle's per-received-token
         # 2-D contract (it sorts each row over the topk axis and sums the per-expert transforms,
@@ -387,9 +342,7 @@ def inspect_dispatch(self, p, h):
             payload, h.recv_topk_idx, h.recv_topk_weights, self.experts_per_rank
         )
 
-    def combine_transformed(self, p, h, transformed):
-        if self.mode == "low-latency":
-            return self._ll_combine_transformed(p, h, transformed)
+    def _normal_combine_transformed(self, p, h, transformed):
         # `transformed` is the oracle's per-received-token combine input [num_recv, hidden]
         # (already summed over the top-k axis) — exactly the per-token buffer legacy combine
         # consumes; combine then sums those per-token aggregates across ranks (unweighted).
@@ -401,8 +354,6 @@ def combine_transformed(self, p, h, transformed):
         )
         return combined
 
-    def recv_tokens(self, h):
-        if self.mode == "low-latency":
-            return int(h.recv_count.sum().item())
+    def _normal_recv_tokens(self, h):
         recv = h.recv_x[0] if self._fp8 else h.recv_x
         return int(recv.shape[0])
diff --git a/collectivex/configs/platform_config.json b/collectivex/configs/platform_config.json
index 6dd9977ab6..53888e0c2e 100644
--- a/collectivex/configs/platform_config.json
+++ b/collectivex/configs/platform_config.json
@@ -146,8 +146,7 @@
         "partition": "batch_1",
         "account": "benchmark",
         "squash_dir": "/data/home/sa-shared/collectivex/containers",
-        "enroot_cache_path": "/data/home/sa-shared/collectivex/enroot-cache",
-        "exclude_nodes": "im-gb300-r01-c003,im-gb300-r01-c005"
+        "enroot_cache_path": "/data/home/sa-shared/collectivex/enroot-cache"
       },
       "network": {
         "socket_ifname": "enP22s22f0np0",
diff --git a/collectivex/tests/test_backends.py b/collectivex/tests/test_backends.py
index 2abafb97bc..5343313166 100644
--- a/collectivex/tests/test_backends.py
+++ b/collectivex/tests/test_backends.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-"""EPBackend contracts: ladder/spec construction, the staging-vs-roundtrip gate, and the NCCL EP handle."""
+"""EPBackend contracts: ladder/spec construction, the staging-vs-roundtrip gate, and graph defaults."""
 from __future__ import annotations
 
 import importlib
@@ -126,234 +126,6 @@ def test_an_unreadable_version_falls_back_to_the_rounding_model(self):
             self.assertFalse(gate(version), f"{version!r} must fall back to the safe model")
 
 
-class NcclLowLatencyLadderSizing(unittest.TestCase):
-    """LL keeps every requested point and allocates receive space for the full ladder."""
-
-    def _module(self):
-        return _import_stubbed("ep_nccl")
-
-    @staticmethod
-    def _construct(module, world_size, mode="low-latency", **env):
-        """NCCLEPBackend.__init__ over a base __init__ reduced to the two fields it reads."""
-        def base_init(instance, options, rank, world_size, local_rank, device):
-            instance.args = options
-            instance.mode = options.mode
-
-        options = types.SimpleNamespace(
-            mode=mode, experts=384, hidden=7168, topk=6, scale_up_domain=8
-        )
-        with mock.patch.object(module.EPBackend, "__init__", base_init), \
-                mock.patch.dict(os.environ, env):
-            return module.NCCLEPBackend(options, 0, world_size, 0, "cuda:0")
-
-    def _backend(self, module, low_latency):
-        """A backend far enough along to run create_buffer against the stubs."""
-        backend = module.NCCLEPBackend.__new__(module.NCCLEPBackend)
-        backend._ll = low_latency
-        backend.zero_copy = True
-        backend.world_size, backend.num_local_experts, backend.device = 8, 4, "cuda:0"
-        backend.args = types.SimpleNamespace(hidden=7168, experts=256, topk=8, phase="decode")
-        backend._algorithm = "LL" if low_latency else "HT"
-        backend._layout = module.Layout.RANK_MAJOR if low_latency else module.Layout.FLAT
-        backend._bootstrap_comm = lambda: None
-        # create_buffer stamps the installed wheel into kernel_generation.
-        module.metadata = types.SimpleNamespace(version=lambda name: "0.2.0.dev20261013")
-        backend._recv_window_for_test = types.SimpleNamespace(
-            is_valid=True, close=lambda: None
-        )
-        backend._comm = types.SimpleNamespace(
-            register_window=mock.Mock(return_value=backend._recv_window_for_test)
-        )
-        backend.created_configs = []
-
-        def group_config(**kwargs):
-            config = types.SimpleNamespace(**kwargs)
-            backend.created_configs.append(config)
-            return config
-
-        module.GroupConfig = group_config
-        module.nccl_ep.Group = types.SimpleNamespace(create=lambda *a, **k: object())
-        return backend
-
-    def test_the_communicator_runs_graph_usage_mode_one(self):
-        module = self._module()
-        with mock.patch.object(module.nccl_core, "NCCLConfig", lambda **kw: kw, create=True):
-            self.assertEqual(module.NCCLEPBackend._comm_config(), {"graph_usage_mode": 1})
-
-    def test_ll_layout_selector_restores_the_expert_major_contract(self):
-        module = self._module()
-        em = self._construct(module, 8, COLLX_NCCL_LL_LAYOUT="expert-major")
-        rm = self._construct(module, 8)
-        ht = self._construct(module, 16, mode="normal")
-        with self.assertRaisesRegex(ValueError, "COLLX_NCCL_LL_LAYOUT"):
-            self._construct(module, 8, COLLX_NCCL_LL_LAYOUT="flat")
-
-        self.assertEqual(em._layout, module.Layout.EXPERT_MAJOR)
-        self.assertEqual(
-            (em.kernel_generation, em.receive_layout, em.combine_weight_semantics),
-            ("nccl-ep-v02-ll-em", "token-expert", "weighted-kernel-sum"),
-        )
-        self.assertFalse(em.zero_copy)
-        self.assertEqual(rm._layout, module.Layout.RANK_MAJOR)
-        # Only LL rank-major selects NCCL's FP32 reduction.
-        self.assertEqual((rm.combine_reduction, em.combine_reduction, ht.combine_reduction),
-                         ("rank-fp32", "domain-fp32", "domain-fp32"))
-
-    def test_ll_ladder_keeps_512_and_larger_points(self):
-        module = self._module()
-        backend = self._backend(module, low_latency=True)
-        backend.mode = "low-latency"
-        backend.args.tokens_ladder = "32 256 512 1024"
-        backend._build_rank_inputs = mock.Mock(return_value=None)
-        spec = backend.make_inputs(backend.args)
-        self.assertEqual(spec.ladder, [32, 256, 512, 1024])
-        self.assertEqual(spec.dropped, [])
-
-    def test_fp8_ll_accepts_both_phases_and_keeps_ht_disabled(self):
-        module = self._module()
-        module.nccl_ep.DispatchQuantizationRecipe = types.SimpleNamespace(DS_FP8E3M4="ds-fp8")
-        module.DispatchConfig = lambda **kw: types.SimpleNamespace(**kw)
-        with mock.patch.dict(os.environ, {"COLLX_NCCL_LL_LAYOUT": "rank-major"}):
-            for phase in ("decode", "prefill"):
-                with self.subTest(phase=phase):
-                    options = args(phase=phase, precision="fp8", mode="low-latency",
-                                   hidden=7168, experts=384, topk=6, scale_up_domain=72)
-                    backend = module.NCCLEPBackend(options, 0, 8, 0, "cuda:0")
-                    self.assertEqual(backend._dispatch_cfg.quantization_recipe, "ds-fp8")
-                    self.assertEqual(backend.dispatch_dtype, "fp8-e4m3fn")
-                    self.assertTrue(backend.zero_copy)
-                    self.assertEqual(backend.cuda_graph_supported, phase == "decode")
-                    options.mode = "normal"
-                    with self.assertRaisesRegex(ValueError, "low-latency mode only"):
-                        module.NCCLEPBackend(options, 0, 8, 0, "cuda:0")
-
-    def test_ll_prefill_uses_the_full_ladder_receive_without_graphs(self):
-        module = self._module()
-        backend = self._backend(module, low_latency=True)
-        backend.mode = "low-latency"
-        backend.args.phase = "prefill"
-        self.assertIsNone(backend.buffer_cap(backend.args))
-        backend.create_buffer(types.SimpleNamespace(max_tokens_per_rank=8192))
-        self.assertEqual(backend._recv_x.shape, (8, 8192, 7168))
-        self.assertEqual(backend.created_configs[0].max_dispatch_tokens_per_rank, 8192)
-        self.assertFalse(backend.cuda_graph_supported)
-
-    def test_ht_registers_a_symmetric_zero_copy_receive_window(self):
-        module = self._module()
-        backend = self._backend(module, low_latency=False)
-        backend.create_buffer(types.SimpleNamespace(max_tokens_per_rank=99))
-
-        self.assertEqual(backend.created_configs[0].zero_copy, module.ZeroCopyMode.ON)
-        backend._comm.register_window.assert_called_once_with(
-            backend._recv_x, flags=module.nccl_core.WindowFlag.COLL_SYMMETRIC
-        )
-        self.assertIs(backend._recv_x_t.window, backend._recv_window_for_test)
-        self.assertEqual(backend._recv_x_t.window_offset, 0)
-
-    def test_ll_rank_major_registers_a_direct_receive_window(self):
-        module = self._module()
-        backend = self._backend(module, low_latency=True)
-        backend.create_buffer(types.SimpleNamespace(ladder=[1, 64], max_tokens_per_rank=64))
-
-        self.assertTrue(backend.zero_copy)
-        self.assertEqual(backend.created_configs[0].zero_copy, module.ZeroCopyMode.ON)
-        backend._comm.register_window.assert_called_once_with(
-            backend._recv_x, flags=module.nccl_core.WindowFlag.COLL_SYMMETRIC
-        )
-        self.assertEqual(backend._recv_x.shape, (8, 64, 7168))
-        self.assertEqual(backend._recv_count.shape, (8,))
-        self.assertIs(backend._recv_x_t.window, backend._recv_window)
-
-    def test_fp8_buffer_binding_follows_selected_policy_in_both_phases(self):
-        for phase in ("decode", "prefill"):
-            for zero_copy in (False, True):
-                with self.subTest(phase=phase, zero_copy=zero_copy):
-                    module = self._module()
-                    backend = self._backend(module, low_latency=True)
-                    backend.args.phase = phase
-                    backend._fp8 = True
-                    backend.zero_copy = zero_copy
-                    windows = [types.SimpleNamespace(is_valid=True, close=mock.Mock())
-                               for _ in range(2)]
-                    backend._comm.register_window.side_effect = windows
-                    backend.create_buffer(types.SimpleNamespace(max_tokens_per_rank=1024))
-                    self.assertEqual(backend._recv_x.shape, (8, 1024, 7168))
-                    self.assertEqual(backend._recv_scales.shape, (8, 1024, 56))
-                    self.assertIs(backend._recv_x_t.window, windows[0] if zero_copy else None)
-                    self.assertIs(backend._recv_scales_t.window,
-                                  windows[1] if zero_copy else None)
-                    self.assertIs(backend._recv_scales_t.buffer, backend._recv_scales)
-                    self.assertIs(backend._combine_x_t.buffer, backend._combine_scratch)
-                    self.assertIsNone(backend._combine_x_t.window)
-                    backend._handle = None
-                    backend._bound = None
-                    backend._ep_group = types.SimpleNamespace(destroy=lambda: None)
-                    backend._comm.destroy = lambda: None
-                    module.dist.barrier = lambda: None
-                    module.dist.destroy_process_group = lambda: None
-                    self.assertEqual(backend.finalize(0), 0)
-                    for window in windows:
-                        self.assertEqual(window.close.call_count, int(zero_copy))
-
-    def test_fp8_scale_registration_failure_releases_token_window_and_group(self):
-        module = self._module()
-        backend = self._backend(module, low_latency=True)
-        backend._fp8 = True
-        windows = [types.SimpleNamespace(is_valid=valid, close=mock.Mock())
-                   for valid in (True, False)]
-        backend._comm.register_window.side_effect = windows
-        group = types.SimpleNamespace(destroy=mock.Mock())
-        module.nccl_ep.Group.create = lambda *a, **k: group
-        with self.assertRaisesRegex(RuntimeError, "scale window registration failed"):
-            backend.create_buffer(types.SimpleNamespace(max_tokens_per_rank=1024))
-        for window in windows:
-            window.close.assert_called_once()
-        group.destroy.assert_called_once()
-        self.assertIsNone(backend._recv_window)
-        self.assertIsNone(backend._recv_scales_window)
-        self.assertIsNone(backend._ep_group)
-
-    def test_ll_dispatch_uses_rank_major_metadata_and_returns_expert_inputs(self):
-        module = self._module()
-        backend = self._backend(module, low_latency=True)
-        backend.create_buffer(types.SimpleNamespace(ladder=[1, 64], max_tokens_per_rank=64))
-        captured = {}
-
-        class DispatchInputs:
-            def __init__(self, **kwargs):
-                captured["inputs"] = kwargs
-
-        class DispatchOutputs:
-            def __init__(self, **kwargs):
-                captured["outputs"] = kwargs
-
-        class LayoutInfo:
-            def __init__(self, **kwargs):
-                captured["layout"] = kwargs
-
-        handle = types.SimpleNamespace(dispatch=mock.Mock())
-        module.DispatchInputs = DispatchInputs
-        module.DispatchOutputs = DispatchOutputs
-        module.LayoutInfo = LayoutInfo
-        backend._handle = None
-        backend._bound = None
-        backend._ep_group = types.SimpleNamespace(create_handle=mock.Mock(return_value=handle))
-        backend._dispatch_cfg = object()
-        backend._stream = lambda: 0
-
-        p = types.SimpleNamespace(T=1, dispatch_x="tokens", topk_idx="indices", topk_weights="weights")
-        backend.dispatch(p)
-
-        self.assertIs(backend._layout, module.Layout.RANK_MAJOR)
-        self.assertEqual(captured["inputs"]["tokens"].buffer, "tokens")
-        self.assertEqual(captured["inputs"]["topk_weights"].buffer, "weights")
-        self.assertEqual(captured["outputs"]["tokens"].window, backend._recv_window)
-        self.assertIs(captured["outputs"]["topk_weights"], backend._recv_w_t)
-        self.assertIs(captured["outputs"]["topk_idx"], backend._recv_idx_t)
-        self.assertIs(captured["layout"]["src_rank_counters"], backend._recv_count_t)
-        handle.dispatch.assert_called_once()
-
-
 class RoundtripStagingGate(unittest.TestCase):
     """`roundtrip` must mean dispatch -> combine in every row, or it is not comparable: the gate
     is `stage_device_work` alone, with `CX_FP8_CONSUME=dequant` as the sole opt-out."""
@@ -441,96 +213,6 @@ def _import_stubbed(name, **vendor):
     return _fakes.fresh_import(name, {**_stub_modules(), **vendor})
 
 
-ep_nccl = _import_stubbed("ep_nccl")
-
-
-class FakeHandle:
-    """Records every rebind so the tests can assert on the collective call pattern."""
-
-    def __init__(self):
-        self.updates = []
-
-    def update(self, topk_idx, *, layout_info=None, stream=None):
-        self.updates.append((topk_idx, layout_info))
-
-
-class FakeGroup:
-    def __init__(self):
-        self.created = 0
-        self.handle = FakeHandle()
-
-    def create_handle(self, layout, topk_idx, *, layout_info=None, config=None, stream=None):
-        self.created += 1
-        return self.handle
-
-
-def backend(ll=True):
-    """An NCCLEPBackend with just the fields _ensure_handle touches (no __init__, no GPU)."""
-    b = object.__new__(ep_nccl.NCCLEPBackend)
-    b._ll = ll
-    b._layout = "EM" if ll else "FLAT"
-    b._handle = None
-    b._bound = None
-    b._ep_group = FakeGroup()
-    b.device = "cuda:0"
-    b.num_local_experts = 4
-    b.args = types.SimpleNamespace(hidden=16)
-    b._t = lambda x: x
-    b._window_t = lambda x: x
-    b._stream = lambda: 0
-    # create_buffer always runs before the first _ensure_handle, so the HT receive plane exists
-    # by then; a list stands in for the tensor because `_t` is identity here.
-    b._recv_x = list(range(64))
-    b._recv_x_t = ("window", "full-plane")
-    return b
-
-
-def problem(T):
-    return types.SimpleNamespace(
-        T=T, dispatch_x=f"x{T}", topk_idx=f"idx{T}", topk_weights=f"w{T}"
-    )
-
-
-class TestSingleHandle(unittest.TestCase):
-    def test_one_handle_across_many_shapes(self):
-        """Nine ladder rungs produce exactly one create_handle, rebound to each later routing."""
-        b = backend()
-        for T in (1, 2, 4, 8, 16, 32, 64, 128, 256):
-            b._ensure_handle(problem(T))
-        self.assertEqual(b._ep_group.created, 1)
-        self.assertEqual([idx for idx, _ in b._ep_group.handle.updates],
-                         [f"idx{T}" for T in (2, 4, 8, 16, 32, 64, 128, 256)])
-
-    def test_ll_rank_major_weight_wrapper_is_built_once_per_handle(self):
-        """LL caches its dispatch-weight wrapper with the handle."""
-        ll = backend(ll=True)
-        ll._t = mock.Mock(side_effect=lambda value: types.SimpleNamespace(value=value))
-        pa = problem(1)
-        h = ll._ensure_handle(pa)
-        first_weights = h.in_weights_t
-        self.assertEqual(first_weights.value, "w1")
-        # Re-entering the same problem reuses the handle and therefore the wrapper.
-        ll._t.reset_mock()
-        self.assertIs(ll._ensure_handle(pa).in_weights_t, first_weights)
-        ll._t.assert_not_called()
-
-    def test_ht_combine_input_is_the_full_static_receive_plane(self):
-        """The FLAT contract gives combine the dispatch output's static [num_recv_slots, hidden]
-        shape (required under graph capture); a count-sized slice needs an AUTO-sized group."""
-        b = backend(ll=False)
-        h = b._ensure_handle(problem(1))
-        # 7 is what the stubbed `torch.zeros(...).item()` reports as the received count.
-        self.assertEqual(h.count, 7)
-        self.assertIs(h.combine_in_t, b._recv_x_t)
-
-
-def _deep_ep(*classes):
-    module = types.ModuleType("deep_ep")
-    for cls in classes:
-        setattr(module, cls, type(cls, (), {}))
-    return module
-
-
 def _gate(cls, mode, phase):
     """An adapter carrying only what `cuda_graph_supported` reads."""
     backend = object.__new__(cls)
@@ -550,58 +232,5 @@ def test_flashinfer_and_nccl_ht_graph_decode_only(self):
         self.assertTrue(_gate(nccl, "low-latency", phase="decode").cuda_graph_supported)
 
 
-class GinWindowOrdering(unittest.TestCase):
-    """Relaxed-ordering rows must not merge into the strict-ordered series they would replace."""
-
-    def test_only_relaxed_scale_out_rows_carry_the_suffix(self):
-        module = _import_stubbed("ep_deepep_v2", deep_ep=_deep_ep("ElasticBuffer", "Buffer"))
-        relaxed = {"EP_WIN_RELAXED_ORDERING": "1"}
-        for world_size, env, suffixed in ((16, relaxed, True), (16, {}, False), (8, relaxed, False)):
-            with self.subTest(world_size=world_size, env=env), \
-                    mock.patch.dict(os.environ, env, clear=True):
-                backend = module.DeepEPV2Backend(
-                    args(scale_up_domain=8, runner="h200-dgxc"), 0, world_size, 0, "cpu")
-                self.assertEqual(backend.kernel_generation.endswith("-relaxed-ordering"), suffixed)
-
-
-class LowLatencyCapDecoupling(unittest.TestCase):
-    """The LL receive size and the measured ladder must stay two numbers -- sizing the receive
-    from `max(ladder)` would shift every rung."""
-
-    @staticmethod
-    def _adapter():
-        # The adapter imports ElasticBuffer by name and fails closed without it.
-        return _import_stubbed("ep_deepep_v2", deep_ep=_deep_ep("Buffer", "ElasticBuffer"))
-
-    def test_ladder_cap_drops_only_oversized_measurement_points(self):
-        module = self._adapter()
-        backend = module.DeepEPV2Backend.__new__(module.DeepEPV2Backend)
-        backend.mode = "low-latency"
-        backend.world_size = 8
-        backend._build_rank_inputs = mock.Mock(return_value=None)
-        args = types.SimpleNamespace(experts=256, tokens_ladder="32 64 128")
-        with mock.patch.object(module, "_LL_LADDER_CAP", 64):
-            spec = backend.make_inputs(args)
-        self.assertEqual(spec.ladder, [32, 64])
-        self.assertEqual(spec.dropped, [128])
-
-    def test_the_receive_is_sized_from_the_buffer_cap_not_the_ladder(self):
-        module = self._adapter()
-        backend = module.DeepEPV2Backend.__new__(module.DeepEPV2Backend)
-        backend.mode, backend.world_size, backend.group = "low-latency", 8, object()
-        backend.args = types.SimpleNamespace(experts=256, hidden=16)
-        vendor_buffer = mock.Mock()
-        vendor_buffer.get_low_latency_rdma_size_hint.return_value = 4096
-        with mock.patch.object(module.deep_ep, "Buffer", vendor_buffer), \
-                mock.patch.object(module, "_LL_BUFFER_CAP", 128), \
-                mock.patch.object(module, "_LL_LADDER_CAP", 64):
-            for ladder_max in (16, 64):
-                backend.create_buffer(types.SimpleNamespace(max_tokens_per_rank=ladder_max))
-                vendor_buffer.get_low_latency_rdma_size_hint.assert_called_with(128, 16, 8, 256)
-                self.assertEqual(vendor_buffer.call_args.kwargs["num_rdma_bytes"], 4096)
-            with self.assertRaisesRegex(RuntimeError, "exceeds"):
-                backend.create_buffer(types.SimpleNamespace(max_tokens_per_rank=129))
-
-
 if __name__ == "__main__":
     unittest.main()
diff --git a/collectivex/tests/test_deepep_v2_contract.py b/collectivex/tests/test_deepep_v2_contract.py
index c3892d1030..7c9fce2c46 100644
--- a/collectivex/tests/test_deepep_v2_contract.py
+++ b/collectivex/tests/test_deepep_v2_contract.py
@@ -349,5 +349,52 @@ def test_one_domain_models_agree_up_to_the_final_cast(self):
         self.assertEqual(torch.tensor(single).to(torch.bfloat16).item(), domain)
 
 
+class GinWindowOrdering(unittest.TestCase):
+    """Relaxed-ordering rows must not merge into the strict-ordered series they would replace."""
+
+    def test_only_relaxed_scale_out_rows_carry_the_suffix(self):
+        module = _adapter()
+        relaxed = {"EP_WIN_RELAXED_ORDERING": "1"}
+        for world_size, env, suffixed in ((16, relaxed, True), (16, {}, False), (8, relaxed, False)):
+            with self.subTest(world_size=world_size, env=env), \
+                    mock.patch.dict(os.environ, env, clear=True):
+                backend = module.DeepEPV2Backend(_args(), 0, world_size, 0, "cpu")
+                self.assertEqual(backend.kernel_generation.endswith("-relaxed-ordering"), suffixed)
+
+
+class LowLatencyCapDecoupling(unittest.TestCase):
+    """The LL receive size and the measured ladder must stay two numbers -- sizing the receive
+    from `max(ladder)` would shift every rung."""
+
+    def test_ladder_cap_drops_only_oversized_measurement_points(self):
+        module = _adapter()
+        backend = module.DeepEPV2Backend.__new__(module.DeepEPV2Backend)
+        backend.mode = "low-latency"
+        backend.world_size = 8
+        backend._build_rank_inputs = mock.Mock(return_value=None)
+        args = types.SimpleNamespace(experts=256, tokens_ladder="32 64 128")
+        with mock.patch.object(module.DeepEPV2Backend, "LL_LADDER_CAP", 64):
+            spec = backend.make_inputs(args)
+        self.assertEqual(spec.ladder, [32, 64])
+        self.assertEqual(spec.dropped, [128])
+
+    def test_the_receive_is_sized_from_the_buffer_cap_not_the_ladder(self):
+        module = _adapter()
+        backend = module.DeepEPV2Backend.__new__(module.DeepEPV2Backend)
+        backend.mode, backend.world_size, backend.group = "low-latency", 8, object()
+        backend.args = types.SimpleNamespace(experts=256, hidden=16)
+        vendor_buffer = mock.Mock()
+        vendor_buffer.get_low_latency_rdma_size_hint.return_value = 4096
+        with mock.patch.object(module.deep_ep, "Buffer", vendor_buffer), \
+                mock.patch.object(module.DeepEPV2Backend, "LL_BUFFER_CAP", 128), \
+                mock.patch.object(module.DeepEPV2Backend, "LL_LADDER_CAP", 64):
+            for ladder_max in (16, 64):
+                backend.create_buffer(types.SimpleNamespace(max_tokens_per_rank=ladder_max))
+                vendor_buffer.get_low_latency_rdma_size_hint.assert_called_with(128, 16, 8, 256)
+                self.assertEqual(vendor_buffer.call_args.kwargs["num_rdma_bytes"], 4096)
+            with self.assertRaisesRegex(RuntimeError, "exceeds"):
+                backend.create_buffer(types.SimpleNamespace(max_tokens_per_rank=129))
+
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/collectivex/tests/test_nccl_ep_contract.py b/collectivex/tests/test_nccl_ep_contract.py
index b1bd8b5d92..ad69aa0ae3 100644
--- a/collectivex/tests/test_nccl_ep_contract.py
+++ b/collectivex/tests/test_nccl_ep_contract.py
@@ -13,7 +13,7 @@
 ROOT = Path(__file__).resolve().parents[1]
 sys.path[:0] = [str(ROOT / "bench"), str(ROOT / "tests")]
 
-from test_backends import _import_stubbed  # noqa: E402
+from test_backends import _import_stubbed, args  # noqa: E402
 
 VERSION = "0.2.0.dev20261013"
 DEVICE_SMS = 132
@@ -296,5 +296,311 @@ def test_the_artifact_reads_the_environment_the_group_was_created_under(self):
         self.assertEqual(details["num_sms"], {"dispatch": 64, "combine": DEVICE_SMS})
 
 
+class NcclLowLatencyLadderSizing(unittest.TestCase):
+    """LL keeps every requested point and allocates receive space for the full ladder."""
+
+    def _module(self):
+        return _import_stubbed("ep_nccl")
+
+    @staticmethod
+    def _construct(module, world_size, mode="low-latency", **env):
+        """NCCLEPBackend.__init__ for a BF16 case under `env`."""
+        options = types.SimpleNamespace(
+            mode=mode, precision="bf16", experts=384, hidden=7168, topk=6, scale_up_domain=8
+        )
+        with mock.patch.dict(os.environ, env):
+            return module.NCCLEPBackend(options, 0, world_size, 0, "cuda:0")
+
+    def _backend(self, module, low_latency):
+        """A backend far enough along to run create_buffer against the stubs."""
+        backend = module.NCCLEPBackend.__new__(module.NCCLEPBackend)
+        backend._ll = low_latency
+        backend.zero_copy = True
+        backend.world_size, backend.num_local_experts, backend.device = 8, 4, "cuda:0"
+        backend.args = types.SimpleNamespace(hidden=7168, experts=256, topk=8, phase="decode")
+        backend._algorithm = "LL" if low_latency else "HT"
+        backend._layout = module.Layout.RANK_MAJOR if low_latency else module.Layout.FLAT
+        backend._bootstrap_comm = lambda: None
+        # create_buffer stamps the installed wheel into kernel_generation.
+        module.metadata = types.SimpleNamespace(version=lambda name: "0.2.0.dev20261013")
+        backend._recv_window_for_test = types.SimpleNamespace(
+            is_valid=True, close=lambda: None
+        )
+        backend._comm = types.SimpleNamespace(
+            register_window=mock.Mock(return_value=backend._recv_window_for_test)
+        )
+        backend.created_configs = []
+
+        def group_config(**kwargs):
+            config = types.SimpleNamespace(**kwargs)
+            backend.created_configs.append(config)
+            return config
+
+        module.GroupConfig = group_config
+        module.nccl_ep.Group = types.SimpleNamespace(create=lambda *a, **k: object())
+        return backend
+
+    def test_the_communicator_runs_graph_usage_mode_one(self):
+        module = self._module()
+        with mock.patch.object(module.nccl_core, "NCCLConfig", lambda **kw: kw, create=True):
+            self.assertEqual(module.NCCLEPBackend._comm_config(), {"graph_usage_mode": 1})
+
+    def test_ll_layout_selector_restores_the_expert_major_contract(self):
+        module = self._module()
+        em = self._construct(module, 8, COLLX_NCCL_LL_LAYOUT="expert-major")
+        rm = self._construct(module, 8)
+        ht = self._construct(module, 16, mode="normal")
+        with self.assertRaisesRegex(ValueError, "COLLX_NCCL_LL_LAYOUT"):
+            self._construct(module, 8, COLLX_NCCL_LL_LAYOUT="flat")
+
+        self.assertEqual(em._layout, module.Layout.EXPERT_MAJOR)
+        self.assertEqual(
+            (em.kernel_generation, em.receive_layout, em.combine_weight_semantics),
+            ("nccl-ep-v02-ll-em", "token-expert", "weighted-kernel-sum"),
+        )
+        self.assertFalse(em.zero_copy)
+        self.assertEqual(rm._layout, module.Layout.RANK_MAJOR)
+        # Only LL rank-major selects NCCL's FP32 reduction.
+        self.assertEqual((rm.combine_reduction, em.combine_reduction, ht.combine_reduction),
+                         ("rank-fp32", "domain-fp32", "domain-fp32"))
+
+    def test_ll_ladder_keeps_512_and_larger_points(self):
+        module = self._module()
+        backend = self._backend(module, low_latency=True)
+        backend.mode = "low-latency"
+        backend.args.tokens_ladder = "32 256 512 1024"
+        backend._build_rank_inputs = mock.Mock(return_value=None)
+        spec = backend.make_inputs(backend.args)
+        self.assertEqual(spec.ladder, [32, 256, 512, 1024])
+        self.assertEqual(spec.dropped, [])
+
+    def test_fp8_ll_accepts_both_phases_and_keeps_ht_disabled(self):
+        module = self._module()
+        module.nccl_ep.DispatchQuantizationRecipe = types.SimpleNamespace(DS_FP8E3M4="ds-fp8")
+        module.DispatchConfig = lambda **kw: types.SimpleNamespace(**kw)
+        with mock.patch.dict(os.environ, {"COLLX_NCCL_LL_LAYOUT": "rank-major"}):
+            for phase in ("decode", "prefill"):
+                with self.subTest(phase=phase):
+                    options = args(phase=phase, precision="fp8", mode="low-latency",
+                                   hidden=7168, experts=384, topk=6, scale_up_domain=72)
+                    backend = module.NCCLEPBackend(options, 0, 8, 0, "cuda:0")
+                    self.assertEqual(backend._dispatch_cfg.quantization_recipe, "ds-fp8")
+                    self.assertEqual(backend.dispatch_dtype, "fp8-e4m3fn")
+                    self.assertTrue(backend.zero_copy)
+                    self.assertEqual(backend.cuda_graph_supported, phase == "decode")
+                    options.mode = "normal"
+                    with self.assertRaisesRegex(ValueError, "low-latency mode only"):
+                        module.NCCLEPBackend(options, 0, 8, 0, "cuda:0")
+
+    def test_ll_prefill_uses_the_full_ladder_receive_without_graphs(self):
+        module = self._module()
+        backend = self._backend(module, low_latency=True)
+        backend.mode = "low-latency"
+        backend.args.phase = "prefill"
+        self.assertIsNone(backend.buffer_cap(backend.args))
+        backend.create_buffer(types.SimpleNamespace(max_tokens_per_rank=8192))
+        self.assertEqual(backend._recv_x.shape, (8, 8192, 7168))
+        self.assertEqual(backend.created_configs[0].max_dispatch_tokens_per_rank, 8192)
+        self.assertFalse(backend.cuda_graph_supported)
+
+    def test_ht_registers_a_symmetric_zero_copy_receive_window(self):
+        module = self._module()
+        backend = self._backend(module, low_latency=False)
+        backend.create_buffer(types.SimpleNamespace(max_tokens_per_rank=99))
+
+        self.assertEqual(backend.created_configs[0].zero_copy, module.ZeroCopyMode.ON)
+        backend._comm.register_window.assert_called_once_with(
+            backend._recv_x, flags=module.nccl_core.WindowFlag.COLL_SYMMETRIC
+        )
+        self.assertIs(backend._recv_x_t.window, backend._recv_window_for_test)
+        self.assertEqual(backend._recv_x_t.window_offset, 0)
+
+    def test_ll_rank_major_registers_a_direct_receive_window(self):
+        module = self._module()
+        backend = self._backend(module, low_latency=True)
+        backend.create_buffer(types.SimpleNamespace(ladder=[1, 64], max_tokens_per_rank=64))
+
+        self.assertTrue(backend.zero_copy)
+        self.assertEqual(backend.created_configs[0].zero_copy, module.ZeroCopyMode.ON)
+        backend._comm.register_window.assert_called_once_with(
+            backend._recv_x, flags=module.nccl_core.WindowFlag.COLL_SYMMETRIC
+        )
+        self.assertEqual(backend._recv_x.shape, (8, 64, 7168))
+        self.assertEqual(backend._recv_count.shape, (8,))
+        self.assertIs(backend._recv_x_t.window, backend._recv_window)
+
+    def test_fp8_buffer_binding_follows_selected_policy_in_both_phases(self):
+        for phase in ("decode", "prefill"):
+            for zero_copy in (False, True):
+                with self.subTest(phase=phase, zero_copy=zero_copy):
+                    module = self._module()
+                    backend = self._backend(module, low_latency=True)
+                    backend.args.phase = phase
+                    backend._fp8 = True
+                    backend.zero_copy = zero_copy
+                    windows = [types.SimpleNamespace(is_valid=True, close=mock.Mock())
+                               for _ in range(2)]
+                    backend._comm.register_window.side_effect = windows
+                    backend.create_buffer(types.SimpleNamespace(max_tokens_per_rank=1024))
+                    self.assertEqual(backend._recv_x.shape, (8, 1024, 7168))
+                    self.assertEqual(backend._recv_scales.shape, (8, 1024, 56))
+                    self.assertIs(backend._recv_x_t.window, windows[0] if zero_copy else None)
+                    self.assertIs(backend._recv_scales_t.window,
+                                  windows[1] if zero_copy else None)
+                    self.assertIs(backend._recv_scales_t.buffer, backend._recv_scales)
+                    self.assertIs(backend._combine_x_t.buffer, backend._combine_scratch)
+                    self.assertIsNone(backend._combine_x_t.window)
+                    backend._handle = None
+                    backend._bound = None
+                    backend._ep_group = types.SimpleNamespace(destroy=lambda: None)
+                    backend._comm.destroy = lambda: None
+                    module.dist.barrier = lambda: None
+                    module.dist.destroy_process_group = lambda: None
+                    self.assertEqual(backend.finalize(0), 0)
+                    for window in windows:
+                        self.assertEqual(window.close.call_count, int(zero_copy))
+
+    def test_fp8_scale_registration_failure_releases_token_window_and_group(self):
+        module = self._module()
+        backend = self._backend(module, low_latency=True)
+        backend._fp8 = True
+        windows = [types.SimpleNamespace(is_valid=valid, close=mock.Mock())
+                   for valid in (True, False)]
+        backend._comm.register_window.side_effect = windows
+        group = types.SimpleNamespace(destroy=mock.Mock())
+        module.nccl_ep.Group.create = lambda *a, **k: group
+        with self.assertRaisesRegex(RuntimeError, "scale window registration failed"):
+            backend.create_buffer(types.SimpleNamespace(max_tokens_per_rank=1024))
+        for window in windows:
+            window.close.assert_called_once()
+        group.destroy.assert_called_once()
+        self.assertIsNone(backend._recv_window)
+        self.assertIsNone(backend._recv_scales_window)
+        self.assertIsNone(backend._ep_group)
+
+    def test_ll_dispatch_uses_rank_major_metadata_and_returns_expert_inputs(self):
+        module = self._module()
+        backend = self._backend(module, low_latency=True)
+        backend.create_buffer(types.SimpleNamespace(ladder=[1, 64], max_tokens_per_rank=64))
+        captured = {}
+
+        class DispatchInputs:
+            def __init__(self, **kwargs):
+                captured["inputs"] = kwargs
+
+        class DispatchOutputs:
+            def __init__(self, **kwargs):
+                captured["outputs"] = kwargs
+
+        class LayoutInfo:
+            def __init__(self, **kwargs):
+                captured["layout"] = kwargs
+
+        handle = types.SimpleNamespace(dispatch=mock.Mock())
+        module.DispatchInputs = DispatchInputs
+        module.DispatchOutputs = DispatchOutputs
+        module.LayoutInfo = LayoutInfo
+        backend._handle = None
+        backend._bound = None
+        backend._ep_group = types.SimpleNamespace(create_handle=mock.Mock(return_value=handle))
+        backend._dispatch_cfg = object()
+        backend._stream = lambda: 0
+
+        p = types.SimpleNamespace(T=1, dispatch_x="tokens", topk_idx="indices", topk_weights="weights")
+        backend.dispatch(p)
+
+        self.assertIs(backend._layout, module.Layout.RANK_MAJOR)
+        self.assertEqual(captured["inputs"]["tokens"].buffer, "tokens")
+        self.assertEqual(captured["inputs"]["topk_weights"].buffer, "weights")
+        self.assertEqual(captured["outputs"]["tokens"].window, backend._recv_window)
+        self.assertIs(captured["outputs"]["topk_weights"], backend._recv_w_t)
+        self.assertIs(captured["outputs"]["topk_idx"], backend._recv_idx_t)
+        self.assertIs(captured["layout"]["src_rank_counters"], backend._recv_count_t)
+        handle.dispatch.assert_called_once()
+
+
+_ep_nccl = _import_stubbed("ep_nccl")
+
+
+class RebindRecordingHandle:
+    """Records every rebind so the tests can assert on the collective call pattern."""
+
+    def __init__(self):
+        self.updates = []
+
+    def update(self, topk_idx, *, layout_info=None, stream=None):
+        self.updates.append((topk_idx, layout_info))
+
+
+class RebindRecordingGroup:
+    def __init__(self):
+        self.created = 0
+        self.handle = RebindRecordingHandle()
+
+    def create_handle(self, layout, topk_idx, *, layout_info=None, config=None, stream=None):
+        self.created += 1
+        return self.handle
+
+
+def _handle_backend(ll=True):
+    """An NCCLEPBackend with just the fields _ensure_handle touches (no __init__, no GPU)."""
+    b = object.__new__(_ep_nccl.NCCLEPBackend)
+    b._ll = ll
+    b._layout = "EM" if ll else "FLAT"
+    b._handle = None
+    b._bound = None
+    b._ep_group = RebindRecordingGroup()
+    b.device = "cuda:0"
+    b.num_local_experts = 4
+    b.args = types.SimpleNamespace(hidden=16)
+    b._t = lambda x: x
+    b._window_t = lambda x: x
+    b._stream = lambda: 0
+    # create_buffer always runs before the first _ensure_handle, so the HT receive plane exists
+    # by then; a list stands in for the tensor because `_t` is identity here.
+    b._recv_x = list(range(64))
+    b._recv_x_t = ("window", "full-plane")
+    return b
+
+
+def _ladder_problem(T):
+    return types.SimpleNamespace(
+        T=T, dispatch_x=f"x{T}", topk_idx=f"idx{T}", topk_weights=f"w{T}"
+    )
+
+
+class TestSingleHandle(unittest.TestCase):
+    def test_one_handle_across_many_shapes(self):
+        """Nine ladder rungs produce exactly one create_handle, rebound to each later routing."""
+        b = _handle_backend()
+        for T in (1, 2, 4, 8, 16, 32, 64, 128, 256):
+            b._ensure_handle(_ladder_problem(T))
+        self.assertEqual(b._ep_group.created, 1)
+        self.assertEqual([idx for idx, _ in b._ep_group.handle.updates],
+                         [f"idx{T}" for T in (2, 4, 8, 16, 32, 64, 128, 256)])
+
+    def test_ll_rank_major_weight_wrapper_is_built_once_per_handle(self):
+        """LL caches its dispatch-weight wrapper with the handle."""
+        ll = _handle_backend(ll=True)
+        ll._t = mock.Mock(side_effect=lambda value: types.SimpleNamespace(value=value))
+        pa = _ladder_problem(1)
+        h = ll._ensure_handle(pa)
+        first_weights = h.in_weights_t
+        self.assertEqual(first_weights.value, "w1")
+        # Re-entering the same problem reuses the handle and therefore the wrapper.
+        ll._t.reset_mock()
+        self.assertIs(ll._ensure_handle(pa).in_weights_t, first_weights)
+        ll._t.assert_not_called()
+
+    def test_ht_combine_input_is_the_full_static_receive_plane(self):
+        """The FLAT contract gives combine the dispatch output's static [num_recv_slots, hidden]
+        shape (required under graph capture); a count-sized slice needs an AUTO-sized group."""
+        b = _handle_backend(ll=False)
+        h = b._ensure_handle(_ladder_problem(1))
+        # 7 is what the stubbed `torch.zeros(...).item()` reports as the received count.
+        self.assertEqual(h.count, 7)
+        self.assertIs(h.combine_in_t, b._recv_x_t)
+
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/RECIPES.md b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/RECIPES.md
index a97d8f0c9a..d3c19b21e3 100644
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/RECIPES.md
+++ b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/RECIPES.md
@@ -2,7 +2,7 @@
 
 InferenceX owns the recipes in this directory. For every NVIDIA srt-slurm launch, the srt driver ([`infx/launch/drivers/srt/checkout.py`](../../../infx/launch/drivers/srt/checkout.py)) makes a job-local Git clone of the pinned submodule and copies this entire tree into `recipes/`. It records the actual revision in `srt-slurm-sha.txt`; power lanes copy that revision into `power-producer-sha.txt` for result validation.
 
-The shared version is the Git submodule pointer at [`utils/srt-slurm`](../../../utils/srt-slurm), currently [v2.65.2](https://github.com/NVIDIA/srt-slurm/releases/tag/v2.65.2) (`59920ea16a13017a990e449d034a495c0b05bc57`). Update that submodule pointer when upgrading, then run the recipe and integration checks. Do not add model-specific checkout branches to launchers.
+The shared version is the Git submodule pointer at [`utils/srt-slurm`](../../../utils/srt-slurm), currently [v2.66.2](https://github.com/NVIDIA/srt-slurm/releases/tag/v2.66.2) (`acfb4dcc3bd48fd6a1e7b615e849e7954c0c3852`). Update that submodule pointer when upgrading, then run the recipe and integration checks. Do not add model-specific checkout branches to launchers.
 
 InferenceX requires srt-slurm 2.0 or newer and `schema: 2` recipes. Legacy recipe layouts are unsupported; migrate them before adding them to this tree.
 
@@ -49,13 +49,47 @@ Keep the recipe and master configuration synchronized. The launcher executes the
 
 All referenced recipes must be checked in: srt-slurm 2 ships curated examples instead of the historical `recipes/` archive. The initial migration restores 204 previously external recipes and two still-referenced AgentX recipes from InferenceX history. Master-config paths follow the layout above; existing override selectors are preserved.
 
+## Single-node parallelism validation
+
+The master search-space fields `tp`, `ep`, and `dp-attn` become `TP`, `EP_SIZE`,
+and `DP_ATTENTION` in the benchmark environment. Each engine's recipe retains
+its native argument names and parallelism conventions.
+[`parallelism_constraints` and `validate_recipe`](../../../infx/srt_slurm/single_node.py)
+compare the recipe with that metadata. The former returns named
+`(actual, expected)` pairs; the latter raises `ValueError` on a mismatch.
+Variant selection requires exactly one matching recipe before launch.
+These checks never rewrite the recipe's parallelism settings or launch flags.
+
+| Engine | Recipe value compared with `tp` | Check against `ep` | Check against `dp-attn` |
+|---|---|---|---|
+| TokenSpeed | `attn-tp-size * data-parallel-size` | `ep-size == ep` | `(data-parallel-size > 1) == dp-attn` |
+| SGLang | `tensor-parallel-size` | `expert-parallel-size`, or `ep-size` | `enable-dp-attention == dp-attn`; `data-parallel-size` must equal `tp` when enabled, otherwise 1 |
+| TensorRT-LLM (`trt` in the master) | `tensor_parallel_size` | `moe_expert_parallel_size == ep` | `enable_attention_dp == dp-attn` |
+| vLLM | `tensor-parallel-size * data-parallel-size` | `enable-expert-parallel == (ep > 1)` | `(data-parallel-size > 1) == dp-attn` |
+| ATOM | `roles.agg.gpus` | `enable-expert-parallel == (ep > 1)`; `ep` must be 1 or `tp` | `enable-dp-attention == dp-attn` |
+
+For example, a master row with `tp: 4`, `ep: 4`, and `dp-attn: true` matches
+TokenSpeed arguments `attn-tp-size: 1`, `data-parallel-size: 4`, and `ep-size: 4`:
+one GPU per attention group times four groups gives the four-GPU width.
+The matching SGLang arguments are `tensor-parallel-size: 4`,
+`data-parallel-size: 4`, `expert-parallel-size: 4`, and
+`enable-dp-attention: true`. This validator compares SGLang's TP directly;
+it does not multiply that TP by DP. Comparing literal TP flags across engines
+would incorrectly reject the TokenSpeed recipe because its attention TP is 1.
+
+The single-node launcher requires pipeline parallelism 1. vLLM's EP check
+verifies the enable flag, not an exact numerical expert group size. `dp-attn`
+is a boolean, not a count, so these checks do not encode every possible engine
+topology. They prevent running and labeling a benchmark with inconsistent
+recipe and master settings; the recipe still owns the native configuration.
+
 ## Recipe fragments
 
 Active recipes, fixed-sequence and AgentX, single- and multi-node, are fragments: native srt-slurm YAML holding only recipe-specific settings. At launch the fragment is composed and bound:
 
-1. The lane's shared block in [`configs/srt-recipes/`](../../../configs/srt-recipes) (`fixed-sequence-{single,multi}.yaml` or `agentic.yaml`) is merged under the fragment (under `base` for bundles). A multi-node row with `power: true` also gets [`telemetry-dcgm.yaml`](../../../configs/srt-recipes/telemetry-dcgm.yaml), its exporter on the cluster's `srt-slurm.power-exporter-port`; the lane must allow power (`POWER_LANES`). The fragment wins: mappings merge and lists replace, so a fragment may keep telemetry tunables such as `collector_join_timeout_seconds`. Native single-node benchmarks also get [`telemetry-native.yaml`](../../../configs/srt-recipes/telemetry-native.yaml) before variant selection. That block enables best-effort power collection with the cluster's `default_gpu_exporter`; eval-only points omit collection. The binder sets `telemetry.required` from `REQUIRE_POWER`, so a single-node fragment may not set it, and gives AgentX clients matching power switches.
+1. The lane's shared block in [`configs/srt-recipes/`](../../../configs/srt-recipes) (`fixed-sequence-{single,multi}.yaml` or `agentic.yaml`) is merged under the fragment (under `base` for bundles). Every multi-node benchmark point on a cluster with a GPU exporter also gets a telemetry block, with the cluster's CPU exporter where it declares one, unless its recipe runs etcd and NATS on a dedicated node: [`telemetry-dcgm.yaml`](../../../configs/srt-recipes/telemetry-dcgm.yaml) where the cluster sets `srt-slurm.power-exporter-port`, else [`telemetry-native.yaml`](../../../configs/srt-recipes/telemetry-native.yaml). The binder sets `telemetry.required` only for a row with `power: true`. The fragment wins: mappings merge and lists replace, so a fragment may keep telemetry tunables such as `collector_join_timeout_seconds`. Native single-node benchmarks also get [`telemetry-native.yaml`](../../../configs/srt-recipes/telemetry-native.yaml) before variant selection. That block enables best-effort power collection with the cluster's `default_gpu_exporter`; eval-only points omit collection. A native single-node point on a cluster that declares `srt-slurm.cpu-power-exporter`, and a `cpu-power: true` row, also gets `telemetry.cpu_power_exporter` with that source. The binder sets `telemetry.required` from `REQUIRE_POWER`, so a single-node fragment may not set it, and gives AgentX clients matching power switches.
 2. The row's selector picks the variant. A single-node variant may name its `benchmark.env.CONC`, which keeps that concurrency paired with its tuning.
-3. The binder ([`workload.py`](../../../infx/srt_slurm/workload.py)) writes the matrix point into the selected recipe: `model.path: hf:<model>`, `model.container: <image>`, `model.precision`, `identity.container.image` (as a registry reference) and `identity.model.repo` when the fragment declares `identity.container`/`identity.model`, and `benchmark.concurrencies` when telemetry is enabled. Fixed-sequence recipes also get `benchmark.env.ISL`/`OSL`; single-node recipes get `MODEL` and `CONC`, and fixed-sequence ones `RANDOM_RANGE_RATIO` and `USE_CHAT_TEMPLATE` (`true` exactly when the recipe speculates). Multi-node AgentX recipes get the client's `RESULT_DIR`, `AIPERF_DATASET_MMAP_CACHE_DIR` and `HF_HUB_CACHE` from the launcher, which derives them from the volumes it mounts (`volume-mounts`, `agentic-volume-mounts`, lane mounts); a fragment that sets `HF_HOME` keeps its own cache. They also get `IS_MULTINODE: "true"` and `ENABLE_AGENTX_POWER`, `"1"` exactly when the launcher collects the point's AgentX power (a `power: true` row whose lane rule collects AgentX or adapter power) and `"0"` otherwise, and `REQUIRE_POWER`, `"1"` when the workflow requires power or the lane rule marks the point `require` (GB200 and GB300 Kimi-K3 AgentX), so the client fails a point whose power is invalid. The multi-node client reads `CONC_LIST`, `CONC`, `MODEL` and the other matrix inputs, prefill and decode topology included, from the job environment, so fragments do not copy them (`TP`, `PP_SIZE`, `PCP_SIZE` and `EP_SIZE` describe single-node points only); single-node AgentX points get them as runtime arguments.
+3. The binder ([`workload.py`](../../../infx/srt_slurm/workload.py)) writes the matrix point into the selected recipe: `model.path: hf:<model>`, `model.container: <image>`, `model.precision`, `identity.container.image` (as a registry reference) and `identity.model.repo` when the fragment declares `identity.container`/`identity.model`, and `benchmark.concurrencies` when telemetry is enabled. Fixed-sequence recipes also get `benchmark.env.ISL`/`OSL`; single-node recipes get `MODEL` and `CONC`, and fixed-sequence ones `RANDOM_RANGE_RATIO` and `USE_CHAT_TEMPLATE` (`true` exactly when the recipe speculates). Multi-node AgentX recipes get the client's `RESULT_DIR`, `AIPERF_DATASET_MMAP_CACHE_DIR` and `HF_HUB_CACHE` from the launcher, which derives them from the volumes it mounts (`volume-mounts`, `agentic-volume-mounts`, lane mounts); a fragment that sets `HF_HOME` keeps its own cache. They also get `IS_MULTINODE: "true"` and `ENABLE_AGENTX_POWER`, `"1"` exactly when the launcher collects the point's AgentX power (a `power: true` row whose lane rule collects AgentX or adapter power, or any GB200 or GB300 AgentX point the launcher measures by default) and `"0"` otherwise, and `REQUIRE_POWER`, `"1"` when the workflow requires power or the lane rule marks the point `require`, so the client fails a point whose power is invalid. The multi-node client reads `CONC_LIST`, `CONC`, `MODEL` and the other matrix inputs, prefill and decode topology included, from the job environment, so fragments do not copy them (`TP`, `PP_SIZE`, `PCP_SIZE` and `EP_SIZE` describe single-node points only); single-node AgentX points get them as runtime arguments.
 4. A component a repository setup script installs gets the master config's version. When `setup_script`, or a service `preamble` that runs `/configs/<script>`, is one of the installers in the binder's `INSTALLERS`, the binder writes the point's `router` or `kv-offload-backend` version as `ROUTER_VERSION` or `KV_OFFLOAD_BACKEND_VERSION` into the top-level `environment` (workers and static routers) or into that service's `env` (services do not inherit `environment`). A point that does not declare the version fails, and a `vllm-router==` pin in `SETUP_PIP_PACKAGES` must equal the master router version.
 
 A fragment that sets a key the binder or launcher writes, or that the workflow exports from the matrix point (`_POINT_KEYS`, `BOUND_ENV` in `workload.py`, and `ROUTER_VERSION` or `KV_OFFLOAD_BACKEND_VERSION` in any env; single-node variants may still name `CONC`), fails before submission, even with the bound value. Values `benchmarks/runtime_settings.sh` and the multi-node `FRAMEWORK` settings export reach every process through the job environment, so a fragment sets one only to override it (an AgentX client `TOKENIZER` names a local checkpoint while `MODEL` stays the published Hugging Face id). `hf:<model>` resolves to the cluster's staged checkpoint (`models.entries`) unless a `models.OVERRIDES` row serves the Hub snapshot, and the master image to its staged container. A multi-node fixed-sequence point with neither checkpoint nor Hub row fails before submission.
@@ -68,11 +102,11 @@ Inspect what the launcher submits without a cluster:
 uv run --extra recipes infx generate --config-key 'dsr1-fp8-h200-*' --output-dir /tmp/recipes
 ```
 
-It writes one bound recipe per fixed-sequence or AgentX point, validated by the pinned srtctl, plus a `manifest.json` that maps each file to its matrix point and to the one cluster its runner label schedules on (`null` when the label spans several). Multi-node points take their cluster's binder inputs (DCGM exporter port, AgentX client env); a point that needs them fails unless its runner label names one cluster and the lane accepts the row's `power`. Native single-node points validate against each eligible cluster's exporter defaults while retaining cluster-independent recipe output. Fabric references take that cluster's facts; when the label spans several clusters they stay references. Launch-time edits such as the job name, health-check floor and runtime `--set` values are not applied.
+It writes one bound recipe per fixed-sequence or AgentX point, validated by the pinned srtctl, plus a `manifest.json` that maps each file to its matrix point and to the one cluster its runner label schedules on (`null` when the label spans several). Multi-node points take their cluster's binder inputs (GPU telemetry, AgentX client env); a point that needs them fails unless its runner label names one cluster and the lane accepts the row's `power`. Every point validates against each eligible cluster's exporter defaults while retaining cluster-independent recipe output, except that a point whose runner label names one cluster takes that cluster's CPU exporter source, and a `cpu-power` point must name one. Fabric references take that cluster's facts; when the label spans several clusters they stay references. Launch-time edits such as the job name, health-check floor and runtime `--set` values are not applied.
 
 ## Recipe fingerprints
 
-The planner gives every benchmark row a `recipe-fingerprint`: a SHA-256 of its matrix fields (except `conc` and `exp-name`) and the bound variant the launcher submits, composed with its shared block and the native single-node or multi-node `power: true` telemetry block. Concurrency values, the job `name` and everything the launcher adds for a cluster stay out, so a recipe keeps one fingerprint across concurrencies and clusters. An `eval-srt-recipe` contributes only its path; rows without an srt-slurm recipe hash their matrix fields alone.
+The planner gives every benchmark row a `recipe-fingerprint`: a SHA-256 of its matrix fields (except `conc` and `exp-name`) and the bound variant the launcher submits, composed with its shared block and the native single-node or multi-node `power: true` telemetry block (the DCGM block, whatever the cluster's exporter); the default multi-node telemetry stays out. Concurrency values, the job `name` and everything the launcher adds for a cluster stay out, so a recipe keeps one fingerprint across concurrencies and clusters. An `eval-srt-recipe` contributes only its path; rows without an srt-slurm recipe hash their matrix fields alone.
 
 The planner selects variants without srtctl ([`variants.py`](../../../infx/srt_slurm/variants.py)), the way the launcher does, so a row that no variant serves fails planning instead of its launch. Before writing a `perf-changelog.yaml` entry, list the config keys whose results the change invalidates:
 
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/configs/kimik3-atom-dspark-draft.sh b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/configs/kimik3-atom-dspark-draft.sh
deleted file mode 100644
index 7419f48b64..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/configs/kimik3-atom-dspark-draft.sh
+++ /dev/null
@@ -1,13 +0,0 @@
-#!/usr/bin/env bash
-# Stage the Kimi-K3 DSpark draft before ATOM starts: with an uncached repo id
-# every rank pulls the same 7 GB at once. Shared-cache downloads can hit
-# transient stale handles, hence the retries.
-set -euo pipefail
-unset HTTP_PROXY HTTPS_PROXY http_proxy https_proxy
-for attempt in 1 2 3 4 5; do
-    hf download Inferact/Kimi-K3-DSpark && exit 0
-    echo "hf download attempt $attempt failed; retrying in 60s" >&2
-    sleep 60
-done
-echo "hf download of Inferact/Kimi-K3-DSpark failed after 5 attempts" >&2
-exit 1
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/configs/kimik3-b300-mooncake.sh b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/configs/kimik3-b300-mooncake.sh
deleted file mode 100755
index ae385b269d..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/configs/kimik3-b300-mooncake.sh
+++ /dev/null
@@ -1,36 +0,0 @@
-#!/usr/bin/env bash
-# Install the worker's Mooncake client and point its store at one active RDMA rail.
-set -eo pipefail
-bash "$(dirname "${BASH_SOURCE[0]}")/vllm-mooncake.sh"
-
-# Rail-isolated nodes: two RNICs cannot reach each other even within a node, so
-# every rank uses one rail. mlx5_0 is down on some nodes, and topology discovery
-# then finds no HCA, so take the first active rail at runtime. DSXE nodes name
-# their rails rdmap*.
-rail=""
-for device in mlx5_0 mlx5_1 mlx5_2 mlx5_3 mlx5_4 mlx5_5 mlx5_8 mlx5_9 \
-              mlx5_10 mlx5_11 mlx5_16 mlx5_17 mlx5_20 mlx5_21 mlx5_22 mlx5_23 \
-              $(ls /sys/class/infiniband 2>/dev/null | grep '^rdmap' | sort -V); do
-    if grep -q ACTIVE "/sys/class/infiniband/$device/ports/1/state" 2>/dev/null; then
-        rail="$device"
-        break
-    fi
-done
-if [[ -z "$rail" ]]; then
-    echo "Error: no active RDMA rail on $(hostname); Mooncake cannot initialise" >&2
-    for state in /sys/class/infiniband/*/ports/*/state; do
-        echo "$state: $(cat "$state" 2>&1)" >&2
-    done
-    exit 1
-fi
-config="${MOONCAKE_CONFIG_PATH:-/logs/mooncake_store_config.json}"
-python3 - "$config" "$rail" <<'PY'
-import json, sys
-path, rail = sys.argv[1:]
-with open(path) as handle:
-    config = json.load(handle)
-config["device_name"] = rail
-with open(path, "w") as handle:
-    json.dump(config, handle, indent=2)
-PY
-echo "Mooncake rail: $rail"
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/configs/kimik3-dspark-config-compat.sh b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/configs/kimik3-dspark-config-compat.sh
deleted file mode 100644
index 29e70028ed..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/configs/kimik3-dspark-config-compat.sh
+++ /dev/null
@@ -1,49 +0,0 @@
-#!/usr/bin/env bash
-set -eo pipefail
-
-# The Kimi K3 DSpark checkpoint publishes its parallel-drafting token as
-# `mask_token_id`. Dynamo's serialized draft config reaches vLLM without the
-# K3 config-class alias, while vLLM's parallel drafter accepts `pard_token`.
-# Build a thin local view of the upstream checkpoint and add that equivalent
-# metadata alias without changing vLLM or the checkpoint weights.
-python3 - <<'PY'
-import json
-import os
-from pathlib import Path
-
-from huggingface_hub import snapshot_download
-
-repo_id = "Inferact/Kimi-K3-DSpark"
-target = Path("/tmp/Kimi-K3-DSpark")
-snapshot = Path(snapshot_download(repo_id=repo_id))
-target.mkdir(parents=True, exist_ok=True)
-
-for source in snapshot.iterdir():
-    if source.name == "config.json":
-        continue
-    destination = target / source.name
-    if destination.is_symlink():
-        if destination.resolve() == source.resolve():
-            continue
-        destination.unlink()
-    elif destination.exists():
-        raise RuntimeError(f"Refusing to replace non-symlink path: {destination}")
-    destination.symlink_to(source)
-
-config = json.loads((snapshot / "config.json").read_text())
-mask_token_id = config.get("mask_token_id")
-if not isinstance(mask_token_id, int):
-    raise RuntimeError(f"{repo_id} config is missing integer mask_token_id")
-
-pard_token = config.get("pard_token")
-if pard_token not in (None, mask_token_id):
-    raise RuntimeError(
-        f"{repo_id} pard_token={pard_token} disagrees with mask_token_id={mask_token_id}"
-    )
-config["pard_token"] = mask_token_id
-
-temporary = target / "config.json.tmp"
-temporary.write_text(json.dumps(config, indent=2) + "\n")
-os.replace(temporary, target / "config.json")
-print(f"Prepared {repo_id} compatibility view at {target}")
-PY
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/configs/tokenspeed-nightly.sh b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/configs/tokenspeed-nightly.sh
new file mode 100755
index 0000000000..0859a4f83b
--- /dev/null
+++ b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/configs/tokenspeed-nightly.sh
@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+set -eo pipefail
+source /infmax-workspace/benchmarks/check_env.sh
+check_env_vars TOKENSPEED_WHEEL_URL TOKENSPEED_KERNEL_WHEEL_URL TOKENSPEED_ENGINE_WHEEL_URL TOKENSPEED_SCHEDULER_VERSION ROUTER_VERSION
+
+pip_install=(python3 -m pip install)
+if python3 -m pip install --help 2>/dev/null | grep -q -- --break-system-packages; then
+    pip_install+=(--break-system-packages)
+fi
+"${pip_install[@]}" --upgrade \
+    --index-url https://pypi.org/simple \
+    "$TOKENSPEED_WHEEL_URL" "$TOKENSPEED_KERNEL_WHEEL_URL" "$TOKENSPEED_ENGINE_WHEEL_URL" \
+    "tokenspeed-scheduler==$TOKENSPEED_SCHEDULER_VERSION" \
+    "tokenspeed-smg==$ROUTER_VERSION"
+python3 -m pip check
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/dsv41flash/vllm/gb300-fp4/agentx/disagg-variants.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/dsv41flash/vllm/gb300-fp4/agentx/disagg-variants.yaml
index e2501ae849..b3a7efe3b9 100644
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/dsv41flash/vllm/gb300-fp4/agentx/disagg-variants.yaml
+++ b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/dsv41flash/vllm/gb300-fp4/agentx/disagg-variants.yaml
@@ -182,8 +182,6 @@ base:
   sbatch_directives:
     mem: "0"
     cpus-per-task: "144"
-    # Prefill Engram host-table allocation hit CUDA_ERROR_OUT_OF_MEMORY on these.
-    exclude: "im-gb300-r01-c[001-002,004-005,010-011],im-gb300-r03-c[001-002]"
   srun_options:
     container-remap-root: ""
   benchmark:
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/glm5.2/sglang/b300-fp4/agentx/agg-tp4-variants.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/glm5.2/sglang/b300-fp4/agentx/agg-tp4-variants.yaml
index 10ce116322..c6b78837e7 100644
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/glm5.2/sglang/b300-fp4/agentx/agg-tp4-variants.yaml
+++ b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/glm5.2/sglang/b300-fp4/agentx/agg-tp4-variants.yaml
@@ -4,7 +4,7 @@
 #
 # EAGLE runs off GLM-5.2's built-in nextn head at K=5 (5 steps, topk 1, 6 draft
 # tokens). The launcher pins acceptance to the golden thinking-on AL for K=5
-# (3.61, infx/golden_al_distribution/glm5.2_mtp.yaml); the recipe sets no
+# (3.61, infx/golden_al_distribution/glm-5.2-fp8__mtp__native__default-default.yaml); the recipe sets no
 # SGLANG_SIMULATE_ACC_* values. The draft head runs at its shipped precision
 # (SGLANG_NVFP4_CKPT_FP8_NEXTN_MOE=0, the pinned image's default).
 
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/b200-fp4/agentx/agg-variants.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/b200-fp4/agentx/agg-variants.yaml
deleted file mode 100644
index b41e608430..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/b200-fp4/agentx/agg-variants.yaml
+++ /dev/null
@@ -1,201 +0,0 @@
-schema: 2
-
-base:
-  identity:
-    model: {}
-    container: {}
-
-  dynamo:
-    install: false
-
-  slurm:
-    time_limit: "8:00:00"
-
-  health_check:
-    interval_seconds: 10
-    max_attempts: 720
-
-  resources:
-    gpu_type: "b200"
-    gpus_per_node: 8
-
-  frontend:
-    type: vllm
-    enable_multiple_frontends: false
-
-  engine:
-    type: vllm
-    connector:
-
-  roles:
-    agg:
-      nodes: 2
-      workers: 1
-      gpus: 16
-      env:
-        VLLM_ENABLE_K3_LATENT_MOE_TAIL_FUSION: "1"
-        MC_GID_INDEX: "@fabric.rdma-gid-index"
-        MC_STORE_MEMCPY: "1"
-        MC_ENABLE_DEST_DEVICE_AFFINITY: "1"
-        MC_SLICE_SIZE: "1048576"
-        MC_WORKERS_PER_CTX: "4"
-        VLLM_MOONCAKE_LOAD_RECV_THREADS: "4"
-        VLLM_ALLREDUCE_USE_FLASHINFER: "1"
-        VLLM_USE_DIRECT_DCP_A2A: "1"
-        VLLM_USE_DIRECT_DCP_Q_GATHER: "1"
-        VLLM_USE_DIRECT_DCP_KV_GATHER: "1"
-        VLLM_EXECUTE_MODEL_TIMEOUT_SECONDS: "1800"
-        VLLM_USE_V2_MODEL_RUNNER: "1"
-        VLLM_SERVER_DEV_MODE: "1"
-        VLLM_LOG_STATS_INTERVAL: "1"
-        VLLM_PREFIX_CACHE_RETENTION_INTERVAL: "0"
-        VLLM_RPC_TIMEOUT: "600000"
-        WITH_NVIDIA_PEERMEM: "0"
-        VLLM_MEMORY_PROFILER_ESTIMATE_CUDAGRAPHS: "0"
-        NCCL_CUMEM_ENABLE: "1"
-        TILELANG_CLEANUP_TEMP_FILES: "1"
-        UCX_MEMTYPE_CACHE: "n"
-        UCX_MEMTYPE_REG_WHOLE: "n"
-        UCX_NET_DEVICES: "@fabric.rdma-device-ports"
-        HF_HUB_CACHE: "/hf_hub_cache"
-        HUGGINGFACE_HUB_CACHE: "/hf_hub_cache"
-      args:
-        served-model-name: "moonshotai/Kimi-K3"
-        tensor-parallel-size: 8
-        pipeline-parallel-size: 2
-        decode-context-parallel-size: 8
-        dcp-comm-backend: a2a
-        trust-remote-code: true
-        load-format: fastsafetensors
-        moe-backend: auto
-        gpu-memory-utilization: 0.92
-        no-enable-flashinfer-autotune: true
-        max-model-len: 1048576
-        kv-cache-dtype: fp8
-        mamba-ssm-cache-dtype: bfloat16
-        kv-transfer-config: '{"kv_connector":"MooncakeStoreConnector","kv_role":"kv_both","kv_load_failure_policy":"recompute","kv_connector_extra_config":{"load_async":true,"lookup_async":true,"enable_offload":false}}'
-        attention-backend: TOKENSPEED_MLA
-        attention-config: '{"mla_prefill_backend":"TRTLLM_RAGGED","use_prefill_query_quantization":true}'
-        enable-prefix-caching: true
-        enable-prompt-tokens-details: true
-        enable-auto-tool-choice: true
-        tool-call-parser: kimi_k3
-        reasoning-parser: kimi_k3
-        language-model-only: true
-        max-num-batched-tokens: 8192
-        prefix-match-unit: 128
-
-  services:
-    - name: mooncake-master
-      type: mooncake-master
-      options:
-        store_config:
-          metadata_server: "P2PHANDSHAKE"
-          global_segment_size: "200GB"
-          local_buffer_size: "4GB"
-          protocol: "rdma"
-          device_name: "mlx5_0,mlx5_1,mlx5_2,mlx5_3"
-          mode: "embedded"
-          enable_offload: false
-
-  sbatch_directives:
-    segment: "1"
-
-  srun_options:
-    container-remap-root: ""
-
-  telemetry:
-    collector_join_timeout_seconds: 12
-
-  benchmark:
-    env:
-      AIPERF_LIVE_FAILED_REQUEST_THRESHOLD: "0.25"
-      AIPERF_REQUIRED_SERVER_METRIC_PREFIX: "vllm:"
-      AIPERF_USE_DYNAMO_CONV_AWARE_ROUTING: "0"
-
-override_tp8pp2_c1:
-  roles:
-    agg:
-      args:
-        max-num-seqs: 2
-        speculative-config: '{"model":"Inferact/Kimi-K3-DSpark","num_speculative_tokens":7,"method":"dspark","attention_backend":"TOKENSPEED_MLA","draft_sample_method":"probabilistic"}'
-        compilation-config: '{"cudagraph_mode":"FULL_AND_PIECEWISE","cudagraph_capture_sizes":[8,16,64,128,256,512,1024,2048,4096,8192]}'
-
-override_tp8pp2_c4:
-  roles:
-    agg:
-      args:
-        max-num-seqs: 8
-        speculative-config: '{"model":"Inferact/Kimi-K3-DSpark","num_speculative_tokens":7,"method":"dspark","attention_backend":"TOKENSPEED_MLA","draft_sample_method":"probabilistic"}'
-        compilation-config: '{"cudagraph_mode":"FULL_AND_PIECEWISE","cudagraph_capture_sizes":[8,16,24,32,40,48,56,64,128,256,512,1024,2048,4096,8192]}'
-
-override_tp8pp2_c8:
-  roles:
-    agg:
-      args:
-        max-num-seqs: 16
-        speculative-config: '{"model":"Inferact/Kimi-K3-DSpark","num_speculative_tokens":7,"method":"dspark","attention_backend":"TOKENSPEED_MLA","draft_sample_method":"probabilistic"}'
-        compilation-config: '{"cudagraph_mode":"FULL_AND_PIECEWISE","cudagraph_capture_sizes":[8,16,24,40,56,64,80,104,128,256,512,1024,2048,4096,8192]}'
-
-override_tp8pp2_c14:
-  roles:
-    agg:
-      args:
-        max-num-seqs: 28
-        speculative-config: '{"model":"Inferact/Kimi-K3-DSpark","num_speculative_tokens":7,"method":"dspark","attention_backend":"TOKENSPEED_MLA","draft_sample_method":"probabilistic"}'
-        compilation-config: '{"cudagraph_mode":"FULL_AND_PIECEWISE","cudagraph_capture_sizes":[8,16,24,40,56,64,80,104,128,256,512,1024,2048,4096,8192]}'
-
-override_tp8pp2_c24:
-  roles:
-    agg:
-      args:
-        max-num-seqs: 48
-        speculative-config: '{"model":"Inferact/Kimi-K3-DSpark","num_speculative_tokens":4,"method":"dspark","attention_backend":"TOKENSPEED_MLA","draft_sample_method":"probabilistic"}'
-        compilation-config: '{"cudagraph_mode":"FULL_AND_PIECEWISE","cudagraph_capture_sizes":[8,16,24,40,56,64,80,104,128,256,512,1024,2048,4096,8192]}'
-
-override_tp8pp2_c48:
-  roles:
-    agg:
-      args:
-        max-num-seqs: 96
-        speculative-config: '{"model":"Inferact/Kimi-K3-DSpark","num_speculative_tokens":4,"method":"dspark","attention_backend":"TOKENSPEED_MLA","draft_sample_method":"probabilistic"}'
-        compilation-config: '{"cudagraph_mode":"FULL_AND_PIECEWISE","cudagraph_capture_sizes":[1,7,18,34,53,64,75,100,128,256,512,1024,2048,4096,8192]}'
-
-override_tp8pp2_c96:
-  roles:
-    agg:
-      args:
-        max-num-seqs: 192
-        compilation-config: '{"cudagraph_mode":"FULL_AND_PIECEWISE","cudagraph_capture_sizes":[1,7,18,34,53,64,75,100,128,256,512,1024,2048,4096,8192]}'
-
-override_tp8pp2_c32:
-  roles:
-    agg:
-      args:
-        max-num-seqs: 64
-        speculative-config: '{"model":"Inferact/Kimi-K3-DSpark","num_speculative_tokens":4,"method":"dspark","attention_backend":"TOKENSPEED_MLA","draft_sample_method":"probabilistic"}'
-        compilation-config: '{"cudagraph_mode":"FULL_AND_PIECEWISE","cudagraph_capture_sizes":[1,7,18,34,53,64,75,100,128,256,512,1024,2048,4096,8192]}'
-
-override_tp8pp2_c56:
-  roles:
-    agg:
-      args:
-        max-num-seqs: 112
-        speculative-config: '{"model":"Inferact/Kimi-K3-DSpark","num_speculative_tokens":4,"method":"dspark","attention_backend":"TOKENSPEED_MLA","draft_sample_method":"probabilistic"}'
-        compilation-config: '{"cudagraph_mode":"FULL_AND_PIECEWISE","cudagraph_capture_sizes":[1,7,18,34,53,64,75,100,128,256,512,1024,2048,4096,8192]}'
-
-override_tp8pp2_c72:
-  roles:
-    agg:
-      args:
-        max-num-seqs: 144
-        speculative-config: '{"model":"Inferact/Kimi-K3-DSpark","num_speculative_tokens":4,"method":"dspark","attention_backend":"TOKENSPEED_MLA","draft_sample_method":"probabilistic"}'
-        compilation-config: '{"cudagraph_mode":"FULL_AND_PIECEWISE","cudagraph_capture_sizes":[1,7,18,34,53,64,75,100,128,256,512,1024,2048,4096,8192]}'
-
-override_tp8pp2_c80:
-  roles:
-    agg:
-      args:
-        max-num-seqs: 160
-        speculative-config: '{"model":"Inferact/Kimi-K3-DSpark","num_speculative_tokens":4,"method":"dspark","attention_backend":"TOKENSPEED_MLA","draft_sample_method":"probabilistic"}'
-        compilation-config: '{"cudagraph_mode":"FULL_AND_PIECEWISE","cudagraph_capture_sizes":[1,7,18,34,53,64,75,100,128,256,512,1024,2048,4096,8192]}'
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/gb200-fp4/agentx/agg-dcp16-dspark4-maxseq2-mooncake.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/gb200-fp4/agentx/agg-dcp16-dspark4-maxseq2-mooncake.yaml
deleted file mode 100644
index fd9a30d641..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/gb200-fp4/agentx/agg-dcp16-dspark4-maxseq2-mooncake.yaml
+++ /dev/null
@@ -1,147 +0,0 @@
-schema: 2
-name: "kimi-k3-vllm-agg-gb200-dcp16-dspark4-maxseq2-mooncake-agentic"
-
-identity:
-  model: {}
-  container: {}
-  frameworks:
-    dynamo: "ba83080ecd31c1ce918559e576d3c5bc9e092ff1"
-
-dynamo:
-  install: true
-
-  source:
-    rev: "ba83080ecd31c1ce918559e576d3c5bc9e092ff1"
-slurm:
-  time_limit: "04:00:00"
-
-health_check:
-  max_attempts: 720
-  interval_seconds: 10
-
-resources:
-  gpu_type: "gb200"
-  gpus_per_node: 4
-services:
-  - name: etcd
-    type: etcd
-    placement:
-      node: infra
-  - name: nats
-    type: nats
-    placement:
-      node: infra
-    options:
-      max_payload_mb: 32
-  - name: mooncake-master
-    type: mooncake-master
-    args:
-      - "--eviction_high_watermark_ratio=0.95"
-      - "--eviction_ratio=0.10"
-    options:
-      store_config:
-        metadata_server: "P2PHANDSHAKE"
-        global_segment_size: "96GB"
-        local_buffer_size: "4GB"
-        protocol: "rdma"
-        device_name: "@fabric.rdma-devices"
-        mode: "embedded"
-        enable_offload: false
-frontend:
-  type: dynamo
-  enable_multiple_frontends: false
-  args:
-    dyn-chat-processor: "vllm"
-    trust-remote-code: true
-    tool-call-parser: "kimi_k3"
-    reasoning-parser: "kimi_k3"
-    enable-auto-tool-choice: true
-    router-mode: "random"
-    router-session-affinity-ttl-secs: 900
-  env:
-    DYN_ROUTER_ACTIVE_REQUEST_EXPIRY_SECS: "3600"
-    DYN_TOKENIZER_CACHE_BYTES: "8589934592"
-
-engine:
-  type: vllm
-  connector:
-roles:
-  agg:
-    nodes: 4
-    workers: 1
-    gpus: 16
-
-    env:
-      VLLM_ALLREDUCE_USE_FLASHINFER: "1"
-      VLLM_ENABLE_K3_LATENT_MOE_TAIL_FUSION: "1"
-      VLLM_USE_V2_MODEL_RUNNER: "1"
-    # Preserve the measured collective fallback when moving to the built image.
-      VLLM_USE_DIRECT_DCP_A2A: "0"
-      VLLM_USE_DIRECT_DCP_Q_GATHER: "0"
-      VLLM_USE_DIRECT_DCP_KV_GATHER: "0"
-      VLLM_RPC_TIMEOUT: "600000"
-      VLLM_PREFIX_CACHE_RETENTION_INTERVAL: "0"
-      VLLM_MEMORY_PROFILER_ESTIMATE_CUDAGRAPHS: "0"
-      PYTHONNOUSERSITE: "1"
-      TORCH_CUDA_ARCH_LIST: "10.0"
-      PYTHONHASHSEED: "42"
-      VLLM_HTTP_TIMEOUT_KEEP_ALIVE: "900"
-      MC_GID_INDEX: "@fabric.rdma-gid-index"
-      MC_STORE_MEMCPY: "1"
-      MC_ENABLE_DEST_DEVICE_AFFINITY: "1"
-      MC_SLICE_SIZE: "1048576"
-      MC_WORKERS_PER_CTX: "4"
-      WITH_NVIDIA_PEERMEM: "0"
-      VLLM_MOONCAKE_LOAD_RECV_THREADS: "4"
-    args:
-      served-model-name: "moonshotai/Kimi-K3"
-      tensor-parallel-size: 16
-      decode-context-parallel-size: 16
-      dcp-comm-backend: "a2a"
-      max-num-seqs: 2
-      max-num-batched-tokens: 8192
-      trust-remote-code: true
-      language-model-only: true
-      dyn-tool-call-parser: "kimi_k3"
-      reasoning-parser: "kimi_k3"
-      dyn-reasoning-parser: "kimi_k3"
-      load-format: "safetensors"
-      safetensors-load-strategy: "lazy"
-      moe-backend: "auto"
-      no-enable-flashinfer-autotune: true
-      enable-cumem-allocator: true
-      enable-prefix-caching: true
-      prefix-match-unit: 128
-      kv-cache-dtype: "fp8"
-      stream-interval: 10
-      attention-backend: "TOKENSPEED_MLA"
-      attention-config: '{"mla_prefill_backend":"TRTLLM_RAGGED","use_prefill_query_quantization":true}'
-      # Throughput jobs inject the committed K=4 golden AL (3.36); EVAL_ONLY
-      # preserves this real target-verification configuration.
-      speculative-config: '{"model":"Inferact/Kimi-K3-DSpark","attention_backend":"TOKENSPEED_MLA","method":"dspark","num_speculative_tokens":4,"draft_sample_method":"probabilistic","rejection_sample_method":"block"}'
-      max-cudagraph-capture-size: 1024
-      kv-cache-memory: 10737418240
-      kv-transfer-config: '{"kv_connector":"MooncakeStoreConnector","kv_role":"kv_both","kv_load_failure_policy":"recompute","kv_connector_extra_config":{"load_async":true,"lookup_async":true,"enable_offload":false}}'
-
-sbatch_directives:
-  mem: "0"
-  cpus-per-task: "144"
-  comment: >-
-    '{"OccupiedIdleGPUsJobReaper":{"exemptIdleTimeMins":"60","reason":"model_loading","description":"Very large model will
-    take extra loading time."}}'
-
-srun_options:
-  mem: "0"
-  container-remap-root: ""
-
-telemetry:
-  collector_join_timeout_seconds: 12
-
-benchmark:
-  placement:
-    node: head
-  env:
-    AIPERF_LIVE_FAILED_REQUEST_THRESHOLD: "0.25"
-    AIPERF_REQUIRED_SERVER_METRIC_PREFIX: "vllm:"
-    AIPERF_HTTP_TCP_USER_TIMEOUT: "900000"
-    AIPERF_USE_DYNAMO_CONV_AWARE_ROUTING: "0"
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/gb200-fp4/agentx/agg-dcp16-nospec-mooncake.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/gb200-fp4/agentx/agg-dcp16-nospec-mooncake.yaml
deleted file mode 100644
index e2e2d65f20..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/gb200-fp4/agentx/agg-dcp16-nospec-mooncake.yaml
+++ /dev/null
@@ -1,143 +0,0 @@
-schema: 2
-name: "kimi-k3-vllm-agg-gb200-dcp16-nospec-mooncake-agentic"
-
-identity:
-  model: {}
-  container: {}
-  frameworks:
-    dynamo: "ba83080ecd31c1ce918559e576d3c5bc9e092ff1"
-
-dynamo:
-  install: true
-
-  source:
-    rev: "ba83080ecd31c1ce918559e576d3c5bc9e092ff1"
-slurm:
-  time_limit: "04:00:00"
-
-health_check:
-  max_attempts: 720
-  interval_seconds: 10
-
-resources:
-  gpu_type: "gb200"
-  gpus_per_node: 4
-services:
-  - name: etcd
-    type: etcd
-    placement:
-      node: infra
-  - name: nats
-    type: nats
-    placement:
-      node: infra
-    options:
-      max_payload_mb: 32
-  - name: mooncake-master
-    type: mooncake-master
-    args:
-      - "--eviction_high_watermark_ratio=0.95"
-      - "--eviction_ratio=0.10"
-    options:
-      store_config:
-        metadata_server: "P2PHANDSHAKE"
-        global_segment_size: "96GB"
-        local_buffer_size: "4GB"
-        protocol: "rdma"
-        device_name: "@fabric.rdma-devices"
-        mode: "embedded"
-        enable_offload: false
-frontend:
-  type: dynamo
-  enable_multiple_frontends: false
-  args:
-    dyn-chat-processor: "vllm"
-    trust-remote-code: true
-    tool-call-parser: "kimi_k3"
-    reasoning-parser: "kimi_k3"
-    enable-auto-tool-choice: true
-    router-mode: "random"
-    router-session-affinity-ttl-secs: 900
-  env:
-    DYN_ROUTER_ACTIVE_REQUEST_EXPIRY_SECS: "3600"
-    DYN_TOKENIZER_CACHE_BYTES: "8589934592"
-
-engine:
-  type: vllm
-  connector:
-roles:
-  agg:
-    nodes: 4
-    workers: 1
-    gpus: 16
-
-    env:
-      VLLM_ALLREDUCE_USE_FLASHINFER: "1"
-      VLLM_ENABLE_K3_LATENT_MOE_TAIL_FUSION: "1"
-      VLLM_USE_V2_MODEL_RUNNER: "1"
-    # Preserve the measured collective fallback when moving to the built image.
-      VLLM_USE_DIRECT_DCP_A2A: "0"
-      VLLM_USE_DIRECT_DCP_Q_GATHER: "0"
-      VLLM_USE_DIRECT_DCP_KV_GATHER: "0"
-      VLLM_RPC_TIMEOUT: "600000"
-      VLLM_PREFIX_CACHE_RETENTION_INTERVAL: "0"
-      VLLM_MEMORY_PROFILER_ESTIMATE_CUDAGRAPHS: "0"
-      PYTHONNOUSERSITE: "1"
-      TORCH_CUDA_ARCH_LIST: "10.0"
-      PYTHONHASHSEED: "42"
-      VLLM_HTTP_TIMEOUT_KEEP_ALIVE: "900"
-      MC_GID_INDEX: "@fabric.rdma-gid-index"
-      MC_STORE_MEMCPY: "1"
-      MC_ENABLE_DEST_DEVICE_AFFINITY: "1"
-      MC_SLICE_SIZE: "1048576"
-      MC_WORKERS_PER_CTX: "4"
-      WITH_NVIDIA_PEERMEM: "0"
-      VLLM_MOONCAKE_LOAD_RECV_THREADS: "4"
-    args:
-      served-model-name: "moonshotai/Kimi-K3"
-      tensor-parallel-size: 16
-      decode-context-parallel-size: 16
-      dcp-comm-backend: "a2a"
-      max-num-batched-tokens: 16384
-      trust-remote-code: true
-      language-model-only: true
-      dyn-tool-call-parser: "kimi_k3"
-      reasoning-parser: "kimi_k3"
-      dyn-reasoning-parser: "kimi_k3"
-      load-format: "safetensors"
-      safetensors-load-strategy: "lazy"
-      moe-backend: "auto"
-      no-enable-flashinfer-autotune: true
-      enable-prefix-caching: true
-      prefix-match-unit: 128
-      kv-cache-dtype: "fp8"
-      stream-interval: 10
-      attention-backend: "FLASHINFER_MLA"
-      attention-config: '{"mla_prefill_backend":"TRTLLM_RAGGED","use_prefill_query_quantization":true}'
-      max-cudagraph-capture-size: 1024
-      max-num-seqs: 1000
-      kv-cache-memory: 10737418240
-      kv-transfer-config: '{"kv_connector":"MooncakeStoreConnector","kv_role":"kv_both","kv_load_failure_policy":"recompute","kv_connector_extra_config":{"load_async":true,"lookup_async":true,"enable_offload":false}}'
-
-sbatch_directives:
-  mem: "0"
-  cpus-per-task: "144"
-  comment: >-
-    '{"OccupiedIdleGPUsJobReaper":{"exemptIdleTimeMins":"60","reason":"model_loading","description":"Very large model will
-    take extra loading time."}}'
-
-srun_options:
-  mem: "0"
-  container-remap-root: ""
-
-telemetry:
-  collector_join_timeout_seconds: 12
-
-benchmark:
-  placement:
-    node: head
-  env:
-    AIPERF_LIVE_FAILED_REQUEST_THRESHOLD: "0.25"
-    AIPERF_REQUIRED_SERVER_METRIC_PREFIX: "vllm:"
-    AIPERF_HTTP_TCP_USER_TIMEOUT: "900000"
-    AIPERF_USE_DYNAMO_CONV_AWARE_ROUTING: "0"
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/gb200-fp4/agentx/agg-tp8pp2-variants.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/gb200-fp4/agentx/agg-tp8pp2-variants.yaml
deleted file mode 100644
index 925dd6aae7..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/gb200-fp4/agentx/agg-tp8pp2-variants.yaml
+++ /dev/null
@@ -1,173 +0,0 @@
-schema: 2
-
-base:
-  identity:
-    model: {}
-    container: {}
-
-  dynamo:
-    install: false
-
-  slurm:
-    time_limit: "8:00:00"
-
-  health_check:
-    interval_seconds: 10
-    max_attempts: 720
-
-  resources:
-    gpu_type: "gb200"
-    gpus_per_node: 4
-
-  frontend:
-    type: vllm
-    enable_multiple_frontends: false
-
-  engine:
-    type: vllm
-    connector:
-
-  roles:
-    agg:
-      nodes: 4
-      workers: 1
-      gpus: 16
-      env:
-        MC_GID_INDEX: "@fabric.rdma-gid-index"
-        MC_STORE_MEMCPY: "1"
-        MC_ENABLE_DEST_DEVICE_AFFINITY: "1"
-        MC_SLICE_SIZE: "1048576"
-        MC_WORKERS_PER_CTX: "4"
-        VLLM_MOONCAKE_LOAD_RECV_THREADS: "4"
-        VLLM_ALLREDUCE_USE_FLASHINFER: "1"
-        VLLM_USE_DIRECT_DCP_A2A: "1"
-        VLLM_USE_DIRECT_DCP_Q_GATHER: "1"
-        VLLM_USE_DIRECT_DCP_KV_GATHER: "1"
-        VLLM_ENGINE_READY_TIMEOUT_S: "3600"
-        VLLM_EXECUTE_MODEL_TIMEOUT_SECONDS: "1800"
-        VLLM_USE_V2_MODEL_RUNNER: "1"
-        VLLM_SERVER_DEV_MODE: "1"
-        VLLM_LOG_STATS_INTERVAL: "1"
-        VLLM_PREFIX_CACHE_RETENTION_INTERVAL: "0"
-        VLLM_RPC_TIMEOUT: "600000"
-        WITH_NVIDIA_PEERMEM: "0"
-        VLLM_MEMORY_PROFILER_ESTIMATE_CUDAGRAPHS: "0"
-        NCCL_CUMEM_ENABLE: "1"
-        TILELANG_CLEANUP_TEMP_FILES: "1"
-        UCX_MEMTYPE_CACHE: "n"
-        UCX_MEMTYPE_REG_WHOLE: "n"
-        UCX_NET_DEVICES: "@fabric.rdma-device-ports"
-        HF_HUB_CACHE: "/hf_hub_cache"
-        HUGGINGFACE_HUB_CACHE: "/hf_hub_cache"
-      args:
-        served-model-name: "moonshotai/Kimi-K3"
-        tensor-parallel-size: 8
-        pipeline-parallel-size: 2
-        decode-context-parallel-size: 8
-        dcp-comm-backend: a2a
-        trust-remote-code: true
-        load-format: fastsafetensors
-        moe-backend: auto
-        gpu-memory-utilization: 0.88
-        no-enable-flashinfer-autotune: true
-        max-model-len: 1048576
-        kv-cache-dtype: fp8
-        mamba-ssm-cache-dtype: bfloat16
-        kv-transfer-config: '{"kv_connector":"MooncakeStoreConnector","kv_role":"kv_both","kv_load_failure_policy":"recompute","kv_connector_extra_config":{"load_async":true,"lookup_async":true,"enable_offload":false}}'
-        attention-backend: TOKENSPEED_MLA
-        attention-config: '{"mla_prefill_backend":"TRTLLM_RAGGED","use_prefill_query_quantization":true}'
-        enable-prefix-caching: true
-        enable-prompt-tokens-details: true
-        enable-auto-tool-choice: true
-        tool-call-parser: kimi_k3
-        reasoning-parser: kimi_k3
-        language-model-only: true
-        max-num-batched-tokens: 8192
-        prefix-match-unit: 128
-
-  services:
-    - name: mooncake-master
-      type: mooncake-master
-      options:
-        store_config:
-          metadata_server: "P2PHANDSHAKE"
-          global_segment_size: "200GB"
-          local_buffer_size: "4GB"
-          protocol: "rdma"
-          device_name: "@fabric.rdma-devices"
-          mode: "embedded"
-          enable_offload: false
-
-  sbatch_directives:
-    segment: "1"
-
-  srun_options:
-    container-remap-root: ""
-
-  telemetry:
-    collector_join_timeout_seconds: 12
-
-  benchmark:
-    placement:
-      node: head
-    env:
-      AIPERF_LIVE_FAILED_REQUEST_THRESHOLD: "0.25"
-      AIPERF_SERVER_METRICS_URLS: "http://localhost:8000/metrics"
-      AIPERF_REQUIRED_SERVER_METRIC_PREFIX: "vllm:"
-      AIPERF_USE_DYNAMO_CONV_AWARE_ROUTING: "0"
-
-override_tp8pp2_c1:
-  roles:
-    agg:
-      args:
-        max-num-seqs: 2
-        speculative-config: '{"model":"Inferact/Kimi-K3-DSpark","num_speculative_tokens":7,"method":"dspark","attention_backend":"TOKENSPEED_MLA","draft_sample_method":"probabilistic"}'
-        compilation-config: '{"cudagraph_mode":"FULL_AND_PIECEWISE","cudagraph_capture_sizes":[8,16,64,128,256,512,1024,2048,4096,8192]}'
-
-override_tp8pp2_c4:
-  roles:
-    agg:
-      args:
-        max-num-seqs: 8
-        speculative-config: '{"model":"Inferact/Kimi-K3-DSpark","num_speculative_tokens":7,"method":"dspark","attention_backend":"TOKENSPEED_MLA","draft_sample_method":"probabilistic"}'
-        compilation-config: '{"cudagraph_mode":"FULL_AND_PIECEWISE","cudagraph_capture_sizes":[8,16,24,32,40,48,56,64,128,256,512,1024,2048,4096,8192]}'
-
-override_tp8pp2_c8:
-  roles:
-    agg:
-      args:
-        max-num-seqs: 16
-        speculative-config: '{"model":"Inferact/Kimi-K3-DSpark","num_speculative_tokens":7,"method":"dspark","attention_backend":"TOKENSPEED_MLA","draft_sample_method":"probabilistic"}'
-        compilation-config: '{"cudagraph_mode":"FULL_AND_PIECEWISE","cudagraph_capture_sizes":[8,16,24,40,56,64,80,104,128,256,512,1024,2048,4096,8192]}'
-
-override_tp8pp2_c24:
-  roles:
-    agg:
-      args:
-        max-num-seqs: 48
-        speculative-config: '{"model":"Inferact/Kimi-K3-DSpark","num_speculative_tokens":4,"method":"dspark","attention_backend":"TOKENSPEED_MLA","draft_sample_method":"probabilistic"}'
-        compilation-config: '{"cudagraph_mode":"FULL_AND_PIECEWISE","cudagraph_capture_sizes":[8,16,24,40,56,64,80,104,128,256,512,1024,2048,4096,8192]}'
-
-override_tp8pp2_c32:
-  roles:
-    agg:
-      args:
-        max-num-seqs: 64
-        speculative-config: '{"model":"Inferact/Kimi-K3-DSpark","num_speculative_tokens":4,"method":"dspark","attention_backend":"TOKENSPEED_MLA","draft_sample_method":"probabilistic"}'
-        compilation-config: '{"cudagraph_mode":"FULL_AND_PIECEWISE","cudagraph_capture_sizes":[1,7,18,34,53,64,75,100,128,256,512,1024,2048,4096,8192]}'
-
-override_tp8pp2_c48:
-  roles:
-    agg:
-      args:
-        max-num-seqs: 96
-        speculative-config: '{"model":"Inferact/Kimi-K3-DSpark","num_speculative_tokens":4,"method":"dspark","attention_backend":"TOKENSPEED_MLA","draft_sample_method":"probabilistic"}'
-        compilation-config: '{"cudagraph_mode":"FULL_AND_PIECEWISE","cudagraph_capture_sizes":[1,7,18,34,53,64,75,100,128,256,512,1024,2048,4096,8192]}'
-
-override_tp8pp2_c56:
-  roles:
-    agg:
-      args:
-        max-num-seqs: 112
-        speculative-config: '{"model":"Inferact/Kimi-K3-DSpark","num_speculative_tokens":4,"method":"dspark","attention_backend":"TOKENSPEED_MLA","draft_sample_method":"probabilistic"}'
-        compilation-config: '{"cudagraph_mode":"FULL_AND_PIECEWISE","cudagraph_capture_sizes":[1,7,18,34,53,64,75,100,128,256,512,1024,2048,4096,8192]}'
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/gb200-fp4/agentx/agg-variants.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/gb200-fp4/agentx/agg-variants.yaml
deleted file mode 100644
index d35b8a2478..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/gb200-fp4/agentx/agg-variants.yaml
+++ /dev/null
@@ -1,205 +0,0 @@
-
-schema: 2
-
-base:
-  identity:
-    model: {}
-    container: {}
-    frameworks:
-      dynamo: "1.3.0"
-  dynamo:
-    install: true
-    source:
-      rev: "ba83080ecd31c1ce918559e576d3c5bc9e092ff1"
-  setup_script: kimik3-dspark-config-compat.sh
-  environment:
-    ETCD_LEASE_TTL: "7200"
-  health_check:
-    max_attempts: 2160
-    interval_seconds: 10
-  resources:
-    gpu_type: "gb200"
-    gpus_per_node: 4
-  services:
-    - name: etcd
-      type: etcd
-      placement:
-        node: infra
-    - name: nats
-      type: nats
-      placement:
-        node: infra
-      options:
-        max_payload_mb: 32
-  frontend:
-    type: dynamo
-    enable_multiple_frontends: false
-    args:
-      # Use vLLM's Kimi K3 parser so OpenAI responses expose structured
-      # tool_calls instead of raw XTML in message.content.
-      dyn-chat-processor: "vllm"
-      trust-remote-code: true
-      tool-call-parser: "kimi_k3"
-      reasoning-parser: "kimi_k3"
-      enable-auto-tool-choice: true
-      router-mode: "kv"
-      router-kv-events: true
-      router-temperature: "0"
-      router-min-initial-workers: 1
-      kv-cache-block-size: 64
-  engine:
-    type: vllm
-    connector:
-  roles:
-    agg:
-      nodes: 4
-      workers: 1
-      gpus: 16
-      env:
-        HF_HUB_CACHE: "/hf_hub_cache"
-        HUGGINGFACE_HUB_CACHE: "/hf_hub_cache"
-        TRANSFORMERS_CACHE: "/hf_hub_cache"
-        VLLM_ENGINE_READY_TIMEOUT_S: "7200"
-        VLLM_RPC_TIMEOUT: "600000"
-        VLLM_LOG_STATS_INTERVAL: "1"
-        VLLM_USE_V2_MODEL_RUNNER: "1"
-        VLLM_ENABLE_K3_LATENT_MOE_TAIL_FUSION: "1"
-        VLLM_ALLREDUCE_USE_FLASHINFER: "1"
-        VLLM_FLASHINFER_ALLREDUCE_BACKEND: "mnnvl"
-        NCCL_CUMEM_ENABLE: "1"
-        NCCL_MNNVL_ENABLE: "1"
-        NCCL_NVLS_ENABLE: "1"
-        UCX_MEMTYPE_CACHE: "n"
-        UCX_NET_DEVICES: "@fabric.rdma-device-ports"
-        UCX_TLS: "rc,cuda_copy"
-        NCCL_IB_HCA: "@fabric.rdma-devices"
-        NCCL_P2P_LEVEL: "NVL"
-        NVIDIA_GDRCOPY: "1"
-        PYTORCH_ALLOC_CONF: "expandable_segments:True"
-      args:
-        served-model-name: "moonshotai/Kimi-K3"
-        pipeline-parallel-size: 1
-        trust-remote-code: true
-        safetensors-load-strategy: "lazy"
-        kv-cache-dtype: "fp8"
-        attention-backend: "FLASHINFER_MLA"
-        attention-config: '{"mla_prefill_backend":"TRTLLM_RAGGED","use_prefill_query_quantization":true}'
-        # DeepGEMM mega-MoE grid barriers time out under DSpark MRV2 with the
-        # one-sided all-to-all worker; use the supported Kimi K3 FlashInfer path.
-        moe-backend: "flashinfer_trtllm"
-        kda-prefill-backend: "flashkda"
-        kernel-config: '{"enable_cutedsl_warmup":true}'
-        speculative-config: '{"method":"dspark","model":"Inferact/Kimi-K3-DSpark","num_speculative_tokens":2,"attention_backend":"FLASHINFER_MLA","draft_sample_method":"probabilistic","rejection_sample_method":"block"}'
-        block-size: 64
-        language-model-only: true
-        disable-custom-all-reduce: true
-        enable-prefix-caching: true
-        scheduler-cls: "vllm.v1.core.sched.async_scheduler.AsyncScheduler"
-        dyn-tool-call-parser: "kimi_k3"
-        reasoning-parser: "kimi_k3"
-        dyn-reasoning-parser: "kimi_k3"
-        no-enable-flashinfer-autotune: true
-  sbatch_directives:
-    cpus-per-task: "144"
-    mem: "0"
-  srun_options:
-    container-remap-root: ""
-  benchmark:
-    env:
-      AIPERF_USE_DYNAMO_CONV_AWARE_ROUTING: "0"
-      AIPERF_DYNAMO_SESSION_TIMEOUT_SECONDS: "14400"
-
-override_tp16_latency:
-  name: "kimi-k3-vllm-agg-gb200-tp16-latency-agentic"
-  slurm:
-    time_limit: "8:00:00"
-  roles:
-    agg:
-      env:
-        DG_JIT_CACHE_DIR: "/tmp/dg-cache-kimi-k3-gb200-tp16-{job_id}"
-      args:
-        tensor-parallel-size: 16
-        load-format: "fastsafetensors"
-        gpu-memory-utilization: 0.92
-        max-num-seqs: 8
-        max-num-batched-tokens: 8192
-        compilation-config: '{"cudagraph_capture_sizes":[3,6,9,12,15,18,21,24],"pass_config":{"fuse_allreduce_rms":false}}'
-  benchmark:
-    env:
-      AIPERF_LIVE_FAILED_REQUEST_THRESHOLD: "0.25"
-
-override_tep16_balanced:
-  name: "kimi-k3-vllm-agg-gb200-tep16-balanced-agentic"
-  slurm:
-    time_limit: "8:00:00"
-  roles:
-    agg:
-      env:
-        DG_JIT_CACHE_DIR: "/tmp/dg-cache-kimi-k3-gb200-tep16-{job_id}"
-      args:
-        tensor-parallel-size: 16
-        enable-expert-parallel: true
-        load-format: "fastsafetensors"
-        all2all-backend: "flashinfer_nvlink_one_sided"
-        gpu-memory-utilization: 0.92
-        max-num-seqs: 32
-        max-num-batched-tokens: 8192
-        compilation-config: '{"cudagraph_capture_sizes":[3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54,57,60,63,66,69,72,75,78,81,84,87,90,93,96],"pass_config":{"fuse_allreduce_rms":false}}'
-
-override_dep16:
-  name: "kimi-k3-vllm-agg-gb200-dep16-throughput-agentic"
-  slurm:
-    time_limit: "12:00:00"
-  roles:
-    agg:
-      env:
-        DG_JIT_CACHE_DIR: "/tmp/dg-cache-kimi-k3-gb200-dep16-{job_id}"
-      args:
-        tensor-parallel-size: 4
-        data-parallel-size: 4
-        data-parallel-rpc-port: 13345
-        enable-expert-parallel: true
-        # FlashInfer's larger TP4 MoE representation leaves too little transient
-        # HBM for fastsafetensors' GPU-staging path when DSpark is loaded.
-        load-format: "safetensors"
-        all2all-backend: "flashinfer_nvlink_one_sided"
-        gpu-memory-utilization: 0.94
-        # The largest regular DEP point is c256 / DP4 = 64 sequences per engine.
-        # Capturing 128 sequence slots consumes 10.9 GiB and leaves too little
-        # runtime workspace for FlashInfer's MXFP4 MoE kernel.
-        max-num-seqs: 64
-        max-num-batched-tokens: 16384
-        compilation-config: '{"cudagraph_mode":"PIECEWISE","cudagraph_capture_sizes":[3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54,57,60,63,66,69,72,75,78,81,84,87,90,93,96,99,102,105,108,111,114,117,120,123,126,129,132,135,138,141,144,147,150,153,156,159,162,165,168,171,174,177,180,183,186,189,192]}'
-  benchmark:
-    env:
-      AGENTIC_WARMUP_GRACE_PERIOD: "3600"
-
-override_dep16_vllm_simple_offload:
-  name: "kimi-k3-vllm-agg-gb200-dep16-throughput-vllm-simple-offload-agentic"
-  slurm:
-    time_limit: "12:00:00"
-  roles:
-    agg:
-      env:
-        PYTHONHASHSEED: "42"
-        DG_JIT_CACHE_DIR: "/tmp/dg-cache-kimi-k3-gb200-dep16-offload-{job_id}"
-      args:
-        tensor-parallel-size: 4
-        data-parallel-size: 4
-        data-parallel-rpc-port: 13345
-        enable-expert-parallel: true
-        # FlashInfer's larger TP4 MoE representation leaves too little transient
-        # HBM for fastsafetensors' GPU-staging path when DSpark is loaded.
-        load-format: "safetensors"
-        all2all-backend: "flashinfer_nvlink_one_sided"
-        gpu-memory-utilization: 0.94
-        # The largest offload point is c384 / DP4 = 96 sequences per engine.
-        # Capture even sequence counts: all configured DP4 steady-state batch
-        # sizes are exact hits, while odd loads pad by at most one sequence.
-        max-num-seqs: 96
-        max-num-batched-tokens: 16384
-        compilation-config: '{"cudagraph_mode":"PIECEWISE","cudagraph_capture_sizes":[6,12,18,24,30,36,42,48,54,60,66,72,78,84,90,96,102,108,114,120,126,132,138,144,150,156,162,168,174,180,186,192,198,204,210,216,222,228,234,240,246,252,258,264,270,276,282,288]}'
-        kv-transfer-config: '{"kv_connector":"SimpleCPUOffloadConnector","kv_role":"kv_both","kv_connector_extra_config":{"cpu_bytes_to_use":549755813888,"cpu_bytes_to_use_per_rank":137438953472,"lazy_offload":false}}'
-  benchmark:
-    env:
-      AGENTIC_WARMUP_GRACE_PERIOD: "3600"
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/gb200-fp4/agentx/disagg-variants.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/gb200-fp4/agentx/disagg-variants.yaml
deleted file mode 100644
index 2a6d5f8f83..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/gb200-fp4/agentx/disagg-variants.yaml
+++ /dev/null
@@ -1,268 +0,0 @@
-# GB200 Kimi-K3 FP4 AgentX, Dynamo + vLLM disaggregated 1P1D: one TP16/DCP16 prefill role (4 nodes) and one
-# TP16/DCP16 decode role (4 nodes), 32 GPUs, DSpark depth 4 (draft_sample_method probabilistic; the launcher
-# selects the golden acceptance), Mooncake DRAM tier at 128 GB per rank. Per-concurrency knobs: max-num-seqs at
-# 2x concurrency on both roles, decode cudagraph capture at max-num-seqs x (K+1) tokens, decode
-# gpu-memory-utilization 0.92 while the capture size is at or under 320 tokens and 0.90 above it.
-# Decode max-num-batched-tokens 1024 bounds the FlashInfer MoE autotune to the token counts decode can
-# reach (at most 480); the 16384-token default bucket needs a 2.9 GiB workspace that fails at 0.92.
-# The *_eval overrides add the Kimi K3 tool and reasoning parsers with structural tags, so a named
-# tool_choice is constrained by the K3 structural tag rather than a generic JSON-schema constraint.
-schema: 2
-
-base:
-  identity:
-    model: {}
-    container: {}
-    frameworks:
-      dynamo: "ffbbaaa6c44370e798687881317535ac17d66a76"
-
-  dynamo:
-    install: true
-
-    source:
-      rev: "ffbbaaa6c44370e798687881317535ac17d66a76"
-  slurm:
-    time_limit: "04:00:00"
-
-  health_check:
-    max_attempts: 720
-    interval_seconds: 10
-
-  resources:
-    gpu_type: "gb200"
-    gpus_per_node: 4
-  services:
-    - name: etcd
-      type: etcd
-    - name: mooncake-master
-      type: mooncake-master
-      args:
-        - "--default_kv_lease_ttl=60000"
-        - "--eviction_high_watermark_ratio=0.95"
-        - "--eviction_ratio=0.10"
-      options:
-        store_config:
-          metadata_server: "P2PHANDSHAKE"
-          global_segment_size: "128GB"
-          local_buffer_size: "4GB"
-          protocol: "rdma"
-          device_name: "@fabric.rdma-devices"
-          mode: "embedded"
-          enable_offload: false
-  frontend:
-    type: dynamo
-    enable_multiple_frontends: false
-    args:
-      router-mode: "least-loaded"
-      router-session-affinity-ttl-secs: 900
-    env:
-      DYN_ROUTER_ACTIVE_REQUEST_EXPIRY_SECS: "3600"
-      DYN_TOKENIZER_CACHE_BYTES: "8589934592"
-
-  engine:
-    type: vllm
-    connector:
-    dp_launch_mode: per_node
-  roles:
-    prefill:
-      nodes: 4
-      workers: 1
-      gpus: 16
-      env: &kimi_env
-        VLLM_USE_DIRECT_DCP_A2A: "1"
-        VLLM_USE_DIRECT_DCP_Q_GATHER: "1"
-        VLLM_USE_DIRECT_DCP_KV_GATHER: "1"
-        VLLM_ALLREDUCE_USE_FLASHINFER: "1"
-        VLLM_KIMI_K3_SHARD_SP_SHARED_EXPERT: "0"
-        DYN_REQUEST_PLANE: "tcp"
-        ETCD_LEASE_TTL: "600"
-        VLLM_ENGINE_READY_TIMEOUT_S: "3600"
-        TILELANG_CLEANUP_TEMP_FILES: "1"
-        VLLM_USE_NCCL_SYMM_MEM: "0"
-        NCCL_CUMEM_ENABLE: "1"
-        NCCL_MNNVL_ENABLE: "1"
-        NCCL_NVLS_ENABLE: "1"
-        VLLM_SERVER_DEV_MODE: "1"
-        VLLM_USE_V2_MODEL_RUNNER: "1"
-        VLLM_MEMORY_PROFILER_ESTIMATE_CUDAGRAPHS: "0"
-        VLLM_USE_RUST_FRONTEND: "1"
-        VLLM_MOONCAKE_LOAD_RECV_THREADS: "4"
-        MC_SLICE_SIZE: "1048576"
-        VLLM_EXECUTE_MODEL_TIMEOUT_SECONDS: "1800"
-        VLLM_PREFIX_CACHE_RETENTION_INTERVAL: "0"
-        NCCL_P2P_LEVEL: "NVL"
-        MC_ENABLE_DEST_DEVICE_AFFINITY: "1"
-        WITH_NVIDIA_PEERMEM: "0"
-        NCCL_NET_PLUGIN: "none"
-        UCX_MEMTYPE_CACHE: "n"
-        UCX_MEMTYPE_REG_WHOLE: "n"
-        UCX_RCACHE_MAX_UNRELEASED: "1024"
-        UCX_TCP_AF_PRIO: "inet"
-        VLLM_SSM_CONV_STATE_LAYOUT: "DS"
-        # The prefill MoE workspace (about 3.3 GiB at 16384 tokens) failed to allocate with 7 GiB
-        # reserved but fragmented; blocks above 512 MiB are not split.
-        PYTORCH_CUDA_ALLOC_CONF: "max_split_size_mb:512"
-      args:
-        kv-transfer-config: '{"kv_connector":"MultiConnector","kv_role":"kv_both","kv_load_failure_policy":"recompute","kv_connector_extra_config":{"connectors":[{"kv_connector":"NixlConnector","kv_role":"kv_both","kv_load_failure_policy":"fail","kv_buffer_device":"cuda","kv_connector_extra_config":{"enforce_handshake_compat":false,"enable_cross_layers_blocks":false}},{"kv_connector":"MooncakeStoreConnector","kv_role":"kv_both","kv_load_failure_policy":"recompute","kv_connector_extra_config":{"load_async":true,"lookup_async":true,"compact_group_io":true,"max_load_batch_keys":2,"enable_cross_layers_blocks":false,"enable_offload":false}}]}}'
-        served-model-name: "moonshotai/Kimi-K3"
-        prefix-match-unit: 128
-        load-format: "safetensors"
-        safetensors-load-strategy: "lazy"
-        kv-cache-dtype: "fp8"
-        mamba-ssm-cache-dtype: "bfloat16"
-        gpu-memory-utilization: 0.88
-        tensor-parallel-size: 16
-        decode-context-parallel-size: 16
-        dcp-comm-backend: "a2a"
-        enable-cumem-allocator: true
-        trust-remote-code: true
-        max-cudagraph-capture-size: 512
-        stream-interval: 10
-        language-model-only: true
-        attention-backend: "TOKENSPEED_MLA"
-        attention-config: '{"mla_prefill_backend": "TRTLLM_RAGGED", "use_prefill_query_quantization": true}'
-        speculative-config: '{"model":"Inferact/Kimi-K3-DSpark","attention_backend":"TOKENSPEED_MLA","method":"dspark","num_speculative_tokens":4,"draft_sample_method":"probabilistic"}'
-        enable-prefix-caching: true
-      kv_events: true
-    decode:
-      nodes: 4
-      workers: 1
-      gpus: 16
-
-      env:
-        <<: *kimi_env
-      args:
-        kv-transfer-config: '{"kv_connector":"MultiConnector","kv_role":"kv_both","kv_load_failure_policy":"recompute","kv_connector_extra_config":{"connectors":[{"kv_connector":"NixlConnector","kv_role":"kv_both","kv_load_failure_policy":"fail","kv_buffer_device":"cuda","kv_connector_extra_config":{"enforce_handshake_compat":false,"enable_cross_layers_blocks":false}},{"kv_connector":"MooncakeStoreConnector","kv_role":"kv_both","kv_load_failure_policy":"recompute","kv_connector_extra_config":{"load_async":true,"lookup_async":true,"compact_group_io":true,"max_load_batch_keys":2,"enable_cross_layers_blocks":false,"enable_offload":false}}]}}'
-        served-model-name: "moonshotai/Kimi-K3"
-        prefix-match-unit: 128
-        load-format: "safetensors"
-        safetensors-load-strategy: "lazy"
-        kv-cache-dtype: "fp8"
-        mamba-ssm-cache-dtype: "bfloat16"
-        max-num-batched-tokens: 1024
-        tensor-parallel-size: 16
-        decode-context-parallel-size: 16
-        dcp-comm-backend: "a2a"
-        enable-cumem-allocator: true
-        trust-remote-code: true
-        stream-interval: 10
-        language-model-only: true
-        attention-backend: "TOKENSPEED_MLA"
-        attention-config: '{"mla_prefill_backend": "TRTLLM_RAGGED", "use_prefill_query_quantization": true}'
-        speculative-config: '{"model":"Inferact/Kimi-K3-DSpark","attention_backend":"TOKENSPEED_MLA","method":"dspark","num_speculative_tokens":4,"draft_sample_method":"probabilistic"}'
-        enable-prefix-caching: true
-
-  sbatch_directives:
-    mem: "0"
-    cpus-per-task: "144"
-    comment: >-
-      '{"OccupiedIdleGPUsJobReaper":{"exemptIdleTimeMins":"60","reason":"model_loading","description":"Very large model will
-      take extra loading time."}}'
-
-  srun_options:
-    mem: "0"
-    container-remap-root: ""
-
-  telemetry:
-    collector_join_timeout_seconds: 12
-
-  benchmark:
-    placement:
-      node: head
-    env:
-      AIPERF_LIVE_FAILED_REQUEST_THRESHOLD: "0.25"
-      AIPERF_REQUIRED_SERVER_METRIC_PREFIX: "vllm:"
-      AIPERF_HTTP_TCP_USER_TIMEOUT: "900000"
-      AIPERF_USE_DYNAMO_CONV_AWARE_ROUTING: "0"
-      AIPERF_HTTP_X_DYNAMO_SESSION_ID_FROM_CORRELATION_ID: "true"
-      AIPERF_DYNAMO_SESSION_TIMEOUT_SECONDS: "14400"
-
-override_1p1d_dcp16_dcp16_dspark4_c16:
-  roles:
-    prefill: &override_1p1d_dcp16_dcp16_dspark4_c16_prefill
-      args: &override_1p1d_dcp16_dcp16_dspark4_c16_prefill_args
-        max-num-seqs: 32
-    decode: &override_1p1d_dcp16_dcp16_dspark4_c16_decode
-      args: &override_1p1d_dcp16_dcp16_dspark4_c16_decode_args
-        gpu-memory-utilization: 0.92
-        max-num-seqs: 32
-        max-cudagraph-capture-size: 160
-
-override_1p1d_dcp16_dcp16_dspark4_c16_eval:
-  roles:
-    prefill:
-      <<: *override_1p1d_dcp16_dcp16_dspark4_c16_prefill
-      args:
-        <<: *override_1p1d_dcp16_dcp16_dspark4_c16_prefill_args
-        reasoning-parser: kimi_k3
-        dyn-tool-call-parser: kimi_k3
-        dyn-reasoning-parser: kimi_k3
-        dyn-enable-structural-tag: true
-    decode:
-      <<: *override_1p1d_dcp16_dcp16_dspark4_c16_decode
-      args:
-        <<: *override_1p1d_dcp16_dcp16_dspark4_c16_decode_args
-        reasoning-parser: kimi_k3
-        dyn-tool-call-parser: kimi_k3
-        dyn-reasoning-parser: kimi_k3
-        dyn-enable-structural-tag: true
-
-override_1p1d_dcp16_dcp16_dspark4_c32:
-  roles:
-    prefill: &override_1p1d_dcp16_dcp16_dspark4_c32_prefill
-      args: &override_1p1d_dcp16_dcp16_dspark4_c32_prefill_args
-        max-num-seqs: 64
-    decode: &override_1p1d_dcp16_dcp16_dspark4_c32_decode
-      args: &override_1p1d_dcp16_dcp16_dspark4_c32_decode_args
-        gpu-memory-utilization: 0.92
-        max-num-seqs: 64
-        max-cudagraph-capture-size: 320
-
-override_1p1d_dcp16_dcp16_dspark4_c32_eval:
-  roles:
-    prefill:
-      <<: *override_1p1d_dcp16_dcp16_dspark4_c32_prefill
-      args:
-        <<: *override_1p1d_dcp16_dcp16_dspark4_c32_prefill_args
-        reasoning-parser: kimi_k3
-        dyn-tool-call-parser: kimi_k3
-        dyn-reasoning-parser: kimi_k3
-        dyn-enable-structural-tag: true
-    decode:
-      <<: *override_1p1d_dcp16_dcp16_dspark4_c32_decode
-      args:
-        <<: *override_1p1d_dcp16_dcp16_dspark4_c32_decode_args
-        reasoning-parser: kimi_k3
-        dyn-tool-call-parser: kimi_k3
-        dyn-reasoning-parser: kimi_k3
-        dyn-enable-structural-tag: true
-
-override_1p1d_dcp16_dcp16_dspark4_c48:
-  roles:
-    prefill: &override_1p1d_dcp16_dcp16_dspark4_c48_prefill
-      args: &override_1p1d_dcp16_dcp16_dspark4_c48_prefill_args
-        max-num-seqs: 96
-    decode: &override_1p1d_dcp16_dcp16_dspark4_c48_decode
-      args: &override_1p1d_dcp16_dcp16_dspark4_c48_decode_args
-        gpu-memory-utilization: 0.9
-        max-num-seqs: 96
-        max-cudagraph-capture-size: 480
-
-override_1p1d_dcp16_dcp16_dspark4_c48_eval:
-  roles:
-    prefill:
-      <<: *override_1p1d_dcp16_dcp16_dspark4_c48_prefill
-      args:
-        <<: *override_1p1d_dcp16_dcp16_dspark4_c48_prefill_args
-        reasoning-parser: kimi_k3
-        dyn-tool-call-parser: kimi_k3
-        dyn-reasoning-parser: kimi_k3
-        dyn-enable-structural-tag: true
-    decode:
-      <<: *override_1p1d_dcp16_dcp16_dspark4_c48_decode
-      args:
-        <<: *override_1p1d_dcp16_dcp16_dspark4_c48_decode_args
-        reasoning-parser: kimi_k3
-        dyn-tool-call-parser: kimi_k3
-        dyn-reasoning-parser: kimi_k3
-        dyn-enable-structural-tag: true
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/gb300-fp4/agentx/agg-megakernel-variants.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/gb300-fp4/agentx/agg-megakernel-variants.yaml
deleted file mode 100644
index 710cb1c7cd..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/gb300-fp4/agentx/agg-megakernel-variants.yaml
+++ /dev/null
@@ -1,89 +0,0 @@
-schema: 2
-base:
-  identity:
-    model: {}
-    container: {}
-    frameworks:
-      vllm: e4a5b5537344b103ed10de7764378ef09604ef3d
-  dynamo:
-    install: false
-  slurm:
-    time_limit: 04:00:00
-  health_check:
-    max_attempts: 720
-    interval_seconds: 10
-  resources:
-    gpu_type: gb300
-    gpus_per_node: 4
-  frontend:
-    type: vllm
-    enable_multiple_frontends: false
-  engine:
-    type: vllm
-    connector: null
-  roles:
-    agg:
-      nodes: 2
-      workers: 1
-      gpus: 8
-      env:
-        VLLM_ALLREDUCE_USE_FLASHINFER: '1'
-        VLLM_ENABLE_K3_LATENT_MOE_TAIL_FUSION: '1'
-        VLLM_USE_DIRECT_DCP_A2A: '1'
-        VLLM_USE_DIRECT_DCP_Q_GATHER: '1'
-        VLLM_USE_DIRECT_DCP_KV_GATHER: '1'
-        VLLM_RPC_TIMEOUT: '600000'
-        VLLM_USE_V2_MODEL_RUNNER: '1'
-        VLLM_USE_RUST_FRONTEND: '0'
-        VLLM_PREFIX_CACHE_RETENTION_INTERVAL: '0'
-        VLLM_LOG_STATS_INTERVAL: '1'
-        VLLM_ENGINE_READY_TIMEOUT_S: '3600'
-      args:
-        served-model-name: moonshotai/Kimi-K3
-        enable-auto-tool-choice: true
-        tool-call-parser: kimi_k3
-        reasoning-parser: kimi_k3
-        load-format: fastsafetensors
-        kv-cache-dtype: fp8
-        mamba-ssm-cache-dtype: float32
-        gpu-memory-utilization: 0.92
-        tensor-parallel-size: 8
-        decode-context-parallel-size: 8
-        dcp-comm-backend: a2a
-        trust-remote-code: true
-        stream-interval: 10
-        language-model-only: true
-        moe-backend: auto
-        no-enable-flashinfer-autotune: true
-        attention-backend: TOKENSPEED_MLA
-        attention-config: '{"mla_prefill_backend":"TRTLLM_RAGGED","use_prefill_query_quantization":true}'
-        enable-prefix-caching: true
-        prefix-match-unit: 128
-        max-num-seqs: 8
-        max-num-batched-tokens: 16384
-        additional-config: '{"decode_backend":"latency_specialized"}'
-  sbatch_directives:
-    mem: '0'
-    cpus-per-task: '72'
-    comment: '''{"OccupiedIdleGPUsJobReaper":{"exemptIdleTimeMins":"60","reason":"model_loading","description":"Very large model will take extra loading time."}}'''
-  srun_options:
-    mem: '0'
-    container-remap-root: ''
-  telemetry:
-    collector_join_timeout_seconds: 12
-  benchmark:
-    env:
-      AIPERF_USE_DYNAMO_CONV_AWARE_ROUTING: '0'
-    placement:
-      node: head
-override_tp16_dspark5:
-  roles:
-    agg:
-      nodes: 4
-      gpus: 16
-      args:
-        tensor-parallel-size: 16
-        decode-context-parallel-size: 16
-        max-cudagraph-capture-size: 48
-        compilation-config: '{"cudagraph_mode":"FULL_AND_PIECEWISE","cudagraph_capture_sizes":[5,6,10,12,20,24,40,48]}'
-        speculative-config: '{"model":"Inferact/Kimi-K3-DSpark","attention_backend":"TOKENSPEED_MLA","method":"dspark","num_speculative_tokens":5,"draft_sample_method":"probabilistic","rejection_sample_method":"block"}'
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/gb300-fp4/agentx/disagg-tp8-dep16.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/gb300-fp4/agentx/disagg-tp8-dep16.yaml
deleted file mode 100644
index 1f7760acd6..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/gb300-fp4/agentx/disagg-tp8-dep16.yaml
+++ /dev/null
@@ -1,218 +0,0 @@
-schema: 2
-
-base:
-  identity:
-    model: {}
-    container: {}
-    frameworks:
-      vllm: "e4a5b5537344b103ed10de7764378ef09604ef3d"
-      dynamo: "a0de541ea8c861d5ac01d15953ca529bea68637b"
-
-  dynamo:
-    install: true
-    source:
-      rev: "a0de541ea8c861d5ac01d15953ca529bea68637b"
-
-  slurm:
-    time_limit: "04:00:00"
-
-  health_check:
-    max_attempts: 720
-    interval_seconds: 10
-
-  resources:
-    gpu_type: "gb300"
-    gpus_per_node: 4
-
-  services:
-  - name: etcd
-    type: etcd
-    placement:
-      node: infra
-  - name: nats
-    type: nats
-    placement:
-      node: infra
-    options:
-      max_payload_mb: 32
-  - name: mooncake-master
-    type: mooncake-master
-    args:
-    - "--default_kv_lease_ttl=60000"
-    - "--eviction_high_watermark_ratio=0.95"
-    - "--eviction_ratio=0.10"
-    options:
-      store_config:
-        metadata_server: "P2PHANDSHAKE"
-        global_segment_size: "160GB"
-        local_buffer_size: "4GB"
-        protocol: "rdma"
-        device_name: "@fabric.rdma-devices"
-        mode: "embedded"
-        enable_offload: false
-
-  frontend:
-    type: dynamo
-    enable_multiple_frontends: false
-    args:
-      router-mode: "least-loaded"
-      router-session-affinity-ttl-secs: 1
-    env:
-      DYN_ROUTER_ACTIVE_REQUEST_EXPIRY_SECS: "3600"
-      DYN_TOKENIZER_CACHE_BYTES: "8589934592"
-      DYN_TCP_REQUEST_TIMEOUT: "120"
-      DYN_DISABLE_OPENAI_STRICT_SCHEMA_VALIDATION: "1"
-
-  engine:
-    type: vllm
-    connector:
-    dp_launch_mode: per_node
-
-  roles:
-    prefill:
-      nodes: 2
-      workers: 1
-      gpus: 8
-      env:
-        <<: &kimi_env
-          VLLM_ENABLE_GEMM_RS: "1"
-          DYN_TCP_REQUEST_TIMEOUT: "120"
-          VLLM_ALLREDUCE_USE_FLASHINFER: "1"
-          DYN_REQUEST_PLANE: "tcp"
-          ETCD_LEASE_TTL: "600"
-          VLLM_ENGINE_READY_TIMEOUT_S: "3600"
-          VLLM_RPC_TIMEOUT: "600000"
-          TILELANG_CLEANUP_TEMP_FILES: "1"
-          VLLM_USE_NCCL_SYMM_MEM: "0"
-          NCCL_CUMEM_ENABLE: "1"
-          NCCL_MNNVL_ENABLE: "1"
-          NCCL_NVLS_ENABLE: "1"
-          VLLM_SERVER_DEV_MODE: "1"
-          VLLM_USE_V2_MODEL_RUNNER: "1"
-          VLLM_USE_RUST_FRONTEND: "1"
-          VLLM_MOONCAKE_LOAD_RECV_THREADS: "4"
-          MC_SLICE_SIZE: "1048576"
-          MC_MAX_MR_SIZE: "4294967296"
-          VLLM_EXECUTE_MODEL_TIMEOUT_SECONDS: "1800"
-          NVSHMEM_REMOTE_TRANSPORT: "none"
-          NVSHMEM_DISABLE_MNNVL: "0"
-          NVSHMEM_IB_ENABLE_IBGDA: "0"
-          NVSHMEM_ENABLE_NIC_PE_MAPPING: "1"
-          NVSHMEM_HCA_LIST: "@fabric.rdma-devices"
-          NCCL_P2P_LEVEL: "NVL"
-          MC_ENABLE_DEST_DEVICE_AFFINITY: "1"
-          WITH_NVIDIA_PEERMEM: "0"
-          NCCL_NET_PLUGIN: "none"
-          UCX_MEMTYPE_CACHE: "n"
-          UCX_MEMTYPE_REG_WHOLE: "n"
-          UCX_RCACHE_MAX_UNRELEASED: "1024"
-          UCX_TCP_AF_PRIO: "inet"
-          VLLM_SSM_CONV_STATE_LAYOUT: "DS"
-        VLLM_KIMI_K3_SHARD_SP_SHARED_EXPERT: "0"
-        DYN_BACKEND_ADMISSION_ENGINE_REQUEST_LIMIT: "1024"
-        DYN_BACKEND_ADMISSION_ENGINE_REQUEST_WAITING_LIMIT: "1024"
-      args:
-        quantization-config: '{"targets":{"*.in_proj_qkvgfab":"mxfp8","*.fused_qkv_a_g_proj":"mxfp8","*.routed_expert_down_proj":"mxfp8","*.routed_expert_up_proj":"mxfp8"}}'
-        kv-transfer-config: '{"kv_connector":"MultiConnector","kv_role":"kv_both","kv_load_failure_policy":"recompute","kv_connector_extra_config":{"connectors":[{"kv_connector":"NixlConnector","kv_role":"kv_both","kv_load_failure_policy":"fail","kv_buffer_device":"cuda","kv_connector_extra_config":{"enforce_handshake_compat":false,"enable_cross_layers_blocks":false}},{"kv_connector":"MooncakeStoreConnector","kv_role":"kv_both","kv_load_failure_policy":"recompute","kv_connector_extra_config":{"load_async":true,"lookup_async":true,"enable_cross_layers_blocks":false,"enable_offload":false}}]}}'
-        served-model-name: "moonshotai/Kimi-K3"
-        prefix-match-unit: 128
-        load-format: "fastsafetensors"
-        enable-flashinfer-autotune: true
-        kv-cache-dtype: "fp8"
-        mamba-ssm-cache-dtype: "bfloat16"
-        gpu-memory-utilization: 0.95
-        tensor-parallel-size: 8
-        enable-expert-parallel: true
-        enable-ep-weight-filter: true
-        moe-backend: deep_gemm_mega_moe
-        enable-cumem-allocator: true
-        trust-remote-code: true
-        max-num-seqs: 32
-        max-num-batched-tokens: 16384
-        max-cudagraph-capture-size: 8192
-        compilation-config: '{"cudagraph_mode":"FULL_AND_PIECEWISE","cudagraph_capture_sizes":[4,8,12,16,20,24,32,40,48,64,80,96,128,160,256,384,512,640,768,896,1024,1152,1280,1408,1536,1664,1792,1920,2048,2304,2560,2816,3072,3328,3584,3840,4096,4608,5120,5632,6144,6656,7168,7680,8192]}'
-        stream-interval: 10
-        language-model-only: true
-        attention-backend: "TOKENSPEED_MLA"
-        attention-config: '{"mla_prefill_backend":"TRTLLM_RAGGED","use_prefill_query_quantization":true,"trtllm_ragged_backend":"cute-dsl"}'
-        enable-prefix-caching: true
-        speculative-config: '{"model":"Inferact/Kimi-K3-DSpark","attention_backend":"TOKENSPEED_MLA","method":"dspark","num_speculative_tokens":4,"draft_sample_method":"probabilistic","rejection_sample_method":"block"}'
-      kv_events: true
-    decode:
-      nodes: 4
-      workers: 1
-      gpus: 16
-      env:
-        <<: *kimi_env
-      args:
-        quantization-config: '{"targets":{"*.in_proj_qkvgfab":"mxfp8","*.fused_qkv_a_g_proj":"mxfp8","*.routed_expert_down_proj":"mxfp8","*.routed_expert_up_proj":"mxfp8","*.o_proj":"mxfp8","*.shared_experts.gate_up_proj":"mxfp8","*.shared_experts.down_proj":"mxfp8"}}'
-        kv-transfer-config: '{"kv_connector":"MultiConnector","kv_role":"kv_both","kv_load_failure_policy":"recompute","kv_connector_extra_config":{"connectors":[{"kv_connector":"NixlConnector","kv_role":"kv_both","kv_load_failure_policy":"fail","kv_buffer_device":"cuda","kv_connector_extra_config":{"enforce_handshake_compat":false,"enable_cross_layers_blocks":false}},{"kv_connector":"MooncakeStoreConnector","kv_role":"kv_consumer","kv_load_failure_policy":"recompute","kv_connector_extra_config":{"load_async":true,"lookup_async":true,"enable_lookup":false,"enable_cross_layers_blocks":false,"enable_offload":false}}]}}'
-        served-model-name: "moonshotai/Kimi-K3"
-        prefix-match-unit: 128
-        load-format: "fastsafetensors"
-        enable-flashinfer-autotune: true
-        kv-cache-dtype: "fp8"
-        mamba-ssm-cache-dtype: "bfloat16"
-        gpu-memory-utilization: 0.95
-        tensor-parallel-size: 1
-        data-parallel-size: 16
-        data-parallel-rpc-port: 13345
-        enable-expert-parallel: true
-        enable-ep-weight-filter: true
-        moe-backend: deep_gemm_mega_moe
-        enable-cumem-allocator: true
-        trust-remote-code: true
-        max-num-seqs: 32
-        max-num-batched-tokens: 512
-        max-cudagraph-capture-size: 512
-        stream-interval: 10
-        language-model-only: true
-        attention-backend: "TOKENSPEED_MLA"
-        attention-config: '{"mla_prefill_backend":"TRTLLM_RAGGED","use_prefill_query_quantization":true,"tokenspeed_mla_min_split_kv":8}'
-        no-enable-prefix-caching: true
-        use-replayssm: true
-        speculative-config: '{"model":"Inferact/Kimi-K3-DSpark","attention_backend":"TOKENSPEED_MLA","method":"dspark","num_speculative_tokens":4,"draft_sample_method":"probabilistic","rejection_sample_method":"block"}'
-  sbatch_directives:
-    mem: "0"
-    cpus-per-task: "72"
-    comment: >-
-      '{"OccupiedIdleGPUsJobReaper":{"exemptIdleTimeMins":"60","reason":"model_loading","description":"Very large model will
-      take extra loading time."}}'
-
-  srun_options:
-    mem: "0"
-    container-remap-root: ""
-
-  telemetry:
-    collector_join_timeout_seconds: 12
-
-  benchmark:
-    placement:
-      node: head
-    env:
-      AIPERF_USE_DYNAMO_CONV_AWARE_ROUTING: "0"
-      AIPERF_HTTP_X_DYNAMO_SESSION_ID_FROM_CORRELATION_ID: "true"
-      AIPERF_DYNAMO_SESSION_TIMEOUT_SECONDS: "14400"
-
-override_3p1d_c336:
-  roles:
-    prefill:
-      nodes: 6
-      workers: 3
-
-override_3p1d_c336_eval:
-  roles:
-    prefill:
-      nodes: 6
-      workers: 3
-      args:
-        reasoning-parser: kimi_k3
-        dyn-tool-call-parser: kimi_k3
-        dyn-reasoning-parser: kimi_k3
-        dyn-enable-structural-tag: true
-    decode:
-      args:
-        reasoning-parser: kimi_k3
-        dyn-tool-call-parser: kimi_k3
-        dyn-reasoning-parser: kimi_k3
-        dyn-enable-structural-tag: true
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/gb300-fp4/agentx/disagg-variants.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/gb300-fp4/agentx/disagg-variants.yaml
deleted file mode 100644
index 6b02be19ed..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/gb300-fp4/agentx/disagg-variants.yaml
+++ /dev/null
@@ -1,367 +0,0 @@
-schema: 2
-
-base:
-  identity:
-    model: {}
-    container: {}
-    frameworks:
-      vllm: "e4a5b5537344b103ed10de7764378ef09604ef3d"
-      dynamo: "a0de541ea8c861d5ac01d15953ca529bea68637b"
-
-  dynamo:
-    install: true
-    source:
-      rev: "a0de541ea8c861d5ac01d15953ca529bea68637b"
-
-  slurm:
-    time_limit: "04:00:00"
-
-  health_check:
-    max_attempts: 720
-    interval_seconds: 10
-
-  resources:
-    gpu_type: "gb300"
-    gpus_per_node: 4
-
-  services:
-  - name: etcd
-    type: etcd
-    placement:
-      node: infra
-  - name: nats
-    type: nats
-    placement:
-      node: infra
-    options:
-      max_payload_mb: 32
-  - name: mooncake-master
-    type: mooncake-master
-    args:
-    - "--default_kv_lease_ttl=60000"
-    - "--eviction_high_watermark_ratio=0.95"
-    - "--eviction_ratio=0.10"
-    options:
-      store_config:
-        metadata_server: "P2PHANDSHAKE"
-        global_segment_size: "160GB"
-        local_buffer_size: "4GB"
-        protocol: "rdma"
-        device_name: "@fabric.rdma-devices"
-        mode: "embedded"
-        enable_offload: false
-
-  frontend:
-    type: dynamo
-    enable_multiple_frontends: false
-    args:
-      router-mode: "least-loaded"
-      router-session-affinity-ttl-secs: 1
-    env:
-      DYN_ROUTER_ACTIVE_REQUEST_EXPIRY_SECS: "3600"
-      DYN_TOKENIZER_CACHE_BYTES: "8589934592"
-      DYN_TCP_REQUEST_TIMEOUT: "120"
-      DYN_DISABLE_OPENAI_STRICT_SCHEMA_VALIDATION: "1"
-
-  engine:
-    type: vllm
-    connector:
-    dp_launch_mode: per_node
-
-  roles:
-    prefill:
-      nodes: 2
-      workers: 1
-      gpus: 8
-      env:
-        <<: &kimi_env
-          DYN_TCP_REQUEST_TIMEOUT: "120"
-          VLLM_USE_DIRECT_DCP_A2A: "1"
-          VLLM_USE_DIRECT_DCP_Q_GATHER: "1"
-          VLLM_USE_DIRECT_DCP_KV_GATHER: "1"
-          VLLM_ALLREDUCE_USE_FLASHINFER: "1"
-          VLLM_KIMI_K3_SHARD_SP_SHARED_EXPERT: "0"
-          DYN_REQUEST_PLANE: "tcp"
-          ETCD_LEASE_TTL: "600"
-          VLLM_RPC_TIMEOUT: "600000"
-          TILELANG_CLEANUP_TEMP_FILES: "1"
-          VLLM_USE_NCCL_SYMM_MEM: "0"
-          NCCL_CUMEM_ENABLE: "1"
-          NCCL_MNNVL_ENABLE: "1"
-          NCCL_NVLS_ENABLE: "1"
-          VLLM_SERVER_DEV_MODE: "1"
-          VLLM_USE_V2_MODEL_RUNNER: "1"
-          VLLM_USE_RUST_FRONTEND: "1"
-          VLLM_MOONCAKE_LOAD_RECV_THREADS: "4"
-          MC_SLICE_SIZE: "1048576"
-          MC_MAX_MR_SIZE: "4294967296"
-          VLLM_EXECUTE_MODEL_TIMEOUT_SECONDS: "1800"
-          VLLM_PREFIX_CACHE_RETENTION_INTERVAL: "0"
-          NCCL_P2P_LEVEL: "NVL"
-          MC_ENABLE_DEST_DEVICE_AFFINITY: "1"
-          WITH_NVIDIA_PEERMEM: "0"
-          NCCL_NET_PLUGIN: "none"
-          UCX_MEMTYPE_CACHE: "n"
-          UCX_MEMTYPE_REG_WHOLE: "n"
-          UCX_RCACHE_MAX_UNRELEASED: "1024"
-          UCX_TCP_AF_PRIO: "inet"
-          VLLM_SSM_CONV_STATE_LAYOUT: "DS"
-          TOKENSPEED_MLA_FP16_PARTIALS: "0"
-          VLLM_ENGINE_READY_TIMEOUT_S: '3600'
-        VLLM_ENABLE_GEMM_RS: '1'
-        DYN_BACKEND_ADMISSION_ENGINE_REQUEST_LIMIT: '1024'
-        DYN_BACKEND_ADMISSION_ENGINE_REQUEST_WAITING_LIMIT: '1024'
-      args:
-        kv-transfer-config: '{"kv_connector":"MultiConnector","kv_role":"kv_both","kv_load_failure_policy":"recompute","kv_connector_extra_config":{"connectors":[{"kv_connector":"NixlConnector","kv_role":"kv_both","kv_load_failure_policy":"fail","kv_buffer_device":"cuda","kv_connector_extra_config":{"enforce_handshake_compat":false,"enable_cross_layers_blocks":false}},{"kv_connector":"MooncakeStoreConnector","kv_role":"kv_both","kv_load_failure_policy":"recompute","kv_connector_extra_config":{"load_async":true,"lookup_async":true,"enable_cross_layers_blocks":false,"enable_offload":false}}]}}'
-        served-model-name: "moonshotai/Kimi-K3"
-        prefix-match-unit: 128
-        load-format: "fastsafetensors"
-        kv-cache-dtype: "fp8"
-        mamba-ssm-cache-dtype: "bfloat16"
-        gpu-memory-utilization: 0.95
-        tensor-parallel-size: 8
-        decode-context-parallel-size: 8
-        dcp-comm-backend: "a2a"
-        enable-flashinfer-autotune: true
-        enable-cumem-allocator: true
-        trust-remote-code: true
-        max-cudagraph-capture-size: 8192
-        compilation-config: '{"cudagraph_mode":"FULL_AND_PIECEWISE","cudagraph_capture_sizes":[4,8,12,16,20,24,32,40,48,64,80,96,128,160,256,384,512,640,768,896,1024,1152,1280,1408,1536,1664,1792,1920,2048,2304,2560,2816,3072,3328,3584,3840,4096,4608,5120,5632,6144,6656,7168,7680,8192]}'
-        stream-interval: 10
-        language-model-only: true
-        attention-backend: "TOKENSPEED_MLA"
-        attention-config: '{"mla_prefill_backend":"TRTLLM_RAGGED","use_prefill_query_quantization":true,"trtllm_ragged_backend":"cute-dsl"}'
-        enable-prefix-caching: true
-        enable-expert-parallel: true
-        moe-backend: deep_gemm_mega_moe
-        max-num-seqs: 32
-        speculative-config: '{"model":"Inferact/Kimi-K3-DSpark","attention_backend":"TOKENSPEED_MLA","method":"dspark","num_speculative_tokens":4,"draft_sample_method":"probabilistic","rejection_sample_method":"block"}'
-      kv_events: true
-    decode:
-      nodes: 2
-      workers: 1
-      gpus: 8
-      env:
-        <<: *kimi_env
-        VLLM_ENABLE_GEMM_RS: '0'
-      args:
-        kv-transfer-config: '{"kv_connector":"MultiConnector","kv_role":"kv_both","kv_load_failure_policy":"recompute","kv_connector_extra_config":{"connectors":[{"kv_connector":"NixlConnector","kv_role":"kv_both","kv_load_failure_policy":"fail","kv_buffer_device":"cuda","kv_connector_extra_config":{"enforce_handshake_compat":false,"enable_cross_layers_blocks":false}},{"kv_connector":"MooncakeStoreConnector","kv_role":"kv_both","kv_load_failure_policy":"recompute","kv_connector_extra_config":{"load_async":true,"lookup_async":true,"enable_cross_layers_blocks":false,"enable_offload":false}}]}}'
-        served-model-name: "moonshotai/Kimi-K3"
-        prefix-match-unit: 128
-        load-format: "fastsafetensors"
-        kv-cache-dtype: "fp8"
-        mamba-ssm-cache-dtype: "bfloat16"
-        gpu-memory-utilization: 0.95
-        tensor-parallel-size: 8
-        decode-context-parallel-size: 8
-        dcp-comm-backend: "a2a"
-        enable-flashinfer-autotune: true
-        enable-cumem-allocator: true
-        trust-remote-code: true
-        max-cudagraph-capture-size: 512
-        stream-interval: 10
-        language-model-only: true
-        attention-backend: "TOKENSPEED_MLA"
-        attention-config: '{"mla_prefill_backend":"TRTLLM_RAGGED","use_prefill_query_quantization":true,"tokenspeed_mla_min_split_kv":8}'
-        enable-prefix-caching: true
-        max-num-seqs: 128
-        speculative-config: '{"model":"Inferact/Kimi-K3-DSpark","attention_backend":"TOKENSPEED_MLA","method":"dspark","num_speculative_tokens":4,"draft_sample_method":"probabilistic","rejection_sample_method":"block"}'
-  sbatch_directives:
-    mem: "0"
-    cpus-per-task: "72"
-    comment: >-
-      '{"OccupiedIdleGPUsJobReaper":{"exemptIdleTimeMins":"60","reason":"model_loading","description":"Very large model will
-      take extra loading time."}}'
-
-  srun_options:
-    mem: "0"
-    container-remap-root: ""
-
-  telemetry:
-    collector_join_timeout_seconds: 12
-
-  benchmark:
-    placement:
-      node: head
-    env:
-      AIPERF_USE_DYNAMO_CONV_AWARE_ROUTING: "0"
-      AIPERF_HTTP_X_DYNAMO_SESSION_ID_FROM_CORRELATION_ID: "true"
-      AIPERF_DYNAMO_SESSION_TIMEOUT_SECONDS: "14400"
-
-# Specialized decode backend (latency_specialized) for the low-concurrency points:
-# decode max-num-seqs = 64 // (K + 1) with DSpark K4, FP32 SSM state, and CUDA
-# graphs captured for every batch size up to 64. The DCP KV interleave is pinned to 1
-# on both roles: otherwise NIXL P/D raises it to the KV block size after the
-# specialized decode has read it, and its spec-verify causal mask uses the stale value.
-override_1p3d_specdecode:
-  roles:
-    prefill: &override_1p3d_specdecode_prefill
-      nodes: 2
-      workers: 1
-      args: &override_1p3d_specdecode_prefill_args
-        mamba-ssm-cache-dtype: "float32"
-        cp-kv-cache-interleave-size: 1
-        enable-flashinfer-autotune: null
-        no-enable-flashinfer-autotune: true
-    decode: &override_1p3d_specdecode_decode
-      nodes: 6
-      workers: 3
-      args: &override_1p3d_specdecode_decode_args
-        mamba-ssm-cache-dtype: "float32"
-        cp-kv-cache-interleave-size: 1
-        enable-flashinfer-autotune: null
-        no-enable-flashinfer-autotune: true
-        additional-config: '{"decode_backend":"latency_specialized"}'
-        attention-config: '{"mla_prefill_backend":"TRTLLM_RAGGED","use_prefill_query_quantization":true}'
-        max-num-seqs: 12
-        max-cudagraph-capture-size: 64
-        compilation-config: '{"cudagraph_capture_sizes":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64]}'
-
-override_1p3d_specdecode_eval:
-  roles:
-    prefill:
-      <<: *override_1p3d_specdecode_prefill
-      args:
-        <<: *override_1p3d_specdecode_prefill_args
-        reasoning-parser: kimi_k3
-        dyn-tool-call-parser: kimi_k3
-        dyn-reasoning-parser: kimi_k3
-        dyn-enable-structural-tag: true
-    decode:
-      <<: *override_1p3d_specdecode_decode
-      args:
-        <<: *override_1p3d_specdecode_decode_args
-        reasoning-parser: kimi_k3
-        dyn-tool-call-parser: kimi_k3
-        dyn-reasoning-parser: kimi_k3
-        dyn-enable-structural-tag: true
-
-override_1p2d_specdecode:
-  roles:
-    prefill: &override_1p2d_specdecode_prefill
-      nodes: 2
-      workers: 1
-      args: &override_1p2d_specdecode_prefill_args
-        <<: *override_1p3d_specdecode_prefill_args
-    decode: &override_1p2d_specdecode_decode
-      nodes: 4
-      workers: 2
-      args: &override_1p2d_specdecode_decode_args
-        <<: *override_1p3d_specdecode_decode_args
-
-override_1p2d_specdecode_eval:
-  roles:
-    prefill:
-      <<: *override_1p2d_specdecode_prefill
-      args:
-        <<: *override_1p2d_specdecode_prefill_args
-        reasoning-parser: kimi_k3
-        dyn-tool-call-parser: kimi_k3
-        dyn-reasoning-parser: kimi_k3
-        dyn-enable-structural-tag: true
-    decode:
-      <<: *override_1p2d_specdecode_decode
-      args:
-        <<: *override_1p2d_specdecode_decode_args
-        reasoning-parser: kimi_k3
-        dyn-tool-call-parser: kimi_k3
-        dyn-reasoning-parser: kimi_k3
-        dyn-enable-structural-tag: true
-
-# Regular decode without a batch cap (base max-num-seqs 128), so TTFT is not
-# traded for ITL by a standing decode queue.
-override_1p2d_cap128:
-  roles:
-    prefill: &override_1p2d_cap128_prefill
-      nodes: 2
-      workers: 1
-      args: &override_1p2d_cap128_prefill_args {}
-    decode: &override_1p2d_cap128_decode
-      nodes: 4
-      workers: 2
-      args: &override_1p2d_cap128_decode_args
-        max-num-seqs: 128
-        use-replayssm: true
-
-override_1p2d_cap128_eval:
-  roles:
-    prefill:
-      <<: *override_1p2d_cap128_prefill
-      args:
-        <<: *override_1p2d_cap128_prefill_args
-        reasoning-parser: kimi_k3
-        dyn-tool-call-parser: kimi_k3
-        dyn-reasoning-parser: kimi_k3
-        dyn-enable-structural-tag: true
-    decode:
-      <<: *override_1p2d_cap128_decode
-      args:
-        <<: *override_1p2d_cap128_decode_args
-        reasoning-parser: kimi_k3
-        dyn-tool-call-parser: kimi_k3
-        dyn-reasoning-parser: kimi_k3
-        dyn-enable-structural-tag: true
-
-override_3p4d_cap128:
-  roles:
-    prefill: &override_3p4d_cap128_prefill
-      nodes: 6
-      workers: 3
-      args: &override_3p4d_cap128_prefill_args {}
-    decode: &override_3p4d_cap128_decode
-      nodes: 8
-      workers: 4
-      args: &override_3p4d_cap128_decode_args
-        max-num-seqs: 128
-        use-replayssm: true
-
-override_3p4d_cap128_eval:
-  roles:
-    prefill:
-      <<: *override_3p4d_cap128_prefill
-      args:
-        <<: *override_3p4d_cap128_prefill_args
-        reasoning-parser: kimi_k3
-        dyn-tool-call-parser: kimi_k3
-        dyn-reasoning-parser: kimi_k3
-        dyn-enable-structural-tag: true
-    decode:
-      <<: *override_3p4d_cap128_decode
-      args:
-        <<: *override_3p4d_cap128_decode_args
-        reasoning-parser: kimi_k3
-        dyn-tool-call-parser: kimi_k3
-        dyn-reasoning-parser: kimi_k3
-        dyn-enable-structural-tag: true
-
-override_2p3d_cap128:
-  roles:
-    prefill: &override_2p3d_cap128_prefill
-      nodes: 4
-      workers: 2
-      args: &override_2p3d_cap128_prefill_args {}
-    decode: &override_2p3d_cap128_decode
-      nodes: 6
-      workers: 3
-      args: &override_2p3d_cap128_decode_args
-        max-num-seqs: 128
-        use-replayssm: true
-
-override_2p3d_cap128_eval:
-  roles:
-    prefill:
-      <<: *override_2p3d_cap128_prefill
-      args:
-        <<: *override_2p3d_cap128_prefill_args
-        reasoning-parser: kimi_k3
-        dyn-tool-call-parser: kimi_k3
-        dyn-reasoning-parser: kimi_k3
-        dyn-enable-structural-tag: true
-    decode:
-      <<: *override_2p3d_cap128_decode
-      args:
-        <<: *override_2p3d_cap128_decode_args
-        reasoning-parser: kimi_k3
-        dyn-tool-call-parser: kimi_k3
-        dyn-reasoning-parser: kimi_k3
-        dyn-enable-structural-tag: true
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/h200-fp4/agentx/agg-tp16dp2ep32-latency.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/h200-fp4/agentx/agg-tp16dp2ep32-latency.yaml
deleted file mode 100644
index d34c126929..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/h200-fp4/agentx/agg-tp16dp2ep32-latency.yaml
+++ /dev/null
@@ -1,79 +0,0 @@
-schema: 2
-name: "kimik3-vllm-agg-h200-tp16dp2ep32-latency-agentic"
-
-identity:
-  model:
-    revision: "9f62e4e9fffbd0a83ddd60e1c209d828994b3569"
-  container: {}
-  frameworks:
-    vllm: "0.1.dev19262+gb6bbf29dd.d20260727"
-
-dynamo:
-  install: false
-
-slurm:
-  time_limit: "8:00:00"
-
-health_check:
-  max_attempts: 720
-  interval_seconds: 10
-
-resources:
-  gpu_type: "h200"
-  gpus_per_node: 8
-frontend:
-  type: vllm
-  enable_multiple_frontends: false
-
-engine:
-  type: vllm
-  connector:
-roles:
-  agg:
-    nodes: 4
-    workers: 1
-    gpus: 32
-
-    env:
-      CUDA_LAUNCH_BLOCKING: "1"
-      GLOO_SOCKET_IFNAME: "@fabric.socket-ifname"
-      HF_HUB_CACHE: "/hf_hub_cache"
-      HUGGINGFACE_HUB_CACHE: "/hf_hub_cache"
-      NCCL_SOCKET_IFNAME: "@fabric.socket-ifname"
-      NCCL_CUMEM_ENABLE: "1"
-      PYTORCH_CUDA_ALLOC_CONF: "expandable_segments:True"
-      PYTHONNOUSERSITE: "1"
-      TRANSFORMERS_CACHE: "/hf_hub_cache"
-      VLLM_ENGINE_READY_TIMEOUT_S: "7200"
-      VLLM_EXECUTE_MODEL_TIMEOUT_SECONDS: "1800"
-      VLLM_ROUTED_DOWN_PROJ_STREAM_TOKEN_THRESHOLD: "0"
-      VLLM_USE_V2_MODEL_RUNNER: "1"
-    args:
-      served-model-name: "moonshotai/Kimi-K3"
-      tensor-parallel-size: 16
-      data-parallel-size: 2
-      enable-expert-parallel: true
-      trust-remote-code: true
-      load-format: fastsafetensors
-      moe-backend: marlin
-      attention-backend: FLASHMLA
-      gpu-memory-utilization: 0.975
-      max-num-seqs: 5
-      max-num-batched-tokens: 4096
-      speculative-config: '{"method":"dspark","model":"Inferact/Kimi-K3-DSpark","num_speculative_tokens":2,"draft_sample_method":"probabilistic","rejection_sample_method":"block"}'
-      enforce-eager: true
-      compilation-config: '{"pass_config":{"fuse_allreduce_rms":false}}'
-      enable-prefix-caching: true
-      enable-prompt-tokens-details: true
-      no-enable-flashinfer-autotune: true
-      disable-custom-all-reduce: true
-      enable-auto-tool-choice: true
-      tool-call-parser: kimi_k3
-      reasoning-parser: kimi_k3
-      language-model-only: true
-
-srun_options:
-  container-remap-root: ""
-
-telemetry:
-  collector_join_timeout_seconds: 12
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/h200-fp4/agentx/agg-tp8dp4ep32-balanced.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/h200-fp4/agentx/agg-tp8dp4ep32-balanced.yaml
deleted file mode 100644
index ae474b2072..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/h200-fp4/agentx/agg-tp8dp4ep32-balanced.yaml
+++ /dev/null
@@ -1,80 +0,0 @@
-schema: 2
-name: "kimik3-vllm-agg-h200-tp8dp4ep32-balanced-agentic"
-
-identity:
-  model:
-    revision: "9f62e4e9fffbd0a83ddd60e1c209d828994b3569"
-  container: {}
-  frameworks:
-    vllm: "0.1.dev19262+gb6bbf29dd.d20260727"
-
-dynamo:
-  install: false
-
-slurm:
-  time_limit: "8:00:00"
-
-health_check:
-  max_attempts: 720
-  interval_seconds: 10
-
-resources:
-  gpu_type: "h200"
-  gpus_per_node: 8
-frontend:
-  type: vllm
-  enable_multiple_frontends: false
-
-engine:
-  type: vllm
-  connector:
-roles:
-  agg:
-    nodes: 4
-    workers: 1
-    gpus: 32
-
-    env:
-      CUDA_LAUNCH_BLOCKING: "1"
-      GLOO_SOCKET_IFNAME: "@fabric.socket-ifname"
-      HF_HUB_CACHE: "/hf_hub_cache"
-      HUGGINGFACE_HUB_CACHE: "/hf_hub_cache"
-      NCCL_SOCKET_IFNAME: "@fabric.socket-ifname"
-      NCCL_CUMEM_ENABLE: "1"
-      PYTORCH_CUDA_ALLOC_CONF: "expandable_segments:True"
-      PYTHONNOUSERSITE: "1"
-      TRANSFORMERS_CACHE: "/hf_hub_cache"
-      VLLM_ENGINE_READY_TIMEOUT_S: "7200"
-      VLLM_EXECUTE_MODEL_TIMEOUT_SECONDS: "1800"
-      VLLM_ROUTED_DOWN_PROJ_STREAM_TOKEN_THRESHOLD: "0"
-      VLLM_USE_V2_MODEL_RUNNER: "1"
-    args:
-      served-model-name: "moonshotai/Kimi-K3"
-      tensor-parallel-size: 8
-      data-parallel-size: 4
-      enable-expert-parallel: true
-      trust-remote-code: true
-      load-format: fastsafetensors
-      moe-backend: marlin
-      attention-backend: FLASHMLA
-      gpu-memory-utilization: 0.95
-      max-num-seqs: 8
-      max-num-batched-tokens: 4096
-      speculative-config: '{"method":"dspark","model":"Inferact/Kimi-K3-DSpark","num_speculative_tokens":2,"draft_sample_method":"probabilistic","rejection_sample_method":"block"}'
-      enforce-eager: true
-      no-async-scheduling: true
-      compilation-config: '{"pass_config":{"fuse_allreduce_rms":false}}'
-      enable-prefix-caching: true
-      enable-prompt-tokens-details: true
-      no-enable-flashinfer-autotune: true
-      disable-custom-all-reduce: true
-      enable-auto-tool-choice: true
-      tool-call-parser: kimi_k3
-      reasoning-parser: kimi_k3
-      language-model-only: true
-
-srun_options:
-  container-remap-root: ""
-
-telemetry:
-  collector_join_timeout_seconds: 12
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/h200-fp4/agentx/agg-tp8dp4ep32-vllm-simple.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/h200-fp4/agentx/agg-tp8dp4ep32-vllm-simple.yaml
deleted file mode 100644
index cf5c57b9bd..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/h200-fp4/agentx/agg-tp8dp4ep32-vllm-simple.yaml
+++ /dev/null
@@ -1,81 +0,0 @@
-schema: 2
-name: "kimik3-vllm-agg-h200-tp8dp4ep32-vllm-simple-agentic"
-
-identity:
-  model:
-    revision: "9f62e4e9fffbd0a83ddd60e1c209d828994b3569"
-  container: {}
-  frameworks:
-    vllm: "0.1.dev19262+gb6bbf29dd.d20260727"
-
-dynamo:
-  install: false
-
-slurm:
-  time_limit: "8:00:00"
-
-health_check:
-  max_attempts: 720
-  interval_seconds: 10
-
-resources:
-  gpu_type: "h200"
-  gpus_per_node: 8
-frontend:
-  type: vllm
-  enable_multiple_frontends: false
-
-engine:
-  type: vllm
-  connector:
-roles:
-  agg:
-    nodes: 4
-    workers: 1
-    gpus: 32
-
-    env:
-      CUDA_LAUNCH_BLOCKING: "1"
-      GLOO_SOCKET_IFNAME: "@fabric.socket-ifname"
-      HF_HUB_CACHE: "/hf_hub_cache"
-      HUGGINGFACE_HUB_CACHE: "/hf_hub_cache"
-      NCCL_SOCKET_IFNAME: "@fabric.socket-ifname"
-      NCCL_CUMEM_ENABLE: "1"
-      PYTHONHASHSEED: "42"
-      PYTHONNOUSERSITE: "1"
-      TRANSFORMERS_CACHE: "/hf_hub_cache"
-      VLLM_ENGINE_READY_TIMEOUT_S: "7200"
-      VLLM_EXECUTE_MODEL_TIMEOUT_SECONDS: "1800"
-      VLLM_ROUTED_DOWN_PROJ_STREAM_TOKEN_THRESHOLD: "0"
-      VLLM_USE_V2_MODEL_RUNNER: "1"
-    args:
-      served-model-name: "moonshotai/Kimi-K3"
-      tensor-parallel-size: 8
-      data-parallel-size: 4
-      enable-expert-parallel: true
-      trust-remote-code: true
-      load-format: fastsafetensors
-      moe-backend: marlin
-      attention-backend: FLASHMLA
-      gpu-memory-utilization: 0.95
-      max-num-seqs: 16
-      max-num-batched-tokens: 4096
-      speculative-config: '{"method":"dspark","model":"Inferact/Kimi-K3-DSpark","num_speculative_tokens":2,"draft_sample_method":"probabilistic","rejection_sample_method":"block"}'
-      enforce-eager: true
-      no-async-scheduling: true
-      compilation-config: '{"pass_config":{"fuse_allreduce_rms":false}}'
-      enable-prefix-caching: true
-      enable-prompt-tokens-details: true
-      kv-transfer-config: '{"kv_connector":"SimpleCPUOffloadConnector","kv_role":"kv_both","kv_connector_extra_config":{"cpu_bytes_to_use_per_rank":154250000000,"lazy_offload":false}}'
-      no-enable-flashinfer-autotune: true
-      disable-custom-all-reduce: true
-      enable-auto-tool-choice: true
-      tool-call-parser: kimi_k3
-      reasoning-parser: kimi_k3
-      language-model-only: true
-
-srun_options:
-  container-remap-root: ""
-
-telemetry:
-  collector_join_timeout_seconds: 12
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/mi355x-fp4/agentx/disagg-variants.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/mi355x-fp4/agentx/disagg-variants.yaml
deleted file mode 100644
index 5517332e9f..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/kimik3/vllm/mi355x-fp4/agentx/disagg-variants.yaml
+++ /dev/null
@@ -1,212 +0,0 @@
-base:
-  schema: 2
-  name: kimik3-fp4-mi355x-vllm-disagg-agentic
-  slurm:
-    time_limit: '08:00:00'
-  sbatch_directives:
-    mem: '0'
-  srun_options:
-    container-remap-root: ''
-    container-writable: ''
-    mem: '0'
-  container_mounts:
-    /dev/infiniband: /dev/infiniband
-  extra_mount:
-    - /it-share/data/Inferact-Kimi-K3-DSpark:/models/Inferact-Kimi-K3-DSpark
-    # Match the host's Ionic provider without replacing the image's verbs core.
-    - /usr/lib/x86_64-linux-gnu/libibverbs/libionic-rdmav34.so:/usr/lib/x86_64-linux-gnu/libibverbs/libionic-rdmav34.so:ro
-  resources:
-    gpu_type: mi355x
-    gpus_per_node: 8
-  frontend:
-    type: vllm-router
-    enable_multiple_frontends: false
-    placement:
-      node: head
-    # Native Pyxis/Enroot digest reference; imported in the frontend's job step.
-    container_image: registry-1.docker.io#vllm/vllm-router:sha256:1fbf06701abce8c8cd459414e472d63999c05b201baffc62e00727c10583f5ea
-    args:
-      policy: consistent_hash
-      prefill-policy: consistent_hash
-      decode-policy: consistent_hash
-      log-level: info
-  observability:
-    enabled: false
-    tachometer:
-      enabled: false
-  health_check:
-    interval_seconds: 10
-    # Match the engine's 7200-second weight-loading budget.
-    max_attempts: 720
-  engine:
-    type: vllm
-    connector: moriio
-  roles:
-    prefill:
-      nodes: 1
-      workers: 1
-      gpus: 8
-      args: &common_args
-        served-model-name: moonshotai/Kimi-K3
-        trust-remote-code: true
-        tensor-parallel-size: 8
-        decode-context-parallel-size: 1
-        cp-kv-cache-interleave-size: 1
-        dcp-comm-backend: a2a
-        moe-backend: auto
-        load-format: fastsafetensors
-        gpu-memory-utilization: 0.90
-        language-model-only: true
-        enable-auto-tool-choice: true
-        tool-call-parser: kimi_k3
-        reasoning-parser: kimi_k3
-        max-model-len: 1048576
-        stream-interval: 10
-        enable-prefix-caching: true
-        prefix-match-unit: 128
-        kv-cache-dtype: fp8
-        mamba-ssm-cache-dtype: float32
-        block-size: 128
-        attention-backend: ROCM_AITER_MLA
-        attention-config: '{"mla_prefill_backend":"ROCM_AITER_FA","use_prefill_query_quantization":true}'
-        # The native srt driver supplies the measured AL for the selected DSpark
-        # draft length in throughput runs and keeps real block rejection for eval.
-        speculative-config: '{"model":"/models/Inferact-Kimi-K3-DSpark","method":"dspark","num_speculative_tokens":4,"attention_backend":"ROCM_AITER_MLA","kv_cache_dtype":"fp8","draft_sample_method":"probabilistic","rejection_sample_method":"block"}'
-        kv-transfer-config: '{"kv_connector":"MultiConnector","kv_role":"kv_both","kv_load_failure_policy":"fail","kv_connector_extra_config":{"connectors":[{"kv_connector":"MoRIIOConnector","kv_role":"kv_producer","kv_load_failure_policy":"fail","kv_connector_extra_config":{"backend":"rdma"}},{"kv_connector":"SimpleCPUOffloadConnector","kv_role":"kv_both","kv_connector_extra_config":{"cpu_bytes_to_use":1799000000000,"lazy_offload":false}}]}}'
-      env: &common_env
-        NCCL_IB_HCA: rdma0,rdma1,rdma2,rdma3,rdma4,rdma5,rdma6,rdma7
-        NCCL_SOCKET_IFNAME: eno0
-        GLOO_SOCKET_IFNAME: eno0
-        # Use the nightly's default SiTUv2 activation selection.
-        VLLM_ROCM_USE_AITER: '1'
-        AITER_BF16_FP8_MOE_BOUND: '0'
-        AITER_FLYDSL_STAGE2_FP8: '1'
-        VLLM_ROCM_AITER_MLA_ASM_PADDING: asm
-        VLLM_ROCM_AITER_MLA_DCP_VERIFY: asm
-        VLLM_ROCM_QUICK_REDUCE_QUANTIZATION: INT4
-        VLLM_ROCM_QUICK_REDUCE_MAX_SIZE_BYTES_MB: '256'
-        SAFETENSORS_FAST_GPU: '1'
-        VLLM_SSM_CONV_STATE_LAYOUT: DS
-        VLLM_KV_CACHE_LAYOUT: HND
-        NCCL_DMABUF_ENABLE: '0'
-        HSA_ENABLE_IPC_MODE_LEGACY: '1'
-        HIP_FORCE_DEV_KERNARG: '1'
-        PYTHONHASHSEED: '42'
-        # Keep DCP collectives on the graph-compatible RCCL path.
-        VLLM_USE_DIRECT_DCP_A2A: '0'
-        VLLM_USE_DIRECT_DCP_Q_GATHER: '0'
-        VLLM_USE_DIRECT_DCP_KV_GATHER: '0'
-        VLLM_ENGINE_READY_TIMEOUT_S: '7200'
-        VLLM_EXECUTE_MODEL_TIMEOUT_SECONDS: '1200'
-        PYTHONNOUSERSITE: '1'
-        VLLM_SERVER_DEV_MODE: '0'
-        # Bound RDMA queue resources and the wait for available send slots.
-        MORI_IO_SQ_BACKOFF_TIMEOUT_US: '50000'
-        MORI_IO_QP_MAX_SEND_WR: '16384'
-        MORI_IO_QP_MAX_CQE: '32768'
-        MORI_IO_QP_MAX_SGE: '2'
-        MORI_IO_TC_DISABLE: '0'
-    decode:
-      nodes: 1
-      workers: 1
-      gpus: 8
-      args:
-        <<: *common_args
-        kv-transfer-config: '{"kv_connector":"MoRIIOConnector","kv_role":"kv_consumer","kv_load_failure_policy":"fail","kv_connector_extra_config":{"backend":"rdma"}}'
-      env: *common_env
-  benchmark:
-    placement:
-      node: head
-
-override_1p3d_c12:
-  roles:
-    prefill:
-      args:
-        max-num-seqs: 24
-        max-num-batched-tokens: 8192
-        compilation-config: '{"mode":3,"cudagraph_mode":"NONE","max_cudagraph_capture_size":0,"custom_ops":["+fused_rms_norm_gated","+quant_fp8","+grouped_topk","+sparse_attn_indexer","none"]}'
-      env:
-        HSA_NO_SCRATCH_RECLAIM: '0'
-    decode:
-      nodes: 3
-      workers: 3
-      args:
-        max-num-seqs: 8
-        max-num-batched-tokens: 512
-        compilation-config: '{"mode":3,"cudagraph_mode":"FULL_DECODE_ONLY","max_cudagraph_capture_size":40,"cudagraph_capture_sizes":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40],"custom_ops":["+fused_rms_norm_gated","+quant_fp8","+grouped_topk","+sparse_attn_indexer","none"]}'
-
-override_1p2d_c24: &tp8_c24
-  roles: &tp8_c24_roles
-    prefill:
-      args:
-        decode-context-parallel-size: 8
-        max-num-seqs: 48
-        max-num-batched-tokens: 8192
-        compilation-config: '{"mode":3,"cudagraph_mode":"NONE","max_cudagraph_capture_size":0,"custom_ops":["+fused_rms_norm_gated","+quant_fp8","+grouped_topk","+sparse_attn_indexer","none"]}'
-    decode: &tp8_c24_decode
-      nodes: 2
-      workers: 2
-      args: &tp8_c24_decode_args
-        decode-context-parallel-size: 8
-        max-num-seqs: 24
-        max-num-batched-tokens: 512
-        compilation-config: '{"mode":3,"cudagraph_mode":"FULL_DECODE_ONLY","max_cudagraph_capture_size":120,"cudagraph_capture_sizes":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,70,80,90,100,110,120],"custom_ops":["+fused_rms_norm_gated","+quant_fp8","+grouped_topk","+sparse_attn_indexer","none"]}'
-
-# Keep the c24 serving policy; scale only the decoder replicas and per-D limit.
-override_1p3d_c24:
-  <<: *tp8_c24
-  roles:
-    <<: *tp8_c24_roles
-    decode:
-      <<: *tp8_c24_decode
-      nodes: 3
-      workers: 3
-      args:
-        <<: *tp8_c24_decode_args
-        max-num-seqs: 16
-
-override_1p1d_c48: &tp8_c48
-  roles: &tp8_c48_roles
-    prefill: &tp8_c48_prefill
-      args: &tp8_c48_prefill_args
-        decode-context-parallel-size: 8
-        max-num-seqs: 96
-        max-num-batched-tokens: 8192
-        compilation-config: '{"mode":3,"cudagraph_mode":"NONE","max_cudagraph_capture_size":0,"custom_ops":["+fused_rms_norm_gated","+quant_fp8","+grouped_topk","+sparse_attn_indexer","none"]}'
-      env:
-        # Short-tail segmented MLA can require ~4.1 GB of non-reclaimable scratch.
-        HSA_NO_SCRATCH_RECLAIM: '0'
-    decode: &tp8_c48_decode
-      args: &tp8_c48_decode_args
-        decode-context-parallel-size: 8
-        max-num-seqs: 96
-        max-num-batched-tokens: 512
-        compilation-config: '{"mode":3,"cudagraph_mode":"FULL_DECODE_ONLY","max_cudagraph_capture_size":240,"cudagraph_capture_sizes":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,130,140,150,160,170,180,190,200,210,220,230,240],"custom_ops":["+fused_rms_norm_gated","+quant_fp8","+grouped_topk","+sparse_attn_indexer","none"]}'
-
-override_1p1d_c56:
-  <<: *tp8_c48
-  roles:
-    <<: *tp8_c48_roles
-    prefill:
-      <<: *tp8_c48_prefill
-      args:
-        <<: *tp8_c48_prefill_args
-        max-num-seqs: 112
-    decode:
-      <<: *tp8_c48_decode
-      args:
-        <<: *tp8_c48_decode_args
-        max-num-seqs: 112
-        compilation-config: '{"mode":3,"cudagraph_mode":"FULL_DECODE_ONLY","max_cudagraph_capture_size":280,"cudagraph_capture_sizes":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,130,140,150,160,170,180,190,200,210,220,230,240,250,260,270,280],"custom_ops":["+fused_rms_norm_gated","+quant_fp8","+grouped_topk","+sparse_attn_indexer","none"]}'
-
-override_1p2d_c48:
-  <<: *tp8_c48
-  roles:
-    <<: *tp8_c48_roles
-    decode:
-      <<: *tp8_c48_decode
-      nodes: 2
-      workers: 2
-      args:
-        <<: *tp8_c48_decode_args
-        max-num-seqs: 48
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/minimaxm31flash/sglang/gb300-fp4/agentx/agg-variants.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/minimaxm31flash/sglang/gb300-fp4/agentx/agg-variants.yaml
new file mode 100644
index 0000000000..f1df9ea6f9
--- /dev/null
+++ b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/minimaxm31flash/sglang/gb300-fp4/agentx/agg-variants.yaml
@@ -0,0 +1,216 @@
+schema: 2
+
+base:
+  name: minimaxm31flash-fp4-gb300-dynamo-sglang-agentx-agg
+  identity:
+    model: {}
+    frameworks:
+      dynamo: "1.7.0.dev20261030"
+      sglang: "0.0.0.dev1+ge3718813e"
+  dynamo:
+    install: false
+    request_plane: tcp
+    event_plane: zmq
+  environment:
+    HF_HUB_CACHE: /hf_hub_cache
+  observability:
+    tachometer:
+      enabled: false
+  slurm:
+    time_limit: "4:00:00"
+  health_check:
+    max_attempts: 1440
+    interval_seconds: 10
+  resources:
+    gpu_type: gb300
+    gpus_per_node: 4
+  services:
+    - name: etcd
+      type: etcd
+      placement:
+        node: infra
+    - name: otel-collector
+      type: otel-collector
+      enabled: false
+  frontend:
+    type: dynamo
+    enable_multiple_frontends: false
+    env:
+      DYN_ROUTER_TEMPERATURE: "0"
+      DYN_ROUTER_QUEUE_THRESHOLD: None
+      DYN_ROUTER_ACTIVE_REQUEST_EXPIRY_SECS: "3600"
+      DYN_TCP_CONNECT_TIMEOUT: "120"
+      DYN_TOKENIZER: "fastokens"
+      DYN_TOKENIZER_CACHE: "1"
+      DYN_TOKENIZER_CACHE_BYTES: "8000000000"
+    args:
+      router-mode: kv
+      router-session-affinity-ttl-secs: "14400"
+      active-decode-blocks-threshold: "None"
+      active-prefill-tokens-threshold: "None"
+      active-prefill-tokens-threshold-frac: "None"
+  engine: sglang
+  roles:
+    agg:
+      nodes: 1
+      workers: 1
+      gpus: 4
+      env:
+        PYTHONUNBUFFERED: "1"
+        PYTHONNOUSERSITE: "1"
+        FMHA_SM100_ALLOW_JIT: "1"
+        SGLANG_TIMEOUT_KEEP_ALIVE: "1800"
+        DYN_BACKEND_ADMISSION_ENGINE_REQUEST_LIMIT: "10000"
+        DYN_BACKEND_ADMISSION_ENGINE_REQUEST_WAITING_LIMIT: "10000"
+        DYN_BACKEND_ADMISSION_REQUEST_QUEUE_LIMIT: "10000"
+      args:
+        served-model-name: MiniMaxAI/MiniMax-M3.1-Flash
+        trust-remote-code: true
+        reasoning-parser: minimax-m3
+        tool-call-parser: minimax-m3
+        moe-runner-backend: flashinfer_trtllm_routed
+        speculative-algorithm: DSPARK
+        speculative-dspark-block-size: 7
+        speculative-use-block-verification: true
+        speculative-draft-kv-cache-dtype: fp8_e4m3
+        cuda-graph-backend-prefill: breakable
+        router-mode: kv
+        router-session-affinity-ttl-secs: "14400"
+        watchdog-timeout: 3600
+        enable-metrics: true
+      kv_events: true
+  benchmark:
+    env:
+      AIPERF_HTTP_X_DYNAMO_SESSION_ID_FROM_CORRELATION_ID: "true"
+      AIPERF_USE_DYNAMO_CONV_AWARE_ROUTING: "0"
+      AIPERF_REQUIRED_SERVER_METRIC_PREFIX: "sglang:"
+
+override_tp4_c1:
+  name: minimaxm31flash-fp4-gb300-dynamo-sglang-agentx-agg-tp4-c1
+  roles:
+    agg:
+      args:
+        tensor-parallel-size: 4
+        chunked-prefill-size: 32768
+        max-running-requests: 2
+        cuda-graph-max-bs-decode: 2
+        mem-fraction-static: 0.8
+
+override_tp4_monokernel_c1:
+  name: minimaxm31flash-fp4-gb300-dynamo-sglang-agentx-agg-tp4-monokernel-c1
+  roles:
+    agg:
+      env:
+        ALLOW_JIT: "1"
+        SGLANG_FORCE_COARSE_WAR_BARRIER: "1"
+      args:
+        tensor-parallel-size: 4
+        chunked-prefill-size: 32768
+        page-size: 128
+        speculative-num-steps: 1
+        speculative-eagle-topk: 1
+        speculative-num-draft-tokens: 8
+        speculative-draft-kv-cache-dtype: auto
+        enable-nvidia-megakernel: true
+        disable-attn-tp-gather: true
+        max-running-requests: 8
+        cuda-graph-max-bs-decode: 8
+        mem-fraction-static: 0.8
+
+override_tp4_c4:
+  name: minimaxm31flash-fp4-gb300-dynamo-sglang-agentx-agg-tp4-c4
+  roles:
+    agg:
+      args:
+        tensor-parallel-size: 4
+        chunked-prefill-size: 32768
+        max-running-requests: 8
+        cuda-graph-max-bs-decode: 8
+        mem-fraction-static: 0.8
+
+override_tp4_c8:
+  name: minimaxm31flash-fp4-gb300-dynamo-sglang-agentx-agg-tp4-c8
+  roles:
+    agg:
+      args:
+        tensor-parallel-size: 4
+        chunked-prefill-size: 32768
+        max-running-requests: 16
+        cuda-graph-max-bs-decode: 16
+        mem-fraction-static: 0.8
+
+override_tp4_c16:
+  name: minimaxm31flash-fp4-gb300-dynamo-sglang-agentx-agg-tp4-c16
+  roles:
+    agg:
+      args:
+        tensor-parallel-size: 4
+        chunked-prefill-size: 32768
+        max-running-requests: 32
+        cuda-graph-max-bs-decode: 32
+        mem-fraction-static: 0.8
+
+override_tp4_hicache_spf_c24:
+  name: minimaxm31flash-fp4-gb300-dynamo-sglang-agentx-agg-tp4-hicache-spf-c24
+  roles:
+    agg:
+      args:
+        tensor-parallel-size: 4
+        chunked-prefill-size: 8192
+        max-running-requests: 48
+        cuda-graph-max-bs-decode: 48
+        mem-fraction-static: 0.87
+        enable-hierarchical-cache: true
+        hicache-size: 180
+        hicache-write-policy: write_back
+        schedule-policy: shortest-prefill-first
+        prefill-decode-interval: 32
+        stream-interval: 20
+
+override_tp2_hicache_spf_c40:
+  name: minimaxm31flash-fp4-gb300-dynamo-sglang-agentx-agg-tp2-hicache-spf-c40
+  roles:
+    agg:
+      gpus: 2
+      args:
+        tensor-parallel-size: 2
+        chunked-prefill-size: 8192
+        max-running-requests: 80
+        cuda-graph-max-bs-decode: 80
+        mem-fraction-static: 0.87
+        enable-hierarchical-cache: true
+        hicache-size: 180
+        hicache-write-policy: write_back
+        schedule-policy: shortest-prefill-first
+        prefill-decode-interval: 32
+        stream-interval: 20
+
+override_tp2_hicache_c40:
+  name: minimaxm31flash-fp4-gb300-dynamo-sglang-agentx-agg-tp2-hicache-c40
+  roles:
+    agg:
+      gpus: 2
+      args:
+        tensor-parallel-size: 2
+        chunked-prefill-size: 32768
+        max-running-requests: 80
+        cuda-graph-max-bs-decode: 80
+        mem-fraction-static: 0.87
+        enable-hierarchical-cache: true
+        hicache-size: 180
+        hicache-write-policy: write_back
+
+override_tp2_hicache_c44:
+  name: minimaxm31flash-fp4-gb300-dynamo-sglang-agentx-agg-tp2-hicache-c44
+  roles:
+    agg:
+      gpus: 2
+      args:
+        tensor-parallel-size: 2
+        chunked-prefill-size: 32768
+        max-running-requests: 88
+        cuda-graph-max-bs-decode: 88
+        mem-fraction-static: 0.87
+        enable-hierarchical-cache: true
+        hicache-size: 180
+        hicache-write-policy: write_back
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/minimaxm31flash/sglang/gb300-fp4/agentx/disagg-variants.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/minimaxm31flash/sglang/gb300-fp4/agentx/disagg-variants.yaml
index fe188169f1..16aaa73769 100644
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/minimaxm31flash/sglang/gb300-fp4/agentx/disagg-variants.yaml
+++ b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/minimaxm31flash/sglang/gb300-fp4/agentx/disagg-variants.yaml
@@ -97,7 +97,7 @@ base:
         # flashinfer_trtllm_routed needs attention TP to match EP, which attention DP breaks.
         moe-a2a-backend: megamoe
         disaggregation-transfer-backend: mooncake
-        chunked-prefill-size: 8192
+        chunked-prefill-size: 16384
         # Shortest uncached prefill first: short cached turns stop queueing
         # behind long uncached prompts, which cuts the TTFT tail.
         schedule-policy: shortest-prefill-first
@@ -186,6 +186,20 @@ base:
       AIPERF_USE_DYNAMO_CONV_AWARE_ROUTING: "0"
       AIPERF_REQUIRED_SERVER_METRIC_PREFIX: "sglang:"
 
+override_4p_dep2_dep8:
+  name: minimaxm31flash-fp4-gb300-dynamo-sglang-agentx-disagg-4p-dep2-dep8
+  roles:
+    prefill:
+      nodes: 2
+      workers: 4
+
+override_8p_dep2_dep8:
+  name: minimaxm31flash-fp4-gb300-dynamo-sglang-agentx-disagg-8p-dep2-dep8
+  roles:
+    prefill:
+      nodes: 4
+      workers: 8
+
 override_6p_dep2_dep8:
   name: minimaxm31flash-fp4-gb300-dynamo-sglang-agentx-disagg-6p-dep2-dep8
 
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp4-v2/8k1k/mtp/1p1d-tp4-tp4-c1.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp4-v2/8k1k/mtp/1p1d-tp4-tp4-c1.yaml
deleted file mode 100644
index 20609e1a05..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp4-v2/8k1k/mtp/1p1d-tp4-tp4-c1.yaml
+++ /dev/null
@@ -1,155 +0,0 @@
-schema: 2
-name: qwen35-v2-gb200-c1-1p1d-tp4-mtp3-baseline
-dynamo:
-  install: false
-frontend:
-  type: dynamo
-  enable_multiple_frontends: false
-  args:
-    enforce-disagg: true
-resources:
-  gpu_type: gb200
-  gpus_per_node: 4
-engine: sglang
-roles:
-  prefill:
-    nodes: 1
-    workers: 1
-    env:
-      NO_COLOR: '1'
-      PYTHONUNBUFFERED: '1'
-      HF_HUB_OFFLINE: '1'
-      TRANSFORMERS_OFFLINE: '1'
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: '3600'
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: '3600'
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: '3600'
-      NCCL_MNNVL_ENABLE: '1'
-      NCCL_NVLS_ENABLE: '0'
-      NCCL_CUMEM_ENABLE: '1'
-      MC_FORCE_MNNVL: '1'
-      SGLANG_ENABLE_SPEC_V2: '1'
-      SGLANG_DG_CACHE_DIR: /configs/deepgemm-cache
-      FLASHINFER_WORKSPACE_BASE: /configs/flashinfer-cache
-      SGLANG_ENABLE_JIT_DEEPGEMM: 'true'
-      SGLANG_ENABLE_FLASHINFER_GEMM: 'true'
-      FLASHINFER_DISABLE_VERSION_CHECK: '1'
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: '100000'
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: '100000'
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: '100000'
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: 'True'
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: '0'
-      SGLANG_DISABLE_TP_MEMORY_INBALANCE_CHECK: '1'
-      SGLANG_HEALTH_CHECK_TIMEOUT: '3600'
-      SGLANG_HEALTH_STARTING_OK: '1'
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: '0'
-    args:
-      served-model-name: nvidia/Qwen3.5-397B-A17B-NVFP4-V2
-      model-path: /model
-      trust-remote-code: true
-      reasoning-parser: qwen3
-      tool-call-parser: qwen3_coder
-      quantization: modelopt_mixed
-      fp4-gemm-backend: flashinfer_cutlass
-      kv-cache-dtype: fp8_e4m3
-      tensor-parallel-size: 4
-      data-parallel-size: 1
-      expert-parallel-size: 1
-      mamba-scheduler-strategy: no_buffer
-      mamba-ssm-dtype: bfloat16
-      mamba-track-interval: 2048
-      attention-backend: trtllm_mha
-      mm-attention-backend: triton_attn
-      moe-runner-backend: flashinfer_trtllm
-      linear-attn-decode-backend: flashinfer
-      disaggregation-mode: prefill
-      disaggregation-transfer-backend: mooncake
-      disaggregation-bootstrap-port: 31000
-      disable-radix-cache: true
-      mem-fraction-static: 0.8
-      context-length: 9236
-      max-total-tokens: 128000
-      max-running-requests: 128
-      cuda-graph-max-bs: 4
-      chunked-prefill-size: 32768
-      max-prefill-tokens: 32768
-      scheduler-recv-interval: 10
-      stream-interval: 30
-      load-balance-method: round_robin
-      page-size: 64
-      watchdog-timeout: 1000000
-      log-level: info
-  decode:
-    nodes: 1
-    workers: 1
-    env:
-      NO_COLOR: '1'
-      PYTHONUNBUFFERED: '1'
-      HF_HUB_OFFLINE: '1'
-      TRANSFORMERS_OFFLINE: '1'
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: '3600'
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: '3600'
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: '3600'
-      NCCL_MNNVL_ENABLE: '1'
-      NCCL_NVLS_ENABLE: '0'
-      NCCL_CUMEM_ENABLE: '1'
-      MC_FORCE_MNNVL: '1'
-      MC_TE_METRIC: 'true'
-      SGLANG_ENABLE_SPEC_V2: '1'
-      SGLANG_DG_CACHE_DIR: /configs/deepgemm-cache
-      FLASHINFER_WORKSPACE_BASE: /configs/flashinfer-cache
-      SGLANG_ENABLE_JIT_DEEPGEMM: 'true'
-      SGLANG_ENABLE_FLASHINFER_GEMM: 'true'
-      FLASHINFER_DISABLE_VERSION_CHECK: '1'
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: '100000'
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: '100000'
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: '100000'
-      SGLANG_DECODE_BOOTSTRAP_TIMEOUT: '1000'
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: 'True'
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: '0'
-      SGLANG_DISABLE_TP_MEMORY_INBALANCE_CHECK: '1'
-      SGLANG_HEALTH_CHECK_TIMEOUT: '3600'
-      SGLANG_HEALTH_STARTING_OK: '1'
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: '0'
-    args:
-      served-model-name: nvidia/Qwen3.5-397B-A17B-NVFP4-V2
-      model-path: /model
-      trust-remote-code: true
-      reasoning-parser: qwen3
-      tool-call-parser: qwen3_coder
-      quantization: modelopt_mixed
-      fp4-gemm-backend: flashinfer_cutlass
-      kv-cache-dtype: fp8_e4m3
-      tensor-parallel-size: 4
-      data-parallel-size: 1
-      expert-parallel-size: 1
-      mamba-scheduler-strategy: no_buffer
-      mamba-ssm-dtype: bfloat16
-      mamba-track-interval: 128
-      attention-backend: trtllm_mha
-      mm-attention-backend: triton_attn
-      moe-runner-backend: flashinfer_trtllm
-      linear-attn-decode-backend: flashinfer
-      speculative-algorithm: NEXTN
-      speculative-num-steps: 3
-      speculative-eagle-topk: 1
-      speculative-num-draft-tokens: 4
-      disaggregation-mode: decode
-      disaggregation-transfer-backend: mooncake
-      disaggregation-bootstrap-port: 31000
-      disable-radix-cache: true
-      mem-fraction-static: 0.8
-      context-length: 9236
-      max-total-tokens: 1500000
-      max-mamba-cache-size: 256
-      max-running-requests: 128
-      cuda-graph-max-bs: 256
-      chunked-prefill-size: 32768
-      max-prefill-tokens: 32768
-      scheduler-recv-interval: 10
-      stream-interval: 30
-      page-size: 64
-      watchdog-timeout: 1000000
-      decode-log-interval: 1
-health_check:
-  max_attempts: 240
-  interval_seconds: 10
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp4-v2/8k1k/mtp/1p1d-tp4-tp4-c4.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp4-v2/8k1k/mtp/1p1d-tp4-tp4-c4.yaml
deleted file mode 100644
index 398b96f45c..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp4-v2/8k1k/mtp/1p1d-tp4-tp4-c4.yaml
+++ /dev/null
@@ -1,155 +0,0 @@
-schema: 2
-name: qwen35-v2-gb200-c4-1p1d-tp4-mtp3-prefill-recv1
-dynamo:
-  install: false
-frontend:
-  type: dynamo
-  enable_multiple_frontends: false
-  args:
-    enforce-disagg: true
-resources:
-  gpu_type: gb200
-  gpus_per_node: 4
-engine: sglang
-roles:
-  prefill:
-    nodes: 1
-    workers: 1
-    env:
-      NO_COLOR: '1'
-      PYTHONUNBUFFERED: '1'
-      HF_HUB_OFFLINE: '1'
-      TRANSFORMERS_OFFLINE: '1'
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: '3600'
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: '3600'
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: '3600'
-      NCCL_MNNVL_ENABLE: '1'
-      NCCL_NVLS_ENABLE: '0'
-      NCCL_CUMEM_ENABLE: '1'
-      MC_FORCE_MNNVL: '1'
-      SGLANG_ENABLE_SPEC_V2: '1'
-      SGLANG_DG_CACHE_DIR: /configs/deepgemm-cache
-      FLASHINFER_WORKSPACE_BASE: /configs/flashinfer-cache
-      SGLANG_ENABLE_JIT_DEEPGEMM: 'true'
-      SGLANG_ENABLE_FLASHINFER_GEMM: 'true'
-      FLASHINFER_DISABLE_VERSION_CHECK: '1'
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: '100000'
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: '100000'
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: '100000'
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: 'True'
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: '0'
-      SGLANG_DISABLE_TP_MEMORY_INBALANCE_CHECK: '1'
-      SGLANG_HEALTH_CHECK_TIMEOUT: '3600'
-      SGLANG_HEALTH_STARTING_OK: '1'
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: '0'
-    args:
-      served-model-name: nvidia/Qwen3.5-397B-A17B-NVFP4-V2
-      model-path: /model
-      trust-remote-code: true
-      reasoning-parser: qwen3
-      tool-call-parser: qwen3_coder
-      quantization: modelopt_mixed
-      fp4-gemm-backend: flashinfer_cutlass
-      kv-cache-dtype: fp8_e4m3
-      tensor-parallel-size: 4
-      data-parallel-size: 1
-      expert-parallel-size: 1
-      mamba-scheduler-strategy: no_buffer
-      mamba-ssm-dtype: bfloat16
-      mamba-track-interval: 2048
-      attention-backend: trtllm_mha
-      mm-attention-backend: triton_attn
-      moe-runner-backend: flashinfer_trtllm
-      linear-attn-decode-backend: flashinfer
-      disaggregation-mode: prefill
-      disaggregation-transfer-backend: mooncake
-      disaggregation-bootstrap-port: 31000
-      disable-radix-cache: true
-      mem-fraction-static: 0.8
-      context-length: 9236
-      max-total-tokens: 128000
-      max-running-requests: 128
-      cuda-graph-max-bs: 4
-      chunked-prefill-size: 32768
-      max-prefill-tokens: 32768
-      scheduler-recv-interval: 1
-      stream-interval: 30
-      load-balance-method: round_robin
-      page-size: 64
-      watchdog-timeout: 1000000
-      log-level: info
-  decode:
-    nodes: 1
-    workers: 1
-    env:
-      NO_COLOR: '1'
-      PYTHONUNBUFFERED: '1'
-      HF_HUB_OFFLINE: '1'
-      TRANSFORMERS_OFFLINE: '1'
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: '3600'
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: '3600'
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: '3600'
-      NCCL_MNNVL_ENABLE: '1'
-      NCCL_NVLS_ENABLE: '0'
-      NCCL_CUMEM_ENABLE: '1'
-      MC_FORCE_MNNVL: '1'
-      MC_TE_METRIC: 'true'
-      SGLANG_ENABLE_SPEC_V2: '1'
-      SGLANG_DG_CACHE_DIR: /configs/deepgemm-cache
-      FLASHINFER_WORKSPACE_BASE: /configs/flashinfer-cache
-      SGLANG_ENABLE_JIT_DEEPGEMM: 'true'
-      SGLANG_ENABLE_FLASHINFER_GEMM: 'true'
-      FLASHINFER_DISABLE_VERSION_CHECK: '1'
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: '100000'
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: '100000'
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: '100000'
-      SGLANG_DECODE_BOOTSTRAP_TIMEOUT: '1000'
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: 'True'
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: '0'
-      SGLANG_DISABLE_TP_MEMORY_INBALANCE_CHECK: '1'
-      SGLANG_HEALTH_CHECK_TIMEOUT: '3600'
-      SGLANG_HEALTH_STARTING_OK: '1'
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: '0'
-    args:
-      served-model-name: nvidia/Qwen3.5-397B-A17B-NVFP4-V2
-      model-path: /model
-      trust-remote-code: true
-      reasoning-parser: qwen3
-      tool-call-parser: qwen3_coder
-      quantization: modelopt_mixed
-      fp4-gemm-backend: flashinfer_cutlass
-      kv-cache-dtype: fp8_e4m3
-      tensor-parallel-size: 4
-      data-parallel-size: 1
-      expert-parallel-size: 1
-      mamba-scheduler-strategy: no_buffer
-      mamba-ssm-dtype: bfloat16
-      mamba-track-interval: 128
-      attention-backend: trtllm_mha
-      mm-attention-backend: triton_attn
-      moe-runner-backend: flashinfer_trtllm
-      linear-attn-decode-backend: flashinfer
-      speculative-algorithm: NEXTN
-      speculative-num-steps: 3
-      speculative-eagle-topk: 1
-      speculative-num-draft-tokens: 4
-      disaggregation-mode: decode
-      disaggregation-transfer-backend: mooncake
-      disaggregation-bootstrap-port: 31000
-      disable-radix-cache: true
-      mem-fraction-static: 0.8
-      context-length: 9236
-      max-total-tokens: 1500000
-      max-mamba-cache-size: 256
-      max-running-requests: 128
-      cuda-graph-max-bs: 256
-      chunked-prefill-size: 32768
-      max-prefill-tokens: 32768
-      scheduler-recv-interval: 10
-      stream-interval: 30
-      page-size: 64
-      watchdog-timeout: 1000000
-      decode-log-interval: 1
-health_check:
-  max_attempts: 240
-  interval_seconds: 10
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp4-v2/8k1k/mtp/1p1d-tp4-tp4-c8.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp4-v2/8k1k/mtp/1p1d-tp4-tp4-c8.yaml
deleted file mode 100644
index 236b708130..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp4-v2/8k1k/mtp/1p1d-tp4-tp4-c8.yaml
+++ /dev/null
@@ -1,155 +0,0 @@
-schema: 2
-name: qwen35-v2-gb200-c8-1p1d-tp4-mtp3-decode-stream50
-dynamo:
-  install: false
-frontend:
-  type: dynamo
-  enable_multiple_frontends: false
-  args:
-    enforce-disagg: true
-resources:
-  gpu_type: gb200
-  gpus_per_node: 4
-engine: sglang
-roles:
-  prefill:
-    nodes: 1
-    workers: 1
-    env:
-      NO_COLOR: '1'
-      PYTHONUNBUFFERED: '1'
-      HF_HUB_OFFLINE: '1'
-      TRANSFORMERS_OFFLINE: '1'
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: '3600'
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: '3600'
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: '3600'
-      NCCL_MNNVL_ENABLE: '1'
-      NCCL_NVLS_ENABLE: '0'
-      NCCL_CUMEM_ENABLE: '1'
-      MC_FORCE_MNNVL: '1'
-      SGLANG_ENABLE_SPEC_V2: '1'
-      SGLANG_DG_CACHE_DIR: /configs/deepgemm-cache
-      FLASHINFER_WORKSPACE_BASE: /configs/flashinfer-cache
-      SGLANG_ENABLE_JIT_DEEPGEMM: 'true'
-      SGLANG_ENABLE_FLASHINFER_GEMM: 'true'
-      FLASHINFER_DISABLE_VERSION_CHECK: '1'
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: '100000'
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: '100000'
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: '100000'
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: 'True'
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: '0'
-      SGLANG_DISABLE_TP_MEMORY_INBALANCE_CHECK: '1'
-      SGLANG_HEALTH_CHECK_TIMEOUT: '3600'
-      SGLANG_HEALTH_STARTING_OK: '1'
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: '0'
-    args:
-      served-model-name: nvidia/Qwen3.5-397B-A17B-NVFP4-V2
-      model-path: /model
-      trust-remote-code: true
-      reasoning-parser: qwen3
-      tool-call-parser: qwen3_coder
-      quantization: modelopt_mixed
-      fp4-gemm-backend: flashinfer_cutlass
-      kv-cache-dtype: fp8_e4m3
-      tensor-parallel-size: 4
-      data-parallel-size: 1
-      expert-parallel-size: 1
-      mamba-scheduler-strategy: no_buffer
-      mamba-ssm-dtype: bfloat16
-      mamba-track-interval: 2048
-      attention-backend: trtllm_mha
-      mm-attention-backend: triton_attn
-      moe-runner-backend: flashinfer_trtllm
-      linear-attn-decode-backend: flashinfer
-      disaggregation-mode: prefill
-      disaggregation-transfer-backend: mooncake
-      disaggregation-bootstrap-port: 31000
-      disable-radix-cache: true
-      mem-fraction-static: 0.8
-      context-length: 9236
-      max-total-tokens: 128000
-      max-running-requests: 128
-      cuda-graph-max-bs: 4
-      chunked-prefill-size: 32768
-      max-prefill-tokens: 32768
-      scheduler-recv-interval: 10
-      stream-interval: 30
-      load-balance-method: round_robin
-      page-size: 64
-      watchdog-timeout: 1000000
-      log-level: info
-  decode:
-    nodes: 1
-    workers: 1
-    env:
-      NO_COLOR: '1'
-      PYTHONUNBUFFERED: '1'
-      HF_HUB_OFFLINE: '1'
-      TRANSFORMERS_OFFLINE: '1'
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: '3600'
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: '3600'
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: '3600'
-      NCCL_MNNVL_ENABLE: '1'
-      NCCL_NVLS_ENABLE: '0'
-      NCCL_CUMEM_ENABLE: '1'
-      MC_FORCE_MNNVL: '1'
-      MC_TE_METRIC: 'true'
-      SGLANG_ENABLE_SPEC_V2: '1'
-      SGLANG_DG_CACHE_DIR: /configs/deepgemm-cache
-      FLASHINFER_WORKSPACE_BASE: /configs/flashinfer-cache
-      SGLANG_ENABLE_JIT_DEEPGEMM: 'true'
-      SGLANG_ENABLE_FLASHINFER_GEMM: 'true'
-      FLASHINFER_DISABLE_VERSION_CHECK: '1'
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: '100000'
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: '100000'
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: '100000'
-      SGLANG_DECODE_BOOTSTRAP_TIMEOUT: '1000'
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: 'True'
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: '0'
-      SGLANG_DISABLE_TP_MEMORY_INBALANCE_CHECK: '1'
-      SGLANG_HEALTH_CHECK_TIMEOUT: '3600'
-      SGLANG_HEALTH_STARTING_OK: '1'
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: '0'
-    args:
-      served-model-name: nvidia/Qwen3.5-397B-A17B-NVFP4-V2
-      model-path: /model
-      trust-remote-code: true
-      reasoning-parser: qwen3
-      tool-call-parser: qwen3_coder
-      quantization: modelopt_mixed
-      fp4-gemm-backend: flashinfer_cutlass
-      kv-cache-dtype: fp8_e4m3
-      tensor-parallel-size: 4
-      data-parallel-size: 1
-      expert-parallel-size: 1
-      mamba-scheduler-strategy: no_buffer
-      mamba-ssm-dtype: bfloat16
-      mamba-track-interval: 128
-      attention-backend: trtllm_mha
-      mm-attention-backend: triton_attn
-      moe-runner-backend: flashinfer_trtllm
-      linear-attn-decode-backend: flashinfer
-      speculative-algorithm: NEXTN
-      speculative-num-steps: 3
-      speculative-eagle-topk: 1
-      speculative-num-draft-tokens: 4
-      disaggregation-mode: decode
-      disaggregation-transfer-backend: mooncake
-      disaggregation-bootstrap-port: 31000
-      disable-radix-cache: true
-      mem-fraction-static: 0.8
-      context-length: 9236
-      max-total-tokens: 1500000
-      max-mamba-cache-size: 256
-      max-running-requests: 128
-      cuda-graph-max-bs: 256
-      chunked-prefill-size: 32768
-      max-prefill-tokens: 32768
-      scheduler-recv-interval: 10
-      stream-interval: 50
-      page-size: 64
-      watchdog-timeout: 1000000
-      decode-log-interval: 1
-health_check:
-  max_attempts: 240
-  interval_seconds: 10
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp4-v2/8k1k/mtp/2p2d-tp2-tp2-c512.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp4-v2/8k1k/mtp/2p2d-tp2-tp2-c512.yaml
deleted file mode 100644
index 8f5268d60e..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp4-v2/8k1k/mtp/2p2d-tp2-tp2-c512.yaml
+++ /dev/null
@@ -1,158 +0,0 @@
-schema: 2
-name: qwen35-v2-gb200-c512-2p2d-tp2-mtp3-cap84
-dynamo:
-  install: false
-frontend:
-  type: dynamo
-  enable_multiple_frontends: false
-  env:
-    ETCD_LEASE_TTL: '120'
-  args:
-    enforce-disagg: true
-resources:
-  gpu_type: gb200
-  gpus_per_node: 2
-  spread_workers: true
-engine: sglang
-roles:
-  prefill:
-    nodes: 2
-    workers: 2
-    env:
-      NO_COLOR: '1'
-      PYTHONUNBUFFERED: '1'
-      ETCD_LEASE_TTL: '120'
-      HF_HUB_OFFLINE: '1'
-      TRANSFORMERS_OFFLINE: '1'
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: '3600'
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: '3600'
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: '3600'
-      NCCL_MNNVL_ENABLE: '1'
-      NCCL_NVLS_ENABLE: '0'
-      NCCL_CUMEM_ENABLE: '1'
-      MC_FORCE_MNNVL: '1'
-      SGLANG_ENABLE_SPEC_V2: '1'
-      SGLANG_DG_CACHE_DIR: /configs/deepgemm-cache
-      FLASHINFER_WORKSPACE_BASE: /configs/flashinfer-cache
-      SGLANG_ENABLE_JIT_DEEPGEMM: 'true'
-      SGLANG_ENABLE_FLASHINFER_GEMM: 'true'
-      FLASHINFER_DISABLE_VERSION_CHECK: '1'
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: '100000'
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: '100000'
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: '100000'
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: 'True'
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: '0'
-      SGLANG_DISABLE_TP_MEMORY_INBALANCE_CHECK: '1'
-      SGLANG_HEALTH_CHECK_TIMEOUT: '3600'
-      SGLANG_HEALTH_STARTING_OK: '1'
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: '0'
-    args:
-      served-model-name: nvidia/Qwen3.5-397B-A17B-NVFP4-V2
-      model-path: /model
-      trust-remote-code: true
-      reasoning-parser: qwen3
-      tool-call-parser: qwen3_coder
-      quantization: modelopt_mixed
-      fp4-gemm-backend: flashinfer_cutlass
-      kv-cache-dtype: fp8_e4m3
-      tensor-parallel-size: 2
-      data-parallel-size: 1
-      expert-parallel-size: 1
-      mamba-scheduler-strategy: no_buffer
-      mamba-ssm-dtype: bfloat16
-      mamba-track-interval: 2048
-      attention-backend: trtllm_mha
-      mm-attention-backend: triton_attn
-      moe-runner-backend: flashinfer_trtllm
-      linear-attn-decode-backend: flashinfer
-      disaggregation-mode: prefill
-      disaggregation-transfer-backend: mooncake
-      disable-radix-cache: true
-      mem-fraction-static: 0.8
-      context-length: 9236
-      max-total-tokens: 64000
-      max-running-requests: 64
-      cuda-graph-max-bs: 4
-      chunked-prefill-size: 16384
-      max-prefill-tokens: 16384
-      scheduler-recv-interval: 10
-      stream-interval: 30
-      load-balance-method: round_robin
-      page-size: 64
-      watchdog-timeout: 1000000
-      log-level: info
-  decode:
-    nodes: 2
-    workers: 2
-    env:
-      NO_COLOR: '1'
-      PYTHONUNBUFFERED: '1'
-      ETCD_LEASE_TTL: '120'
-      HF_HUB_OFFLINE: '1'
-      TRANSFORMERS_OFFLINE: '1'
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: '3600'
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: '3600'
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: '3600'
-      NCCL_MNNVL_ENABLE: '1'
-      NCCL_NVLS_ENABLE: '0'
-      NCCL_CUMEM_ENABLE: '1'
-      MC_FORCE_MNNVL: '1'
-      MC_TE_METRIC: 'true'
-      SGLANG_ENABLE_SPEC_V2: '1'
-      SGLANG_DG_CACHE_DIR: /configs/deepgemm-cache
-      FLASHINFER_WORKSPACE_BASE: /configs/flashinfer-cache
-      SGLANG_ENABLE_JIT_DEEPGEMM: 'true'
-      SGLANG_ENABLE_FLASHINFER_GEMM: 'true'
-      FLASHINFER_DISABLE_VERSION_CHECK: '1'
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: '100000'
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: '100000'
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: '100000'
-      SGLANG_DECODE_BOOTSTRAP_TIMEOUT: '1000'
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: 'True'
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: '0'
-      SGLANG_DISABLE_TP_MEMORY_INBALANCE_CHECK: '1'
-      SGLANG_HEALTH_CHECK_TIMEOUT: '3600'
-      SGLANG_HEALTH_STARTING_OK: '1'
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: '0'
-    args:
-      served-model-name: nvidia/Qwen3.5-397B-A17B-NVFP4-V2
-      model-path: /model
-      trust-remote-code: true
-      reasoning-parser: qwen3
-      tool-call-parser: qwen3_coder
-      quantization: modelopt_mixed
-      fp4-gemm-backend: flashinfer_cutlass
-      kv-cache-dtype: fp8_e4m3
-      tensor-parallel-size: 2
-      data-parallel-size: 1
-      expert-parallel-size: 1
-      mamba-scheduler-strategy: no_buffer
-      mamba-ssm-dtype: bfloat16
-      mamba-track-interval: 128
-      attention-backend: trtllm_mha
-      mm-attention-backend: triton_attn
-      moe-runner-backend: flashinfer_trtllm
-      linear-attn-decode-backend: flashinfer
-      speculative-algorithm: NEXTN
-      speculative-num-steps: 3
-      speculative-eagle-topk: 1
-      speculative-num-draft-tokens: 4
-      disaggregation-mode: decode
-      disaggregation-transfer-backend: mooncake
-      disable-radix-cache: true
-      mem-fraction-static: 0.8
-      context-length: 9236
-      max-total-tokens: 750000
-      max-mamba-cache-size: 128
-      max-running-requests: 84
-      cuda-graph-max-bs: 88
-      chunked-prefill-size: 32768
-      max-prefill-tokens: 32768
-      scheduler-recv-interval: 10
-      stream-interval: 30
-      page-size: 64
-      watchdog-timeout: 1000000
-      decode-log-interval: 1
-health_check:
-  max_attempts: 240
-  interval_seconds: 10
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp4-v2/8k1k/mtp/2p3d-tp2-tp2-c768.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp4-v2/8k1k/mtp/2p3d-tp2-tp2-c768.yaml
deleted file mode 100644
index 947d18fc6d..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp4-v2/8k1k/mtp/2p3d-tp2-tp2-c768.yaml
+++ /dev/null
@@ -1,154 +0,0 @@
-schema: 2
-name: qwen35-v2-gb200-c768-2p3d-tp2-mtp3-cap86
-dynamo:
-  install: false
-frontend:
-  type: dynamo
-  enable_multiple_frontends: false
-  args:
-    enforce-disagg: true
-resources:
-  gpu_type: gb200
-  gpus_per_node: 2
-  spread_workers: true
-engine: sglang
-roles:
-  prefill:
-    nodes: 2
-    workers: 2
-    env:
-      NO_COLOR: '1'
-      PYTHONUNBUFFERED: '1'
-      HF_HUB_OFFLINE: '1'
-      TRANSFORMERS_OFFLINE: '1'
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: '3600'
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: '3600'
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: '3600'
-      NCCL_MNNVL_ENABLE: '1'
-      NCCL_NVLS_ENABLE: '0'
-      NCCL_CUMEM_ENABLE: '1'
-      MC_FORCE_MNNVL: '1'
-      SGLANG_ENABLE_SPEC_V2: '1'
-      SGLANG_DG_CACHE_DIR: /configs/deepgemm-cache
-      FLASHINFER_WORKSPACE_BASE: /configs/flashinfer-cache
-      SGLANG_ENABLE_JIT_DEEPGEMM: 'true'
-      SGLANG_ENABLE_FLASHINFER_GEMM: 'true'
-      FLASHINFER_DISABLE_VERSION_CHECK: '1'
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: '100000'
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: '100000'
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: '100000'
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: 'True'
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: '0'
-      SGLANG_DISABLE_TP_MEMORY_INBALANCE_CHECK: '1'
-      SGLANG_HEALTH_CHECK_TIMEOUT: '3600'
-      SGLANG_HEALTH_STARTING_OK: '1'
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: '0'
-    args:
-      served-model-name: nvidia/Qwen3.5-397B-A17B-NVFP4-V2
-      model-path: /model
-      trust-remote-code: true
-      reasoning-parser: qwen3
-      tool-call-parser: qwen3_coder
-      quantization: modelopt_mixed
-      fp4-gemm-backend: flashinfer_cutlass
-      kv-cache-dtype: fp8_e4m3
-      tensor-parallel-size: 2
-      data-parallel-size: 1
-      expert-parallel-size: 1
-      mamba-scheduler-strategy: no_buffer
-      mamba-ssm-dtype: bfloat16
-      mamba-track-interval: 2048
-      attention-backend: trtllm_mha
-      mm-attention-backend: triton_attn
-      moe-runner-backend: flashinfer_trtllm
-      linear-attn-decode-backend: flashinfer
-      disaggregation-mode: prefill
-      disaggregation-transfer-backend: mooncake
-      disable-radix-cache: true
-      mem-fraction-static: 0.8
-      context-length: 9236
-      max-total-tokens: 64000
-      max-running-requests: 64
-      cuda-graph-max-bs: 4
-      chunked-prefill-size: 16384
-      max-prefill-tokens: 16384
-      scheduler-recv-interval: 10
-      stream-interval: 30
-      load-balance-method: round_robin
-      page-size: 64
-      watchdog-timeout: 1000000
-      log-level: info
-  decode:
-    nodes: 3
-    workers: 3
-    env:
-      NO_COLOR: '1'
-      PYTHONUNBUFFERED: '1'
-      HF_HUB_OFFLINE: '1'
-      TRANSFORMERS_OFFLINE: '1'
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: '3600'
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: '3600'
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: '3600'
-      NCCL_MNNVL_ENABLE: '1'
-      NCCL_NVLS_ENABLE: '0'
-      NCCL_CUMEM_ENABLE: '1'
-      MC_FORCE_MNNVL: '1'
-      MC_TE_METRIC: 'true'
-      SGLANG_ENABLE_SPEC_V2: '1'
-      SGLANG_DG_CACHE_DIR: /configs/deepgemm-cache
-      FLASHINFER_WORKSPACE_BASE: /configs/flashinfer-cache
-      SGLANG_ENABLE_JIT_DEEPGEMM: 'true'
-      SGLANG_ENABLE_FLASHINFER_GEMM: 'true'
-      FLASHINFER_DISABLE_VERSION_CHECK: '1'
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: '100000'
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: '100000'
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: '100000'
-      SGLANG_DECODE_BOOTSTRAP_TIMEOUT: '1000'
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: 'True'
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: '0'
-      SGLANG_DISABLE_TP_MEMORY_INBALANCE_CHECK: '1'
-      SGLANG_HEALTH_CHECK_TIMEOUT: '3600'
-      SGLANG_HEALTH_STARTING_OK: '1'
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: '0'
-    args:
-      served-model-name: nvidia/Qwen3.5-397B-A17B-NVFP4-V2
-      model-path: /model
-      trust-remote-code: true
-      reasoning-parser: qwen3
-      tool-call-parser: qwen3_coder
-      quantization: modelopt_mixed
-      fp4-gemm-backend: flashinfer_cutlass
-      kv-cache-dtype: fp8_e4m3
-      tensor-parallel-size: 2
-      data-parallel-size: 1
-      expert-parallel-size: 1
-      mamba-scheduler-strategy: no_buffer
-      mamba-ssm-dtype: bfloat16
-      mamba-track-interval: 128
-      attention-backend: trtllm_mha
-      mm-attention-backend: triton_attn
-      moe-runner-backend: flashinfer_trtllm
-      linear-attn-decode-backend: flashinfer
-      speculative-algorithm: NEXTN
-      speculative-num-steps: 3
-      speculative-eagle-topk: 1
-      speculative-num-draft-tokens: 4
-      disaggregation-mode: decode
-      disaggregation-transfer-backend: mooncake
-      disable-radix-cache: true
-      mem-fraction-static: 0.8
-      context-length: 9236
-      max-total-tokens: 750000
-      max-mamba-cache-size: 128
-      max-running-requests: 86
-      cuda-graph-max-bs: 88
-      chunked-prefill-size: 32768
-      max-prefill-tokens: 32768
-      scheduler-recv-interval: 10
-      stream-interval: 30
-      page-size: 64
-      watchdog-timeout: 1000000
-      decode-log-interval: 1
-health_check:
-  max_attempts: 240
-  interval_seconds: 10
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp4-v2/8k1k/mtp/3p5d-tp4-tp4-c128.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp4-v2/8k1k/mtp/3p5d-tp4-tp4-c128.yaml
deleted file mode 100644
index f3771aa7c2..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp4-v2/8k1k/mtp/3p5d-tp4-tp4-c128.yaml
+++ /dev/null
@@ -1,155 +0,0 @@
-schema: 2
-name: qwen35-v2-gb200-c128-3p5d-tp4-mtp3
-dynamo:
-  install: false
-frontend:
-  type: dynamo
-  enable_multiple_frontends: false
-  args:
-    enforce-disagg: true
-resources:
-  gpu_type: gb200
-  gpus_per_node: 4
-engine: sglang
-roles:
-  prefill:
-    nodes: 3
-    workers: 3
-    env:
-      NO_COLOR: '1'
-      PYTHONUNBUFFERED: '1'
-      HF_HUB_OFFLINE: '1'
-      TRANSFORMERS_OFFLINE: '1'
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: '3600'
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: '3600'
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: '3600'
-      NCCL_MNNVL_ENABLE: '1'
-      NCCL_NVLS_ENABLE: '0'
-      NCCL_CUMEM_ENABLE: '1'
-      MC_FORCE_MNNVL: '1'
-      SGLANG_ENABLE_SPEC_V2: '1'
-      SGLANG_DG_CACHE_DIR: /configs/deepgemm-cache
-      FLASHINFER_WORKSPACE_BASE: /configs/flashinfer-cache
-      SGLANG_ENABLE_JIT_DEEPGEMM: 'true'
-      SGLANG_ENABLE_FLASHINFER_GEMM: 'true'
-      FLASHINFER_DISABLE_VERSION_CHECK: '1'
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: '100000'
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: '100000'
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: '100000'
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: 'True'
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: '0'
-      SGLANG_DISABLE_TP_MEMORY_INBALANCE_CHECK: '1'
-      SGLANG_HEALTH_CHECK_TIMEOUT: '3600'
-      SGLANG_HEALTH_STARTING_OK: '1'
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: '0'
-    args:
-      served-model-name: nvidia/Qwen3.5-397B-A17B-NVFP4-V2
-      model-path: /model
-      trust-remote-code: true
-      reasoning-parser: qwen3
-      tool-call-parser: qwen3_coder
-      quantization: modelopt_mixed
-      fp4-gemm-backend: flashinfer_cutlass
-      kv-cache-dtype: fp8_e4m3
-      tensor-parallel-size: 4
-      data-parallel-size: 1
-      expert-parallel-size: 1
-      mamba-scheduler-strategy: no_buffer
-      mamba-ssm-dtype: bfloat16
-      mamba-track-interval: 2048
-      attention-backend: trtllm_mha
-      mm-attention-backend: triton_attn
-      moe-runner-backend: flashinfer_trtllm
-      linear-attn-decode-backend: flashinfer
-      disaggregation-mode: prefill
-      disaggregation-transfer-backend: mooncake
-      disaggregation-bootstrap-port: 31000
-      disable-radix-cache: true
-      mem-fraction-static: 0.8
-      context-length: 9236
-      max-total-tokens: 128000
-      max-running-requests: 128
-      cuda-graph-max-bs: 4
-      chunked-prefill-size: 32768
-      max-prefill-tokens: 32768
-      scheduler-recv-interval: 10
-      stream-interval: 30
-      load-balance-method: round_robin
-      page-size: 64
-      watchdog-timeout: 1000000
-      log-level: info
-  decode:
-    nodes: 5
-    workers: 5
-    env:
-      NO_COLOR: '1'
-      PYTHONUNBUFFERED: '1'
-      HF_HUB_OFFLINE: '1'
-      TRANSFORMERS_OFFLINE: '1'
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: '3600'
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: '3600'
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: '3600'
-      NCCL_MNNVL_ENABLE: '1'
-      NCCL_NVLS_ENABLE: '0'
-      NCCL_CUMEM_ENABLE: '1'
-      MC_FORCE_MNNVL: '1'
-      MC_TE_METRIC: 'true'
-      SGLANG_ENABLE_SPEC_V2: '1'
-      SGLANG_DG_CACHE_DIR: /configs/deepgemm-cache
-      FLASHINFER_WORKSPACE_BASE: /configs/flashinfer-cache
-      SGLANG_ENABLE_JIT_DEEPGEMM: 'true'
-      SGLANG_ENABLE_FLASHINFER_GEMM: 'true'
-      FLASHINFER_DISABLE_VERSION_CHECK: '1'
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: '100000'
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: '100000'
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: '100000'
-      SGLANG_DECODE_BOOTSTRAP_TIMEOUT: '1000'
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: 'True'
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: '0'
-      SGLANG_DISABLE_TP_MEMORY_INBALANCE_CHECK: '1'
-      SGLANG_HEALTH_CHECK_TIMEOUT: '3600'
-      SGLANG_HEALTH_STARTING_OK: '1'
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: '0'
-    args:
-      served-model-name: nvidia/Qwen3.5-397B-A17B-NVFP4-V2
-      model-path: /model
-      trust-remote-code: true
-      reasoning-parser: qwen3
-      tool-call-parser: qwen3_coder
-      quantization: modelopt_mixed
-      fp4-gemm-backend: flashinfer_cutlass
-      kv-cache-dtype: fp8_e4m3
-      tensor-parallel-size: 4
-      data-parallel-size: 1
-      expert-parallel-size: 1
-      mamba-scheduler-strategy: no_buffer
-      mamba-ssm-dtype: bfloat16
-      mamba-track-interval: 128
-      attention-backend: trtllm_mha
-      mm-attention-backend: triton_attn
-      moe-runner-backend: flashinfer_trtllm
-      linear-attn-decode-backend: flashinfer
-      speculative-algorithm: NEXTN
-      speculative-num-steps: 3
-      speculative-eagle-topk: 1
-      speculative-num-draft-tokens: 4
-      disaggregation-mode: decode
-      disaggregation-transfer-backend: mooncake
-      disaggregation-bootstrap-port: 31000
-      disable-radix-cache: true
-      mem-fraction-static: 0.8
-      context-length: 9236
-      max-total-tokens: 1500000
-      max-mamba-cache-size: 256
-      max-running-requests: 128
-      cuda-graph-max-bs: 256
-      chunked-prefill-size: 32768
-      max-prefill-tokens: 32768
-      scheduler-recv-interval: 10
-      stream-interval: 30
-      page-size: 64
-      watchdog-timeout: 1000000
-      decode-log-interval: 1
-health_check:
-  max_attempts: 240
-  interval_seconds: 10
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp4-v2/8k1k/mtp/7p1d-dep4-dep16-c5120.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp4-v2/8k1k/mtp/7p1d-dep4-dep16-c5120.yaml
deleted file mode 100644
index 7ad4de2f07..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp4-v2/8k1k/mtp/7p1d-dep4-dep16-c5120.yaml
+++ /dev/null
@@ -1,165 +0,0 @@
-schema: 2
-name: qwen35-v2-gb200-c5120-7p1d-dep4-dep16-mtp2-cap2048
-dynamo:
-  install: false
-frontend:
-  type: dynamo
-  enable_multiple_frontends: true
-  num_additional_frontends: 2
-  nginx_container: nginx
-  args:
-    enforce-disagg: true
-resources:
-  gpu_type: gb200
-  gpus_per_node: 4
-engine: sglang
-roles:
-  prefill:
-    nodes: 7
-    workers: 7
-    env:
-      NO_COLOR: '1'
-      PYTHONUNBUFFERED: '1'
-      HF_HUB_OFFLINE: '1'
-      TRANSFORMERS_OFFLINE: '1'
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: '3600'
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: '3600'
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: '3600'
-      NCCL_MNNVL_ENABLE: '1'
-      NCCL_NVLS_ENABLE: '0'
-      NCCL_CUMEM_ENABLE: '1'
-      MC_FORCE_MNNVL: '1'
-      SGLANG_ENABLE_SPEC_V2: '1'
-      SGLANG_DG_CACHE_DIR: /configs/deepgemm-cache
-      FLASHINFER_WORKSPACE_BASE: /configs/flashinfer-cache
-      SGLANG_ENABLE_JIT_DEEPGEMM: 'true'
-      SGLANG_ENABLE_FLASHINFER_GEMM: 'true'
-      FLASHINFER_DISABLE_VERSION_CHECK: '1'
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: '100000'
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: '100000'
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: '100000'
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: 'True'
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: '0'
-      SGLANG_DISABLE_TP_MEMORY_INBALANCE_CHECK: '1'
-      SGLANG_HEALTH_CHECK_TIMEOUT: '3600'
-      SGLANG_HEALTH_STARTING_OK: '1'
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: '0'
-    args:
-      served-model-name: nvidia/Qwen3.5-397B-A17B-NVFP4-V2
-      model-path: /model
-      trust-remote-code: true
-      reasoning-parser: qwen3
-      tool-call-parser: qwen3_coder
-      quantization: modelopt_mixed
-      fp4-gemm-backend: flashinfer_cutlass
-      kv-cache-dtype: fp8_e4m3
-      tensor-parallel-size: 4
-      data-parallel-size: 4
-      expert-parallel-size: 4
-      enable-dp-attention: true
-      enable-dp-lm-head: true
-      mamba-scheduler-strategy: no_buffer
-      mamba-ssm-dtype: bfloat16
-      mamba-track-interval: 2048
-      attention-backend: trtllm_mha
-      mm-attention-backend: triton_attn
-      moe-runner-backend: flashinfer_trtllm
-      linear-attn-decode-backend: flashinfer
-      disaggregation-mode: prefill
-      disaggregation-transfer-backend: mooncake
-      disable-radix-cache: true
-      mem-fraction-static: 0.8
-      context-length: 9236
-      max-total-tokens: 128000
-      max-running-requests: 128
-      cuda-graph-max-bs: 4
-      chunked-prefill-size: 65536
-      max-prefill-tokens: 65536
-      scheduler-recv-interval: 1
-      stream-interval: 50
-      load-balance-method: round_robin
-      page-size: 64
-      watchdog-timeout: 1000000
-      log-level: info
-  decode:
-    nodes: 4
-    workers: 1
-    env:
-      NO_COLOR: '1'
-      PYTHONUNBUFFERED: '1'
-      HF_HUB_OFFLINE: '1'
-      TRANSFORMERS_OFFLINE: '1'
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: '3600'
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: '3600'
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: '3600'
-      NCCL_MNNVL_ENABLE: '1'
-      NCCL_NVLS_ENABLE: '0'
-      NCCL_CUMEM_ENABLE: '1'
-      MC_FORCE_MNNVL: '1'
-      MC_TE_METRIC: 'true'
-      SGLANG_ENABLE_SPEC_V2: '1'
-      SGLANG_DG_CACHE_DIR: /configs/deepgemm-cache
-      FLASHINFER_WORKSPACE_BASE: /configs/flashinfer-cache
-      SGLANG_ENABLE_JIT_DEEPGEMM: 'true'
-      SGLANG_ENABLE_FLASHINFER_GEMM: 'true'
-      FLASHINFER_DISABLE_VERSION_CHECK: '1'
-      SGLANG_MOE_NVFP4_DISPATCH: '1'
-      SGLANG_FLASHINFER_NUM_MAX_DISPATCH_TOKENS_PER_RANK: '1024'
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: '100000'
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: '100000'
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: '100000'
-      SGLANG_DECODE_BOOTSTRAP_TIMEOUT: '1000'
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: 'True'
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: '0'
-      SGLANG_DISABLE_TP_MEMORY_INBALANCE_CHECK: '1'
-      SGLANG_HEALTH_CHECK_TIMEOUT: '3600'
-      SGLANG_HEALTH_STARTING_OK: '1'
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: '0'
-    args:
-      served-model-name: nvidia/Qwen3.5-397B-A17B-NVFP4-V2
-      model-path: /model
-      trust-remote-code: true
-      reasoning-parser: qwen3
-      tool-call-parser: qwen3_coder
-      quantization: modelopt_mixed
-      fp4-gemm-backend: flashinfer_cutlass
-      kv-cache-dtype: fp8_e4m3
-      tensor-parallel-size: 16
-      data-parallel-size: 16
-      expert-parallel-size: 16
-      enable-dp-attention: true
-      enable-dp-lm-head: true
-      mamba-scheduler-strategy: no_buffer
-      mamba-ssm-dtype: bfloat16
-      mamba-track-interval: 128
-      attention-backend: trtllm_mha
-      mm-attention-backend: triton_attn
-      moe-a2a-backend: flashinfer
-      moe-runner-backend: flashinfer_cutedsl
-      speculative-moe-a2a-backend: none
-      speculative-moe-runner-backend: flashinfer_trtllm
-      disable-shared-experts-fusion: true
-      linear-attn-decode-backend: flashinfer
-      speculative-algorithm: NEXTN
-      speculative-num-steps: 2
-      speculative-eagle-topk: 1
-      speculative-num-draft-tokens: 3
-      disaggregation-mode: decode
-      disaggregation-transfer-backend: mooncake
-      disable-radix-cache: true
-      cuda-graph-max-bs: 256
-      mem-fraction-static: 0.8
-      context-length: 9236
-      max-total-tokens: 2200000
-      max-mamba-cache-size: 2048
-      max-running-requests: 2048
-      chunked-prefill-size: 4096
-      max-prefill-tokens: 32768
-      scheduler-recv-interval: 1
-      stream-interval: 50
-      page-size: 64
-      watchdog-timeout: 1000000
-      decode-log-interval: 50
-health_check:
-  max_attempts: 360
-  interval_seconds: 10
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp4-v2/8k1k/mtp/7p1d-dep4-dep16-c8192.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp4-v2/8k1k/mtp/7p1d-dep4-dep16-c8192.yaml
deleted file mode 100644
index dd8964559d..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp4-v2/8k1k/mtp/7p1d-dep4-dep16-c8192.yaml
+++ /dev/null
@@ -1,165 +0,0 @@
-schema: 2
-name: qwen35-v2-gb200-c8192-7p1d-dep4-dep16-mtp2-cap3413
-dynamo:
-  install: false
-frontend:
-  type: dynamo
-  enable_multiple_frontends: true
-  num_additional_frontends: 2
-  nginx_container: nginx
-  args:
-    enforce-disagg: true
-resources:
-  gpu_type: gb200
-  gpus_per_node: 4
-engine: sglang
-roles:
-  prefill:
-    nodes: 7
-    workers: 7
-    env:
-      NO_COLOR: '1'
-      PYTHONUNBUFFERED: '1'
-      HF_HUB_OFFLINE: '1'
-      TRANSFORMERS_OFFLINE: '1'
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: '3600'
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: '3600'
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: '3600'
-      NCCL_MNNVL_ENABLE: '1'
-      NCCL_NVLS_ENABLE: '0'
-      NCCL_CUMEM_ENABLE: '1'
-      MC_FORCE_MNNVL: '1'
-      SGLANG_ENABLE_SPEC_V2: '1'
-      SGLANG_DG_CACHE_DIR: /configs/deepgemm-cache
-      FLASHINFER_WORKSPACE_BASE: /configs/flashinfer-cache
-      SGLANG_ENABLE_JIT_DEEPGEMM: 'true'
-      SGLANG_ENABLE_FLASHINFER_GEMM: 'true'
-      FLASHINFER_DISABLE_VERSION_CHECK: '1'
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: '100000'
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: '100000'
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: '100000'
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: 'True'
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: '0'
-      SGLANG_DISABLE_TP_MEMORY_INBALANCE_CHECK: '1'
-      SGLANG_HEALTH_CHECK_TIMEOUT: '3600'
-      SGLANG_HEALTH_STARTING_OK: '1'
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: '0'
-    args:
-      served-model-name: nvidia/Qwen3.5-397B-A17B-NVFP4-V2
-      model-path: /model
-      trust-remote-code: true
-      reasoning-parser: qwen3
-      tool-call-parser: qwen3_coder
-      quantization: modelopt_mixed
-      fp4-gemm-backend: flashinfer_cutlass
-      kv-cache-dtype: fp8_e4m3
-      tensor-parallel-size: 4
-      data-parallel-size: 4
-      expert-parallel-size: 4
-      enable-dp-attention: true
-      enable-dp-lm-head: true
-      mamba-scheduler-strategy: no_buffer
-      mamba-ssm-dtype: bfloat16
-      mamba-track-interval: 2048
-      attention-backend: trtllm_mha
-      mm-attention-backend: triton_attn
-      moe-runner-backend: flashinfer_trtllm
-      linear-attn-decode-backend: flashinfer
-      disaggregation-mode: prefill
-      disaggregation-transfer-backend: mooncake
-      disable-radix-cache: true
-      mem-fraction-static: 0.8
-      context-length: 9236
-      max-total-tokens: 128000
-      max-running-requests: 128
-      cuda-graph-max-bs: 4
-      chunked-prefill-size: 65536
-      max-prefill-tokens: 65536
-      scheduler-recv-interval: 1
-      stream-interval: 50
-      load-balance-method: round_robin
-      page-size: 64
-      watchdog-timeout: 1000000
-      log-level: info
-  decode:
-    nodes: 4
-    workers: 1
-    env:
-      NO_COLOR: '1'
-      PYTHONUNBUFFERED: '1'
-      HF_HUB_OFFLINE: '1'
-      TRANSFORMERS_OFFLINE: '1'
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: '3600'
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: '3600'
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: '3600'
-      NCCL_MNNVL_ENABLE: '1'
-      NCCL_NVLS_ENABLE: '0'
-      NCCL_CUMEM_ENABLE: '1'
-      MC_FORCE_MNNVL: '1'
-      MC_TE_METRIC: 'true'
-      SGLANG_ENABLE_SPEC_V2: '1'
-      SGLANG_DG_CACHE_DIR: /configs/deepgemm-cache
-      FLASHINFER_WORKSPACE_BASE: /configs/flashinfer-cache
-      SGLANG_ENABLE_JIT_DEEPGEMM: 'true'
-      SGLANG_ENABLE_FLASHINFER_GEMM: 'true'
-      FLASHINFER_DISABLE_VERSION_CHECK: '1'
-      SGLANG_MOE_NVFP4_DISPATCH: '1'
-      SGLANG_FLASHINFER_NUM_MAX_DISPATCH_TOKENS_PER_RANK: '1024'
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: '100000'
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: '100000'
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: '100000'
-      SGLANG_DECODE_BOOTSTRAP_TIMEOUT: '1000'
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: 'True'
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: '0'
-      SGLANG_DISABLE_TP_MEMORY_INBALANCE_CHECK: '1'
-      SGLANG_HEALTH_CHECK_TIMEOUT: '3600'
-      SGLANG_HEALTH_STARTING_OK: '1'
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: '0'
-    args:
-      served-model-name: nvidia/Qwen3.5-397B-A17B-NVFP4-V2
-      model-path: /model
-      trust-remote-code: true
-      reasoning-parser: qwen3
-      tool-call-parser: qwen3_coder
-      quantization: modelopt_mixed
-      fp4-gemm-backend: flashinfer_cutlass
-      kv-cache-dtype: fp8_e4m3
-      tensor-parallel-size: 16
-      data-parallel-size: 16
-      expert-parallel-size: 16
-      enable-dp-attention: true
-      enable-dp-lm-head: true
-      mamba-scheduler-strategy: no_buffer
-      mamba-ssm-dtype: bfloat16
-      mamba-track-interval: 128
-      attention-backend: trtllm_mha
-      mm-attention-backend: triton_attn
-      moe-a2a-backend: flashinfer
-      moe-runner-backend: flashinfer_cutedsl
-      speculative-moe-a2a-backend: none
-      speculative-moe-runner-backend: flashinfer_trtllm
-      disable-shared-experts-fusion: true
-      linear-attn-decode-backend: flashinfer
-      speculative-algorithm: NEXTN
-      speculative-num-steps: 2
-      speculative-eagle-topk: 1
-      speculative-num-draft-tokens: 3
-      disaggregation-mode: decode
-      disaggregation-transfer-backend: mooncake
-      disable-radix-cache: true
-      cuda-graph-max-bs: 256
-      mem-fraction-static: 0.8
-      context-length: 9236
-      max-total-tokens: 2200000
-      max-mamba-cache-size: 3413
-      max-running-requests: 3413
-      chunked-prefill-size: 4096
-      max-prefill-tokens: 32768
-      scheduler-recv-interval: 1
-      stream-interval: 50
-      page-size: 64
-      watchdog-timeout: 1000000
-      decode-log-interval: 50
-health_check:
-  max_attempts: 360
-  interval_seconds: 10
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp4-v2/8k1k/mtp/7p4d-dep4-dep4-c12288.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp4-v2/8k1k/mtp/7p4d-dep4-dep4-c12288.yaml
deleted file mode 100644
index 3d4979c22e..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp4-v2/8k1k/mtp/7p4d-dep4-dep4-c12288.yaml
+++ /dev/null
@@ -1,178 +0,0 @@
-schema: 2
-name: qwen35-v2-gb200-c12288-7p4d-dep4-mtp1-cap1056
-dynamo:
-  install: true
-  source:
-    wheel: "1.2.1"
-  request_plane: "nats"
-frontend:
-  type: dynamo
-  enable_multiple_frontends: false
-  args:
-    enforce-disagg: true
-resources:
-  gpu_type: gb200
-  gpus_per_node: 4
-engine: sglang
-roles:
-  prefill:
-    nodes: 7
-    workers: 7
-    env:
-      NO_COLOR: '1'
-      PYTHONUNBUFFERED: '1'
-      HF_HUB_OFFLINE: '1'
-      TRANSFORMERS_OFFLINE: '1'
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: '3600'
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: '3600'
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: '3600'
-      NCCL_MNNVL_ENABLE: '1'
-      NCCL_NVLS_ENABLE: '0'
-      NCCL_CUMEM_ENABLE: '1'
-      MC_FORCE_MNNVL: '1'
-      SGLANG_ENABLE_SPEC_V2: '1'
-      SGLANG_DG_CACHE_DIR: /configs/deepgemm-cache
-      FLASHINFER_WORKSPACE_BASE: /configs/flashinfer-cache
-      SGLANG_ENABLE_JIT_DEEPGEMM: 'true'
-      SGLANG_ENABLE_FLASHINFER_GEMM: 'true'
-      FLASHINFER_DISABLE_VERSION_CHECK: '1'
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: '100000'
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: '100000'
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: '100000'
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: 'True'
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: '0'
-      SGLANG_DISABLE_TP_MEMORY_INBALANCE_CHECK: '1'
-      SGLANG_HEALTH_CHECK_TIMEOUT: '3600'
-      SGLANG_HEALTH_STARTING_OK: '1'
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: '0'
-    args:
-      served-model-name: nvidia/Qwen3.5-397B-A17B-NVFP4-V2
-      model-path: /model
-      trust-remote-code: true
-      reasoning-parser: qwen3
-      tool-call-parser: qwen3_coder
-      quantization: modelopt_mixed
-      fp4-gemm-backend: flashinfer_cutlass
-      kv-cache-dtype: fp8_e4m3
-      tensor-parallel-size: 4
-      data-parallel-size: 4
-      expert-parallel-size: 4
-      enable-dp-attention: true
-      enable-dp-attention-local-control-broadcast: true
-      enable-dp-lm-head: true
-      mamba-scheduler-strategy: no_buffer
-      mamba-ssm-dtype: bfloat16
-      mamba-track-interval: 2048
-      attention-backend: trtllm_mha
-      mm-attention-backend: triton_attn
-      moe-runner-backend: flashinfer_trtllm
-      linear-attn-decode-backend: flashinfer
-      disaggregation-mode: prefill
-      disaggregation-transfer-backend: mooncake
-      disable-radix-cache: true
-      mem-fraction-static: 0.8
-      context-length: 9236
-      max-total-tokens: 256000
-      max-running-requests: 128
-      cuda-graph-max-bs: 4
-      chunked-prefill-size: 262144
-      max-prefill-tokens: 131072
-      scheduler-recv-interval: 1
-      stream-interval: 50
-      load-balance-method: round_robin
-      page-size: 64
-      watchdog-timeout: 1000000
-      log-level: info
-  decode:
-    nodes: 4
-    workers: 4
-    env:
-      NO_COLOR: '1'
-      PYTHONUNBUFFERED: '1'
-      HF_HUB_OFFLINE: '1'
-      TRANSFORMERS_OFFLINE: '1'
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: '3600'
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: '3600'
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: '3600'
-      NCCL_DEBUG: INFO
-      NCCL_DEBUG_SUBSYS: COLL
-      NCCL_MNNVL_ENABLE: '1'
-      NCCL_NVLS_ENABLE: '0'
-      NCCL_CUMEM_ENABLE: '1'
-      MC_FORCE_MNNVL: '1'
-      MC_TE_METRIC: 'true'
-      SGLANG_ENABLE_SPEC_V2: '1'
-      SGLANG_DG_CACHE_DIR: /configs/deepgemm-cache
-      FLASHINFER_WORKSPACE_BASE: /configs/flashinfer-cache
-      SGLANG_ENABLE_JIT_DEEPGEMM: 'true'
-      SGLANG_ENABLE_FLASHINFER_GEMM: 'true'
-      FLASHINFER_DISABLE_VERSION_CHECK: '1'
-      SGLANG_MOE_NVFP4_DISPATCH: '1'
-      SGLANG_FLASHINFER_NUM_MAX_DISPATCH_TOKENS_PER_RANK: '1024'
-      SGLANG_NCCL_ALL_GATHER_IN_OVERLAP_SCHEDULER_SYNC_BATCH: '1'
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: '100000'
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: '100000'
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: '100000'
-      SGLANG_DECODE_BOOTSTRAP_TIMEOUT: '1000'
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: 'True'
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: '0'
-      SGLANG_DISABLE_TP_MEMORY_INBALANCE_CHECK: '1'
-      SGLANG_HEALTH_CHECK_TIMEOUT: '3600'
-      SGLANG_HEALTH_STARTING_OK: '1'
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: '0'
-      CUDA_ENABLE_COREDUMP_ON_EXCEPTION: '1'
-      CUDA_ENABLE_CPU_COREDUMP_ON_EXCEPTION: '0'
-      CUDA_COREDUMP_FILE: /logs/cuda_coredump_%h_%p
-      CUDA_COREDUMP_GENERATION_FLAGS: 
-        skip_nonrelocated_elf_images,skip_global_memory,skip_shared_memory,skip_local_memory,skip_constbank_memory
-    args:
-      served-model-name: nvidia/Qwen3.5-397B-A17B-NVFP4-V2
-      model-path: /model
-      trust-remote-code: true
-      reasoning-parser: qwen3
-      tool-call-parser: qwen3_coder
-      quantization: modelopt_mixed
-      fp4-gemm-backend: flashinfer_cutlass
-      kv-cache-dtype: fp8_e4m3
-      tensor-parallel-size: 4
-      data-parallel-size: 4
-      expert-parallel-size: 4
-      enable-dp-attention: true
-      enable-dp-lm-head: true
-      mamba-scheduler-strategy: no_buffer
-      mamba-ssm-dtype: bfloat16
-      mamba-track-interval: 128
-      attention-backend: trtllm_mha
-      mm-attention-backend: triton_attn
-      moe-a2a-backend: none
-      moe-runner-backend: flashinfer_trtllm
-      speculative-moe-a2a-backend: none
-      speculative-moe-runner-backend: flashinfer_trtllm
-      disable-shared-experts-fusion: true
-      linear-attn-decode-backend: flashinfer
-      speculative-algorithm: NEXTN
-      speculative-num-steps: 1
-      speculative-eagle-topk: 1
-      speculative-num-draft-tokens: 2
-      disable-flashinfer-autotune: true
-      disaggregation-mode: decode
-      disaggregation-transfer-backend: mooncake
-      disable-radix-cache: true
-      cuda-graph-max-bs: 512
-      mem-fraction-static: 0.94
-      context-length: 9236
-      max-total-tokens: 2052736
-      max-mamba-cache-size: 1056
-      max-running-requests: 1056
-      chunked-prefill-size: 4096
-      max-prefill-tokens: 32768
-      scheduler-recv-interval: 1
-      disaggregation-decode-polling-interval: 8
-      stream-interval: 50
-      page-size: 64
-      soft-watchdog-timeout: 240
-      watchdog-timeout: 300
-      decode-log-interval: 50
-health_check:
-  max_attempts: 360
-  interval_seconds: 10
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp8/8k1k/disagg-1p1d-p-tp4-d-tp4-b128-c1x2x8-mtp.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp8/8k1k/disagg-1p1d-p-tp4-d-tp4-b128-c1x2x8-mtp.yaml
deleted file mode 100644
index 7e1523b1cc..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp8/8k1k/disagg-1p1d-p-tp4-d-tp4-b128-c1x2x8-mtp.yaml
+++ /dev/null
@@ -1,130 +0,0 @@
-
-schema: 2
-name: "qwen3.5-fp8-gb200-mtp-8k1k-1p1d-tp4-tp4"
-
-sbatch_directives:
-  mem: "0"
-
-dynamo:
-  install: true
-
-  source:
-    wheel: "1.5.0.dev20260917"
-frontend:
-  type: dynamo
-  enable_multiple_frontends: true
-  num_additional_frontends: 1
-  nginx_container: nginx
-
-resources:
-  gpu_type: "gb200"
-  gpus_per_node: 4
-engine: sglang
-roles:
-  prefill:
-    nodes: 1
-    workers: 1
-    env:
-      SGLANG_JIT_DEEPGEMM_PRECOMPILE: "0"
-      SGLANG_ENABLE_SPEC_V2: "1"
-      NO_COLOR: "1"
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: "3600"
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: "3600"
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: "3600"
-      PYTHONUNBUFFERED: "1"
-      NCCL_MNNVL_ENABLE: "1"
-      NCCL_CUMEM_ENABLE: "1"
-      MC_FORCE_MNNVL: "1"
-      SGLANG_DG_CACHE_DIR: "/configs/deepgemm-cache"
-      FLASHINFER_WORKSPACE_BASE: "/configs/flashinfer-cache"
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: "100000"
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: "100000"
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: "100000"
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: "True"
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: "0"
-      SGLANG_ENABLE_TP_MEMORY_INBALANCE_CHECK: "0"
-      SGLANG_HEALTH_STARTING_OK: "1"
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: "0"
-
-    args:
-      served-model-name: "Qwen/Qwen3.5-397B-A17B-FP8"
-      model-path: "/model/"
-      quantization: "fp8"
-      kv-cache-dtype: "fp8_e4m3"
-      trust-remote-code: true
-      attention-backend: "trtllm_mha"
-      tensor-parallel-size: 4
-      mamba-radix-cache-strategy: "no_buffer"
-      mamba-track-interval: 2048
-      mamba-ssm-dtype: "bfloat16"
-      moe-runner-backend: "flashinfer_trtllm"
-      disable-radix-cache: true
-      max-running-requests: 1024
-      mem-fraction-static: 0.8
-      chunked-prefill-size: 16384
-      max-prefill-tokens: 16384
-      context-length: 16384
-      cuda-graph-max-bs-decode: 1024
-      decode-log-interval: 1
-      stream-interval: 50
-      disaggregation-mode: "prefill"
-
-  decode:
-    nodes: 1
-    workers: 1
-
-    env:
-      SGLANG_JIT_DEEPGEMM_PRECOMPILE: "0"
-      SGLANG_ENABLE_SPEC_V2: "1"
-      NO_COLOR: "1"
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: "3600"
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: "3600"
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: "3600"
-      PYTHONUNBUFFERED: "1"
-      NCCL_MNNVL_ENABLE: "1"
-      NCCL_CUMEM_ENABLE: "1"
-      MC_FORCE_MNNVL: "1"
-      MC_TE_METRIC: "true"
-      SGLANG_DG_CACHE_DIR: "/configs/deepgemm-cache"
-      FLASHINFER_WORKSPACE_BASE: "/configs/flashinfer-cache"
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: "100000"
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: "100000"
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: "100000"
-      SGLANG_DECODE_BOOTSTRAP_TIMEOUT: "1000"
-      SGLANG_HACK_SEQ_BOOTSTRAP_ROOM: "1"
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: "True"
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: "0"
-      SGLANG_ENABLE_TP_MEMORY_INBALANCE_CHECK: "0"
-      SGLANG_HEALTH_CHECK_TIMEOUT: "1800"
-      SGLANG_HEALTH_STARTING_OK: "1"
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: "0"
-
-    args:
-      served-model-name: "Qwen/Qwen3.5-397B-A17B-FP8"
-      model-path: "/model/"
-      quantization: "fp8"
-      kv-cache-dtype: "fp8_e4m3"
-      trust-remote-code: true
-      attention-backend: "trtllm_mha"
-      tensor-parallel-size: 4
-      mamba-radix-cache-strategy: "no_buffer"
-      mamba-track-interval: 128
-      mamba-ssm-dtype: "bfloat16"
-      max-mamba-cache-size: 256
-      moe-runner-backend: "flashinfer_trtllm"
-
-      speculative-algorithm: "EAGLE"
-      speculative-num-steps: 3
-      speculative-eagle-topk: 1
-      speculative-num-draft-tokens: 4
-
-      disable-radix-cache: true
-      max-running-requests: 128
-      mem-fraction-static: 0.8
-      chunked-prefill-size: 16384
-      max-prefill-tokens: 16384
-      context-length: 16384
-      cuda-graph-max-bs-decode: 1024
-      decode-log-interval: 1
-      stream-interval: 50
-      disaggregation-mode: "decode"
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp8/8k1k/disagg-1p1d-p-tp8-ep8-d-tp8-ep8-b1024-c32x48x80-mtp.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp8/8k1k/disagg-1p1d-p-tp8-ep8-d-tp8-ep8-b1024-c32x48x80-mtp.yaml
deleted file mode 100644
index 43591e6464..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp8/8k1k/disagg-1p1d-p-tp8-ep8-d-tp8-ep8-b1024-c32x48x80-mtp.yaml
+++ /dev/null
@@ -1,142 +0,0 @@
-
-schema: 2
-name: "qwen3.5-fp8-gb200-mtp-8k1k-1p1d-tep8-tep8"
-
-sbatch_directives:
-  mem: "0"
-
-dynamo:
-  install: true
-
-  source:
-    wheel: "1.5.0.dev20260917"
-frontend:
-  type: dynamo
-  enable_multiple_frontends: true
-  num_additional_frontends: 1
-  nginx_container: nginx
-
-resources:
-  gpu_type: "gb200"
-  gpus_per_node: 4
-engine: sglang
-roles:
-  prefill:
-    nodes: 2
-    workers: 1
-    env:
-      SGLANG_JIT_DEEPGEMM_PRECOMPILE: "0"
-      SGLANG_ENABLE_SPEC_V2: "1"
-      NO_COLOR: "1"
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: "3600"
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: "3600"
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: "3600"
-      PYTHONUNBUFFERED: "1"
-      NCCL_MNNVL_ENABLE: "1"
-      NCCL_CUMEM_ENABLE: "1"
-      MC_FORCE_MNNVL: "1"
-      SGLANG_DG_CACHE_DIR: "/configs/deepgemm-cache"
-      FLASHINFER_WORKSPACE_BASE: "/configs/flashinfer-cache"
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: "100000"
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: "100000"
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: "100000"
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: "True"
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: "0"
-      SGLANG_ENABLE_TP_MEMORY_INBALANCE_CHECK: "0"
-      SGLANG_HEALTH_STARTING_OK: "1"
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: "0"
-
-    args:
-      served-model-name: "Qwen/Qwen3.5-397B-A17B-FP8"
-      model-path: "/model/"
-      random-seed: 42
-      quantization: "fp8"
-      kv-cache-dtype: "fp8_e4m3"
-      trust-remote-code: true
-      attention-backend: "trtllm_mha"
-      tensor-parallel-size: 8
-      data-parallel-size: 1
-      expert-parallel-size: 8
-      mamba-radix-cache-strategy: "no_buffer"
-      mamba-track-interval: 2048
-      mamba-ssm-dtype: "bfloat16"
-      moe-runner-backend: "flashinfer_trtllm"
-      disable-radix-cache: true
-      max-running-requests: 1024
-      mem-fraction-static: 0.8
-      max-total-tokens: 128000
-      chunked-prefill-size: 16384
-      max-prefill-tokens: 16384
-      context-length: 9236
-      cuda-graph-max-bs-decode: 320
-      scheduler-recv-interval: 10
-      decode-log-interval: 50
-      stream-interval: 50
-      disaggregation-mode: "prefill"
-      disaggregation-transfer-backend: "mooncake"
-
-  decode:
-    nodes: 2
-    workers: 1
-
-    env:
-      SGLANG_JIT_DEEPGEMM_PRECOMPILE: "0"
-      SGLANG_ENABLE_SPEC_V2: "1"
-      NO_COLOR: "1"
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: "3600"
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: "3600"
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: "3600"
-      PYTHONUNBUFFERED: "1"
-      NCCL_MNNVL_ENABLE: "1"
-      NCCL_CUMEM_ENABLE: "1"
-      MC_FORCE_MNNVL: "1"
-      MC_TE_METRIC: "true"
-      SGLANG_DG_CACHE_DIR: "/configs/deepgemm-cache"
-      FLASHINFER_WORKSPACE_BASE: "/configs/flashinfer-cache"
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: "100000"
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: "100000"
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: "100000"
-      SGLANG_DECODE_BOOTSTRAP_TIMEOUT: "1000"
-      SGLANG_HACK_SEQ_BOOTSTRAP_ROOM: "1"
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: "True"
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: "0"
-      SGLANG_ENABLE_TP_MEMORY_INBALANCE_CHECK: "0"
-      SGLANG_HEALTH_CHECK_TIMEOUT: "1800"
-      SGLANG_HEALTH_STARTING_OK: "1"
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: "0"
-
-    args:
-      served-model-name: "Qwen/Qwen3.5-397B-A17B-FP8"
-      model-path: "/model/"
-      random-seed: 42
-      quantization: "fp8"
-      kv-cache-dtype: "fp8_e4m3"
-      trust-remote-code: true
-      attention-backend: "trtllm_mha"
-      tensor-parallel-size: 8
-      data-parallel-size: 1
-      expert-parallel-size: 8
-      mamba-radix-cache-strategy: "no_buffer"
-      mamba-track-interval: 128
-      mamba-ssm-dtype: "bfloat16"
-      max-mamba-cache-size: 1024
-      moe-runner-backend: "flashinfer_trtllm"
-
-      speculative-algorithm: "EAGLE"
-      speculative-num-steps: 3
-      speculative-eagle-topk: 1
-      speculative-num-draft-tokens: 4
-
-      disable-radix-cache: true
-      max-running-requests: 1024
-      mem-fraction-static: 0.8
-      max-total-tokens: 2200000
-      chunked-prefill-size: 4096
-      max-prefill-tokens: 16384
-      context-length: 9236
-      cuda-graph-max-bs-decode: 320
-      scheduler-recv-interval: 10
-      decode-log-interval: 50
-      stream-interval: 50
-      disaggregation-mode: "decode"
-      disaggregation-transfer-backend: "mooncake"
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp8/8k1k/disagg-1p1d-tp4-tp4-stp.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp8/8k1k/disagg-1p1d-tp4-tp4-stp.yaml
deleted file mode 100644
index 1a9ae0ecff..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp8/8k1k/disagg-1p1d-tp4-tp4-stp.yaml
+++ /dev/null
@@ -1,110 +0,0 @@
-schema: 2
-name: "qwen3.5-1p1d-tp4-tp4"
-
-sbatch_directives:
-  mem: "0"
-
-dynamo:
-  install: true
-
-  source:
-    wheel: "1.5.0.dev20260917"
-frontend:
-  type: dynamo
-  enable_multiple_frontends: true
-  num_additional_frontends: 1
-  nginx_container: nginx
-
-resources:
-  gpu_type: "gb200"
-  gpus_per_node: 4
-engine: sglang
-roles:
-  prefill:
-    nodes: 1
-    workers: 1
-    env:
-      SGLANG_JIT_DEEPGEMM_PRECOMPILE: "0"
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: "3600"
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: "3600"
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: "3600"
-      PYTHONUNBUFFERED: "1"
-      NCCL_MNNVL_ENABLE: "1"
-      NCCL_CUMEM_ENABLE: "1"
-      SGLANG_DG_CACHE_DIR: "/configs/deepgemm-cache"
-      FLASHINFER_WORKSPACE_BASE: "/configs/flashinfer-cache"
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: "100000"
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: "100000"
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: "100000"
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: "0"
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: "True"
-      MC_FORCE_MNNVL: "1"
-
-    args:
-      served-model-name: "Qwen/Qwen3.5-397B-A17B-FP8"
-      model-path: "/model/"
-      quantization: "fp8"
-      kv-cache-dtype: "fp8_e4m3"
-      trust-remote-code: true
-      attention-backend: "trtllm_mha"
-      tensor-parallel-size: 4
-      mamba-ssm-dtype: "bfloat16"
-      moe-runner-backend: "flashinfer_trtllm"
-      disable-radix-cache: true
-      max-running-requests: 1024
-      mem-fraction-static: 0.8
-      chunked-prefill-size: 16384
-      max-prefill-tokens: 16384
-      context-length: 16384
-      cuda-graph-max-bs-decode: 1024
-      decode-log-interval: 1
-      stream-interval: 50
-      disaggregation-mode: "prefill"
-
-  decode:
-    nodes: 1
-    workers: 1
-
-    env:
-      SGLANG_JIT_DEEPGEMM_PRECOMPILE: "0"
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: "3600"
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: "3600"
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: "3600"
-      PYTHONUNBUFFERED: "1"
-      NCCL_MNNVL_ENABLE: "1"
-      NCCL_CUMEM_ENABLE: "1"
-      SGLANG_DG_CACHE_DIR: "/configs/deepgemm-cache"
-      FLASHINFER_WORKSPACE_BASE: "/configs/flashinfer-cache"
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: "100000"
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: "100000"
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: "100000"
-      SGLANG_DECODE_BOOTSTRAP_TIMEOUT: "1000"
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: "True"
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: "0"
-      SGLANG_HEALTH_CHECK_TIMEOUT: "3600"
-      SGLANG_HEALTH_STARTING_OK: "1"
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: "0"
-      MC_FORCE_MNNVL: "1"
-      MC_TE_METRIC: "true"
-      SGLANG_HACK_SEQ_BOOTSTRAP_ROOM: "1"
-
-    args:
-      served-model-name: "Qwen/Qwen3.5-397B-A17B-FP8"
-      model-path: "/model/"
-      quantization: "fp8"
-      kv-cache-dtype: "fp8_e4m3"
-      trust-remote-code: true
-      attention-backend: "trtllm_mha"
-      tensor-parallel-size: 4
-      mamba-ssm-dtype: "bfloat16"
-      moe-runner-backend: "flashinfer_trtllm"
-      disable-radix-cache: true
-      max-running-requests: 1024
-      mem-fraction-static: 0.8
-      chunked-prefill-size: 16384
-      max-prefill-tokens: 16384
-      context-length: 16384
-      cuda-graph-max-bs-decode: 1024
-      decode-log-interval: 1
-      stream-interval: 50
-      disaggregation-mode: "decode"
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp8/8k1k/disagg-3p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b1024-c480-mtp.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp8/8k1k/disagg-3p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b1024-c480-mtp.yaml
deleted file mode 100644
index 977750092f..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp8/8k1k/disagg-3p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b1024-c480-mtp.yaml
+++ /dev/null
@@ -1,157 +0,0 @@
-
-schema: 2
-name: "qwen3.5-fp8-gb200-mtp-8k1k-3p1d-dep4-dep16"
-
-sbatch_directives:
-  mem: "0"
-
-dynamo:
-  install: true
-
-  source:
-    wheel: "1.5.0.dev20260917"
-frontend:
-  type: dynamo
-  enable_multiple_frontends: true
-  num_additional_frontends: 2
-  nginx_container: nginx
-
-resources:
-  gpu_type: "gb200"
-  gpus_per_node: 4
-engine: sglang
-roles:
-  prefill:
-    nodes: 3
-    workers: 3
-    env:
-      SGLANG_JIT_DEEPGEMM_PRECOMPILE: "0"
-      SGLANG_ENABLE_SPEC_V2: "1"
-      NO_COLOR: "1"
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: "3600"
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: "3600"
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: "3600"
-      PYTHONUNBUFFERED: "1"
-      NCCL_MNNVL_ENABLE: "1"
-      NCCL_CUMEM_ENABLE: "1"
-      MC_FORCE_MNNVL: "1"
-      SGLANG_DG_CACHE_DIR: "/configs/deepgemm-cache"
-      FLASHINFER_WORKSPACE_BASE: "/configs/flashinfer-cache"
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: "100000"
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: "100000"
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: "100000"
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: "True"
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: "0"
-      SGLANG_ENABLE_TP_MEMORY_INBALANCE_CHECK: "0"
-      SGLANG_HEALTH_STARTING_OK: "1"
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: "0"
-
-    args:
-      served-model-name: "Qwen/Qwen3.5-397B-A17B-FP8"
-      model-path: "/model/"
-      random-seed: 42
-      quantization: "fp8"
-      kv-cache-dtype: "fp8_e4m3"
-      trust-remote-code: true
-
-      tensor-parallel-size: 4
-      data-parallel-size: 4
-      expert-parallel-size: 4
-      enable-dp-attention: true
-      enable-dp-lm-head: true
-      moe-dense-tp-size: 1
-
-      mamba-radix-cache-strategy: "no_buffer"
-      mamba-track-interval: 2048
-      mamba-ssm-dtype: "bfloat16"
-      disaggregation-mode: "prefill"
-      disable-radix-cache: true
-      disaggregation-bootstrap-port: 31000
-      mem-fraction-static: 0.7
-      chunked-prefill-size: 65536
-      max-prefill-tokens: 16384
-      load-balance-method: "round_robin"
-      watchdog-timeout: 1000000
-      disable-cuda-graph: true
-      log-level: "info"
-      page-size: 64
-      attention-backend: "trtllm_mha"
-      moe-runner-backend: "flashinfer_trtllm"
-
-  decode:
-    nodes: 4
-    workers: 1
-
-    env:
-      SGLANG_JIT_DEEPGEMM_PRECOMPILE: "0"
-      SGLANG_ENABLE_SPEC_V2: "1"
-      NO_COLOR: "1"
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: "3600"
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: "3600"
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: "3600"
-      PYTHONUNBUFFERED: "1"
-      NCCL_MNNVL_ENABLE: "1"
-      NCCL_CUMEM_ENABLE: "1"
-      MC_FORCE_MNNVL: "1"
-      MC_TE_METRIC: "true"
-      SGLANG_DG_CACHE_DIR: "/tmp/deepgemm-cache"
-      FLASHINFER_WORKSPACE_BASE: "/configs/flashinfer-cache"
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: "100000"
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: "100000"
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: "100000"
-      SGLANG_DECODE_BOOTSTRAP_TIMEOUT: "1000"
-      SGLANG_HACK_SEQ_BOOTSTRAP_ROOM: "1"
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: "True"
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: "0"
-      SGLANG_ENABLE_TP_MEMORY_INBALANCE_CHECK: "0"
-      SGLANG_DEEPEP_NUM_MAX_DISPATCH_TOKENS_PER_RANK: "512"
-      SGLANG_HEALTH_CHECK_TIMEOUT: "1800"
-      SGLANG_HEALTH_STARTING_OK: "1"
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: "0"
-
-    args:
-      served-model-name: "Qwen/Qwen3.5-397B-A17B-FP8"
-      model-path: "/model/"
-      random-seed: 42
-      trust-remote-code: true
-      quantization: "fp8"
-      kv-cache-dtype: "fp8_e4m3"
-
-      tensor-parallel-size: 16
-      data-parallel-size: 16
-      expert-parallel-size: 16
-      moe-dense-tp-size: 1
-      enable-dp-attention: true
-      enable-dp-lm-head: true
-      load-balance-method: "follow_bootstrap_room"
-      mamba-radix-cache-strategy: "no_buffer"
-      mamba-track-interval: 128
-      mamba-ssm-dtype: "bfloat16"
-
-      speculative-algorithm: "EAGLE"
-      speculative-num-steps: 3
-      speculative-eagle-topk: 1
-      speculative-num-draft-tokens: 4
-
-      disaggregation-mode: "decode"
-      disable-radix-cache: true
-      disaggregation-bootstrap-port: 31000
-
-      chunked-prefill-size: 4096
-      context-length: 16384
-      mem-fraction-static: 0.7
-      max-mamba-cache-size: 1024
-      max-running-requests: 1024
-      cuda-graph-max-bs-decode: 128
-      watchdog-timeout: 1000000
-
-      page-size: 64
-      attention-backend: "trtllm_mha"
-      moe-runner-backend: "deep_gemm"
-      moe-a2a-backend: "deepep"
-      deepep-mode: "low_latency"
-      ep-dispatch-algorithm: "static"
-      eplb-algorithm: "deepseek"
-
-      decode-log-interval: 1
-      stream-interval: 50
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp8/8k1k/disagg-4p1d-dep4-dep16-stp.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp8/8k1k/disagg-4p1d-dep4-dep16-stp.yaml
deleted file mode 100644
index f00b35dcb2..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp8/8k1k/disagg-4p1d-dep4-dep16-stp.yaml
+++ /dev/null
@@ -1,146 +0,0 @@
-schema: 2
-name: "qwen3.5-4p1d-dep4-dep16"
-
-setup_script: rebuild-deepep.sh
-
-sbatch_directives:
-  mem: "0"
-
-dynamo:
-  install: true
-
-  source:
-    wheel: "1.5.0.dev20260917"
-frontend:
-  type: dynamo
-  enable_multiple_frontends: true
-  num_additional_frontends: 3
-  nginx_container: nginx
-
-resources:
-  gpu_type: "gb200"
-  gpus_per_node: 4
-engine: sglang
-roles:
-  prefill:
-    nodes: 4
-    workers: 4
-    env:
-      SGLANG_JIT_DEEPGEMM_PRECOMPILE: "0"
-      NO_COLOR: "1"
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: "3600"
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: "3600"
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: "3600"
-      PYTHONUNBUFFERED: "1"
-      NCCL_MNNVL_ENABLE: "1"
-      NCCL_CUMEM_ENABLE: "1"
-      MC_FORCE_MNNVL: "1"
-      SGLANG_DG_CACHE_DIR: "/configs/deepgemm-cache"
-      FLASHINFER_WORKSPACE_BASE: "/configs/flashinfer-cache"
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: "100000"
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: "100000"
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: "100000"
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: "True"
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: "0"
-      SGLANG_ENABLE_TP_MEMORY_INBALANCE_CHECK: "0"
-      SGLANG_HEALTH_STARTING_OK: "1"
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: "0"
-
-    args:
-      served-model-name: "Qwen/Qwen3.5-397B-A17B-FP8"
-      model-path: "/model/"
-      quantization: "fp8"
-      kv-cache-dtype: "fp8_e4m3"
-      trust-remote-code: true
-
-      tensor-parallel-size: 4
-      data-parallel-size: 4
-      expert-parallel-size: 4
-      enable-dp-attention: true
-      enable-dp-lm-head: true
-
-      mamba-radix-cache-strategy: "no_buffer"
-      mamba-track-interval: 2048
-      mamba-ssm-dtype: "bfloat16"
-      disaggregation-mode: "prefill"
-      disable-radix-cache: true
-      disaggregation-bootstrap-port: 31000
-      mem-fraction-static: 0.8
-      chunked-prefill-size: 65536
-      load-balance-method: "round_robin"
-      watchdog-timeout: 1000000
-      disable-cuda-graph: true
-      log-level: "info"
-      page-size: 64
-      attention-backend: "trtllm_mha"
-      moe-runner-backend: "flashinfer_trtllm"
-
-  decode:
-    nodes: 4
-    workers: 1
-
-    env:
-      SGLANG_JIT_DEEPGEMM_PRECOMPILE: "0"
-      NO_COLOR: "1"
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: "3600"
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: "3600"
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: "3600"
-      PYTHONUNBUFFERED: "1"
-      NCCL_MNNVL_ENABLE: "1"
-      NCCL_CUMEM_ENABLE: "1"
-      MC_FORCE_MNNVL: "1"
-      MC_TE_METRIC: "true"
-      SGLANG_DG_CACHE_DIR: "/tmp/deepgemm-cache"
-      FLASHINFER_WORKSPACE_BASE: "/configs/flashinfer-cache"
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: "100000"
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: "100000"
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: "100000"
-      SGLANG_DECODE_BOOTSTRAP_TIMEOUT: "1000"
-      SGLANG_HACK_SEQ_BOOTSTRAP_ROOM: "1"
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: "True"
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: "0"
-      SGLANG_ENABLE_TP_MEMORY_INBALANCE_CHECK: "0"
-      SGLANG_DEEPEP_NUM_MAX_DISPATCH_TOKENS_PER_RANK: "512"
-      SGLANG_HEALTH_CHECK_TIMEOUT: "1800"
-      SGLANG_HEALTH_STARTING_OK: "1"
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: "0"
-
-    args:
-      served-model-name: "Qwen/Qwen3.5-397B-A17B-FP8"
-      model-path: "/model/"
-      trust-remote-code: true
-      quantization: "fp8"
-      kv-cache-dtype: "fp8_e4m3"
-
-      tensor-parallel-size: 16
-      data-parallel-size: 16
-      expert-parallel-size: 16
-      enable-dp-attention: true
-      enable-dp-lm-head: true
-      load-balance-method: "follow_bootstrap_room"
-      mamba-radix-cache-strategy: "no_buffer"
-      mamba-track-interval: 128
-      mamba-ssm-dtype: "bfloat16"
-
-      disaggregation-mode: "decode"
-      disable-radix-cache: true
-      disaggregation-bootstrap-port: 31000
-
-      chunked-prefill-size: 4096
-      context-length: 16384
-      mem-fraction-static: 0.80
-      max-mamba-cache-size: 2048
-      max-running-requests: 2048
-      cuda-graph-max-bs-decode: 128
-      watchdog-timeout: 1000000
-
-      page-size: 64
-      attention-backend: "trtllm_mha"
-      moe-runner-backend: "deep_gemm"
-      moe-a2a-backend: "deepep"
-      deepep-mode: "low_latency"
-      ep-dispatch-algorithm: "static"
-      eplb-algorithm: "deepseek"
-
-      decode-log-interval: 1
-      stream-interval: 50
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp8/8k1k/disagg-4p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b1024-c768-mtp.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp8/8k1k/disagg-4p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b1024-c768-mtp.yaml
deleted file mode 100644
index 1be00ae5d9..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp8/8k1k/disagg-4p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b1024-c768-mtp.yaml
+++ /dev/null
@@ -1,157 +0,0 @@
-
-schema: 2
-name: "qwen3.5-fp8-gb200-mtp-8k1k-4p1d-dep4-dep16"
-
-sbatch_directives:
-  mem: "0"
-
-dynamo:
-  install: true
-
-  source:
-    wheel: "1.5.0.dev20260917"
-frontend:
-  type: dynamo
-  enable_multiple_frontends: true
-  num_additional_frontends: 3
-  nginx_container: nginx
-
-resources:
-  gpu_type: "gb200"
-  gpus_per_node: 4
-engine: sglang
-roles:
-  prefill:
-    nodes: 4
-    workers: 4
-    env:
-      SGLANG_JIT_DEEPGEMM_PRECOMPILE: "0"
-      SGLANG_ENABLE_SPEC_V2: "1"
-      NO_COLOR: "1"
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: "3600"
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: "3600"
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: "3600"
-      PYTHONUNBUFFERED: "1"
-      NCCL_MNNVL_ENABLE: "1"
-      NCCL_CUMEM_ENABLE: "1"
-      MC_FORCE_MNNVL: "1"
-      SGLANG_DG_CACHE_DIR: "/configs/deepgemm-cache"
-      FLASHINFER_WORKSPACE_BASE: "/configs/flashinfer-cache"
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: "100000"
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: "100000"
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: "100000"
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: "True"
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: "0"
-      SGLANG_ENABLE_TP_MEMORY_INBALANCE_CHECK: "0"
-      SGLANG_HEALTH_STARTING_OK: "1"
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: "0"
-
-    args:
-      served-model-name: "Qwen/Qwen3.5-397B-A17B-FP8"
-      model-path: "/model/"
-      random-seed: 42
-      quantization: "fp8"
-      kv-cache-dtype: "fp8_e4m3"
-      trust-remote-code: true
-
-      tensor-parallel-size: 4
-      data-parallel-size: 4
-      expert-parallel-size: 4
-      enable-dp-attention: true
-      enable-dp-lm-head: true
-      moe-dense-tp-size: 1
-
-      mamba-radix-cache-strategy: "no_buffer"
-      mamba-track-interval: 2048
-      mamba-ssm-dtype: "bfloat16"
-      disaggregation-mode: "prefill"
-      disable-radix-cache: true
-      disaggregation-bootstrap-port: 31000
-      mem-fraction-static: 0.7
-      chunked-prefill-size: 98304
-      max-prefill-tokens: 24576
-      load-balance-method: "round_robin"
-      watchdog-timeout: 1000000
-      disable-cuda-graph: true
-      log-level: "info"
-      page-size: 64
-      attention-backend: "trtllm_mha"
-      moe-runner-backend: "flashinfer_trtllm"
-
-  decode:
-    nodes: 4
-    workers: 1
-
-    env:
-      SGLANG_JIT_DEEPGEMM_PRECOMPILE: "0"
-      SGLANG_ENABLE_SPEC_V2: "1"
-      NO_COLOR: "1"
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: "3600"
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: "3600"
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: "3600"
-      PYTHONUNBUFFERED: "1"
-      NCCL_MNNVL_ENABLE: "1"
-      NCCL_CUMEM_ENABLE: "1"
-      MC_FORCE_MNNVL: "1"
-      MC_TE_METRIC: "true"
-      SGLANG_DG_CACHE_DIR: "/tmp/deepgemm-cache"
-      FLASHINFER_WORKSPACE_BASE: "/configs/flashinfer-cache"
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: "100000"
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: "100000"
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: "100000"
-      SGLANG_DECODE_BOOTSTRAP_TIMEOUT: "1000"
-      SGLANG_HACK_SEQ_BOOTSTRAP_ROOM: "1"
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: "True"
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: "0"
-      SGLANG_ENABLE_TP_MEMORY_INBALANCE_CHECK: "0"
-      SGLANG_DEEPEP_NUM_MAX_DISPATCH_TOKENS_PER_RANK: "512"
-      SGLANG_HEALTH_CHECK_TIMEOUT: "1800"
-      SGLANG_HEALTH_STARTING_OK: "1"
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: "0"
-
-    args:
-      served-model-name: "Qwen/Qwen3.5-397B-A17B-FP8"
-      model-path: "/model/"
-      random-seed: 42
-      trust-remote-code: true
-      quantization: "fp8"
-      kv-cache-dtype: "fp8_e4m3"
-
-      tensor-parallel-size: 16
-      data-parallel-size: 16
-      expert-parallel-size: 16
-      moe-dense-tp-size: 1
-      enable-dp-attention: true
-      enable-dp-lm-head: true
-      load-balance-method: "follow_bootstrap_room"
-      mamba-radix-cache-strategy: "no_buffer"
-      mamba-track-interval: 128
-      mamba-ssm-dtype: "bfloat16"
-
-      speculative-algorithm: "EAGLE"
-      speculative-num-steps: 3
-      speculative-eagle-topk: 1
-      speculative-num-draft-tokens: 4
-
-      disaggregation-mode: "decode"
-      disable-radix-cache: true
-      disaggregation-bootstrap-port: 31000
-
-      chunked-prefill-size: 4096
-      context-length: 16384
-      mem-fraction-static: 0.7
-      max-mamba-cache-size: 1024
-      max-running-requests: 1024
-      cuda-graph-max-bs-decode: 128
-      watchdog-timeout: 1000000
-
-      page-size: 64
-      attention-backend: "trtllm_mha"
-      moe-runner-backend: "deep_gemm"
-      moe-a2a-backend: "deepep"
-      deepep-mode: "low_latency"
-      ep-dispatch-algorithm: "static"
-      eplb-algorithm: "deepseek"
-
-      decode-log-interval: 1
-      stream-interval: 50
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp8/8k1k/disagg-6p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b1024-c1280-mtp.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp8/8k1k/disagg-6p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b1024-c1280-mtp.yaml
deleted file mode 100644
index 523d346759..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp8/8k1k/disagg-6p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b1024-c1280-mtp.yaml
+++ /dev/null
@@ -1,157 +0,0 @@
-
-schema: 2
-name: "qwen3.5-fp8-gb200-mtp-8k1k-6p1d-dep4-dep16"
-
-sbatch_directives:
-  mem: "0"
-
-dynamo:
-  install: true
-
-  source:
-    wheel: "1.5.0.dev20260917"
-frontend:
-  type: dynamo
-  enable_multiple_frontends: true
-  num_additional_frontends: 5
-  nginx_container: nginx
-
-resources:
-  gpu_type: "gb200"
-  gpus_per_node: 4
-engine: sglang
-roles:
-  prefill:
-    nodes: 6
-    workers: 6
-    env:
-      SGLANG_JIT_DEEPGEMM_PRECOMPILE: "0"
-      SGLANG_ENABLE_SPEC_V2: "1"
-      NO_COLOR: "1"
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: "3600"
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: "3600"
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: "3600"
-      PYTHONUNBUFFERED: "1"
-      NCCL_MNNVL_ENABLE: "1"
-      NCCL_CUMEM_ENABLE: "1"
-      MC_FORCE_MNNVL: "1"
-      SGLANG_DG_CACHE_DIR: "/configs/deepgemm-cache"
-      FLASHINFER_WORKSPACE_BASE: "/configs/flashinfer-cache"
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: "100000"
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: "100000"
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: "100000"
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: "True"
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: "0"
-      SGLANG_ENABLE_TP_MEMORY_INBALANCE_CHECK: "0"
-      SGLANG_HEALTH_STARTING_OK: "1"
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: "0"
-
-    args:
-      served-model-name: "Qwen/Qwen3.5-397B-A17B-FP8"
-      model-path: "/model/"
-      random-seed: 42
-      quantization: "fp8"
-      kv-cache-dtype: "fp8_e4m3"
-      trust-remote-code: true
-
-      tensor-parallel-size: 4
-      data-parallel-size: 4
-      expert-parallel-size: 4
-      enable-dp-attention: true
-      enable-dp-lm-head: true
-      moe-dense-tp-size: 1
-
-      mamba-radix-cache-strategy: "no_buffer"
-      mamba-track-interval: 2048
-      mamba-ssm-dtype: "bfloat16"
-      disaggregation-mode: "prefill"
-      disable-radix-cache: true
-      disaggregation-bootstrap-port: 31001
-      mem-fraction-static: 0.7
-      chunked-prefill-size: 65536
-      max-prefill-tokens: 16384
-      load-balance-method: "round_robin"
-      watchdog-timeout: 1000000
-      disable-cuda-graph: true
-      log-level: "info"
-      page-size: 64
-      attention-backend: "trtllm_mha"
-      moe-runner-backend: "flashinfer_trtllm"
-
-  decode:
-    nodes: 4
-    workers: 1
-
-    env:
-      SGLANG_JIT_DEEPGEMM_PRECOMPILE: "0"
-      SGLANG_ENABLE_SPEC_V2: "1"
-      NO_COLOR: "1"
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: "3600"
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: "3600"
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: "3600"
-      PYTHONUNBUFFERED: "1"
-      NCCL_MNNVL_ENABLE: "1"
-      NCCL_CUMEM_ENABLE: "1"
-      MC_FORCE_MNNVL: "1"
-      MC_TE_METRIC: "true"
-      SGLANG_DG_CACHE_DIR: "/tmp/deepgemm-cache"
-      FLASHINFER_WORKSPACE_BASE: "/configs/flashinfer-cache"
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: "100000"
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: "100000"
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: "100000"
-      SGLANG_DECODE_BOOTSTRAP_TIMEOUT: "1000"
-      SGLANG_HACK_SEQ_BOOTSTRAP_ROOM: "1"
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: "True"
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: "0"
-      SGLANG_ENABLE_TP_MEMORY_INBALANCE_CHECK: "0"
-      SGLANG_DEEPEP_NUM_MAX_DISPATCH_TOKENS_PER_RANK: "512"
-      SGLANG_HEALTH_CHECK_TIMEOUT: "1800"
-      SGLANG_HEALTH_STARTING_OK: "1"
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: "0"
-
-    args:
-      served-model-name: "Qwen/Qwen3.5-397B-A17B-FP8"
-      model-path: "/model/"
-      random-seed: 42
-      trust-remote-code: true
-      quantization: "fp8"
-      kv-cache-dtype: "fp8_e4m3"
-
-      tensor-parallel-size: 16
-      data-parallel-size: 16
-      expert-parallel-size: 16
-      moe-dense-tp-size: 1
-      enable-dp-attention: true
-      enable-dp-lm-head: true
-      load-balance-method: "follow_bootstrap_room"
-      mamba-radix-cache-strategy: "no_buffer"
-      mamba-track-interval: 128
-      mamba-ssm-dtype: "bfloat16"
-
-      speculative-algorithm: "EAGLE"
-      speculative-num-steps: 3
-      speculative-eagle-topk: 1
-      speculative-num-draft-tokens: 4
-
-      disaggregation-mode: "decode"
-      disable-radix-cache: true
-      disaggregation-bootstrap-port: 31001
-
-      chunked-prefill-size: 4096
-      context-length: 16384
-      mem-fraction-static: 0.7
-      max-mamba-cache-size: 1024
-      max-running-requests: 1024
-      cuda-graph-max-bs-decode: 128
-      watchdog-timeout: 1000000
-
-      page-size: 64
-      attention-backend: "trtllm_mha"
-      moe-runner-backend: "deep_gemm"
-      moe-a2a-backend: "deepep"
-      deepep-mode: "low_latency"
-      ep-dispatch-algorithm: "static"
-      eplb-algorithm: "deepseek"
-
-      decode-log-interval: 1
-      stream-interval: 50
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp8/8k1k/disagg-7p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b2048-c1344-mtp.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp8/8k1k/disagg-7p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b2048-c1344-mtp.yaml
deleted file mode 100644
index c67158730e..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp8/8k1k/disagg-7p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b2048-c1344-mtp.yaml
+++ /dev/null
@@ -1,157 +0,0 @@
-
-schema: 2
-name: "qwen3.5-fp8-gb200-mtp-8k1k-7p1d-dep4-dep16"
-
-sbatch_directives:
-  mem: "0"
-
-dynamo:
-  install: true
-
-  source:
-    wheel: "1.5.0.dev20260917"
-frontend:
-  type: dynamo
-  enable_multiple_frontends: true
-  num_additional_frontends: 6
-  nginx_container: nginx
-
-resources:
-  gpu_type: "gb200"
-  gpus_per_node: 4
-engine: sglang
-roles:
-  prefill:
-    nodes: 7
-    workers: 7
-    env:
-      SGLANG_JIT_DEEPGEMM_PRECOMPILE: "0"
-      SGLANG_ENABLE_SPEC_V2: "1"
-      NO_COLOR: "1"
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: "3600"
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: "3600"
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: "3600"
-      PYTHONUNBUFFERED: "1"
-      NCCL_MNNVL_ENABLE: "1"
-      NCCL_CUMEM_ENABLE: "1"
-      MC_FORCE_MNNVL: "1"
-      SGLANG_DG_CACHE_DIR: "/configs/deepgemm-cache"
-      FLASHINFER_WORKSPACE_BASE: "/configs/flashinfer-cache"
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: "100000"
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: "100000"
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: "100000"
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: "True"
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: "0"
-      SGLANG_ENABLE_TP_MEMORY_INBALANCE_CHECK: "0"
-      SGLANG_HEALTH_STARTING_OK: "1"
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: "0"
-
-    args:
-      served-model-name: "Qwen/Qwen3.5-397B-A17B-FP8"
-      model-path: "/model/"
-      random-seed: 42
-      quantization: "fp8"
-      kv-cache-dtype: "fp8_e4m3"
-      trust-remote-code: true
-
-      tensor-parallel-size: 4
-      data-parallel-size: 4
-      expert-parallel-size: 4
-      enable-dp-attention: true
-      enable-dp-lm-head: true
-      moe-dense-tp-size: 1
-
-      mamba-radix-cache-strategy: "no_buffer"
-      mamba-track-interval: 2048
-      mamba-ssm-dtype: "bfloat16"
-      disaggregation-mode: "prefill"
-      disable-radix-cache: true
-      disaggregation-bootstrap-port: 31001
-      mem-fraction-static: 0.7
-      chunked-prefill-size: 65536
-      max-prefill-tokens: 16384
-      load-balance-method: "round_robin"
-      watchdog-timeout: 1000000
-      disable-cuda-graph: true
-      log-level: "info"
-      page-size: 64
-      attention-backend: "trtllm_mha"
-      moe-runner-backend: "flashinfer_trtllm"
-
-  decode:
-    nodes: 4
-    workers: 1
-
-    env:
-      SGLANG_JIT_DEEPGEMM_PRECOMPILE: "0"
-      SGLANG_ENABLE_SPEC_V2: "1"
-      NO_COLOR: "1"
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: "3600"
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: "3600"
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: "3600"
-      PYTHONUNBUFFERED: "1"
-      NCCL_MNNVL_ENABLE: "1"
-      NCCL_CUMEM_ENABLE: "1"
-      MC_FORCE_MNNVL: "1"
-      MC_TE_METRIC: "true"
-      SGLANG_DG_CACHE_DIR: "/tmp/deepgemm-cache"
-      FLASHINFER_WORKSPACE_BASE: "/configs/flashinfer-cache"
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: "100000"
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: "100000"
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: "100000"
-      SGLANG_DECODE_BOOTSTRAP_TIMEOUT: "1000"
-      SGLANG_HACK_SEQ_BOOTSTRAP_ROOM: "1"
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: "True"
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: "0"
-      SGLANG_ENABLE_TP_MEMORY_INBALANCE_CHECK: "0"
-      SGLANG_DEEPEP_NUM_MAX_DISPATCH_TOKENS_PER_RANK: "512"
-      SGLANG_HEALTH_CHECK_TIMEOUT: "1800"
-      SGLANG_HEALTH_STARTING_OK: "1"
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: "0"
-
-    args:
-      served-model-name: "Qwen/Qwen3.5-397B-A17B-FP8"
-      model-path: "/model/"
-      random-seed: 42
-      trust-remote-code: true
-      quantization: "fp8"
-      kv-cache-dtype: "fp8_e4m3"
-
-      tensor-parallel-size: 16
-      data-parallel-size: 16
-      expert-parallel-size: 16
-      moe-dense-tp-size: 1
-      enable-dp-attention: true
-      enable-dp-lm-head: true
-      load-balance-method: "follow_bootstrap_room"
-      mamba-radix-cache-strategy: "no_buffer"
-      mamba-track-interval: 128
-      mamba-ssm-dtype: "bfloat16"
-
-      speculative-algorithm: "EAGLE"
-      speculative-num-steps: 3
-      speculative-eagle-topk: 1
-      speculative-num-draft-tokens: 4
-
-      disaggregation-mode: "decode"
-      disable-radix-cache: true
-      disaggregation-bootstrap-port: 31001
-
-      chunked-prefill-size: 4096
-      context-length: 16384
-      mem-fraction-static: 0.7
-      max-mamba-cache-size: 2048
-      max-running-requests: 2048
-      cuda-graph-max-bs-decode: 128
-      watchdog-timeout: 1000000
-
-      page-size: 64
-      attention-backend: "trtllm_mha"
-      moe-runner-backend: "deep_gemm"
-      moe-a2a-backend: "deepep"
-      deepep-mode: "low_latency"
-      ep-dispatch-algorithm: "static"
-      eplb-algorithm: "deepseek"
-
-      decode-log-interval: 1
-      stream-interval: 50
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp8/8k1k/disagg-8p1d-dep4-dep16-stp.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp8/8k1k/disagg-8p1d-dep4-dep16-stp.yaml
deleted file mode 100644
index babe512b1b..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp8/8k1k/disagg-8p1d-dep4-dep16-stp.yaml
+++ /dev/null
@@ -1,155 +0,0 @@
-schema: 2
-name: "qwen3.5-8p1d-dep4-dep16"
-
-setup_script: rebuild-deepep.sh
-
-sbatch_directives:
-  mem: "0"
-
-services:
-  - name: etcd
-    type: etcd
-    placement:
-      node: dedicated
-  - name: nats
-    type: nats
-    placement:
-      node: dedicated
-dynamo:
-  install: true
-
-  source:
-    wheel: "1.5.0.dev20260917"
-frontend:
-  type: dynamo
-  enable_multiple_frontends: true
-  num_additional_frontends: 4
-  nginx_container: nginx
-
-resources:
-  gpu_type: "gb200"
-  gpus_per_node: 4
-engine: sglang
-roles:
-  prefill:
-    nodes: 8
-    workers: 8
-    env:
-      SGLANG_JIT_DEEPGEMM_PRECOMPILE: "0"
-      NO_COLOR: "1"
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: "3600"
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: "3600"
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: "3600"
-      PYTHONUNBUFFERED: "1"
-      NCCL_MNNVL_ENABLE: "1"
-      NCCL_CUMEM_ENABLE: "1"
-      MC_FORCE_MNNVL: "1"
-      SGLANG_DG_CACHE_DIR: "/configs/deepgemm-cache"
-      FLASHINFER_WORKSPACE_BASE: "/configs/flashinfer-cache"
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: "100000"
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: "100000"
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: "100000"
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: "True"
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: "0"
-      SGLANG_ENABLE_TP_MEMORY_INBALANCE_CHECK: "0"
-      SGLANG_HEALTH_STARTING_OK: "1"
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: "0"
-
-    args:
-      served-model-name: "Qwen/Qwen3.5-397B-A17B-FP8"
-      model-path: "/model/"
-      quantization: "fp8"
-      kv-cache-dtype: "fp8_e4m3"
-      trust-remote-code: true
-
-      tensor-parallel-size: 4
-      data-parallel-size: 4
-      expert-parallel-size: 4
-      enable-dp-attention: true
-      enable-dp-lm-head: true
-
-      mamba-radix-cache-strategy: "no_buffer"
-      mamba-track-interval: 2048
-      mamba-ssm-dtype: "bfloat16"
-      disaggregation-mode: "prefill"
-      disable-radix-cache: true
-      disaggregation-bootstrap-port: 31000
-      mem-fraction-static: 0.8
-      chunked-prefill-size: 65536
-      load-balance-method: "round_robin"
-      watchdog-timeout: 1000000
-      disable-cuda-graph: true
-      log-level: "info"
-      page-size: 64
-      attention-backend: "trtllm_mha"
-      moe-runner-backend: "flashinfer_trtllm"
-
-  decode:
-    nodes: 4
-    workers: 1
-
-    env:
-      SGLANG_JIT_DEEPGEMM_PRECOMPILE: "0"
-      NO_COLOR: "1"
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: "3600"
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: "3600"
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: "3600"
-      PYTHONUNBUFFERED: "1"
-      NCCL_MNNVL_ENABLE: "1"
-      NCCL_CUMEM_ENABLE: "1"
-      MC_FORCE_MNNVL: "1"
-      MC_TE_METRIC: "true"
-      SGLANG_DG_CACHE_DIR: "/tmp/deepgemm-cache"
-      FLASHINFER_WORKSPACE_BASE: "/configs/flashinfer-cache"
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: "100000"
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: "100000"
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: "100000"
-      SGLANG_DECODE_BOOTSTRAP_TIMEOUT: "1000"
-      SGLANG_HACK_SEQ_BOOTSTRAP_ROOM: "1"
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: "True"
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: "0"
-      SGLANG_ENABLE_TP_MEMORY_INBALANCE_CHECK: "0"
-      SGLANG_DEEPEP_NUM_MAX_DISPATCH_TOKENS_PER_RANK: "512"
-      SGLANG_HEALTH_CHECK_TIMEOUT: "1800"
-      SGLANG_HEALTH_STARTING_OK: "1"
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: "0"
-
-    args:
-      served-model-name: "Qwen/Qwen3.5-397B-A17B-FP8"
-      model-path: "/model/"
-      trust-remote-code: true
-      quantization: "fp8"
-      kv-cache-dtype: "fp8_e4m3"
-
-      tensor-parallel-size: 16
-      data-parallel-size: 16
-      expert-parallel-size: 16
-      enable-dp-attention: true
-      enable-dp-lm-head: true
-      load-balance-method: "follow_bootstrap_room"
-      mamba-radix-cache-strategy: "no_buffer"
-      mamba-track-interval: 128
-      mamba-ssm-dtype: "bfloat16"
-
-      disaggregation-mode: "decode"
-      disable-radix-cache: true
-      disaggregation-bootstrap-port: 31000
-
-      chunked-prefill-size: 4096
-      context-length: 16384
-      mem-fraction-static: 0.80
-      max-mamba-cache-size: 2048
-      max-running-requests: 2048
-      cuda-graph-max-bs-decode: 128
-      watchdog-timeout: 1000000
-
-      page-size: 64
-      attention-backend: "trtllm_mha"
-      moe-runner-backend: "deep_gemm"
-      moe-a2a-backend: "deepep"
-      deepep-mode: "low_latency"
-      ep-dispatch-algorithm: "static"
-      eplb-algorithm: "deepseek"
-
-      decode-log-interval: 1
-      stream-interval: 50
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp8/8k1k/disagg-8p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b2048-c1920x2304-mtp.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp8/8k1k/disagg-8p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b2048-c1920x2304-mtp.yaml
deleted file mode 100644
index 11844a3556..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb200-fp8/8k1k/disagg-8p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b2048-c1920x2304-mtp.yaml
+++ /dev/null
@@ -1,157 +0,0 @@
-
-schema: 2
-name: "qwen3.5-fp8-gb200-mtp-8k1k-8p1d-dep4-dep16"
-
-sbatch_directives:
-  mem: "0"
-
-dynamo:
-  install: true
-
-  source:
-    wheel: "1.5.0.dev20260917"
-frontend:
-  type: dynamo
-  enable_multiple_frontends: true
-  num_additional_frontends: 7
-  nginx_container: nginx
-
-resources:
-  gpu_type: "gb200"
-  gpus_per_node: 4
-engine: sglang
-roles:
-  prefill:
-    nodes: 8
-    workers: 8
-    env:
-      SGLANG_JIT_DEEPGEMM_PRECOMPILE: "0"
-      SGLANG_ENABLE_SPEC_V2: "1"
-      NO_COLOR: "1"
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: "3600"
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: "3600"
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: "3600"
-      PYTHONUNBUFFERED: "1"
-      NCCL_MNNVL_ENABLE: "1"
-      NCCL_CUMEM_ENABLE: "1"
-      MC_FORCE_MNNVL: "1"
-      SGLANG_DG_CACHE_DIR: "/configs/deepgemm-cache"
-      FLASHINFER_WORKSPACE_BASE: "/configs/flashinfer-cache"
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: "100000"
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: "100000"
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: "100000"
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: "True"
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: "0"
-      SGLANG_ENABLE_TP_MEMORY_INBALANCE_CHECK: "0"
-      SGLANG_HEALTH_STARTING_OK: "1"
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: "0"
-
-    args:
-      served-model-name: "Qwen/Qwen3.5-397B-A17B-FP8"
-      model-path: "/model/"
-      random-seed: 42
-      quantization: "fp8"
-      kv-cache-dtype: "fp8_e4m3"
-      trust-remote-code: true
-
-      tensor-parallel-size: 4
-      data-parallel-size: 4
-      expert-parallel-size: 4
-      enable-dp-attention: true
-      enable-dp-lm-head: true
-      moe-dense-tp-size: 1
-
-      mamba-radix-cache-strategy: "no_buffer"
-      mamba-track-interval: 2048
-      mamba-ssm-dtype: "bfloat16"
-      disaggregation-mode: "prefill"
-      disable-radix-cache: true
-      disaggregation-bootstrap-port: 31001
-      mem-fraction-static: 0.7
-      chunked-prefill-size: 98304
-      max-prefill-tokens: 24576
-      load-balance-method: "round_robin"
-      watchdog-timeout: 1000000
-      disable-cuda-graph: true
-      log-level: "info"
-      page-size: 64
-      attention-backend: "trtllm_mha"
-      moe-runner-backend: "flashinfer_trtllm"
-
-  decode:
-    nodes: 4
-    workers: 1
-
-    env:
-      SGLANG_JIT_DEEPGEMM_PRECOMPILE: "0"
-      SGLANG_ENABLE_SPEC_V2: "1"
-      NO_COLOR: "1"
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: "3600"
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: "3600"
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: "3600"
-      PYTHONUNBUFFERED: "1"
-      NCCL_MNNVL_ENABLE: "1"
-      NCCL_CUMEM_ENABLE: "1"
-      MC_FORCE_MNNVL: "1"
-      MC_TE_METRIC: "true"
-      SGLANG_DG_CACHE_DIR: "/tmp/deepgemm-cache"
-      FLASHINFER_WORKSPACE_BASE: "/configs/flashinfer-cache"
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: "100000"
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: "100000"
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: "100000"
-      SGLANG_DECODE_BOOTSTRAP_TIMEOUT: "1000"
-      SGLANG_HACK_SEQ_BOOTSTRAP_ROOM: "1"
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: "True"
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: "0"
-      SGLANG_ENABLE_TP_MEMORY_INBALANCE_CHECK: "0"
-      SGLANG_DEEPEP_NUM_MAX_DISPATCH_TOKENS_PER_RANK: "512"
-      SGLANG_HEALTH_CHECK_TIMEOUT: "1800"
-      SGLANG_HEALTH_STARTING_OK: "1"
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: "0"
-
-    args:
-      served-model-name: "Qwen/Qwen3.5-397B-A17B-FP8"
-      model-path: "/model/"
-      random-seed: 42
-      trust-remote-code: true
-      quantization: "fp8"
-      kv-cache-dtype: "fp8_e4m3"
-
-      tensor-parallel-size: 16
-      data-parallel-size: 16
-      expert-parallel-size: 16
-      moe-dense-tp-size: 1
-      enable-dp-attention: true
-      enable-dp-lm-head: true
-      load-balance-method: "follow_bootstrap_room"
-      mamba-radix-cache-strategy: "no_buffer"
-      mamba-track-interval: 128
-      mamba-ssm-dtype: "bfloat16"
-
-      speculative-algorithm: "EAGLE"
-      speculative-num-steps: 3
-      speculative-eagle-topk: 1
-      speculative-num-draft-tokens: 4
-
-      disaggregation-mode: "decode"
-      disable-radix-cache: true
-      disaggregation-bootstrap-port: 31001
-
-      chunked-prefill-size: 4096
-      context-length: 16384
-      mem-fraction-static: 0.7
-      max-mamba-cache-size: 2048
-      max-running-requests: 2048
-      cuda-graph-max-bs-decode: 128
-      watchdog-timeout: 1000000
-
-      page-size: 64
-      attention-backend: "trtllm_mha"
-      moe-runner-backend: "deep_gemm"
-      moe-a2a-backend: "deepep"
-      deepep-mode: "low_latency"
-      ep-dispatch-algorithm: "static"
-      eplb-algorithm: "deepseek"
-
-      decode-log-interval: 1
-      stream-interval: 50
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp4/8k1k/disagg-1p1d-p-tp4-d-tp4-b128-c1x4x8x16x32x64x256-stp.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp4/8k1k/disagg-1p1d-p-tp4-d-tp4-b128-c1x4x8x16x32x64x256-stp.yaml
deleted file mode 100644
index 3783e6d628..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp4/8k1k/disagg-1p1d-p-tp4-d-tp4-b128-c1x4x8x16x32x64x256-stp.yaml
+++ /dev/null
@@ -1,157 +0,0 @@
-
-schema: 2
-name: "gb300-fp4-qwen3.5_8k1k_lowlat_0"
-
-dynamo:
-  source:
-    pypi: "1.6.0.dev20261007"
-
-frontend:
-  type: dynamo
-  enable_multiple_frontends: true
-  num_additional_frontends: 2
-  nginx_container: nginx
-
-resources:
-  gpu_type: "gb300"
-  gpus_per_node: 4
-engine: sglang
-roles:
-  prefill:
-    nodes: 1
-    workers: 1
-    env:
-      NO_COLOR: "1"
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: "1800"
-      SGLANG_ENABLE_SPEC_V2: "1"
-      PYTHONUNBUFFERED: "1"
-      NCCL_MNNVL_ENABLE: "1"
-      NCCL_CUMEM_ENABLE: "1"
-      NCCL_NVLS_ENABLE: "1"
-      MC_FORCE_MNNVL: "1"
-      SGLANG_ENABLE_JIT_DEEPGEMM: "true"
-      SGLANG_ENABLE_FLASHINFER_GEMM: "true"
-      FLASHINFER_DISABLE_VERSION_CHECK: "1"
-      SGLANG_DG_CACHE_DIR: "/configs/deepgemm-cache"
-      FLASHINFER_WORKSPACE_BASE: "/configs/flashinfer-cache"
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: "100000"
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: "100000"
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: "100000"
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: "True"
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: "0"
-      SGLANG_DISABLE_TP_MEMORY_INBALANCE_CHECK: "1"
-
-    args:
-      served-model-name: "nvidia/Qwen3.5-397B-A17B-NVFP4-V2"
-      model-path: "/model/"
-      trust-remote-code: true
-
-      tensor-parallel-size: 4
-      data-parallel-size: 1
-      expert-parallel-size: 1
-
-      reasoning-parser: "qwen3"
-      tool-call-parser: "qwen3_coder"
-
-      quantization: "modelopt_fp4"
-      fp4-gemm-backend: "flashinfer_cutlass"
-      kv-cache-dtype: "fp8_e4m3"
-
-      mamba-radix-cache-strategy: "no_buffer"
-      mamba-ssm-dtype: "bfloat16"
-      mamba-track-interval: 2048
-
-      attention-backend: "trtllm_mha"
-      mm-attention-backend: "triton_attn"
-      moe-runner-backend: "flashinfer_trtllm"
-      linear-attn-decode-backend: "flashinfer"
-
-      disaggregation-mode: "prefill"
-      disable-radix-cache: true
-
-      mem-fraction-static: 0.8
-      context-length: 9236
-      max-total-tokens: 128000
-      max-running-requests: 128
-      cuda-graph-max-bs-decode: 4
-      chunked-prefill-size: 32768
-      max-prefill-tokens: 32768
-      scheduler-recv-interval: 10
-      stream-interval: 30
-      load-balance-method: "round_robin"
-      page-size: 64
-      watchdog-timeout: 1000000
-      log-level: "info"
-
-  decode:
-    nodes: 1
-    workers: 1
-
-    env:
-      NO_COLOR: "1"
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: "1800"
-      SGLANG_ENABLE_SPEC_V2: "1"
-      PYTHONUNBUFFERED: "1"
-      NCCL_MNNVL_ENABLE: "1"
-      NCCL_CUMEM_ENABLE: "1"
-      NCCL_NVLS_ENABLE: "1"
-      MC_FORCE_MNNVL: "1"
-      MC_TE_METRIC: "true"
-      SGLANG_ENABLE_JIT_DEEPGEMM: "true"
-      SGLANG_ENABLE_FLASHINFER_GEMM: "true"
-      FLASHINFER_DISABLE_VERSION_CHECK: "1"
-      SGLANG_DG_CACHE_DIR: "/configs/deepgemm-cache"
-      FLASHINFER_WORKSPACE_BASE: "/configs/flashinfer-cache"
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: "100000"
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: "100000"
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: "100000"
-      SGLANG_DECODE_BOOTSTRAP_TIMEOUT: "1000"
-      SGLANG_HACK_SEQ_BOOTSTRAP_ROOM: "1"
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: "True"
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: "0"
-      SGLANG_DISABLE_TP_MEMORY_INBALANCE_CHECK: "1"
-      SGLANG_HEALTH_CHECK_TIMEOUT: "1800"
-      SGLANG_HEALTH_STARTING_OK: "1"
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: "0"
-
-    args:
-      served-model-name: "nvidia/Qwen3.5-397B-A17B-NVFP4-V2"
-      model-path: "/model/"
-      trust-remote-code: true
-
-      tensor-parallel-size: 4
-      data-parallel-size: 1
-      expert-parallel-size: 1
-
-      reasoning-parser: "qwen3"
-      tool-call-parser: "qwen3_coder"
-
-      quantization: "modelopt_fp4"
-      fp4-gemm-backend: "flashinfer_cutlass"
-      kv-cache-dtype: "fp8_e4m3"
-
-      mamba-radix-cache-strategy: "no_buffer"
-      mamba-ssm-dtype: "bfloat16"
-      mamba-track-interval: 128
-
-      attention-backend: "trtllm_mha"
-      mm-attention-backend: "triton_attn"
-      moe-runner-backend: "flashinfer_trtllm"
-      linear-attn-decode-backend: "flashinfer"
-
-      disaggregation-mode: "decode"
-      disable-radix-cache: true
-
-      mem-fraction-static: 0.8
-      context-length: 9236
-      max-total-tokens: 1500000
-      max-mamba-cache-size: 256
-      max-running-requests: 128
-      cuda-graph-max-bs-decode: 256
-      chunked-prefill-size: 32768
-      max-prefill-tokens: 32768
-      scheduler-recv-interval: 10
-      stream-interval: 30
-      page-size: 64
-      watchdog-timeout: 1000000
-      decode-log-interval: 50
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp4/8k1k/disagg-5p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b4096-c2048-stp.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp4/8k1k/disagg-5p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b4096-c2048-stp.yaml
deleted file mode 100644
index 735d157170..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp4/8k1k/disagg-5p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b4096-c2048-stp.yaml
+++ /dev/null
@@ -1,157 +0,0 @@
-
-schema: 2
-name: "gb300-fp4-qwen3.5_8k1k_maxtpt_0"
-
-dynamo:
-  source:
-    pypi: "1.6.0.dev20261007"
-
-frontend:
-  type: dynamo
-  enable_multiple_frontends: true
-  num_additional_frontends: 2
-  nginx_container: nginx
-
-resources:
-  gpu_type: "gb300"
-  gpus_per_node: 4
-engine: sglang
-roles:
-  prefill:
-    nodes: 5
-    workers: 5
-    env:
-      NO_COLOR: "1"
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: "1800"
-      SGLANG_ENABLE_SPEC_V2: "1"
-      PYTHONUNBUFFERED: "1"
-      NCCL_MNNVL_ENABLE: "1"
-      NCCL_CUMEM_ENABLE: "1"
-      NCCL_NVLS_ENABLE: "1"
-      MC_FORCE_MNNVL: "1"
-      SGLANG_ENABLE_JIT_DEEPGEMM: "true"
-      SGLANG_ENABLE_FLASHINFER_GEMM: "true"
-      SGLANG_FLASHINFER_FP4_GEMM_BACKEND: "cutlass"
-      FLASHINFER_DISABLE_VERSION_CHECK: "1"
-      SGLANG_DG_CACHE_DIR: "/configs/deepgemm-cache"
-      FLASHINFER_WORKSPACE_BASE: "/configs/flashinfer-cache"
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: "100000"
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: "100000"
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: "100000"
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: "True"
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: "0"
-      SGLANG_DISABLE_TP_MEMORY_INBALANCE_CHECK: "1"
-      SGLANG_ENABLE_NIXL: "1"
-
-    args:
-      served-model-name: "nvidia/Qwen3.5-397B-A17B-NVFP4-V2"
-      model-path: "/model/"
-      trust-remote-code: true
-
-      quantization: "modelopt_fp4"
-      kv-cache-dtype: "fp8_e4m3"
-
-      tensor-parallel-size: 4
-      data-parallel-size: 4
-      expert-parallel-size: 4
-      enable-dp-attention: true
-      enable-dp-lm-head: true
-
-      mamba-radix-cache-strategy: "no_buffer"
-      mamba-track-interval: 2048
-      mamba-ssm-dtype: "bfloat16"
-
-      disaggregation-mode: "prefill"
-      disable-radix-cache: true
-      disaggregation-bootstrap-port: 31000
-      disaggregation-transfer-backend: "nixl"
-
-      mem-fraction-static: 0.8
-      max-total-tokens: 128000
-      chunked-prefill-size: 65536
-      load-balance-method: "round_robin"
-      watchdog-timeout: 1000000
-      log-level: "info"
-      page-size: 64
-
-      attention-backend: "trtllm_mha"
-      moe-runner-backend: "flashinfer_trtllm"
-      linear-attn-decode-backend: "flashinfer"
-
-  decode:
-    nodes: 4
-    workers: 1
-
-    env:
-      NO_COLOR: "1"
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: "1800"
-      SGLANG_ENABLE_SPEC_V2: "1"
-      PYTHONUNBUFFERED: "1"
-      NCCL_MNNVL_ENABLE: "1"
-      NCCL_CUMEM_ENABLE: "1"
-      NCCL_NVLS_ENABLE: "1"
-      MC_FORCE_MNNVL: "1"
-      MC_TE_METRIC: "true"
-      SGLANG_ENABLE_JIT_DEEPGEMM: "true"
-      SGLANG_ENABLE_FLASHINFER_GEMM: "true"
-      SGLANG_FLASHINFER_FP4_GEMM_BACKEND: "cutlass"
-      SGLANG_MOE_NVFP4_DISPATCH: "1"
-      SGLANG_CUTEDSL_MOE_NVFP4_DISPATCH: "1"
-      SGLANG_NCCL_ALL_GATHER_IN_OVERLAP_SCHEDULER_SYNC_BATCH: "1"
-      FLASHINFER_DISABLE_VERSION_CHECK: "1"
-      SGLANG_DG_CACHE_DIR: "/configs/deepgemm-cache"
-      FLASHINFER_WORKSPACE_BASE: "/configs/flashinfer-cache"
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: "100000"
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: "100000"
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: "100000"
-      SGLANG_DECODE_BOOTSTRAP_TIMEOUT: "1000"
-      SGLANG_HACK_SEQ_BOOTSTRAP_ROOM: "1"
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: "True"
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: "0"
-      SGLANG_DISABLE_TP_MEMORY_INBALANCE_CHECK: "1"
-      SGLANG_DEEPEP_NUM_MAX_DISPATCH_TOKENS_PER_RANK: "1024"
-      SGLANG_HEALTH_CHECK_TIMEOUT: "1800"
-      SGLANG_HEALTH_STARTING_OK: "1"
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: "0"
-      SGLANG_ENABLE_NIXL: "1"
-
-    args:
-      served-model-name: "nvidia/Qwen3.5-397B-A17B-NVFP4-V2"
-      model-path: "/model/"
-      trust-remote-code: true
-
-      quantization: "modelopt_fp4"
-      kv-cache-dtype: "fp8_e4m3"
-
-      tensor-parallel-size: 16
-      data-parallel-size: 16
-      expert-parallel-size: 16
-      enable-dp-attention: true
-      enable-dp-lm-head: true
-      enable-two-batch-overlap: true
-
-      mamba-radix-cache-strategy: "no_buffer"
-      mamba-track-interval: 128
-      mamba-ssm-dtype: "bfloat16"
-
-      disaggregation-mode: "decode"
-      disable-radix-cache: true
-      disaggregation-bootstrap-port: 31000
-      disaggregation-transfer-backend: "nixl"
-
-      chunked-prefill-size: 4096
-      max-mamba-cache-size: 4096
-      max-total-tokens: 2200000
-      max-running-requests: 4096
-      mem-fraction-static: 0.8
-      watchdog-timeout: 1000000
-      page-size: 64
-
-      attention-backend: "trtllm_mha"
-      moe-runner-backend: "flashinfer_cutedsl"
-      moe-a2a-backend: "flashinfer"
-      disable-shared-experts-fusion: true
-      linear-attn-decode-backend: "flashinfer"
-
-      decode-log-interval: 50
-      stream-interval: 50
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp4/8k1k/disagg-6p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b5120-c5120-stp.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp4/8k1k/disagg-6p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b5120-c5120-stp.yaml
deleted file mode 100644
index ab61f51198..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp4/8k1k/disagg-6p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b5120-c5120-stp.yaml
+++ /dev/null
@@ -1,155 +0,0 @@
-
-schema: 2
-name: "gb300-fp4-qwen3.5_8k1k_maxtpt_1"
-
-dynamo:
-  source:
-    pypi: "1.6.0.dev20261007"
-
-frontend:
-  type: dynamo
-  enable_multiple_frontends: true
-  num_additional_frontends: 2
-  nginx_container: nginx
-
-resources:
-  gpu_type: "gb300"
-  gpus_per_node: 4
-engine: sglang
-roles:
-  prefill:
-    nodes: 6
-    workers: 6
-    env:
-      NO_COLOR: "1"
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: "1800"
-      SGLANG_ENABLE_SPEC_V2: "1"
-      PYTHONUNBUFFERED: "1"
-      NCCL_MNNVL_ENABLE: "1"
-      NCCL_CUMEM_ENABLE: "1"
-      NCCL_NVLS_ENABLE: "1"
-      MC_FORCE_MNNVL: "1"
-      SGLANG_ENABLE_JIT_DEEPGEMM: "true"
-      SGLANG_ENABLE_FLASHINFER_GEMM: "true"
-      SGLANG_FLASHINFER_FP4_GEMM_BACKEND: "cutlass"
-      FLASHINFER_DISABLE_VERSION_CHECK: "1"
-      SGLANG_DG_CACHE_DIR: "/configs/deepgemm-cache"
-      FLASHINFER_WORKSPACE_BASE: "/configs/flashinfer-cache"
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: "100000"
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: "100000"
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: "100000"
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: "True"
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: "0"
-      SGLANG_DISABLE_TP_MEMORY_INBALANCE_CHECK: "1"
-
-    args:
-      served-model-name: "nvidia/Qwen3.5-397B-A17B-NVFP4-V2"
-      model-path: "/model/"
-      trust-remote-code: true
-
-      quantization: "modelopt_fp4"
-      kv-cache-dtype: "fp8_e4m3"
-
-      tensor-parallel-size: 4
-      data-parallel-size: 4
-      expert-parallel-size: 4
-      enable-dp-attention: true
-      enable-dp-lm-head: true
-
-      mamba-radix-cache-strategy: "no_buffer"
-      mamba-track-interval: 2048
-      mamba-ssm-dtype: "bfloat16"
-
-      disaggregation-mode: "prefill"
-      disable-radix-cache: true
-      disaggregation-bootstrap-port: 31000
-      disaggregation-transfer-backend: "mooncake"
-
-      mem-fraction-static: 0.8
-      max-total-tokens: 128000
-      chunked-prefill-size: 65536
-      load-balance-method: "round_robin"
-      watchdog-timeout: 1000000
-      log-level: "info"
-      page-size: 64
-
-      attention-backend: "trtllm_mha"
-      moe-runner-backend: "flashinfer_trtllm"
-      linear-attn-decode-backend: "flashinfer"
-
-  decode:
-    nodes: 4
-    workers: 1
-
-    env:
-      NO_COLOR: "1"
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: "1800"
-      SGLANG_ENABLE_SPEC_V2: "1"
-      PYTHONUNBUFFERED: "1"
-      NCCL_MNNVL_ENABLE: "1"
-      NCCL_CUMEM_ENABLE: "1"
-      NCCL_NVLS_ENABLE: "1"
-      MC_FORCE_MNNVL: "1"
-      MC_TE_METRIC: "true"
-      SGLANG_ENABLE_JIT_DEEPGEMM: "true"
-      SGLANG_ENABLE_FLASHINFER_GEMM: "true"
-      SGLANG_FLASHINFER_FP4_GEMM_BACKEND: "cutlass"
-      SGLANG_MOE_NVFP4_DISPATCH: "1"
-      SGLANG_CUTEDSL_MOE_NVFP4_DISPATCH: "1"
-      SGLANG_NCCL_ALL_GATHER_IN_OVERLAP_SCHEDULER_SYNC_BATCH: "1"
-      FLASHINFER_DISABLE_VERSION_CHECK: "1"
-      SGLANG_DG_CACHE_DIR: "/configs/deepgemm-cache"
-      FLASHINFER_WORKSPACE_BASE: "/configs/flashinfer-cache"
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: "100000"
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: "100000"
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: "100000"
-      SGLANG_DECODE_BOOTSTRAP_TIMEOUT: "1000"
-      SGLANG_HACK_SEQ_BOOTSTRAP_ROOM: "1"
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: "True"
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: "0"
-      SGLANG_DISABLE_TP_MEMORY_INBALANCE_CHECK: "1"
-      SGLANG_DEEPEP_NUM_MAX_DISPATCH_TOKENS_PER_RANK: "1024"
-      SGLANG_HEALTH_CHECK_TIMEOUT: "1800"
-      SGLANG_HEALTH_STARTING_OK: "1"
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: "0"
-
-    args:
-      served-model-name: "nvidia/Qwen3.5-397B-A17B-NVFP4-V2"
-      model-path: "/model/"
-      trust-remote-code: true
-
-      quantization: "modelopt_fp4"
-      kv-cache-dtype: "fp8_e4m3"
-
-      tensor-parallel-size: 16
-      data-parallel-size: 16
-      expert-parallel-size: 16
-      enable-dp-attention: true
-      enable-dp-lm-head: true
-      enable-two-batch-overlap: true
-
-      mamba-radix-cache-strategy: "no_buffer"
-      mamba-track-interval: 128
-      mamba-ssm-dtype: "bfloat16"
-
-      disaggregation-mode: "decode"
-      disable-radix-cache: true
-      disaggregation-bootstrap-port: 31000
-      disaggregation-transfer-backend: "mooncake"
-
-      chunked-prefill-size: 5120
-      max-mamba-cache-size: 5120
-      max-total-tokens: 3200000
-      max-running-requests: 5120
-      mem-fraction-static: 0.8
-      watchdog-timeout: 1000000
-      page-size: 64
-
-      attention-backend: "trtllm_mha"
-      moe-runner-backend: "flashinfer_cutedsl"
-      moe-a2a-backend: "flashinfer"
-      disable-shared-experts-fusion: true
-      linear-attn-decode-backend: "flashinfer"
-
-      decode-log-interval: 50
-      stream-interval: 50
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp4/8k1k/disagg-7p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b5120-c5120-stp.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp4/8k1k/disagg-7p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b5120-c5120-stp.yaml
deleted file mode 100644
index 880a348233..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp4/8k1k/disagg-7p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b5120-c5120-stp.yaml
+++ /dev/null
@@ -1,155 +0,0 @@
-
-schema: 2
-name: "gb300-fp4-qwen3.5_8k1k_maxtpt_2"
-
-dynamo:
-  source:
-    pypi: "1.6.0.dev20261007"
-
-frontend:
-  type: dynamo
-  enable_multiple_frontends: true
-  num_additional_frontends: 2
-  nginx_container: nginx
-
-resources:
-  gpu_type: "gb300"
-  gpus_per_node: 4
-engine: sglang
-roles:
-  prefill:
-    nodes: 7
-    workers: 7
-    env:
-      NO_COLOR: "1"
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: "1800"
-      SGLANG_ENABLE_SPEC_V2: "1"
-      PYTHONUNBUFFERED: "1"
-      NCCL_MNNVL_ENABLE: "1"
-      NCCL_CUMEM_ENABLE: "1"
-      NCCL_NVLS_ENABLE: "1"
-      MC_FORCE_MNNVL: "1"
-      SGLANG_ENABLE_JIT_DEEPGEMM: "true"
-      SGLANG_ENABLE_FLASHINFER_GEMM: "true"
-      SGLANG_FLASHINFER_FP4_GEMM_BACKEND: "cutlass"
-      FLASHINFER_DISABLE_VERSION_CHECK: "1"
-      SGLANG_DG_CACHE_DIR: "/configs/deepgemm-cache"
-      FLASHINFER_WORKSPACE_BASE: "/configs/flashinfer-cache"
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: "100000"
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: "100000"
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: "100000"
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: "True"
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: "0"
-      SGLANG_DISABLE_TP_MEMORY_INBALANCE_CHECK: "1"
-
-    args:
-      served-model-name: "nvidia/Qwen3.5-397B-A17B-NVFP4-V2"
-      model-path: "/model/"
-      trust-remote-code: true
-
-      quantization: "modelopt_fp4"
-      kv-cache-dtype: "fp8_e4m3"
-
-      tensor-parallel-size: 4
-      data-parallel-size: 4
-      expert-parallel-size: 4
-      enable-dp-attention: true
-      enable-dp-lm-head: true
-
-      mamba-radix-cache-strategy: "no_buffer"
-      mamba-track-interval: 2048
-      mamba-ssm-dtype: "bfloat16"
-
-      disaggregation-mode: "prefill"
-      disable-radix-cache: true
-      disaggregation-bootstrap-port: 31000
-      disaggregation-transfer-backend: "mooncake"
-
-      mem-fraction-static: 0.8
-      max-total-tokens: 128000
-      chunked-prefill-size: 65536
-      load-balance-method: "round_robin"
-      watchdog-timeout: 1000000
-      log-level: "info"
-      page-size: 64
-
-      attention-backend: "trtllm_mha"
-      moe-runner-backend: "flashinfer_trtllm"
-      linear-attn-decode-backend: "flashinfer"
-
-  decode:
-    nodes: 4
-    workers: 1
-
-    env:
-      NO_COLOR: "1"
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: "1800"
-      SGLANG_ENABLE_SPEC_V2: "1"
-      PYTHONUNBUFFERED: "1"
-      NCCL_MNNVL_ENABLE: "1"
-      NCCL_CUMEM_ENABLE: "1"
-      NCCL_NVLS_ENABLE: "1"
-      MC_FORCE_MNNVL: "1"
-      MC_TE_METRIC: "true"
-      SGLANG_ENABLE_JIT_DEEPGEMM: "true"
-      SGLANG_ENABLE_FLASHINFER_GEMM: "true"
-      SGLANG_FLASHINFER_FP4_GEMM_BACKEND: "cutlass"
-      SGLANG_MOE_NVFP4_DISPATCH: "1"
-      SGLANG_CUTEDSL_MOE_NVFP4_DISPATCH: "1"
-      SGLANG_NCCL_ALL_GATHER_IN_OVERLAP_SCHEDULER_SYNC_BATCH: "1"
-      FLASHINFER_DISABLE_VERSION_CHECK: "1"
-      SGLANG_DG_CACHE_DIR: "/configs/deepgemm-cache"
-      FLASHINFER_WORKSPACE_BASE: "/configs/flashinfer-cache"
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: "100000"
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: "100000"
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: "100000"
-      SGLANG_DECODE_BOOTSTRAP_TIMEOUT: "1000"
-      SGLANG_HACK_SEQ_BOOTSTRAP_ROOM: "1"
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: "True"
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: "0"
-      SGLANG_DISABLE_TP_MEMORY_INBALANCE_CHECK: "1"
-      SGLANG_DEEPEP_NUM_MAX_DISPATCH_TOKENS_PER_RANK: "1024"
-      SGLANG_HEALTH_CHECK_TIMEOUT: "1800"
-      SGLANG_HEALTH_STARTING_OK: "1"
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: "0"
-
-    args:
-      served-model-name: "nvidia/Qwen3.5-397B-A17B-NVFP4-V2"
-      model-path: "/model/"
-      trust-remote-code: true
-
-      quantization: "modelopt_fp4"
-      kv-cache-dtype: "fp8_e4m3"
-
-      tensor-parallel-size: 16
-      data-parallel-size: 16
-      expert-parallel-size: 16
-      enable-dp-attention: true
-      enable-dp-lm-head: true
-      enable-two-batch-overlap: true
-
-      mamba-radix-cache-strategy: "no_buffer"
-      mamba-track-interval: 128
-      mamba-ssm-dtype: "bfloat16"
-
-      disaggregation-mode: "decode"
-      disable-radix-cache: true
-      disaggregation-bootstrap-port: 31000
-      disaggregation-transfer-backend: "mooncake"
-
-      chunked-prefill-size: 5120
-      max-mamba-cache-size: 5120
-      max-total-tokens: 3200000
-      max-running-requests: 5120
-      mem-fraction-static: 0.8
-      watchdog-timeout: 1000000
-      page-size: 64
-
-      attention-backend: "trtllm_mha"
-      moe-runner-backend: "flashinfer_cutedsl"
-      moe-a2a-backend: "flashinfer"
-      disable-shared-experts-fusion: true
-      linear-attn-decode-backend: "flashinfer"
-
-      decode-log-interval: 50
-      stream-interval: 50
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp8/8k1k/disagg-1p1d-p-tp4-d-tp4-b1024-c1x2x8-mtp.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp8/8k1k/disagg-1p1d-p-tp4-d-tp4-b1024-c1x2x8-mtp.yaml
deleted file mode 100644
index 9673c6a03b..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp8/8k1k/disagg-1p1d-p-tp4-d-tp4-b1024-c1x2x8-mtp.yaml
+++ /dev/null
@@ -1,130 +0,0 @@
-
-schema: 2
-name: "qwen3.5-fp8-gb300-mtp-8k1k-1p1d-tp4-tp4"
-
-sbatch_directives:
-  mem: "0"
-
-dynamo:
-  install: true
-
-  source:
-    rev: 46520ca59afe992fb5ef61b3197b2316f8df9b2b
-frontend:
-  type: dynamo
-  enable_multiple_frontends: true
-  num_additional_frontends: 1
-  nginx_container: nginx
-
-resources:
-  gpu_type: "gb300"
-  gpus_per_node: 4
-engine: sglang
-roles:
-  prefill:
-    nodes: 1
-    workers: 1
-    env:
-      SGLANG_JIT_DEEPGEMM_PRECOMPILE: "0"
-      SGLANG_ENABLE_SPEC_V2: "1"
-      NO_COLOR: "1"
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: "3600"
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: "3600"
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: "3600"
-      PYTHONUNBUFFERED: "1"
-      NCCL_MNNVL_ENABLE: "1"
-      NCCL_CUMEM_ENABLE: "1"
-      MC_FORCE_MNNVL: "1"
-      SGLANG_DG_CACHE_DIR: "/configs/deepgemm-cache"
-      FLASHINFER_WORKSPACE_BASE: "/configs/flashinfer-cache"
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: "100000"
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: "100000"
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: "100000"
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: "True"
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: "0"
-      SGLANG_DISABLE_TP_MEMORY_INBALANCE_CHECK: "1"
-      SGLANG_HEALTH_STARTING_OK: "1"
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: "0"
-
-    args:
-      served-model-name: "Qwen/Qwen3.5-397B-A17B-FP8"
-      model-path: "/model/"
-      quantization: "fp8"
-      kv-cache-dtype: "fp8_e4m3"
-      trust-remote-code: true
-      attention-backend: "trtllm_mha"
-      tensor-parallel-size: 4
-      mamba-scheduler-strategy: "no_buffer"
-      mamba-track-interval: 2048
-      mamba-ssm-dtype: "bfloat16"
-      moe-runner-backend: "flashinfer_trtllm"
-      disable-radix-cache: true
-      max-running-requests: 1024
-      mem-fraction-static: 0.8
-      chunked-prefill-size: 16384
-      max-prefill-tokens: 16384
-      context-length: 16384
-      cuda-graph-max-bs: 1024
-      decode-log-interval: 1
-      stream-interval: 50
-      disaggregation-mode: "prefill"
-
-  decode:
-    nodes: 1
-    workers: 1
-
-    env:
-      SGLANG_JIT_DEEPGEMM_PRECOMPILE: "0"
-      SGLANG_ENABLE_SPEC_V2: "1"
-      NO_COLOR: "1"
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: "3600"
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: "3600"
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: "3600"
-      PYTHONUNBUFFERED: "1"
-      NCCL_MNNVL_ENABLE: "1"
-      NCCL_CUMEM_ENABLE: "1"
-      MC_FORCE_MNNVL: "1"
-      MC_TE_METRIC: "true"
-      SGLANG_DG_CACHE_DIR: "/configs/deepgemm-cache"
-      FLASHINFER_WORKSPACE_BASE: "/configs/flashinfer-cache"
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: "100000"
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: "100000"
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: "100000"
-      SGLANG_DECODE_BOOTSTRAP_TIMEOUT: "1000"
-      SGLANG_HACK_SEQ_BOOTSTRAP_ROOM: "1"
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: "True"
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: "0"
-      SGLANG_DISABLE_TP_MEMORY_INBALANCE_CHECK: "1"
-      SGLANG_HEALTH_CHECK_TIMEOUT: "1800"
-      SGLANG_HEALTH_STARTING_OK: "1"
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: "0"
-
-    args:
-      served-model-name: "Qwen/Qwen3.5-397B-A17B-FP8"
-      model-path: "/model/"
-      quantization: "fp8"
-      kv-cache-dtype: "fp8_e4m3"
-      trust-remote-code: true
-      attention-backend: "trtllm_mha"
-      tensor-parallel-size: 4
-      mamba-scheduler-strategy: "no_buffer"
-      mamba-track-interval: 128
-      mamba-ssm-dtype: "bfloat16"
-      max-mamba-cache-size: 1024
-      moe-runner-backend: "flashinfer_trtllm"
-
-      speculative-algorithm: "EAGLE"
-      speculative-num-steps: 3
-      speculative-eagle-topk: 1
-      speculative-num-draft-tokens: 4
-
-      disable-radix-cache: true
-      max-running-requests: 1024
-      mem-fraction-static: 0.8
-      chunked-prefill-size: 16384
-      max-prefill-tokens: 16384
-      context-length: 16384
-      cuda-graph-max-bs: 1024
-      decode-log-interval: 1
-      stream-interval: 50
-      disaggregation-mode: "decode"
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp8/8k1k/disagg-1p1d-p-tp8-ep8-d-tp8-ep8-b1024-c32x48x80-mtp.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp8/8k1k/disagg-1p1d-p-tp8-ep8-d-tp8-ep8-b1024-c32x48x80-mtp.yaml
deleted file mode 100644
index fa60eb5b8a..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp8/8k1k/disagg-1p1d-p-tp8-ep8-d-tp8-ep8-b1024-c32x48x80-mtp.yaml
+++ /dev/null
@@ -1,142 +0,0 @@
-
-schema: 2
-name: "qwen3.5-fp8-gb300-mtp-8k1k-1p1d-tep8-tep8"
-
-sbatch_directives:
-  mem: "0"
-
-dynamo:
-  install: true
-
-  source:
-    rev: 46520ca59afe992fb5ef61b3197b2316f8df9b2b
-frontend:
-  type: dynamo
-  enable_multiple_frontends: true
-  num_additional_frontends: 1
-  nginx_container: nginx
-
-resources:
-  gpu_type: "gb300"
-  gpus_per_node: 4
-engine: sglang
-roles:
-  prefill:
-    nodes: 2
-    workers: 1
-    env:
-      SGLANG_JIT_DEEPGEMM_PRECOMPILE: "0"
-      SGLANG_ENABLE_SPEC_V2: "1"
-      NO_COLOR: "1"
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: "3600"
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: "3600"
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: "3600"
-      PYTHONUNBUFFERED: "1"
-      NCCL_MNNVL_ENABLE: "1"
-      NCCL_CUMEM_ENABLE: "1"
-      MC_FORCE_MNNVL: "1"
-      SGLANG_DG_CACHE_DIR: "/configs/deepgemm-cache"
-      FLASHINFER_WORKSPACE_BASE: "/configs/flashinfer-cache"
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: "100000"
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: "100000"
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: "100000"
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: "True"
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: "0"
-      SGLANG_DISABLE_TP_MEMORY_INBALANCE_CHECK: "1"
-      SGLANG_HEALTH_STARTING_OK: "1"
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: "0"
-
-    args:
-      served-model-name: "Qwen/Qwen3.5-397B-A17B-FP8"
-      model-path: "/model/"
-      random-seed: 42
-      quantization: "fp8"
-      kv-cache-dtype: "fp8_e4m3"
-      trust-remote-code: true
-      attention-backend: "trtllm_mha"
-      tensor-parallel-size: 8
-      data-parallel-size: 1
-      expert-parallel-size: 8
-      mamba-scheduler-strategy: "no_buffer"
-      mamba-track-interval: 2048
-      mamba-ssm-dtype: "bfloat16"
-      moe-runner-backend: "flashinfer_trtllm"
-      disable-radix-cache: true
-      max-running-requests: 1024
-      mem-fraction-static: 0.8
-      max-total-tokens: 128000
-      chunked-prefill-size: 16384
-      max-prefill-tokens: 16384
-      context-length: 9236
-      cuda-graph-max-bs: 320
-      scheduler-recv-interval: 10
-      decode-log-interval: 50
-      stream-interval: 50
-      disaggregation-mode: "prefill"
-      disaggregation-transfer-backend: "mooncake"
-
-  decode:
-    nodes: 2
-    workers: 1
-
-    env:
-      SGLANG_JIT_DEEPGEMM_PRECOMPILE: "0"
-      SGLANG_ENABLE_SPEC_V2: "1"
-      NO_COLOR: "1"
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: "3600"
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: "3600"
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: "3600"
-      PYTHONUNBUFFERED: "1"
-      NCCL_MNNVL_ENABLE: "1"
-      NCCL_CUMEM_ENABLE: "1"
-      MC_FORCE_MNNVL: "1"
-      MC_TE_METRIC: "true"
-      SGLANG_DG_CACHE_DIR: "/configs/deepgemm-cache"
-      FLASHINFER_WORKSPACE_BASE: "/configs/flashinfer-cache"
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: "100000"
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: "100000"
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: "100000"
-      SGLANG_DECODE_BOOTSTRAP_TIMEOUT: "1000"
-      SGLANG_HACK_SEQ_BOOTSTRAP_ROOM: "1"
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: "True"
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: "0"
-      SGLANG_DISABLE_TP_MEMORY_INBALANCE_CHECK: "1"
-      SGLANG_HEALTH_CHECK_TIMEOUT: "1800"
-      SGLANG_HEALTH_STARTING_OK: "1"
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: "0"
-
-    args:
-      served-model-name: "Qwen/Qwen3.5-397B-A17B-FP8"
-      model-path: "/model/"
-      random-seed: 42
-      quantization: "fp8"
-      kv-cache-dtype: "fp8_e4m3"
-      trust-remote-code: true
-      attention-backend: "trtllm_mha"
-      tensor-parallel-size: 8
-      data-parallel-size: 1
-      expert-parallel-size: 8
-      mamba-scheduler-strategy: "no_buffer"
-      mamba-track-interval: 128
-      mamba-ssm-dtype: "bfloat16"
-      max-mamba-cache-size: 1024
-      moe-runner-backend: "flashinfer_trtllm"
-
-      speculative-algorithm: "EAGLE"
-      speculative-num-steps: 3
-      speculative-eagle-topk: 1
-      speculative-num-draft-tokens: 4
-
-      disable-radix-cache: true
-      max-running-requests: 1024
-      mem-fraction-static: 0.8
-      max-total-tokens: 2200000
-      chunked-prefill-size: 4096
-      max-prefill-tokens: 16384
-      context-length: 9236
-      cuda-graph-max-bs: 320
-      scheduler-recv-interval: 10
-      decode-log-interval: 50
-      stream-interval: 50
-      disaggregation-mode: "decode"
-      disaggregation-transfer-backend: "mooncake"
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp8/8k1k/disagg-1p1d-tp4-tp4-stp.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp8/8k1k/disagg-1p1d-tp4-tp4-stp.yaml
deleted file mode 100644
index 3726af8901..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp8/8k1k/disagg-1p1d-tp4-tp4-stp.yaml
+++ /dev/null
@@ -1,110 +0,0 @@
-schema: 2
-name: "qwen3.5-1p1d-tp4-tp4"
-
-sbatch_directives:
-  mem: "0"
-
-dynamo:
-  install: true
-
-  source:
-    wheel: "1.5.0.dev20260917"
-frontend:
-  type: dynamo
-  enable_multiple_frontends: true
-  num_additional_frontends: 1
-  nginx_container: nginx
-
-resources:
-  gpu_type: "gb300"
-  gpus_per_node: 4
-engine: sglang
-roles:
-  prefill:
-    nodes: 1
-    workers: 1
-    env:
-      SGLANG_JIT_DEEPGEMM_PRECOMPILE: "0"
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: "3600"
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: "3600"
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: "3600"
-      PYTHONUNBUFFERED: "1"
-      NCCL_MNNVL_ENABLE: "1"
-      NCCL_CUMEM_ENABLE: "1"
-      SGLANG_DG_CACHE_DIR: "/configs/deepgemm-cache"
-      FLASHINFER_WORKSPACE_BASE: "/configs/flashinfer-cache"
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: "100000"
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: "100000"
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: "100000"
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: "0"
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: "True"
-      MC_FORCE_MNNVL: "1"
-
-    args:
-      served-model-name: "Qwen/Qwen3.5-397B-A17B-FP8"
-      model-path: "/model/"
-      quantization: "fp8"
-      kv-cache-dtype: "fp8_e4m3"
-      trust-remote-code: true
-      attention-backend: "trtllm_mha"
-      tensor-parallel-size: 4
-      mamba-ssm-dtype: "bfloat16"
-      moe-runner-backend: "flashinfer_trtllm"
-      disable-radix-cache: true
-      max-running-requests: 1024
-      mem-fraction-static: 0.8
-      chunked-prefill-size: 16384
-      max-prefill-tokens: 16384
-      context-length: 16384
-      cuda-graph-max-bs-decode: 1024
-      decode-log-interval: 1
-      stream-interval: 50
-      disaggregation-mode: "prefill"
-
-  decode:
-    nodes: 1
-    workers: 1
-
-    env:
-      SGLANG_JIT_DEEPGEMM_PRECOMPILE: "0"
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: "3600"
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: "3600"
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: "3600"
-      PYTHONUNBUFFERED: "1"
-      NCCL_MNNVL_ENABLE: "1"
-      NCCL_CUMEM_ENABLE: "1"
-      SGLANG_DG_CACHE_DIR: "/configs/deepgemm-cache"
-      FLASHINFER_WORKSPACE_BASE: "/configs/flashinfer-cache"
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: "100000"
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: "100000"
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: "100000"
-      SGLANG_DECODE_BOOTSTRAP_TIMEOUT: "1000"
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: "True"
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: "0"
-      SGLANG_HEALTH_CHECK_TIMEOUT: "3600"
-      SGLANG_HEALTH_STARTING_OK: "1"
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: "0"
-      MC_FORCE_MNNVL: "1"
-      MC_TE_METRIC: "true"
-      SGLANG_HACK_SEQ_BOOTSTRAP_ROOM: "1"
-
-    args:
-      served-model-name: "Qwen/Qwen3.5-397B-A17B-FP8"
-      model-path: "/model/"
-      quantization: "fp8"
-      kv-cache-dtype: "fp8_e4m3"
-      trust-remote-code: true
-      attention-backend: "trtllm_mha"
-      tensor-parallel-size: 4
-      mamba-ssm-dtype: "bfloat16"
-      moe-runner-backend: "flashinfer_trtllm"
-      disable-radix-cache: true
-      max-running-requests: 1024
-      mem-fraction-static: 0.8
-      chunked-prefill-size: 16384
-      max-prefill-tokens: 16384
-      context-length: 16384
-      cuda-graph-max-bs-decode: 1024
-      decode-log-interval: 1
-      stream-interval: 50
-      disaggregation-mode: "decode"
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp8/8k1k/disagg-3p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b1024-c480-mtp.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp8/8k1k/disagg-3p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b1024-c480-mtp.yaml
deleted file mode 100644
index 134d6b0de4..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp8/8k1k/disagg-3p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b1024-c480-mtp.yaml
+++ /dev/null
@@ -1,158 +0,0 @@
-
-schema: 2
-name: "qwen3.5-fp8-gb300-mtp-8k1k-3p1d-dep4-dep16"
-
-sbatch_directives:
-  mem: "0"
-
-dynamo:
-  install: true
-
-  source:
-    rev: 46520ca59afe992fb5ef61b3197b2316f8df9b2b
-frontend:
-  type: dynamo
-  enable_multiple_frontends: true
-  num_additional_frontends: 2
-  nginx_container: nginx
-
-resources:
-  gpu_type: "gb300"
-  gpus_per_node: 4
-engine: sglang
-roles:
-  prefill:
-    nodes: 3
-    workers: 3
-    env:
-      SGLANG_JIT_DEEPGEMM_PRECOMPILE: "0"
-      SGLANG_ENABLE_SPEC_V2: "1"
-      NO_COLOR: "1"
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: "3600"
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: "3600"
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: "3600"
-      PYTHONUNBUFFERED: "1"
-      NCCL_MNNVL_ENABLE: "1"
-      NCCL_CUMEM_ENABLE: "1"
-      MC_FORCE_MNNVL: "1"
-      SGLANG_DG_CACHE_DIR: "/configs/deepgemm-cache"
-      FLASHINFER_WORKSPACE_BASE: "/configs/flashinfer-cache"
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: "100000"
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: "100000"
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: "100000"
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: "True"
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: "0"
-      SGLANG_DISABLE_TP_MEMORY_INBALANCE_CHECK: "1"
-      SGLANG_HEALTH_STARTING_OK: "1"
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: "0"
-
-    args:
-      served-model-name: "Qwen/Qwen3.5-397B-A17B-FP8"
-      model-path: "/model/"
-      random-seed: 42
-      quantization: "fp8"
-      kv-cache-dtype: "fp8_e4m3"
-      trust-remote-code: true
-
-      tensor-parallel-size: 4
-      data-parallel-size: 4
-      expert-parallel-size: 4
-      enable-dp-attention: true
-      enable-dp-lm-head: true
-      moe-dense-tp-size: 1
-
-      mamba-scheduler-strategy: "no_buffer"
-      mamba-track-interval: 2048
-      mamba-ssm-dtype: "bfloat16"
-      disaggregation-mode: "prefill"
-      disable-radix-cache: true
-      disaggregation-bootstrap-port: 31000
-      mem-fraction-static: 0.7
-      chunked-prefill-size: 65536
-      max-prefill-tokens: 16384
-      load-balance-method: "round_robin"
-      watchdog-timeout: 1000000
-      disable-cuda-graph: true
-      log-level: "info"
-      page-size: 64
-      attention-backend: "trtllm_mha"
-      moe-runner-backend: "flashinfer_trtllm"
-
-  decode:
-    nodes: 4
-    workers: 1
-
-    env:
-      SGLANG_JIT_DEEPGEMM_PRECOMPILE: "0"
-      SGLANG_ENABLE_SPEC_V2: "1"
-      NO_COLOR: "1"
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: "3600"
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: "3600"
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: "3600"
-      PYTHONUNBUFFERED: "1"
-      NCCL_MNNVL_ENABLE: "1"
-      NCCL_CUMEM_ENABLE: "1"
-      MC_FORCE_MNNVL: "1"
-      MC_TE_METRIC: "true"
-      SGLANG_DG_CACHE_DIR: "/tmp/deepgemm-cache"
-      FLASHINFER_WORKSPACE_BASE: "/configs/flashinfer-cache"
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: "100000"
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: "100000"
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: "100000"
-      SGLANG_DECODE_BOOTSTRAP_TIMEOUT: "1000"
-      SGLANG_HACK_SEQ_BOOTSTRAP_ROOM: "1"
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: "True"
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: "0"
-      SGLANG_DISABLE_TP_MEMORY_INBALANCE_CHECK: "1"
-      SGLANG_DEEPEP_NUM_MAX_DISPATCH_TOKENS_PER_RANK: "512"
-      SGLANG_HEALTH_CHECK_TIMEOUT: "1800"
-      SGLANG_HEALTH_STARTING_OK: "1"
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: "0"
-
-    args:
-      served-model-name: "Qwen/Qwen3.5-397B-A17B-FP8"
-      model-path: "/model/"
-      random-seed: 42
-      trust-remote-code: true
-      quantization: "fp8"
-      kv-cache-dtype: "fp8_e4m3"
-
-      tensor-parallel-size: 16
-      data-parallel-size: 16
-      expert-parallel-size: 16
-      moe-dense-tp-size: 1
-      enable-dp-attention: true
-      enable-dp-lm-head: true
-      prefill-round-robin-balance: true
-
-      mamba-scheduler-strategy: "no_buffer"
-      mamba-track-interval: 128
-      mamba-ssm-dtype: "bfloat16"
-
-      speculative-algorithm: "EAGLE"
-      speculative-num-steps: 3
-      speculative-eagle-topk: 1
-      speculative-num-draft-tokens: 4
-
-      disaggregation-mode: "decode"
-      disable-radix-cache: true
-      disaggregation-bootstrap-port: 31000
-
-      chunked-prefill-size: 4096
-      context-length: 16384
-      mem-fraction-static: 0.7
-      max-mamba-cache-size: 1024
-      max-running-requests: 1024
-      cuda-graph-max-bs: 128
-      watchdog-timeout: 1000000
-
-      page-size: 64
-      attention-backend: "trtllm_mha"
-      moe-runner-backend: "deep_gemm"
-      moe-a2a-backend: "deepep"
-      deepep-mode: "low_latency"
-      ep-dispatch-algorithm: "static"
-      eplb-algorithm: "deepseek"
-
-      decode-log-interval: 1
-      stream-interval: 50
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp8/8k1k/disagg-4p1d-dep4-dep16-stp.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp8/8k1k/disagg-4p1d-dep4-dep16-stp.yaml
deleted file mode 100644
index 4b012610d4..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp8/8k1k/disagg-4p1d-dep4-dep16-stp.yaml
+++ /dev/null
@@ -1,145 +0,0 @@
-schema: 2
-name: "qwen3.5-4p1d-dep4-dep16"
-
-
-sbatch_directives:
-  mem: "0"
-
-dynamo:
-  install: true
-
-  source:
-    wheel: "1.5.0.dev20260917"
-frontend:
-  type: dynamo
-  enable_multiple_frontends: true
-  num_additional_frontends: 3
-  nginx_container: nginx
-
-resources:
-  gpu_type: "gb300"
-  gpus_per_node: 4
-engine: sglang
-roles:
-  prefill:
-    nodes: 4
-    workers: 4
-    env:
-      SGLANG_JIT_DEEPGEMM_PRECOMPILE: "0"
-      NO_COLOR: "1"
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: "3600"
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: "3600"
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: "3600"
-      PYTHONUNBUFFERED: "1"
-      NCCL_MNNVL_ENABLE: "1"
-      NCCL_CUMEM_ENABLE: "1"
-      MC_FORCE_MNNVL: "1"
-      SGLANG_DG_CACHE_DIR: "/configs/deepgemm-cache"
-      FLASHINFER_WORKSPACE_BASE: "/configs/flashinfer-cache"
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: "100000"
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: "100000"
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: "100000"
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: "True"
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: "0"
-      SGLANG_ENABLE_TP_MEMORY_INBALANCE_CHECK: "0"
-      SGLANG_HEALTH_STARTING_OK: "1"
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: "0"
-
-    args:
-      served-model-name: "Qwen/Qwen3.5-397B-A17B-FP8"
-      model-path: "/model/"
-      quantization: "fp8"
-      kv-cache-dtype: "fp8_e4m3"
-      trust-remote-code: true
-
-      tensor-parallel-size: 4
-      data-parallel-size: 4
-      expert-parallel-size: 4
-      enable-dp-attention: true
-      enable-dp-lm-head: true
-
-      mamba-radix-cache-strategy: "no_buffer"
-      mamba-track-interval: 2048
-      mamba-ssm-dtype: "bfloat16"
-      disaggregation-mode: "prefill"
-      disable-radix-cache: true
-      disaggregation-bootstrap-port: 31000
-      mem-fraction-static: 0.8
-      chunked-prefill-size: 65536
-      load-balance-method: "round_robin"
-      watchdog-timeout: 1000000
-      disable-cuda-graph: true
-      log-level: "info"
-      page-size: 64
-      attention-backend: "trtllm_mha"
-      moe-runner-backend: "flashinfer_trtllm"
-
-  decode:
-    nodes: 4
-    workers: 1
-
-    env:
-      SGLANG_JIT_DEEPGEMM_PRECOMPILE: "0"
-      NO_COLOR: "1"
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: "3600"
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: "3600"
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: "3600"
-      PYTHONUNBUFFERED: "1"
-      NCCL_MNNVL_ENABLE: "1"
-      NCCL_CUMEM_ENABLE: "1"
-      MC_FORCE_MNNVL: "1"
-      MC_TE_METRIC: "true"
-      SGLANG_DG_CACHE_DIR: "/tmp/deepgemm-cache"
-      FLASHINFER_WORKSPACE_BASE: "/configs/flashinfer-cache"
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: "100000"
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: "100000"
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: "100000"
-      SGLANG_DECODE_BOOTSTRAP_TIMEOUT: "1000"
-      SGLANG_HACK_SEQ_BOOTSTRAP_ROOM: "1"
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: "True"
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: "0"
-      SGLANG_ENABLE_TP_MEMORY_INBALANCE_CHECK: "0"
-      SGLANG_DEEPEP_NUM_MAX_DISPATCH_TOKENS_PER_RANK: "512"
-      SGLANG_HEALTH_CHECK_TIMEOUT: "1800"
-      SGLANG_HEALTH_STARTING_OK: "1"
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: "0"
-
-    args:
-      served-model-name: "Qwen/Qwen3.5-397B-A17B-FP8"
-      model-path: "/model/"
-      trust-remote-code: true
-      quantization: "fp8"
-      kv-cache-dtype: "fp8_e4m3"
-
-      tensor-parallel-size: 16
-      data-parallel-size: 16
-      expert-parallel-size: 16
-      enable-dp-attention: true
-      enable-dp-lm-head: true
-      load-balance-method: "follow_bootstrap_room"
-      mamba-radix-cache-strategy: "no_buffer"
-      mamba-track-interval: 128
-      mamba-ssm-dtype: "bfloat16"
-
-      disaggregation-mode: "decode"
-      disable-radix-cache: true
-      disaggregation-bootstrap-port: 31000
-
-      chunked-prefill-size: 4096
-      context-length: 16384
-      mem-fraction-static: 0.80
-      max-mamba-cache-size: 2048
-      max-running-requests: 2048
-      cuda-graph-max-bs-decode: 128
-      watchdog-timeout: 1000000
-
-      page-size: 64
-      attention-backend: "trtllm_mha"
-      moe-runner-backend: "deep_gemm"
-      moe-a2a-backend: "deepep"
-      deepep-mode: "low_latency"
-      ep-dispatch-algorithm: "static"
-      eplb-algorithm: "deepseek"
-
-      decode-log-interval: 1
-      stream-interval: 50
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp8/8k1k/disagg-4p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b1024-c768-mtp.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp8/8k1k/disagg-4p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b1024-c768-mtp.yaml
deleted file mode 100644
index e9167eb417..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp8/8k1k/disagg-4p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b1024-c768-mtp.yaml
+++ /dev/null
@@ -1,158 +0,0 @@
-
-schema: 2
-name: "qwen3.5-fp8-gb300-mtp-8k1k-4p1d-dep4-dep16"
-
-sbatch_directives:
-  mem: "0"
-
-dynamo:
-  install: true
-
-  source:
-    rev: 46520ca59afe992fb5ef61b3197b2316f8df9b2b
-frontend:
-  type: dynamo
-  enable_multiple_frontends: true
-  num_additional_frontends: 3
-  nginx_container: nginx
-
-resources:
-  gpu_type: "gb300"
-  gpus_per_node: 4
-engine: sglang
-roles:
-  prefill:
-    nodes: 4
-    workers: 4
-    env:
-      SGLANG_JIT_DEEPGEMM_PRECOMPILE: "0"
-      SGLANG_ENABLE_SPEC_V2: "1"
-      NO_COLOR: "1"
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: "3600"
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: "3600"
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: "3600"
-      PYTHONUNBUFFERED: "1"
-      NCCL_MNNVL_ENABLE: "1"
-      NCCL_CUMEM_ENABLE: "1"
-      MC_FORCE_MNNVL: "1"
-      SGLANG_DG_CACHE_DIR: "/configs/deepgemm-cache"
-      FLASHINFER_WORKSPACE_BASE: "/configs/flashinfer-cache"
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: "100000"
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: "100000"
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: "100000"
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: "True"
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: "0"
-      SGLANG_DISABLE_TP_MEMORY_INBALANCE_CHECK: "1"
-      SGLANG_HEALTH_STARTING_OK: "1"
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: "0"
-
-    args:
-      served-model-name: "Qwen/Qwen3.5-397B-A17B-FP8"
-      model-path: "/model/"
-      random-seed: 42
-      quantization: "fp8"
-      kv-cache-dtype: "fp8_e4m3"
-      trust-remote-code: true
-
-      tensor-parallel-size: 4
-      data-parallel-size: 4
-      expert-parallel-size: 4
-      enable-dp-attention: true
-      enable-dp-lm-head: true
-      moe-dense-tp-size: 1
-
-      mamba-scheduler-strategy: "no_buffer"
-      mamba-track-interval: 2048
-      mamba-ssm-dtype: "bfloat16"
-      disaggregation-mode: "prefill"
-      disable-radix-cache: true
-      disaggregation-bootstrap-port: 31000
-      mem-fraction-static: 0.7
-      chunked-prefill-size: 98304
-      max-prefill-tokens: 24576
-      load-balance-method: "round_robin"
-      watchdog-timeout: 1000000
-      disable-cuda-graph: true
-      log-level: "info"
-      page-size: 64
-      attention-backend: "trtllm_mha"
-      moe-runner-backend: "flashinfer_trtllm"
-
-  decode:
-    nodes: 4
-    workers: 1
-
-    env:
-      SGLANG_JIT_DEEPGEMM_PRECOMPILE: "0"
-      SGLANG_ENABLE_SPEC_V2: "1"
-      NO_COLOR: "1"
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: "3600"
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: "3600"
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: "3600"
-      PYTHONUNBUFFERED: "1"
-      NCCL_MNNVL_ENABLE: "1"
-      NCCL_CUMEM_ENABLE: "1"
-      MC_FORCE_MNNVL: "1"
-      MC_TE_METRIC: "true"
-      SGLANG_DG_CACHE_DIR: "/tmp/deepgemm-cache"
-      FLASHINFER_WORKSPACE_BASE: "/configs/flashinfer-cache"
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: "100000"
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: "100000"
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: "100000"
-      SGLANG_DECODE_BOOTSTRAP_TIMEOUT: "1000"
-      SGLANG_HACK_SEQ_BOOTSTRAP_ROOM: "1"
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: "True"
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: "0"
-      SGLANG_DISABLE_TP_MEMORY_INBALANCE_CHECK: "1"
-      SGLANG_DEEPEP_NUM_MAX_DISPATCH_TOKENS_PER_RANK: "512"
-      SGLANG_HEALTH_CHECK_TIMEOUT: "1800"
-      SGLANG_HEALTH_STARTING_OK: "1"
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: "0"
-
-    args:
-      served-model-name: "Qwen/Qwen3.5-397B-A17B-FP8"
-      model-path: "/model/"
-      random-seed: 42
-      trust-remote-code: true
-      quantization: "fp8"
-      kv-cache-dtype: "fp8_e4m3"
-
-      tensor-parallel-size: 16
-      data-parallel-size: 16
-      expert-parallel-size: 16
-      moe-dense-tp-size: 1
-      enable-dp-attention: true
-      enable-dp-lm-head: true
-      prefill-round-robin-balance: true
-
-      mamba-scheduler-strategy: "no_buffer"
-      mamba-track-interval: 128
-      mamba-ssm-dtype: "bfloat16"
-
-      speculative-algorithm: "EAGLE"
-      speculative-num-steps: 3
-      speculative-eagle-topk: 1
-      speculative-num-draft-tokens: 4
-
-      disaggregation-mode: "decode"
-      disable-radix-cache: true
-      disaggregation-bootstrap-port: 31000
-
-      chunked-prefill-size: 4096
-      context-length: 16384
-      mem-fraction-static: 0.7
-      max-mamba-cache-size: 1024
-      max-running-requests: 1024
-      cuda-graph-max-bs: 128
-      watchdog-timeout: 1000000
-
-      page-size: 64
-      attention-backend: "trtllm_mha"
-      moe-runner-backend: "deep_gemm"
-      moe-a2a-backend: "deepep"
-      deepep-mode: "low_latency"
-      ep-dispatch-algorithm: "static"
-      eplb-algorithm: "deepseek"
-
-      decode-log-interval: 1
-      stream-interval: 50
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp8/8k1k/disagg-6p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b1024-c1280-mtp.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp8/8k1k/disagg-6p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b1024-c1280-mtp.yaml
deleted file mode 100644
index 29f8140b9c..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp8/8k1k/disagg-6p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b1024-c1280-mtp.yaml
+++ /dev/null
@@ -1,158 +0,0 @@
-
-schema: 2
-name: "qwen3.5-fp8-gb300-mtp-8k1k-6p1d-dep4-dep16"
-
-sbatch_directives:
-  mem: "0"
-
-dynamo:
-  install: true
-
-  source:
-    rev: 46520ca59afe992fb5ef61b3197b2316f8df9b2b
-frontend:
-  type: dynamo
-  enable_multiple_frontends: true
-  num_additional_frontends: 5
-  nginx_container: nginx
-
-resources:
-  gpu_type: "gb300"
-  gpus_per_node: 4
-engine: sglang
-roles:
-  prefill:
-    nodes: 6
-    workers: 6
-    env:
-      SGLANG_JIT_DEEPGEMM_PRECOMPILE: "0"
-      SGLANG_ENABLE_SPEC_V2: "1"
-      NO_COLOR: "1"
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: "3600"
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: "3600"
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: "3600"
-      PYTHONUNBUFFERED: "1"
-      NCCL_MNNVL_ENABLE: "1"
-      NCCL_CUMEM_ENABLE: "1"
-      MC_FORCE_MNNVL: "1"
-      SGLANG_DG_CACHE_DIR: "/configs/deepgemm-cache"
-      FLASHINFER_WORKSPACE_BASE: "/configs/flashinfer-cache"
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: "100000"
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: "100000"
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: "100000"
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: "True"
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: "0"
-      SGLANG_DISABLE_TP_MEMORY_INBALANCE_CHECK: "1"
-      SGLANG_HEALTH_STARTING_OK: "1"
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: "0"
-
-    args:
-      served-model-name: "Qwen/Qwen3.5-397B-A17B-FP8"
-      model-path: "/model/"
-      random-seed: 42
-      quantization: "fp8"
-      kv-cache-dtype: "fp8_e4m3"
-      trust-remote-code: true
-
-      tensor-parallel-size: 4
-      data-parallel-size: 4
-      expert-parallel-size: 4
-      enable-dp-attention: true
-      enable-dp-lm-head: true
-      moe-dense-tp-size: 1
-
-      mamba-scheduler-strategy: "no_buffer"
-      mamba-track-interval: 2048
-      mamba-ssm-dtype: "bfloat16"
-      disaggregation-mode: "prefill"
-      disable-radix-cache: true
-      disaggregation-bootstrap-port: 31001
-      mem-fraction-static: 0.7
-      chunked-prefill-size: 65536
-      max-prefill-tokens: 16384
-      load-balance-method: "round_robin"
-      watchdog-timeout: 1000000
-      disable-cuda-graph: true
-      log-level: "info"
-      page-size: 64
-      attention-backend: "trtllm_mha"
-      moe-runner-backend: "flashinfer_trtllm"
-
-  decode:
-    nodes: 4
-    workers: 1
-
-    env:
-      SGLANG_JIT_DEEPGEMM_PRECOMPILE: "0"
-      SGLANG_ENABLE_SPEC_V2: "1"
-      NO_COLOR: "1"
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: "3600"
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: "3600"
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: "3600"
-      PYTHONUNBUFFERED: "1"
-      NCCL_MNNVL_ENABLE: "1"
-      NCCL_CUMEM_ENABLE: "1"
-      MC_FORCE_MNNVL: "1"
-      MC_TE_METRIC: "true"
-      SGLANG_DG_CACHE_DIR: "/tmp/deepgemm-cache"
-      FLASHINFER_WORKSPACE_BASE: "/configs/flashinfer-cache"
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: "100000"
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: "100000"
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: "100000"
-      SGLANG_DECODE_BOOTSTRAP_TIMEOUT: "1000"
-      SGLANG_HACK_SEQ_BOOTSTRAP_ROOM: "1"
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: "True"
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: "0"
-      SGLANG_DISABLE_TP_MEMORY_INBALANCE_CHECK: "1"
-      SGLANG_DEEPEP_NUM_MAX_DISPATCH_TOKENS_PER_RANK: "512"
-      SGLANG_HEALTH_CHECK_TIMEOUT: "1800"
-      SGLANG_HEALTH_STARTING_OK: "1"
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: "0"
-
-    args:
-      served-model-name: "Qwen/Qwen3.5-397B-A17B-FP8"
-      model-path: "/model/"
-      random-seed: 42
-      trust-remote-code: true
-      quantization: "fp8"
-      kv-cache-dtype: "fp8_e4m3"
-
-      tensor-parallel-size: 16
-      data-parallel-size: 16
-      expert-parallel-size: 16
-      moe-dense-tp-size: 1
-      enable-dp-attention: true
-      enable-dp-lm-head: true
-      prefill-round-robin-balance: true
-
-      mamba-scheduler-strategy: "no_buffer"
-      mamba-track-interval: 128
-      mamba-ssm-dtype: "bfloat16"
-
-      speculative-algorithm: "EAGLE"
-      speculative-num-steps: 3
-      speculative-eagle-topk: 1
-      speculative-num-draft-tokens: 4
-
-      disaggregation-mode: "decode"
-      disable-radix-cache: true
-      disaggregation-bootstrap-port: 31001
-
-      chunked-prefill-size: 4096
-      context-length: 16384
-      mem-fraction-static: 0.7
-      max-mamba-cache-size: 1024
-      max-running-requests: 1024
-      cuda-graph-max-bs: 128
-      watchdog-timeout: 1000000
-
-      page-size: 64
-      attention-backend: "trtllm_mha"
-      moe-runner-backend: "deep_gemm"
-      moe-a2a-backend: "deepep"
-      deepep-mode: "low_latency"
-      ep-dispatch-algorithm: "static"
-      eplb-algorithm: "deepseek"
-
-      decode-log-interval: 1
-      stream-interval: 50
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp8/8k1k/disagg-7p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b2048-c1344-mtp.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp8/8k1k/disagg-7p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b2048-c1344-mtp.yaml
deleted file mode 100644
index 27ebb7d1cd..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp8/8k1k/disagg-7p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b2048-c1344-mtp.yaml
+++ /dev/null
@@ -1,158 +0,0 @@
-
-schema: 2
-name: "qwen3.5-fp8-gb300-mtp-8k1k-7p1d-dep4-dep16"
-
-sbatch_directives:
-  mem: "0"
-
-dynamo:
-  install: true
-
-  source:
-    rev: 46520ca59afe992fb5ef61b3197b2316f8df9b2b
-frontend:
-  type: dynamo
-  enable_multiple_frontends: true
-  num_additional_frontends: 6
-  nginx_container: nginx
-
-resources:
-  gpu_type: "gb300"
-  gpus_per_node: 4
-engine: sglang
-roles:
-  prefill:
-    nodes: 7
-    workers: 7
-    env:
-      SGLANG_JIT_DEEPGEMM_PRECOMPILE: "0"
-      SGLANG_ENABLE_SPEC_V2: "1"
-      NO_COLOR: "1"
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: "3600"
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: "3600"
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: "3600"
-      PYTHONUNBUFFERED: "1"
-      NCCL_MNNVL_ENABLE: "1"
-      NCCL_CUMEM_ENABLE: "1"
-      MC_FORCE_MNNVL: "1"
-      SGLANG_DG_CACHE_DIR: "/configs/deepgemm-cache"
-      FLASHINFER_WORKSPACE_BASE: "/configs/flashinfer-cache"
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: "100000"
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: "100000"
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: "100000"
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: "True"
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: "0"
-      SGLANG_DISABLE_TP_MEMORY_INBALANCE_CHECK: "1"
-      SGLANG_HEALTH_STARTING_OK: "1"
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: "0"
-
-    args:
-      served-model-name: "Qwen/Qwen3.5-397B-A17B-FP8"
-      model-path: "/model/"
-      random-seed: 42
-      quantization: "fp8"
-      kv-cache-dtype: "fp8_e4m3"
-      trust-remote-code: true
-
-      tensor-parallel-size: 4
-      data-parallel-size: 4
-      expert-parallel-size: 4
-      enable-dp-attention: true
-      enable-dp-lm-head: true
-      moe-dense-tp-size: 1
-
-      mamba-scheduler-strategy: "no_buffer"
-      mamba-track-interval: 2048
-      mamba-ssm-dtype: "bfloat16"
-      disaggregation-mode: "prefill"
-      disable-radix-cache: true
-      disaggregation-bootstrap-port: 31001
-      mem-fraction-static: 0.7
-      chunked-prefill-size: 65536
-      max-prefill-tokens: 16384
-      load-balance-method: "round_robin"
-      watchdog-timeout: 1000000
-      disable-cuda-graph: true
-      log-level: "info"
-      page-size: 64
-      attention-backend: "trtllm_mha"
-      moe-runner-backend: "flashinfer_trtllm"
-
-  decode:
-    nodes: 4
-    workers: 1
-
-    env:
-      SGLANG_JIT_DEEPGEMM_PRECOMPILE: "0"
-      SGLANG_ENABLE_SPEC_V2: "1"
-      NO_COLOR: "1"
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: "3600"
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: "3600"
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: "3600"
-      PYTHONUNBUFFERED: "1"
-      NCCL_MNNVL_ENABLE: "1"
-      NCCL_CUMEM_ENABLE: "1"
-      MC_FORCE_MNNVL: "1"
-      MC_TE_METRIC: "true"
-      SGLANG_DG_CACHE_DIR: "/tmp/deepgemm-cache"
-      FLASHINFER_WORKSPACE_BASE: "/configs/flashinfer-cache"
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: "100000"
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: "100000"
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: "100000"
-      SGLANG_DECODE_BOOTSTRAP_TIMEOUT: "1000"
-      SGLANG_HACK_SEQ_BOOTSTRAP_ROOM: "1"
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: "True"
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: "0"
-      SGLANG_DISABLE_TP_MEMORY_INBALANCE_CHECK: "1"
-      SGLANG_DEEPEP_NUM_MAX_DISPATCH_TOKENS_PER_RANK: "512"
-      SGLANG_HEALTH_CHECK_TIMEOUT: "1800"
-      SGLANG_HEALTH_STARTING_OK: "1"
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: "0"
-
-    args:
-      served-model-name: "Qwen/Qwen3.5-397B-A17B-FP8"
-      model-path: "/model/"
-      random-seed: 42
-      trust-remote-code: true
-      quantization: "fp8"
-      kv-cache-dtype: "fp8_e4m3"
-
-      tensor-parallel-size: 16
-      data-parallel-size: 16
-      expert-parallel-size: 16
-      moe-dense-tp-size: 1
-      enable-dp-attention: true
-      enable-dp-lm-head: true
-      prefill-round-robin-balance: true
-
-      mamba-scheduler-strategy: "no_buffer"
-      mamba-track-interval: 128
-      mamba-ssm-dtype: "bfloat16"
-
-      speculative-algorithm: "EAGLE"
-      speculative-num-steps: 3
-      speculative-eagle-topk: 1
-      speculative-num-draft-tokens: 4
-
-      disaggregation-mode: "decode"
-      disable-radix-cache: true
-      disaggregation-bootstrap-port: 31001
-
-      chunked-prefill-size: 4096
-      context-length: 16384
-      mem-fraction-static: 0.7
-      max-mamba-cache-size: 2048
-      max-running-requests: 2048
-      cuda-graph-max-bs: 128
-      watchdog-timeout: 1000000
-
-      page-size: 64
-      attention-backend: "trtllm_mha"
-      moe-runner-backend: "deep_gemm"
-      moe-a2a-backend: "deepep"
-      deepep-mode: "low_latency"
-      ep-dispatch-algorithm: "static"
-      eplb-algorithm: "deepseek"
-
-      decode-log-interval: 1
-      stream-interval: 50
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp8/8k1k/disagg-8p1d-dep4-dep16-stp.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp8/8k1k/disagg-8p1d-dep4-dep16-stp.yaml
deleted file mode 100644
index 038bed370c..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp8/8k1k/disagg-8p1d-dep4-dep16-stp.yaml
+++ /dev/null
@@ -1,154 +0,0 @@
-schema: 2
-name: "qwen3.5-8p1d-dep4-dep16"
-
-
-sbatch_directives:
-  mem: "0"
-
-services:
-  - name: etcd
-    type: etcd
-    placement:
-      node: dedicated
-  - name: nats
-    type: nats
-    placement:
-      node: dedicated
-dynamo:
-  install: true
-
-  source:
-    wheel: "1.5.0.dev20260917"
-frontend:
-  type: dynamo
-  enable_multiple_frontends: true
-  num_additional_frontends: 4
-  nginx_container: nginx
-
-resources:
-  gpu_type: "gb300"
-  gpus_per_node: 4
-engine: sglang
-roles:
-  prefill:
-    nodes: 8
-    workers: 8
-    env:
-      SGLANG_JIT_DEEPGEMM_PRECOMPILE: "0"
-      NO_COLOR: "1"
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: "3600"
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: "3600"
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: "3600"
-      PYTHONUNBUFFERED: "1"
-      NCCL_MNNVL_ENABLE: "1"
-      NCCL_CUMEM_ENABLE: "1"
-      MC_FORCE_MNNVL: "1"
-      SGLANG_DG_CACHE_DIR: "/configs/deepgemm-cache"
-      FLASHINFER_WORKSPACE_BASE: "/configs/flashinfer-cache"
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: "100000"
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: "100000"
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: "100000"
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: "True"
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: "0"
-      SGLANG_ENABLE_TP_MEMORY_INBALANCE_CHECK: "0"
-      SGLANG_HEALTH_STARTING_OK: "1"
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: "0"
-
-    args:
-      served-model-name: "Qwen/Qwen3.5-397B-A17B-FP8"
-      model-path: "/model/"
-      quantization: "fp8"
-      kv-cache-dtype: "fp8_e4m3"
-      trust-remote-code: true
-
-      tensor-parallel-size: 4
-      data-parallel-size: 4
-      expert-parallel-size: 4
-      enable-dp-attention: true
-      enable-dp-lm-head: true
-
-      mamba-radix-cache-strategy: "no_buffer"
-      mamba-track-interval: 2048
-      mamba-ssm-dtype: "bfloat16"
-      disaggregation-mode: "prefill"
-      disable-radix-cache: true
-      disaggregation-bootstrap-port: 31000
-      mem-fraction-static: 0.8
-      chunked-prefill-size: 65536
-      load-balance-method: "round_robin"
-      watchdog-timeout: 1000000
-      disable-cuda-graph: true
-      log-level: "info"
-      page-size: 64
-      attention-backend: "trtllm_mha"
-      moe-runner-backend: "flashinfer_trtllm"
-
-  decode:
-    nodes: 4
-    workers: 1
-
-    env:
-      SGLANG_JIT_DEEPGEMM_PRECOMPILE: "0"
-      NO_COLOR: "1"
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: "3600"
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: "3600"
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: "3600"
-      PYTHONUNBUFFERED: "1"
-      NCCL_MNNVL_ENABLE: "1"
-      NCCL_CUMEM_ENABLE: "1"
-      MC_FORCE_MNNVL: "1"
-      MC_TE_METRIC: "true"
-      SGLANG_DG_CACHE_DIR: "/tmp/deepgemm-cache"
-      FLASHINFER_WORKSPACE_BASE: "/configs/flashinfer-cache"
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: "100000"
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: "100000"
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: "100000"
-      SGLANG_DECODE_BOOTSTRAP_TIMEOUT: "1000"
-      SGLANG_HACK_SEQ_BOOTSTRAP_ROOM: "1"
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: "True"
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: "0"
-      SGLANG_ENABLE_TP_MEMORY_INBALANCE_CHECK: "0"
-      SGLANG_DEEPEP_NUM_MAX_DISPATCH_TOKENS_PER_RANK: "512"
-      SGLANG_HEALTH_CHECK_TIMEOUT: "1800"
-      SGLANG_HEALTH_STARTING_OK: "1"
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: "0"
-
-    args:
-      served-model-name: "Qwen/Qwen3.5-397B-A17B-FP8"
-      model-path: "/model/"
-      trust-remote-code: true
-      quantization: "fp8"
-      kv-cache-dtype: "fp8_e4m3"
-
-      tensor-parallel-size: 16
-      data-parallel-size: 16
-      expert-parallel-size: 16
-      enable-dp-attention: true
-      enable-dp-lm-head: true
-      load-balance-method: "follow_bootstrap_room"
-      mamba-radix-cache-strategy: "no_buffer"
-      mamba-track-interval: 128
-      mamba-ssm-dtype: "bfloat16"
-
-      disaggregation-mode: "decode"
-      disable-radix-cache: true
-      disaggregation-bootstrap-port: 31000
-
-      chunked-prefill-size: 4096
-      context-length: 16384
-      mem-fraction-static: 0.80
-      max-mamba-cache-size: 2048
-      max-running-requests: 2048
-      cuda-graph-max-bs-decode: 128
-      watchdog-timeout: 1000000
-
-      page-size: 64
-      attention-backend: "trtllm_mha"
-      moe-runner-backend: "deep_gemm"
-      moe-a2a-backend: "deepep"
-      deepep-mode: "low_latency"
-      ep-dispatch-algorithm: "static"
-      eplb-algorithm: "deepseek"
-
-      decode-log-interval: 1
-      stream-interval: 50
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp8/8k1k/disagg-8p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b2048-c1920x2304-mtp.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp8/8k1k/disagg-8p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b2048-c1920x2304-mtp.yaml
deleted file mode 100644
index 2a677cbad6..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/gb300-fp8/8k1k/disagg-8p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b2048-c1920x2304-mtp.yaml
+++ /dev/null
@@ -1,158 +0,0 @@
-
-schema: 2
-name: "qwen3.5-fp8-gb300-mtp-8k1k-8p1d-dep4-dep16"
-
-sbatch_directives:
-  mem: "0"
-
-dynamo:
-  install: true
-
-  source:
-    rev: 46520ca59afe992fb5ef61b3197b2316f8df9b2b
-frontend:
-  type: dynamo
-  enable_multiple_frontends: true
-  num_additional_frontends: 7
-  nginx_container: nginx
-
-resources:
-  gpu_type: "gb300"
-  gpus_per_node: 4
-engine: sglang
-roles:
-  prefill:
-    nodes: 8
-    workers: 8
-    env:
-      SGLANG_JIT_DEEPGEMM_PRECOMPILE: "0"
-      SGLANG_ENABLE_SPEC_V2: "1"
-      NO_COLOR: "1"
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: "3600"
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: "3600"
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: "3600"
-      PYTHONUNBUFFERED: "1"
-      NCCL_MNNVL_ENABLE: "1"
-      NCCL_CUMEM_ENABLE: "1"
-      MC_FORCE_MNNVL: "1"
-      SGLANG_DG_CACHE_DIR: "/configs/deepgemm-cache"
-      FLASHINFER_WORKSPACE_BASE: "/configs/flashinfer-cache"
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: "100000"
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: "100000"
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: "100000"
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: "True"
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: "0"
-      SGLANG_DISABLE_TP_MEMORY_INBALANCE_CHECK: "1"
-      SGLANG_HEALTH_STARTING_OK: "1"
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: "0"
-
-    args:
-      served-model-name: "Qwen/Qwen3.5-397B-A17B-FP8"
-      model-path: "/model/"
-      random-seed: 42
-      quantization: "fp8"
-      kv-cache-dtype: "fp8_e4m3"
-      trust-remote-code: true
-
-      tensor-parallel-size: 4
-      data-parallel-size: 4
-      expert-parallel-size: 4
-      enable-dp-attention: true
-      enable-dp-lm-head: true
-      moe-dense-tp-size: 1
-
-      mamba-scheduler-strategy: "no_buffer"
-      mamba-track-interval: 2048
-      mamba-ssm-dtype: "bfloat16"
-      disaggregation-mode: "prefill"
-      disable-radix-cache: true
-      disaggregation-bootstrap-port: 31001
-      mem-fraction-static: 0.7
-      chunked-prefill-size: 98304
-      max-prefill-tokens: 24576
-      load-balance-method: "round_robin"
-      watchdog-timeout: 1000000
-      disable-cuda-graph: true
-      log-level: "info"
-      page-size: 64
-      attention-backend: "trtllm_mha"
-      moe-runner-backend: "flashinfer_trtllm"
-
-  decode:
-    nodes: 4
-    workers: 1
-
-    env:
-      SGLANG_JIT_DEEPGEMM_PRECOMPILE: "0"
-      SGLANG_ENABLE_SPEC_V2: "1"
-      NO_COLOR: "1"
-      TORCH_DISTRIBUTED_DEFAULT_TIMEOUT: "3600"
-      TORCH_NCCL_WATCHDOG_TIMEOUT_SEC: "3600"
-      TORCH_NCCL_HEARTBEAT_TIMEOUT_SEC: "3600"
-      PYTHONUNBUFFERED: "1"
-      NCCL_MNNVL_ENABLE: "1"
-      NCCL_CUMEM_ENABLE: "1"
-      MC_FORCE_MNNVL: "1"
-      MC_TE_METRIC: "true"
-      SGLANG_DG_CACHE_DIR: "/tmp/deepgemm-cache"
-      FLASHINFER_WORKSPACE_BASE: "/configs/flashinfer-cache"
-      SGLANG_DISAGGREGATION_HEARTBEAT_MAX_FAILURE: "100000"
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: "100000"
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: "100000"
-      SGLANG_DECODE_BOOTSTRAP_TIMEOUT: "1000"
-      SGLANG_HACK_SEQ_BOOTSTRAP_ROOM: "1"
-      SGLANG_MOONCAKE_CUSTOM_MEM_POOL: "True"
-      SGLANG_USE_MESSAGE_QUEUE_BROADCASTER: "0"
-      SGLANG_DISABLE_TP_MEMORY_INBALANCE_CHECK: "1"
-      SGLANG_DEEPEP_NUM_MAX_DISPATCH_TOKENS_PER_RANK: "512"
-      SGLANG_HEALTH_CHECK_TIMEOUT: "1800"
-      SGLANG_HEALTH_STARTING_OK: "1"
-      SGLANG_ENABLE_HEALTH_ENDPOINT_GENERATION: "0"
-
-    args:
-      served-model-name: "Qwen/Qwen3.5-397B-A17B-FP8"
-      model-path: "/model/"
-      random-seed: 42
-      trust-remote-code: true
-      quantization: "fp8"
-      kv-cache-dtype: "fp8_e4m3"
-
-      tensor-parallel-size: 16
-      data-parallel-size: 16
-      expert-parallel-size: 16
-      moe-dense-tp-size: 1
-      enable-dp-attention: true
-      enable-dp-lm-head: true
-      prefill-round-robin-balance: true
-
-      mamba-scheduler-strategy: "no_buffer"
-      mamba-track-interval: 128
-      mamba-ssm-dtype: "bfloat16"
-
-      speculative-algorithm: "EAGLE"
-      speculative-num-steps: 3
-      speculative-eagle-topk: 1
-      speculative-num-draft-tokens: 4
-
-      disaggregation-mode: "decode"
-      disable-radix-cache: true
-      disaggregation-bootstrap-port: 31001
-
-      chunked-prefill-size: 4096
-      context-length: 16384
-      mem-fraction-static: 0.7
-      max-mamba-cache-size: 2048
-      max-running-requests: 2048
-      cuda-graph-max-bs: 128
-      watchdog-timeout: 1000000
-
-      page-size: 64
-      attention-backend: "trtllm_mha"
-      moe-runner-backend: "deep_gemm"
-      moe-a2a-backend: "deepep"
-      deepep-mode: "low_latency"
-      ep-dispatch-algorithm: "static"
-      eplb-algorithm: "deepseek"
-
-      decode-log-interval: 1
-      stream-interval: 50
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/mi355x-fp4/8k1k/disagg-1p1d-tp8.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/mi355x-fp4/8k1k/disagg-1p1d-tp8.yaml
deleted file mode 100644
index 1f098d7943..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/mi355x-fp4/8k1k/disagg-1p1d-tp8.yaml
+++ /dev/null
@@ -1,100 +0,0 @@
-
-schema: 2
-name: "mi355x-sglang-qwen3.5-mxfp4-disagg-1p1d-tp8-fixed-seq"
-
-identity:
-  model: {}
-  container: {}
-  frameworks:
-    sglang: "0.5.17.dev20260809+g7120f3ee13"
-    sglang-router: "0.3.2"
-    amd-mori: "0.5.17.dev20260809+g7120f3ee13"
-
-slurm:
-  time_limit: "08:00:00"
-
-sbatch_directives:
-  cpus-per-task: "128"
-  mem: "0"
-
-resources:
-  gpu_type: "mi355x"
-  gpus_per_node: 8
-frontend:
-  type: sglang-router
-  enable_multiple_frontends: false
-  args:
-    policy: round_robin
-    prefill-policy: round_robin
-    decode-policy: round_robin
-
-engine: sglang
-roles:
-  prefill:
-    nodes: 1
-    workers: 1
-    gpus: 8
-    env: &common_environment
-      HF_HOME: "/hf_hub_cache"
-      HF_HUB_CACHE: "/hf_hub_cache/hub"
-      HUGGINGFACE_HUB_CACHE: "/hf_hub_cache/hub"
-      PYTHONUNBUFFERED: "1"
-      IBDEVICES: "@fabric.rdma-devices"
-      GLOO_SOCKET_IFNAME: "@fabric.socket-ifname"
-      NCCL_SOCKET_IFNAME: "@fabric.socket-ifname"
-      MORI_RDMA_TC: "@fabric.rdma-tc"
-      MORI_IO_TC: "@fabric.rdma-tc"
-      MORI_SHMEM_MODE: "ISOLATION"
-      SGLANG_USE_AITER: "1"
-      AITER_LOG_LEVEL: "ERROR"
-      SGLANG_MORI_DISPATCH_DTYPE: "auto"
-      SGLANG_MORI_QP_PER_TRANSFER: "4"
-      SGLANG_MORI_NUM_WORKERS: "4"
-      SGLANG_DISAGGREGATION_NUM_PRE_ALLOCATE_REQS: "32"
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: "3600"
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: "3600"
-      SGLANG_HEALTH_CHECK_TIMEOUT: "600"
-    args: &common_config
-      served-model-name: "amd/Qwen3.5-397B-A17B-MXFP4"
-      tensor-parallel-size: 8
-      disaggregation-transfer-backend: mori
-      disaggregation-ib-device: "@fabric.rdma-devices"
-      kv-cache-dtype: "fp8_e4m3"
-      attention-backend: aiter
-      moe-dense-tp-size: 1
-      load-balance-method: round_robin
-      watchdog-timeout: 3600
-      decode-log-interval: 1000
-      log-level: warning
-      mem-fraction-static: 0.80
-      max-running-requests: 128
-      chunked-prefill-size: 262144
-      context-length: 16384
-      disable-radix-cache: true
-      cuda-graph-bs: [1, 2, 3, 4, 5, 6, 7, 8]
-      enable-metrics: true
-  decode:
-    nodes: 1
-    workers: 1
-    gpus: 8
-
-    env: *common_environment
-    args:
-      <<: *common_config
-      mem-fraction-static: 0.85
-      prefill-round-robin-balance: true
-
-srun_options:
-  container-writable: ""
-  container-remap-root: ""
-  mem: "0"
-
-health_check:
-  max_attempts: 720
-  interval_seconds: 5
-
-benchmark:
-  env:
-    HF_HOME: /hf_hub_cache
-    HF_HUB_CACHE: /hf_hub_cache/hub
-    HUGGINGFACE_HUB_CACHE: /hf_hub_cache/hub
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/mi355x-fp8/8k1k/disagg-1p1d-p-tp4-d-tp8.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/mi355x-fp8/8k1k/disagg-1p1d-p-tp4-d-tp8.yaml
deleted file mode 100644
index e544d37c3e..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/sglang/mi355x-fp8/8k1k/disagg-1p1d-p-tp4-d-tp8.yaml
+++ /dev/null
@@ -1,105 +0,0 @@
-
-schema: 2
-name: "mi355x-sglang-qwen3.5-fp8-disagg-1p1d-tp4p-tp8d-fixed-seq"
-
-identity:
-  model: {}
-  container: {}
-  frameworks:
-    sglang: "0.5.16"
-    sglang-router: "0.3.2"
-
-slurm:
-  time_limit: "08:00:00"
-
-# This topology owns every GPU on each MI355X node. Give SGLang the complete
-# 128-core cpuset as well: its ROCm image enables per-GPU CPU affinity, which
-# maps the eight TP ranks across the full dual-socket CPU topology.
-sbatch_directives:
-  cpus-per-task: "128"
-  mem: "0"
-
-resources:
-  gpu_type: "mi355x"
-  gpus_per_node: 8
-frontend:
-  type: sglang-router
-  enable_multiple_frontends: false
-  args:
-    policy: round_robin
-    prefill-policy: round_robin
-    decode-policy: round_robin
-
-engine: sglang
-roles:
-  prefill:
-    nodes: 1
-    workers: 1
-    gpus: 4
-    env: &common_environment
-      HF_HOME: "/hf_hub_cache"
-    # Hugging Face stores hub snapshots under $HF_HOME/hub. Keep the explicit
-    # cache variables on that same path so srt-slurm's prefetch and every
-    # backend process resolve the identical, current snapshot.
-      HF_HUB_CACHE: "/hf_hub_cache/hub"
-      HUGGINGFACE_HUB_CACHE: "/hf_hub_cache/hub"
-      PYTHONUNBUFFERED: "1"
-      IBDEVICES: "@fabric.rdma-devices"
-      GLOO_SOCKET_IFNAME: "@fabric.socket-ifname"
-      NCCL_SOCKET_IFNAME: "@fabric.socket-ifname"
-      MORI_RDMA_TC: "@fabric.rdma-tc"
-      MORI_IO_TC: "@fabric.rdma-tc"
-      MORI_SHMEM_MODE: "ISOLATION"
-      SGLANG_USE_AITER: "1"
-      AITER_LOG_LEVEL: "ERROR"
-      SGLANG_MORI_DISPATCH_DTYPE: "auto"
-      SGLANG_MORI_QP_PER_TRANSFER: "4"
-      SGLANG_MORI_NUM_WORKERS: "4"
-      SGLANG_DISAGGREGATION_NUM_PRE_ALLOCATE_REQS: "32"
-      SGLANG_DISAGGREGATION_BOOTSTRAP_TIMEOUT: "3600"
-      SGLANG_DISAGGREGATION_WAITING_TIMEOUT: "3600"
-      SGLANG_HEALTH_CHECK_TIMEOUT: "600"
-    args: &common_config
-      served-model-name: "Qwen/Qwen3.5-397B-A17B-FP8"
-      tensor-parallel-size: 4
-      disaggregation-transfer-backend: mori
-      disaggregation-ib-device: "@fabric.rdma-devices"
-      kv-cache-dtype: "fp8_e4m3"
-      attention-backend: aiter
-      moe-dense-tp-size: 1
-      load-balance-method: round_robin
-      watchdog-timeout: 3600
-      decode-log-interval: 1000
-      log-level: warning
-      mem-fraction-static: 0.80
-      max-running-requests: 128
-      chunked-prefill-size: 262144
-      context-length: 16384
-      disable-radix-cache: true
-      cuda-graph-bs: [1, 2, 3, 4, 5, 6, 7, 8]
-      enable-metrics: true
-  decode:
-    nodes: 1
-    workers: 1
-    gpus: 8
-
-    env: *common_environment
-    args:
-      <<: *common_config
-      mem-fraction-static: 0.85
-      prefill-round-robin-balance: true
-
-srun_options:
-  container-writable: ""
-  container-remap-root: ""
-  mem: "0"
-
-health_check:
-  max_attempts: 720
-  interval_seconds: 5
-
-benchmark:
-  env:
-    HF_HOME: /hf_hub_cache
-    HF_HUB_CACHE: /hf_hub_cache/hub
-    HUGGINGFACE_HUB_CACHE: /hf_hub_cache/hub
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/trtllm/gb300-fp4/8k1k/disagg-mtp-variants.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/trtllm/gb300-fp4/8k1k/disagg-mtp-variants.yaml
deleted file mode 100644
index f1d7737789..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/trtllm/gb300-fp4/8k1k/disagg-mtp-variants.yaml
+++ /dev/null
@@ -1,796 +0,0 @@
-schema: 2
-
-base:
-  dynamo:
-    install: true
-    source:
-      wheel: 1.4.0.dev20260807
-
-  identity:
-    container: {}
-
-  slurm:
-    time_limit: 04:00:00
-
-  health_check:
-    max_attempts: 540
-    interval_seconds: 10
-
-  resources:
-    gpu_type: gb300
-    gpus_per_node: 4
-
-  engine:
-    type: trtllm
-    # Dynamo builds before ai-dynamo/dynamo#12162 reject --publish-metrics.
-    publish_metrics: false
-
-  roles:
-    prefill:
-      env:
-        TLLM_LOG_LEVEL: INFO
-        TRTLLM_SERVER_DISABLE_GC: '1'
-        TRTLLM_WORKER_DISABLE_GC: '1'
-        TRTLLM_ENABLE_PDL: '1'
-        NCCL_GRAPH_MIXING_SUPPORT: '0'
-        MIMALLOC_PURGE_DELAY: '0'
-        UCX_TLS: cuda_ipc,cuda_copy,sm,self,tcp
-      args:
-        cache_transceiver_config:
-          kv_transfer_timeout_ms: 600000
-          max_tokens_in_buffer: 16384
-        cuda_graph_config:
-        disable_overlap_scheduler: true
-        enable_attention_dp: true
-        kv_cache_config:
-          dtype: fp8
-          enable_block_reuse: false
-        max_num_tokens: 16896
-        max_seq_len: 8448
-        moe_config:
-          backend: CUTEDSL
-        nvfp4_gemm_config:
-          allowed_backends:
-            - cutlass
-            - cublaslt
-            - cutedsl
-            - cuda_core
-        pipeline_parallel_size: 1
-        print_iter_log: true
-        trust_remote_code: true
-    decode:
-      env:
-        TLLM_LOG_LEVEL: INFO
-        TRTLLM_SERVER_DISABLE_GC: '1'
-        TRTLLM_WORKER_DISABLE_GC: '1'
-        TRTLLM_ENABLE_PDL: '1'
-        NCCL_GRAPH_MIXING_SUPPORT: '0'
-        MIMALLOC_PURGE_DELAY: '0'
-        UCX_TLS: cuda_ipc,cuda_copy,sm,self,tcp
-      args:
-        cache_transceiver_config:
-          kv_transfer_timeout_ms: 600000
-          max_tokens_in_buffer: 16384
-        cuda_graph_config:
-          enable_padding: true
-        kv_cache_config:
-          dtype: fp8
-          enable_block_reuse: false
-        max_seq_len: 9472
-        moe_config:
-          use_low_precision_moe_combine: true
-        num_postprocess_workers: 4
-        nvfp4_gemm_config:
-          allowed_backends:
-            - cutlass
-            - cublaslt
-            - cutedsl
-            - cuda_core
-        pipeline_parallel_size: 1
-        print_iter_log: true
-        stream_interval: 100
-        trust_remote_code: true
-
-  frontend:
-    type: dynamo
-    env:
-      ETCD_LEASE_TTL: '120'
-      DYN_TOKENIZER: "fastokens"
-
-override_1p2d_tep8_b8_mtp3_c20:
-  roles:
-    prefill:
-      nodes: 1
-      workers: 1
-      gpus: 1
-      env:
-        TRT_LLM_DISABLE_LOAD_WEIGHTS_IN_PARALLEL: '1'
-        CTX_LOAD_STAGGER_S: '180'
-      args:
-        cache_transceiver_config:
-          backend: UCX
-        kv_cache_config:
-          free_gpu_memory_fraction: 0.85
-        max_batch_size: 32
-        moe_expert_parallel_size: 1
-        speculative_config:
-          decoding_type: MTP
-          max_draft_len: 3
-        tensor_parallel_size: 1
-    decode:
-      nodes: 4
-      workers: 2
-      gpus: 8
-      args:
-        cache_transceiver_config:
-          backend: UCX
-        cuda_graph_config:
-          batch_sizes:
-            - 1
-            - 2
-            - 4
-            - 8
-        enable_attention_dp: false
-        enable_lm_head_tp_in_adp: false
-        kv_cache_config:
-          free_gpu_memory_fraction: 0.9
-        max_batch_size: 8
-        max_num_tokens: 32
-        moe_config:
-          backend: TRTLLM
-        moe_expert_parallel_size: 8
-        speculative_config:
-          decoding_type: MTP
-          max_draft_len: 3
-        tensor_parallel_size: 8
-  frontend:
-    enable_multiple_frontends: false
-
-override_1p4d_tep8_b1_mtp3_c12:
-  roles:
-    prefill:
-      nodes: 1
-      workers: 1
-      gpus: 1
-      env:
-        TRT_LLM_DISABLE_LOAD_WEIGHTS_IN_PARALLEL: '1'
-        CTX_LOAD_STAGGER_S: '180'
-      args:
-        cache_transceiver_config:
-          backend: UCX
-        kv_cache_config:
-          free_gpu_memory_fraction: 0.85
-        max_batch_size: 32
-        moe_expert_parallel_size: 1
-        speculative_config:
-          decoding_type: MTP
-          max_draft_len: 3
-        tensor_parallel_size: 1
-    decode:
-      nodes: 8
-      workers: 4
-      gpus: 8
-      args:
-        cache_transceiver_config:
-          backend: UCX
-        cuda_graph_config:
-          batch_sizes:
-            - 1
-            - 2
-            - 4
-        enable_attention_dp: false
-        enable_lm_head_tp_in_adp: false
-        kv_cache_config:
-          free_gpu_memory_fraction: 0.9
-        max_batch_size: 1
-        max_num_tokens: 4
-        moe_config:
-          backend: TRTLLM
-        moe_expert_parallel_size: 8
-        speculative_config:
-          decoding_type: MTP
-          max_draft_len: 3
-        tensor_parallel_size: 8
-  frontend:
-    enable_multiple_frontends: false
-
-override_1p4d_tep8_b2_mtp3_c8:
-  identity:
-    frameworks:
-      tensorrt_llm: 1.3.0rc24
-  roles:
-    prefill:
-      nodes: 1
-      workers: 1
-      gpus: 1
-      env:
-        TRT_LLM_DISABLE_LOAD_WEIGHTS_IN_PARALLEL: '1'
-        CTX_LOAD_STAGGER_S: '180'
-      args:
-        cache_transceiver_config:
-          backend: UCX
-        kv_cache_config:
-          free_gpu_memory_fraction: 0.85
-        max_batch_size: 32
-        moe_expert_parallel_size: 1
-        speculative_config:
-          decoding_type: MTP
-          max_draft_len: 3
-        tensor_parallel_size: 1
-    decode:
-      nodes: 8
-      workers: 4
-      gpus: 8
-      args:
-        cache_transceiver_config:
-          backend: UCX
-        cuda_graph_config:
-          batch_sizes:
-            - 1
-            - 2
-            - 4
-        enable_attention_dp: false
-        enable_lm_head_tp_in_adp: false
-        kv_cache_config:
-          free_gpu_memory_fraction: 0.9
-        max_batch_size: 2
-        max_num_tokens: 8
-        moe_config:
-          backend: TRTLLM
-        moe_expert_parallel_size: 8
-        speculative_config:
-          decoding_type: MTP
-          max_draft_len: 3
-        tensor_parallel_size: 8
-  frontend:
-    enable_multiple_frontends: false
-
-override_4p3d_tep8_b32_mtp3_c126:
-  engine:
-    sequential_node_start: 2
-  roles:
-    prefill:
-      nodes: 1
-      workers: 4
-      gpus: 1
-      env:
-        TRT_LLM_DISABLE_LOAD_WEIGHTS_IN_PARALLEL: '1'
-        CTX_LOAD_STAGGER_S: '180'
-      args:
-        cache_transceiver_config:
-          backend: UCX
-        kv_cache_config:
-          free_gpu_memory_fraction: 0.85
-        max_batch_size: 32
-        moe_expert_parallel_size: 1
-        speculative_config:
-          decoding_type: MTP
-          max_draft_len: 3
-        tensor_parallel_size: 1
-    decode:
-      nodes: 6
-      workers: 3
-      gpus: 8
-      args:
-        cache_transceiver_config:
-          backend: UCX
-        cuda_graph_config:
-          batch_sizes:
-            - 1
-            - 2
-            - 4
-            - 8
-            - 12
-            - 16
-            - 20
-            - 24
-            - 28
-            - 32
-        enable_attention_dp: false
-        enable_lm_head_tp_in_adp: false
-        kv_cache_config:
-          free_gpu_memory_fraction: 0.9
-        max_batch_size: 32
-        max_num_tokens: 128
-        moe_config:
-          backend: TRTLLM
-        moe_expert_parallel_size: 8
-        speculative_config:
-          decoding_type: MTP
-          max_draft_len: 3
-        tensor_parallel_size: 8
-  frontend:
-    enable_multiple_frontends: false
-
-override_5p1d_dep16_b8_mtp3_c154:
-  identity:
-    frameworks:
-      tensorrt_llm: 1.3.0rc24
-  engine:
-    sequential_node_start: 2
-  roles:
-    prefill:
-      nodes: 2
-      workers: 5
-      gpus: 1
-      env:
-        TRT_LLM_DISABLE_LOAD_WEIGHTS_IN_PARALLEL: '1'
-        CTX_LOAD_STAGGER_S: '180'
-      args:
-        cache_transceiver_config:
-          backend: NIXL
-          transceiver_runtime: PYTHON
-        kv_cache_config:
-          free_gpu_memory_fraction: 0.7
-        max_batch_size: 2
-        moe_expert_parallel_size: 1
-        speculative_config:
-          decoding_type: MTP
-          max_draft_len: 3
-        tensor_parallel_size: 1
-    decode:
-      nodes: 4
-      workers: 1
-      gpus: 16
-      args:
-        cache_transceiver_config:
-          backend: NIXL
-          transceiver_runtime: PYTHON
-        cuda_graph_config:
-          batch_sizes:
-            - 1
-            - 2
-            - 4
-            - 8
-        enable_attention_dp: true
-        enable_lm_head_tp_in_adp: true
-        kv_cache_config:
-          free_gpu_memory_fraction: 0.75
-        max_batch_size: 8
-        max_num_tokens: 32
-        moe_config:
-          backend: CUTEDSL
-        moe_expert_parallel_size: 16
-        speculative_config:
-          decoding_type: MTP
-          max_draft_len: 3
-        tensor_parallel_size: 16
-  frontend:
-    enable_multiple_frontends: false
-
-override_7p1d_dep16_b32_mtp3_c666:
-  engine:
-    sequential_node_start: 2
-  roles:
-    prefill:
-      nodes: 4
-      workers: 7
-      gpus: 2
-      args:
-        cache_transceiver_config:
-          backend: UCX
-        kv_cache_config:
-          free_gpu_memory_fraction: 0.85
-        max_batch_size: 32
-        moe_expert_parallel_size: 2
-        speculative_config:
-          decoding_type: MTP
-          max_draft_len: 3
-        tensor_parallel_size: 2
-    decode:
-      nodes: 4
-      workers: 1
-      gpus: 16
-      args:
-        cache_transceiver_config:
-          backend: UCX
-        cuda_graph_config:
-          batch_sizes:
-            - 1
-            - 2
-            - 4
-            - 8
-            - 12
-            - 16
-            - 20
-            - 24
-            - 28
-            - 32
-        enable_attention_dp: true
-        enable_lm_head_tp_in_adp: true
-        kv_cache_config:
-          free_gpu_memory_fraction: 0.75
-        max_batch_size: 32
-        max_num_tokens: 128
-        moe_config:
-          backend: CUTEDSL
-        moe_expert_parallel_size: 16
-        speculative_config:
-          decoding_type: MTP
-          max_draft_len: 3
-        tensor_parallel_size: 16
-  frontend:
-    enable_multiple_frontends: true
-
-override_11p1d_dep8_b128_mtp3_c1229:
-  identity:
-    frameworks:
-      tensorrt_llm: 1.3.0rc24
-  engine:
-    sequential_node_start: 2
-  roles:
-    prefill:
-      nodes: 3
-      workers: 11
-      gpus: 1
-      env:
-        TRT_LLM_DISABLE_LOAD_WEIGHTS_IN_PARALLEL: '1'
-        CTX_LOAD_STAGGER_S: '180'
-      args:
-        cache_transceiver_config:
-          backend: NIXL
-          transceiver_runtime: PYTHON
-        kv_cache_config:
-          free_gpu_memory_fraction: 0.7
-        max_batch_size: 2
-        moe_expert_parallel_size: 1
-        speculative_config:
-          decoding_type: MTP
-          max_draft_len: 3
-        tensor_parallel_size: 1
-    decode:
-      nodes: 2
-      workers: 1
-      gpus: 8
-      args:
-        cache_transceiver_config:
-          backend: NIXL
-          transceiver_runtime: PYTHON
-        cuda_graph_config:
-          batch_sizes:
-            - 1
-            - 2
-            - 4
-            - 8
-            - 12
-            - 16
-            - 20
-            - 24
-            - 28
-            - 32
-            - 36
-            - 40
-            - 44
-            - 48
-            - 52
-            - 56
-            - 60
-            - 64
-            - 68
-            - 72
-            - 76
-            - 80
-            - 84
-            - 88
-            - 92
-            - 96
-            - 100
-            - 104
-            - 108
-            - 112
-            - 116
-            - 120
-            - 124
-            - 128
-        enable_attention_dp: true
-        enable_lm_head_tp_in_adp: true
-        kv_cache_config:
-          free_gpu_memory_fraction: 0.8
-        max_batch_size: 128
-        max_num_tokens: 512
-        moe_config:
-          backend: CUTEDSL
-        moe_expert_parallel_size: 8
-        speculative_config:
-          decoding_type: MTP
-          max_draft_len: 3
-        tensor_parallel_size: 8
-  frontend:
-    enable_multiple_frontends: true
-
-override_17p2d_dep8_b64_mtp3_c1126:
-  identity:
-    frameworks:
-      tensorrt_llm: 1.3.0rc24
-  engine:
-    sequential_node_start: 2
-  roles:
-    prefill:
-      nodes: 5
-      workers: 17
-      gpus: 1
-      env:
-        TRT_LLM_DISABLE_LOAD_WEIGHTS_IN_PARALLEL: '1'
-        CTX_LOAD_STAGGER_S: '180'
-      args:
-        cache_transceiver_config:
-          backend: NIXL
-        kv_cache_config:
-          free_gpu_memory_fraction: 0.7
-        max_batch_size: 2
-        moe_expert_parallel_size: 1
-        speculative_config:
-          decoding_type: MTP
-          max_draft_len: 3
-        tensor_parallel_size: 1
-    decode:
-      nodes: 4
-      workers: 2
-      gpus: 8
-      args:
-        cache_transceiver_config:
-          backend: NIXL
-        cuda_graph_config:
-          batch_sizes:
-            - 1
-            - 2
-            - 4
-            - 8
-            - 12
-            - 16
-            - 20
-            - 24
-            - 28
-            - 32
-            - 36
-            - 40
-            - 44
-            - 48
-            - 52
-            - 56
-            - 60
-            - 64
-        enable_attention_dp: true
-        enable_lm_head_tp_in_adp: true
-        kv_cache_config:
-          free_gpu_memory_fraction: 0.8
-        max_batch_size: 64
-        max_num_tokens: 256
-        moe_config:
-          backend: CUTEDSL
-        moe_expert_parallel_size: 8
-        speculative_config:
-          decoding_type: MTP
-          max_draft_len: 3
-        tensor_parallel_size: 8
-  frontend:
-    enable_multiple_frontends: true
-
-override_26p1d_dep16_b256_mtp2_c4301:
-  identity:
-    frameworks:
-      tensorrt_llm: 1.3.0rc24
-  engine:
-    sequential_node_start: 2
-  roles:
-    prefill:
-      nodes: 7
-      workers: 26
-      gpus: 1
-      env:
-        TRT_LLM_DISABLE_LOAD_WEIGHTS_IN_PARALLEL: '1'
-        CTX_LOAD_STAGGER_S: '180'
-      args:
-        cache_transceiver_config:
-          backend: NIXL
-          transceiver_runtime: PYTHON
-        kv_cache_config:
-          free_gpu_memory_fraction: 0.7
-        max_batch_size: 2
-        moe_expert_parallel_size: 1
-        speculative_config:
-          decoding_type: MTP
-          max_draft_len: 2
-        tensor_parallel_size: 1
-    decode:
-      nodes: 4
-      workers: 1
-      gpus: 16
-      args:
-        cache_transceiver_config:
-          backend: NIXL
-          transceiver_runtime: PYTHON
-        cuda_graph_config:
-          batch_sizes:
-            - 1
-            - 2
-            - 4
-            - 8
-            - 12
-            - 16
-            - 20
-            - 24
-            - 28
-            - 32
-            - 36
-            - 40
-            - 44
-            - 48
-            - 52
-            - 56
-            - 60
-            - 64
-            - 68
-            - 72
-            - 76
-            - 80
-            - 84
-            - 88
-            - 92
-            - 96
-            - 100
-            - 104
-            - 108
-            - 112
-            - 116
-            - 120
-            - 124
-            - 128
-            - 132
-            - 136
-            - 140
-            - 144
-            - 148
-            - 152
-            - 156
-            - 160
-            - 164
-            - 168
-            - 172
-            - 176
-            - 180
-            - 184
-            - 188
-            - 192
-            - 196
-            - 200
-            - 204
-            - 208
-            - 212
-            - 216
-            - 220
-            - 224
-            - 228
-            - 232
-            - 236
-            - 240
-            - 244
-            - 248
-            - 252
-            - 256
-        enable_attention_dp: true
-        enable_lm_head_tp_in_adp: true
-        kv_cache_config:
-          free_gpu_memory_fraction: 0.75
-        max_batch_size: 256
-        max_num_tokens: 768
-        moe_config:
-          backend: CUTEDSL
-        moe_expert_parallel_size: 16
-        speculative_config:
-          decoding_type: MTP
-          max_draft_len: 2
-        tensor_parallel_size: 16
-  frontend:
-    enable_multiple_frontends: true
-
-override_24p1d_dep16_b512_mtp0_c8192_mtp_sweep:
-  identity:
-    frameworks:
-      tensorrt_llm: 1.3.0rc24
-  engine:
-    sequential_node_start: 2
-  roles:
-    prefill:
-      nodes: 6
-      workers: 24
-      gpus: 1
-      env:
-        TRT_LLM_DISABLE_LOAD_WEIGHTS_IN_PARALLEL: '1'
-        CTX_LOAD_STAGGER_S: '180'
-      args:
-        cache_transceiver_config:
-          backend: NIXL
-        kv_cache_config:
-          free_gpu_memory_fraction: 0.7
-        max_batch_size: 2
-        moe_expert_parallel_size: 1
-        tensor_parallel_size: 1
-    decode:
-      nodes: 4
-      workers: 1
-      gpus: 16
-      args:
-        cache_transceiver_config:
-          backend: NIXL
-        cuda_graph_config:
-          batch_sizes:
-            - 1
-            - 2
-            - 4
-            - 8
-            - 16
-            - 24
-            - 32
-            - 40
-            - 48
-            - 56
-            - 64
-            - 72
-            - 80
-            - 88
-            - 96
-            - 104
-            - 112
-            - 120
-            - 128
-            - 136
-            - 144
-            - 152
-            - 160
-            - 168
-            - 176
-            - 184
-            - 192
-            - 200
-            - 208
-            - 216
-            - 224
-            - 232
-            - 240
-            - 248
-            - 256
-            - 264
-            - 272
-            - 280
-            - 288
-            - 296
-            - 304
-            - 312
-            - 320
-            - 328
-            - 336
-            - 344
-            - 352
-            - 360
-            - 368
-            - 376
-            - 384
-            - 392
-            - 400
-            - 408
-            - 416
-            - 424
-            - 432
-            - 440
-            - 448
-            - 456
-            - 464
-            - 472
-            - 480
-            - 488
-            - 496
-            - 504
-            - 512
-        enable_attention_dp: true
-        enable_lm_head_tp_in_adp: false
-        kv_cache_config:
-          free_gpu_memory_fraction: 0.75
-        max_batch_size: 512
-        max_num_tokens: 512
-        moe_config:
-          backend: CUTEDSL
-        moe_expert_parallel_size: 16
-        tensor_parallel_size: 16
-  frontend:
-    enable_multiple_frontends: true
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/trtllm/gb300-fp4/8k1k/disagg-stp-variants.yaml b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/trtllm/gb300-fp4/8k1k/disagg-stp-variants.yaml
deleted file mode 100644
index 4f56806608..0000000000
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/qwen3.5/trtllm/gb300-fp4/8k1k/disagg-stp-variants.yaml
+++ /dev/null
@@ -1,681 +0,0 @@
-schema: 2
-
-base:
-  dynamo:
-    install: true
-    source:
-      wheel: 1.4.0.dev20260807
-
-  identity:
-    container: {}
-
-  slurm:
-    time_limit: 04:00:00
-
-  health_check:
-    max_attempts: 540
-    interval_seconds: 10
-
-  resources:
-    gpu_type: gb300
-    gpus_per_node: 4
-
-  engine:
-    type: trtllm
-    # Dynamo builds before ai-dynamo/dynamo#12162 reject --publish-metrics.
-    publish_metrics: false
-
-  roles:
-    prefill:
-      env:
-        TLLM_LOG_LEVEL: INFO
-        TRTLLM_SERVER_DISABLE_GC: '1'
-        TRTLLM_WORKER_DISABLE_GC: '1'
-        TRTLLM_ENABLE_PDL: '1'
-        NCCL_GRAPH_MIXING_SUPPORT: '0'
-        MIMALLOC_PURGE_DELAY: '0'
-        UCX_TLS: cuda_ipc,cuda_copy,sm,self,tcp
-      args:
-        cache_transceiver_config:
-          kv_transfer_timeout_ms: 600000
-          max_tokens_in_buffer: 16384
-        cuda_graph_config:
-        disable_overlap_scheduler: true
-        enable_attention_dp: true
-        kv_cache_config:
-          dtype: fp8
-          enable_block_reuse: false
-        max_num_tokens: 16896
-        max_seq_len: 8448
-        moe_config:
-          backend: CUTEDSL
-        nvfp4_gemm_config:
-          allowed_backends:
-            - cutlass
-            - cublaslt
-            - cutedsl
-            - cuda_core
-        pipeline_parallel_size: 1
-        print_iter_log: true
-        trust_remote_code: true
-    decode:
-      env:
-        TLLM_LOG_LEVEL: INFO
-        TRTLLM_SERVER_DISABLE_GC: '1'
-        TRTLLM_WORKER_DISABLE_GC: '1'
-        TRTLLM_ENABLE_PDL: '1'
-        NCCL_GRAPH_MIXING_SUPPORT: '0'
-        MIMALLOC_PURGE_DELAY: '0'
-        UCX_TLS: cuda_ipc,cuda_copy,sm,self,tcp
-      args:
-        cache_transceiver_config:
-          kv_transfer_timeout_ms: 600000
-          max_tokens_in_buffer: 16384
-        cuda_graph_config:
-          enable_padding: true
-        enable_lm_head_tp_in_adp: false
-        kv_cache_config:
-          dtype: fp8
-          enable_block_reuse: false
-        max_seq_len: 9472
-        moe_config:
-          use_low_precision_moe_combine: true
-        num_postprocess_workers: 4
-        nvfp4_gemm_config:
-          allowed_backends:
-            - cutlass
-            - cublaslt
-            - cutedsl
-            - cuda_core
-        pipeline_parallel_size: 1
-        print_iter_log: true
-        stream_interval: 100
-        trust_remote_code: true
-
-  frontend:
-    type: dynamo
-    env:
-      ETCD_LEASE_TTL: '120'
-      DYN_TOKENIZER: "fastokens"
-
-override_1p2d_tep8_b16_c42:
-  roles:
-    prefill:
-      nodes: 1
-      workers: 1
-      gpus: 1
-      env:
-        TRT_LLM_DISABLE_LOAD_WEIGHTS_IN_PARALLEL: '1'
-        CTX_LOAD_STAGGER_S: '180'
-      args:
-        cache_transceiver_config:
-          backend: UCX
-        kv_cache_config:
-          free_gpu_memory_fraction: 0.85
-        max_batch_size: 32
-        moe_expert_parallel_size: 1
-        tensor_parallel_size: 1
-    decode:
-      nodes: 4
-      workers: 2
-      gpus: 8
-      args:
-        cache_transceiver_config:
-          backend: UCX
-        cuda_graph_config:
-          batch_sizes:
-            - 1
-            - 2
-            - 4
-            - 8
-            - 16
-        enable_attention_dp: false
-        kv_cache_config:
-          free_gpu_memory_fraction: 0.9
-        max_batch_size: 16
-        max_num_tokens: 16
-        moe_config:
-          backend: TRTLLM
-        moe_expert_parallel_size: 8
-        tensor_parallel_size: 8
-  frontend:
-    enable_multiple_frontends: false
-
-override_1p4d_tep8_b1_c8:
-  roles:
-    prefill:
-      nodes: 1
-      workers: 1
-      gpus: 2
-      args:
-        cache_transceiver_config:
-          backend: UCX
-        kv_cache_config:
-          free_gpu_memory_fraction: 0.85
-        max_batch_size: 32
-        moe_expert_parallel_size: 2
-        tensor_parallel_size: 2
-    decode:
-      nodes: 8
-      workers: 4
-      gpus: 8
-      args:
-        cache_transceiver_config:
-          backend: UCX
-        cuda_graph_config:
-          batch_sizes:
-            - 1
-            - 2
-            - 4
-        enable_attention_dp: false
-        kv_cache_config:
-          free_gpu_memory_fraction: 0.9
-        max_batch_size: 1
-        max_num_tokens: 1
-        moe_config:
-          backend: TRTLLM
-        moe_expert_parallel_size: 8
-        tensor_parallel_size: 8
-  frontend:
-    enable_multiple_frontends: false
-
-override_1p4d_tep8_b4_c24:
-  roles:
-    prefill:
-      nodes: 1
-      workers: 1
-      gpus: 1
-      env:
-        TRT_LLM_DISABLE_LOAD_WEIGHTS_IN_PARALLEL: '1'
-        CTX_LOAD_STAGGER_S: '180'
-      args:
-        cache_transceiver_config:
-          backend: UCX
-        kv_cache_config:
-          free_gpu_memory_fraction: 0.85
-        max_batch_size: 32
-        moe_expert_parallel_size: 1
-        tensor_parallel_size: 1
-    decode:
-      nodes: 8
-      workers: 4
-      gpus: 8
-      args:
-        cache_transceiver_config:
-          backend: UCX
-        cuda_graph_config:
-          batch_sizes:
-            - 1
-            - 2
-            - 4
-        enable_attention_dp: false
-        kv_cache_config:
-          free_gpu_memory_fraction: 0.9
-        max_batch_size: 4
-        max_num_tokens: 4
-        moe_config:
-          backend: TRTLLM
-        moe_expert_parallel_size: 8
-        tensor_parallel_size: 8
-  frontend:
-    enable_multiple_frontends: false
-
-override_4p1d_dep16_b16_c282:
-  identity:
-    frameworks:
-      tensorrt_llm: 1.3.0rc24
-  engine:
-    sequential_node_start: 2
-  roles:
-    prefill:
-      nodes: 1
-      workers: 4
-      gpus: 1
-      env:
-        TRT_LLM_DISABLE_LOAD_WEIGHTS_IN_PARALLEL: '1'
-        CTX_LOAD_STAGGER_S: '180'
-      args:
-        cache_transceiver_config:
-          backend: NIXL
-        kv_cache_config:
-          free_gpu_memory_fraction: 0.7
-        max_batch_size: 2
-        moe_expert_parallel_size: 1
-        tensor_parallel_size: 1
-    decode:
-      nodes: 4
-      workers: 1
-      gpus: 16
-      args:
-        cache_transceiver_config:
-          backend: NIXL
-        cuda_graph_config:
-          batch_sizes:
-            - 1
-            - 2
-            - 4
-            - 8
-            - 16
-        enable_attention_dp: true
-        kv_cache_config:
-          free_gpu_memory_fraction: 0.75
-        max_batch_size: 16
-        max_num_tokens: 16
-        moe_config:
-          backend: CUTEDSL
-        moe_expert_parallel_size: 16
-        tensor_parallel_size: 16
-  frontend:
-    enable_multiple_frontends: false
-
-override_4p3d_tep8_b64_c210:
-  identity:
-    frameworks:
-      tensorrt_llm: 1.3.0rc24
-  engine:
-    sequential_node_start: 2
-  roles:
-    prefill:
-      nodes: 1
-      workers: 4
-      gpus: 1
-      env:
-        TRT_LLM_DISABLE_LOAD_WEIGHTS_IN_PARALLEL: '1'
-        CTX_LOAD_STAGGER_S: '180'
-      args:
-        cache_transceiver_config:
-          backend: UCX
-        kv_cache_config:
-          free_gpu_memory_fraction: 0.85
-        max_batch_size: 32
-        moe_expert_parallel_size: 1
-        tensor_parallel_size: 1
-    decode:
-      nodes: 6
-      workers: 3
-      gpus: 8
-      args:
-        cache_transceiver_config:
-          backend: UCX
-        cuda_graph_config:
-          batch_sizes:
-            - 1
-            - 2
-            - 4
-            - 8
-            - 16
-            - 24
-            - 32
-            - 40
-            - 48
-            - 56
-            - 64
-        enable_attention_dp: false
-        kv_cache_config:
-          free_gpu_memory_fraction: 0.9
-        max_batch_size: 64
-        max_num_tokens: 64
-        moe_config:
-          backend: TRTLLM
-        moe_expert_parallel_size: 8
-        tensor_parallel_size: 8
-  frontend:
-    enable_multiple_frontends: false
-
-override_7p1d_dep16_b32_c563:
-  identity:
-    frameworks:
-      tensorrt_llm: 1.3.0rc24
-  engine:
-    sequential_node_start: 2
-  roles:
-    prefill:
-      nodes: 2
-      workers: 7
-      gpus: 1
-      env:
-        TRT_LLM_DISABLE_LOAD_WEIGHTS_IN_PARALLEL: '1'
-        CTX_LOAD_STAGGER_S: '180'
-      args:
-        cache_transceiver_config:
-          backend: NIXL
-        kv_cache_config:
-          free_gpu_memory_fraction: 0.7
-        max_batch_size: 2
-        moe_expert_parallel_size: 1
-        tensor_parallel_size: 1
-    decode:
-      nodes: 4
-      workers: 1
-      gpus: 16
-      args:
-        cache_transceiver_config:
-          backend: NIXL
-        cuda_graph_config:
-          batch_sizes:
-            - 1
-            - 2
-            - 4
-            - 8
-            - 16
-            - 24
-            - 32
-        enable_attention_dp: true
-        kv_cache_config:
-          free_gpu_memory_fraction: 0.75
-        max_batch_size: 32
-        max_num_tokens: 32
-        moe_config:
-          backend: CUTEDSL
-        moe_expert_parallel_size: 16
-        tensor_parallel_size: 16
-  frontend:
-    enable_multiple_frontends: true
-
-override_10p1d_dep8_b256_c2150:
-  identity:
-    frameworks:
-      tensorrt_llm: 1.3.0rc24
-  engine:
-    sequential_node_start: 2
-  roles:
-    prefill:
-      nodes: 3
-      workers: 10
-      gpus: 1
-      env:
-        TRT_LLM_DISABLE_LOAD_WEIGHTS_IN_PARALLEL: '1'
-        CTX_LOAD_STAGGER_S: '180'
-      args:
-        cache_transceiver_config:
-          backend: NIXL
-        kv_cache_config:
-          free_gpu_memory_fraction: 0.7
-        max_batch_size: 2
-        moe_expert_parallel_size: 1
-        tensor_parallel_size: 1
-    decode:
-      nodes: 2
-      workers: 1
-      gpus: 8
-      args:
-        cache_transceiver_config:
-          backend: NIXL
-        cuda_graph_config:
-          batch_sizes:
-            - 1
-            - 2
-            - 4
-            - 8
-            - 16
-            - 24
-            - 32
-            - 40
-            - 48
-            - 56
-            - 64
-            - 72
-            - 80
-            - 88
-            - 96
-            - 104
-            - 112
-            - 120
-            - 128
-            - 136
-            - 144
-            - 152
-            - 160
-            - 168
-            - 176
-            - 184
-            - 192
-            - 200
-            - 208
-            - 216
-            - 224
-            - 232
-            - 240
-            - 248
-            - 256
-        enable_attention_dp: true
-        kv_cache_config:
-          free_gpu_memory_fraction: 0.8
-        max_batch_size: 256
-        max_num_tokens: 256
-        moe_config:
-          backend: CUTEDSL
-        moe_expert_parallel_size: 8
-        tensor_parallel_size: 8
-  frontend:
-    enable_multiple_frontends: true
-
-override_11p1d_dep16_b64_c1076:
-  identity:
-    frameworks:
-      tensorrt_llm: 1.3.0rc24
-  engine:
-    sequential_node_start: 2
-  roles:
-    prefill:
-      nodes: 3
-      workers: 11
-      gpus: 1
-      env:
-        TRT_LLM_DISABLE_LOAD_WEIGHTS_IN_PARALLEL: '1'
-        CTX_LOAD_STAGGER_S: '180'
-      args:
-        cache_transceiver_config:
-          backend: NIXL
-          transceiver_runtime: PYTHON
-        kv_cache_config:
-          free_gpu_memory_fraction: 0.7
-        max_batch_size: 2
-        moe_expert_parallel_size: 1
-        tensor_parallel_size: 1
-    decode:
-      nodes: 4
-      workers: 1
-      gpus: 16
-      args:
-        cache_transceiver_config:
-          backend: NIXL
-          transceiver_runtime: PYTHON
-        cuda_graph_config:
-          batch_sizes:
-            - 1
-            - 2
-            - 4
-            - 8
-            - 16
-            - 24
-            - 32
-            - 40
-            - 48
-            - 56
-            - 64
-        enable_attention_dp: true
-        kv_cache_config:
-          free_gpu_memory_fraction: 0.75
-        max_batch_size: 64
-        max_num_tokens: 64
-        moe_config:
-          backend: CUTEDSL
-        moe_expert_parallel_size: 16
-        tensor_parallel_size: 16
-  frontend:
-    enable_multiple_frontends: true
-
-override_16p1d_dep16_b128_c2253:
-  identity:
-    frameworks:
-      tensorrt_llm: 1.3.0rc24
-  engine:
-    sequential_node_start: 2
-  roles:
-    prefill:
-      nodes: 4
-      workers: 16
-      gpus: 1
-      env:
-        TRT_LLM_DISABLE_LOAD_WEIGHTS_IN_PARALLEL: '1'
-        CTX_LOAD_STAGGER_S: '180'
-      args:
-        cache_transceiver_config:
-          backend: NIXL
-          transceiver_runtime: PYTHON
-        kv_cache_config:
-          free_gpu_memory_fraction: 0.7
-        max_batch_size: 2
-        moe_expert_parallel_size: 1
-        tensor_parallel_size: 1
-    decode:
-      nodes: 4
-      workers: 1
-      gpus: 16
-      args:
-        cache_transceiver_config:
-          backend: NIXL
-          transceiver_runtime: PYTHON
-        cuda_graph_config:
-          batch_sizes:
-            - 1
-            - 2
-            - 4
-            - 8
-            - 16
-            - 24
-            - 32
-            - 40
-            - 48
-            - 56
-            - 64
-            - 72
-            - 80
-            - 88
-            - 96
-            - 104
-            - 112
-            - 120
-            - 128
-        enable_attention_dp: true
-        kv_cache_config:
-          free_gpu_memory_fraction: 0.75
-        max_batch_size: 128
-        max_num_tokens: 128
-        moe_config:
-          backend: CUTEDSL
-        moe_expert_parallel_size: 16
-        tensor_parallel_size: 16
-  frontend:
-    enable_multiple_frontends: true
-
-override_24p1d_dep16_b512_c8192_stp_sweep:
-  identity:
-    frameworks:
-      tensorrt_llm: 1.3.0rc24
-  engine:
-    sequential_node_start: 2
-  roles:
-    prefill:
-      nodes: 6
-      workers: 24
-      gpus: 1
-      env:
-        TRT_LLM_DISABLE_LOAD_WEIGHTS_IN_PARALLEL: '1'
-        CTX_LOAD_STAGGER_S: '180'
-      args:
-        cache_transceiver_config:
-          backend: NIXL
-        kv_cache_config:
-          free_gpu_memory_fraction: 0.7
-        max_batch_size: 2
-        moe_expert_parallel_size: 1
-        tensor_parallel_size: 1
-    decode:
-      nodes: 4
-      workers: 1
-      gpus: 16
-      args:
-        cache_transceiver_config:
-          backend: NIXL
-        cuda_graph_config:
-          batch_sizes:
-            - 1
-            - 2
-            - 4
-            - 8
-            - 16
-            - 24
-            - 32
-            - 40
-            - 48
-            - 56
-            - 64
-            - 72
-            - 80
-            - 88
-            - 96
-            - 104
-            - 112
-            - 120
-            - 128
-            - 136
-            - 144
-            - 152
-            - 160
-            - 168
-            - 176
-            - 184
-            - 192
-            - 200
-            - 208
-            - 216
-            - 224
-            - 232
-            - 240
-            - 248
-            - 256
-            - 264
-            - 272
-            - 280
-            - 288
-            - 296
-            - 304
-            - 312
-            - 320
-            - 328
-            - 336
-            - 344
-            - 352
-            - 360
-            - 368
-            - 376
-            - 384
-            - 392
-            - 400
-            - 408
-            - 416
-            - 424
-            - 432
-            - 440
-            - 448
-            - 456
-            - 464
-            - 472
-            - 480
-            - 488
-            - 496
-            - 504
-            - 512
-        enable_attention_dp: true
-        kv_cache_config:
-          free_gpu_memory_fraction: 0.75
-        max_batch_size: 512
-        max_num_tokens: 512
-        moe_config:
-          backend: CUTEDSL
-        moe_expert_parallel_size: 16
-        tensor_parallel_size: 16
-  frontend:
-    enable_multiple_frontends: true
diff --git a/inferencex-e2e/benchmarks/multi_node/srt_eval.sh b/inferencex-e2e/benchmarks/multi_node/srt_eval.sh
index 69a76297a4..b935967d8c 100644
--- a/inferencex-e2e/benchmarks/multi_node/srt_eval.sh
+++ b/inferencex-e2e/benchmarks/multi_node/srt_eval.sh
@@ -10,6 +10,11 @@ if [[ $# -ne 2 || -z "$1" || -z "$2" ]]; then
     echo "Usage: $0 endpoint infmax_workspace" >&2
     exit 1
 fi
+# An agentic eval's acceptance gate ran as this job's benchmark stage, which srt-slurm runs only
+# without EVAL_ONLY; the eval itself is still eval-only.
+if [[ "${EVAL_AL_GATE:-}" == true ]]; then
+    export EVAL_ONLY=true RUN_EVAL=false
+fi
 source "$2/benchmarks/check_env.sh"
 # The workflow supplies the topology; srt-slurm supplies MODEL_NAME (served) and EVAL_CONC.
 check_env_vars \
diff --git a/inferencex-e2e/benchmarks/single_node/speedbench/dsv4_fp4_b300_vllm.sh b/inferencex-e2e/benchmarks/single_node/speedbench/dsv4_fp4_b300_vllm.sh
index 926a1735fb..fa9e1a19f5 100755
--- a/inferencex-e2e/benchmarks/single_node/speedbench/dsv4_fp4_b300_vllm.sh
+++ b/inferencex-e2e/benchmarks/single_node/speedbench/dsv4_fp4_b300_vllm.sh
@@ -25,7 +25,7 @@ SERVE_MODEL="${MODEL_PATH}"
 MODEL_KEY="$(basename "$SERVE_MODEL" | tr '[:upper:]' '[:lower:]')"
 CONCURRENCY="1"
 TEMPERATURE="1.0"
-# MUST match the golden config: infx/golden_al_distribution/dsv4_mtp.yaml was measured
+# MUST match the golden config: infx/golden_al_distribution/deepseek-v4-pro__mtp__native__default-default.yaml was measured
 # with reasoning_effort=high.
 
 SPEEDBENCH_DIR="/workspace/speed_bench_data"
@@ -37,8 +37,17 @@ mkdir -p "$RESULTS_DIR"
 nvidia-smi
 if [[ "$SERVE_MODEL" != /* ]]; then hf download "$SERVE_MODEL"; fi
 
+# Some nodes run another service on the default port; serve on a free one instead.
+if ! python3 -c 'import socket, sys; socket.socket().bind(("0.0.0.0", int(sys.argv[1])))' "$PORT" 2>/dev/null; then
+    busy_port="$PORT"
+    PORT="$(python3 -c 'import socket; s = socket.socket(); s.bind(("0.0.0.0", 0)); print(s.getsockname()[1])')"
+    echo "Port $busy_port is in use on $(hostname); serving on $PORT"
+fi
+
 echo "=== Downloading SPEED-Bench dataset ==="
-pip install -q datasets tiktoken
+# Pin the image's Hugging Face stack: an unconstrained install can pull huggingface-hub 2.x,
+# which transformers 5.x rejects, and then no server starts.
+pip install -q -c <(pip freeze | grep -iE '^(huggingface[-_]hub|transformers|tokenizers)==') datasets tiktoken
 curl -LsSf https://raw.githubusercontent.com/NVIDIA-NeMo/Skills/refs/heads/main/nemo_skills/dataset/speed-bench/prepare.py \
   | python3 - --config qualitative --output_dir "$SPEEDBENCH_DIR"
 
diff --git a/inferencex-e2e/benchmarks/single_node/speedbench/dsv4dspark_fp4_b300_vllm.sh b/inferencex-e2e/benchmarks/single_node/speedbench/dsv4dspark_fp4_b300_vllm.sh
index 2ef26539f0..d8e41df1aa 100755
--- a/inferencex-e2e/benchmarks/single_node/speedbench/dsv4dspark_fp4_b300_vllm.sh
+++ b/inferencex-e2e/benchmarks/single_node/speedbench/dsv4dspark_fp4_b300_vllm.sh
@@ -7,8 +7,8 @@
 # golden_al_distribution shape. DSpark ships as a separate checkpoint
 # (deepseek-ai/DeepSeek-V4-Pro-DSpark, 960 GB) with the draft baked in, so there is no
 # external draft head and no "model" key in the speculative-config. Every flag that
-# affects drafting is byte-identical to the DSV4 MTP collector so the two AL curves
-# stay comparable.
+# affects drafting matches the DSV4 MTP collector so the two AL curves stay comparable,
+# except the attention config, which follows the newer vLLM image the DSpark recipes use.
 #
 # Dispatch this collector through speedbench-al.yml.
 #
@@ -40,10 +40,10 @@ MAX_NUM_SEQS="64"
 # Reserve device memory for KV cache and speculative verification.
 GPU_MEM_UTIL="0.90"
 TEMPERATURE="1.0"
-# MUST match the golden config: infx/golden_al_distribution/dsv4_mtp.yaml was measured
+# MUST match the golden config: infx/golden_al_distribution/deepseek-v4-pro__mtp__native__default-default.yaml was measured
 # with reasoning_effort=high.
 # The published recipe uses greedy; probabilistic won at every level on Kimi-K3
-# (infx/golden_al_distribution/kimik3_dspark*.yaml). vLLM accepts exactly these two values
+# (infx/golden_al_distribution/kimi-k3__dspark__kimi-k3-dspark__*.yaml). vLLM accepts exactly these two values
 # (vllm/config/speculative.py: DraftSampleMethod).
 case "$DRAFT_SAMPLE_METHOD" in
     greedy|probabilistic) ;;
@@ -81,8 +81,17 @@ else
     if [[ "$SERVE_MODEL" != /* ]]; then hf download "$SERVE_MODEL"; fi
 fi
 
+# Some nodes run another service on the default port; serve on a free one instead.
+if ! python3 -c 'import socket, sys; socket.socket().bind(("0.0.0.0", int(sys.argv[1])))' "$PORT" 2>/dev/null; then
+    busy_port="$PORT"
+    PORT="$(python3 -c 'import socket; s = socket.socket(); s.bind(("0.0.0.0", 0)); print(s.getsockname()[1])')"
+    echo "Port $busy_port is in use on $(hostname); serving on $PORT"
+fi
+
 echo "=== Downloading SPEED-Bench dataset ==="
-pip install -q datasets tiktoken
+# Pin the image's Hugging Face stack: an unconstrained install can pull huggingface-hub 2.x,
+# which transformers 5.x rejects, and then no server starts.
+pip install -q -c <(pip freeze | grep -iE '^(huggingface[-_]hub|transformers|tokenizers)==') datasets tiktoken
 curl -LsSf https://raw.githubusercontent.com/NVIDIA-NeMo/Skills/refs/heads/main/nemo_skills/dataset/speed-bench/prepare.py \
   | python3 - --config qualitative --output_dir "$SPEEDBENCH_DIR"
 
@@ -173,7 +182,9 @@ run_cell() {
         "${EP_ARGS[@]}"
         "${MOE_ARGS[@]}"
         --compilation-config '{"cudagraph_mode":"FULL_AND_PIECEWISE","custom_ops":["all"]}'
-        --attention_config.use_fp4_indexer_cache True
+        # Same attention config as the 0813 DSpark recipes on the 20ebb28 nightly, which
+        # renamed use_fp4_indexer_cache to indexer_kv_dtype=mxfp4.
+        --attention-config '{"backend":"FLASHINFER_MLA_SPARSE_DSV4","use_prefill_query_quantization":true,"indexer_kv_dtype":"mxfp4"}'
         --tokenizer-mode deepseek_v4
         --tool-call-parser deepseek_v4
         --enable-auto-tool-choice
diff --git a/inferencex-e2e/benchmarks/single_node/speedbench/dsv4dspark_fp4_b300_vllm_probabilistic_sample_method_block_rejection_sample_method.sh b/inferencex-e2e/benchmarks/single_node/speedbench/dsv4dspark_fp4_b300_vllm_probabilistic_sample_method_block_rejection_sample_method.sh
new file mode 100755
index 0000000000..8e2cc5a332
--- /dev/null
+++ b/inferencex-e2e/benchmarks/single_node/speedbench/dsv4dspark_fp4_b300_vllm_probabilistic_sample_method_block_rejection_sample_method.sh
@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+
+exec env DRAFT_SAMPLE_METHOD=probabilistic REJECTION_SAMPLE_METHOD=block \
+    bash "$(dirname "$0")/dsv4dspark_fp4_b300_vllm.sh" "$@"
diff --git a/inferencex-e2e/benchmarks/single_node/speedbench/glm5.3_fp4_b300_sglang.sh b/inferencex-e2e/benchmarks/single_node/speedbench/glm5.3_fp4_b300_sglang.sh
new file mode 100755
index 0000000000..cbf4692921
--- /dev/null
+++ b/inferencex-e2e/benchmarks/single_node/speedbench/glm5.3_fp4_b300_sglang.sh
@@ -0,0 +1,203 @@
+#!/usr/bin/env bash
+
+set -o pipefail
+repo_root="$(cd "$(dirname "$0")/../../.." && pwd)"
+source "$repo_root/benchmarks/check_env.sh"
+check_env_vars \
+    CATEGORY MODEL MODEL_PATH MTP_LIST OUT_YAML PORT SPEEDBENCH_OUTPUT_LEN THINKING_MODES
+
+if [[ "$THINKING_MODES" != "on" ]]; then
+    echo "CRITICAL: SGLang's SPEED-Bench loader renders only the default (thinking on); dispatch with thinking-modes=on (got '$THINKING_MODES')"
+    exit 1
+fi
+
+SERVE_MODEL="${MODEL_PATH}"
+
+MODEL_KEY="$(basename "$SERVE_MODEL" | tr '[:upper:]' '[:lower:]')"
+# AL is a per-draft accept/reject property independent of batch size, so batch the
+# SPEED-Bench pass to cut wall-clock, as the DSV4 DSpark collector does.
+CONCURRENCY="32"
+TEMPERATURE="1.0"
+TOP_P="0.95"
+
+SPEEDBENCH_DIR="/workspace/speed_bench_data"
+RESULTS_DIR="/workspace/speedbench_results"
+
+mkdir -p "$RESULTS_DIR"
+nvidia-smi
+GPU_NAME="$(nvidia-smi --query-gpu=name --format=csv,noheader | head -1)"
+
+if [[ ! -d "$MODEL_PATH" || -z "$(ls -A "$MODEL_PATH" 2>/dev/null)" ]]; then
+    if [[ ! -w "$(dirname "$MODEL_PATH")" ]]; then
+        echo "CRITICAL: $MODEL_PATH is empty and $(dirname "$MODEL_PATH") is not writable."
+        echo "The cluster's models.entries names this checkpoint but the weights were never staged."
+        exit 1
+    fi
+    echo "=== $MODEL_PATH is empty; downloading $MODEL (first run only) ==="
+    hf download "$MODEL" --local-dir "$MODEL_PATH"
+fi
+
+# Some nodes run another service on the default port; serve on a free one instead.
+if ! python3 -c 'import socket, sys; socket.socket().bind(("0.0.0.0", int(sys.argv[1])))' "$PORT" 2>/dev/null; then
+    busy_port="$PORT"
+    PORT="$(python3 -c 'import socket; s = socket.socket(); s.bind(("0.0.0.0", 0)); print(s.getsockname()[1])')"
+    echo "Port $busy_port is in use on $(hostname); serving on $PORT"
+fi
+
+echo "=== Downloading SPEED-Bench dataset ==="
+# Pin the image's Hugging Face stack: an unconstrained install can pull huggingface-hub 2.x,
+# which transformers 5.x rejects, and then no server starts.
+pip install -q -c <(pip freeze | grep -iE '^(huggingface[-_]hub|transformers|tokenizers)==') datasets tiktoken
+curl -LsSf https://raw.githubusercontent.com/NVIDIA-NeMo/Skills/refs/heads/main/nemo_skills/dataset/speed-bench/prepare.py \
+  | python3 - --config qualitative --output_dir "$SPEEDBENCH_DIR"
+
+if [[ ! -f "$SPEEDBENCH_DIR/qualitative.jsonl" ]]; then
+    echo "CRITICAL: SPEED-Bench download failed — $SPEEDBENCH_DIR/qualitative.jsonl not found"
+    exit 1
+fi
+
+# SGLang's speed-bench loader only accepts the throughput-split categories on the CLI and
+# reads prompts from "turns", while prepare.py writes "messages". Filter the qualitative
+# split to $CATEGORY and restore "turns" from the user messages.
+CATEGORY_JSONL="$SPEEDBENCH_DIR/qualitative_${CATEGORY}.jsonl"
+python3 - "$SPEEDBENCH_DIR/qualitative.jsonl" "$CATEGORY_JSONL" "$CATEGORY" <<'EOF'
+import json, sys
+src, dst, category = sys.argv[1:]
+with open(src) as f, open(dst, "w") as out:
+    for line in f:
+        row = json.loads(line)
+        if row.get("category") == category:
+            row["turns"] = [m["content"] for m in row["messages"] if m["role"] == "user"]
+            out.write(json.dumps(row) + "\n")
+EOF
+NUM_PROMPTS=$(wc -l < "$CATEGORY_JSONL")
+if [[ "$NUM_PROMPTS" -eq 0 ]]; then
+    echo "CRITICAL: no SPEED-Bench qualitative rows for category '$CATEGORY'"
+    exit 1
+fi
+
+SERVER_PID=""
+_descendants() {
+    local pid="$1" child
+    for child in $(pgrep -P "$pid" 2>/dev/null || true); do
+        echo "$child"
+        _descendants "$child"
+    done
+}
+cleanup_server() {
+    if [[ -n "$SERVER_PID" ]]; then
+        local descendants
+        descendants=$(_descendants "$SERVER_PID")
+        kill "$SERVER_PID" 2>/dev/null || true
+        wait "$SERVER_PID" 2>/dev/null || true
+        local pid
+        for pid in $descendants; do
+            kill -9 "$pid" 2>/dev/null || true
+        done
+        local waited=0
+        while [[ $waited -lt 120 ]]; do
+            local used
+            used=$(nvidia-smi --query-gpu=memory.used --format=csv,noheader,nounits 2>/dev/null | sort -rn | head -1)
+            if [[ -z "$used" || "$used" -lt 2000 ]]; then break; fi
+            sleep 3; waited=$((waited + 3))
+        done
+        SERVER_PID=""
+    fi
+}
+trap 'cleanup_server' EXIT
+
+declare -A AL_RESULT
+
+run_cell() {
+    local mode="$1" mtp="$2"
+
+    echo ""
+    echo "=========================================="
+    echo "  Cell: thinking=$mode  MTP=$mtp  category=$CATEGORY"
+    echo "=========================================="
+
+    # Flags follow srt-slurm-recipes/glm5.3/sglang/b300-fp4-mtp/agentic.yaml.
+    local serve_args=(
+        --model-path "$SERVE_MODEL"
+        --host 0.0.0.0 --port "$PORT"
+        --tp-size 8 --ep-size 1
+        --quantization modelopt_fp4
+        --trust-remote-code
+        --mem-fraction-static 0.86
+        --chunked-prefill-size 8192
+        --max-prefill-tokens 8192
+        --reasoning-parser glm45
+        --tool-call-parser glm47
+        --speculative-algorithm NEXTN
+        --speculative-num-steps "$mtp"
+        --speculative-eagle-topk 1
+        --speculative-num-draft-tokens "$((mtp + 1))"
+    )
+
+    local server_log="$RESULTS_DIR/server_${mode}_mtp${mtp}.log"
+    python3 -m sglang.launch_server "${serve_args[@]}" > "$server_log" 2>&1 &
+    SERVER_PID=$!
+
+    if ! PYTHONSAFEPATH=1 PYTHONPATH="$repo_root${PYTHONPATH:+:$PYTHONPATH}" python3 -m infx.bench wait \
+            --url "http://0.0.0.0:${PORT}/health" --pid "$SERVER_PID" --log "$server_log"; then
+        echo "  -> server failed to start (thinking=$mode mtp=$mtp), recording N/A"
+        AL_RESULT["${mode}_${mtp}"]="N/A"
+        cleanup_server
+        return
+    fi
+
+    local result_file="$RESULTS_DIR/speedbench_${mode}_mtp${mtp}.jsonl"
+    python3 -m sglang.bench_serving \
+        --backend sglang \
+        --port "$PORT" \
+        --model "$SERVE_MODEL" \
+        --dataset-name speed-bench \
+        --dataset-path "$CATEGORY_JSONL" \
+        --speed-bench-output-len "$SPEEDBENCH_OUTPUT_LEN" \
+        --num-prompts "$NUM_PROMPTS" \
+        --max-concurrency "$CONCURRENCY" \
+        --temperature "$TEMPERATURE" \
+        --top-p "$TOP_P" \
+        --disable-ignore-eos \
+        --output-file "$result_file" \
+        --output-details
+
+    # accept_length counts the bonus token, like vLLM's 1 + accepted/drafts.
+    local al
+    al=$(python3 -c '
+import json, sys
+with open(sys.argv[1]) as f:
+    al = json.loads(f.readlines()[-1]).get("accept_length")
+print(f"{al:.2f}" if al else "N/A")
+' "$result_file" 2>/dev/null || echo "N/A")
+    echo "  -> thinking=$mode MTP=$mtp AL=$al"
+    AL_RESULT["${mode}_${mtp}"]="$al"
+
+    cleanup_server
+}
+
+for mtp in $MTP_LIST; do
+    run_cell on "$mtp"
+done
+
+{
+    echo "# Acceptance Length (AL) reference values measured with SPEED-Bench."
+    echo "# dataset: $CATEGORY | temperature: $TEMPERATURE | top_p: $TOP_P | output_len: $SPEEDBENCH_OUTPUT_LEN"
+    echo "# thinking_on: chat template default"
+    echo "# speculative: NEXTN, eagle-topk 1, num-draft-tokens = level + 1; kv_cache_dtype: engine default"
+    echo "# Measured on $MODEL_KEY ($GPU_NAME, SGLang MTP), per num_speculative_tokens."
+    echo "# Auto-generated by benchmarks/single_node/speedbench/glm5.3_fp4_b300_sglang.sh (speedbench-al.yml)."
+    echo "#"
+    echo "# key = num_speculative_tokens (MTP level); value = golden AL"
+    echo "${MODEL_KEY}:"
+    echo "  thinking_on:"
+    for mtp in $MTP_LIST; do
+        echo "    $mtp: ${AL_RESULT[on_${mtp}]:-N/A}"
+    done
+} > "$OUT_YAML"
+
+echo ""
+echo "=========================================="
+echo "  SPEED-Bench AL matrix written to: $OUT_YAML"
+echo "=========================================="
+cat "$OUT_YAML"
diff --git a/inferencex-e2e/benchmarks/single_node/speedbench/glm52_fp4_b300_vllm.sh b/inferencex-e2e/benchmarks/single_node/speedbench/glm52_fp4_b300_vllm.sh
index 62e209309e..bd7929625d 100644
--- a/inferencex-e2e/benchmarks/single_node/speedbench/glm52_fp4_b300_vllm.sh
+++ b/inferencex-e2e/benchmarks/single_node/speedbench/glm52_fp4_b300_vllm.sh
@@ -49,8 +49,17 @@ else
     if [[ "$SERVE_MODEL" != /* ]]; then hf download "$SERVE_MODEL"; fi
 fi
 
+# Some nodes run another service on the default port; serve on a free one instead.
+if ! python3 -c 'import socket, sys; socket.socket().bind(("0.0.0.0", int(sys.argv[1])))' "$PORT" 2>/dev/null; then
+    busy_port="$PORT"
+    PORT="$(python3 -c 'import socket; s = socket.socket(); s.bind(("0.0.0.0", 0)); print(s.getsockname()[1])')"
+    echo "Port $busy_port is in use on $(hostname); serving on $PORT"
+fi
+
 echo "=== Downloading SPEED-Bench dataset ==="
-pip install -q datasets tiktoken
+# Pin the image's Hugging Face stack: an unconstrained install can pull huggingface-hub 2.x,
+# which transformers 5.x rejects, and then no server starts.
+pip install -q -c <(pip freeze | grep -iE '^(huggingface[-_]hub|transformers|tokenizers)==') datasets tiktoken
 curl -LsSf https://raw.githubusercontent.com/NVIDIA-NeMo/Skills/refs/heads/main/nemo_skills/dataset/speed-bench/prepare.py \
   | python3 - --config qualitative --output_dir "$SPEEDBENCH_DIR"
 
diff --git a/inferencex-e2e/benchmarks/single_node/speedbench/glm53flash_fp8_b300_vllm.sh b/inferencex-e2e/benchmarks/single_node/speedbench/glm53flash_fp8_b300_vllm.sh
deleted file mode 100644
index 088c65a168..0000000000
--- a/inferencex-e2e/benchmarks/single_node/speedbench/glm53flash_fp8_b300_vllm.sh
+++ /dev/null
@@ -1,27 +0,0 @@
-#!/usr/bin/env bash
-set -eo pipefail
-repo_root="$(cd "$(dirname "$0")/../../.." && pwd)"
-source "$repo_root/benchmarks/check_env.sh"
-check_env_vars \
-    CATEGORY CHAT_TEMPLATE_KWARGS_ON IMAGE MODEL MODEL_PATH MTP_LIST \
-    OUT_YAML PORT SPEEDBENCH_OUTPUT_LEN THINKING_MODES TP
-
-export PYTHONPATH="$repo_root${PYTHONPATH:+:$PYTHONPATH}"
-export VLLM_ENGINE_READY_TIMEOUT_S=3600
-export VLLM_USE_RUST_FRONTEND=0
-exec python3 -m infx.bench speedbench-al \
-    --concurrency 1 \
-    --temperature 1.0 \
-    --top-p 0.95 \
-    -- \
-    --tensor-parallel-size "$TP" --data-parallel-size 1 \
-    --trust-remote-code \
-    --gpu-memory-utilization 0.80 \
-    --max-model-len 32768 \
-    --max-num-batched-tokens 8192 \
-    --max-num-seqs 32 \
-    --kv-cache-dtype fp8 \
-    --tokenizer-mode auto \
-    --reasoning-parser glm47 \
-    --chat-template-content-format string \
-    --no-enable-prefix-caching
diff --git a/inferencex-e2e/benchmarks/single_node/speedbench/kimik3.1_fp4_b300_sglang.sh b/inferencex-e2e/benchmarks/single_node/speedbench/kimik3.1_fp4_b300_sglang.sh
new file mode 100755
index 0000000000..b992b44655
--- /dev/null
+++ b/inferencex-e2e/benchmarks/single_node/speedbench/kimik3.1_fp4_b300_sglang.sh
@@ -0,0 +1,276 @@
+#!/usr/bin/env bash
+
+set -o pipefail
+repo_root="$(cd "$(dirname "$0")/../../.." && pwd)"
+source "$repo_root/benchmarks/check_env.sh"
+check_env_vars \
+    CATEGORY MODEL MODEL_PATH MTP_LIST OUT_YAML PORT SPEEDBENCH_OUTPUT_LEN THINKING_MODES
+
+if [[ "$THINKING_MODES" != "on" ]]; then
+    echo "CRITICAL: the K3.1 DSpark curve this matches has thinking_on only; dispatch with thinking-modes=on (got '$THINKING_MODES')"
+    exit 1
+fi
+
+SERVE_MODEL="${MODEL_PATH}"
+DRAFT_MODEL="RadixArk/Kimi-K3.1-Dflash2-Preview"
+MODEL_KEY="$(basename "$SERVE_MODEL" | tr '[:upper:]' '[:lower:]')"
+# Client settings of the K3.1 DSpark curve's vLLM collection, so the two curves differ only
+# in the drafter.
+CONCURRENCY="64"
+CHAT_TEMPLATE_KWARGS='{"thinking": true}'
+SAMPLING='{"temperature": 1.0, "top_p": 0.95, "repetition_penalty": 1.0}'
+
+SPEEDBENCH_DIR="/workspace/speed_bench_data"
+RESULTS_DIR="/workspace/speedbench_results"
+mkdir -p "$RESULTS_DIR"
+
+nvidia-smi
+GPU_NAME="$(nvidia-smi --query-gpu=name --format=csv,noheader | head -1)"
+
+# Pyxis containers share the host network and some B300 nodes run another service on the
+# workflow's port, so serve on a free one instead.
+if ! python3 -c 'import socket, sys; socket.socket().bind(("0.0.0.0", int(sys.argv[1])))' "$PORT" 2>/dev/null; then
+    busy_port="$PORT"
+    PORT="$(python3 -c 'import socket; s = socket.socket(); s.bind(("0.0.0.0", 0)); print(s.getsockname()[1])')"
+    echo "Port $busy_port is in use on $(hostname); serving on $PORT"
+fi
+
+# An unstaged checkpoint lands in the cluster's writable download root; hf download resumes and
+# verifies a partial copy, which a non-empty-directory check would accept as complete.
+if [[ ! -e "$MODEL_PATH" || -w "$MODEL_PATH" ]]; then
+    hf download "$MODEL" --local-dir "$MODEL_PATH"
+fi
+hf download "$DRAFT_MODEL"
+
+echo "=== Downloading SPEED-Bench dataset ==="
+# Pin the image's Hugging Face stack: an unconstrained install can pull a huggingface-hub
+# that the image's transformers rejects, and then no server starts.
+pip install -q -c <(pip freeze | grep -iE '^(huggingface[-_]hub|transformers|tokenizers)==') datasets tiktoken
+curl -LsSf https://raw.githubusercontent.com/NVIDIA-NeMo/Skills/refs/heads/main/nemo_skills/dataset/speed-bench/prepare.py \
+  | python3 - --config qualitative --output_dir "$SPEEDBENCH_DIR"
+if [[ ! -f "$SPEEDBENCH_DIR/qualitative.jsonl" ]]; then
+    echo "CRITICAL: SPEED-Bench download failed — $SPEEDBENCH_DIR/qualitative.jsonl not found"
+    exit 1
+fi
+
+# SGLang's SPEED-Bench loaders reorder the prompts, so this client sends them itself: each
+# category row's first user message, in vllm bench serve's order (random.seed(0) shuffle),
+# rendered by the AL gate's chat-template renderer and streamed to /v1/completions with
+# max_tokens 4096 and the engine-default ignore_eos, exactly as the vLLM collection did.
+BENCH_CLIENT="$RESULTS_DIR/speedbench_completions_client.py"
+cat > "$BENCH_CLIENT" <<'PYEOF'
+import json, random, sys, urllib.request
+from concurrent.futures import ThreadPoolExecutor
+
+from transformers import AutoTokenizer
+
+from infx.bench.al_gate import render
+
+dataset, category, model, url, concurrency, max_tokens, kwargs, sampling = sys.argv[1:]
+prompts = []
+with open(dataset) as rows:
+    for line in rows:
+        row = json.loads(line)
+        if row.get("category") == category:
+            prompts.append(next(m["content"] for m in row["messages"] if m["role"] == "user"))
+if not prompts:
+    sys.exit(f"no SPEED-Bench qualitative rows for category {category!r}")
+random.Random(0).shuffle(prompts)
+tokenizer = AutoTokenizer.from_pretrained(model, trust_remote_code=True)
+texts = [render(p, "chat_template", json.loads(kwargs), tokenizer) for p in prompts]
+body = {"model": model, "max_tokens": int(max_tokens), "stream": True, **json.loads(sampling)}
+
+
+def send(text):
+    data = json.dumps({**body, "prompt": text}).encode()
+    request = urllib.request.Request(url, data=data, headers={"Content-Type": "application/json"})
+    with urllib.request.urlopen(request, timeout=3600) as response:
+        for _ in response:
+            pass
+
+
+with ThreadPoolExecutor(int(concurrency)) as pool:
+    list(pool.map(send, texts))
+print(f"sent {len(texts)} {category} prompts at concurrency {concurrency}")
+PYEOF
+
+scrape_metrics() {
+    curl -sf "http://localhost:${PORT}/metrics" > "$1"
+}
+
+# The AL gate's own SGLang counter reader, loaded by path: the infx.results package needs
+# dependencies the serving image does not ship.
+acceptance_length() {
+    python3 - "$repo_root/infx/results/agentic/spec_decode.py" "$1" "$2" <<'EOF'
+import importlib.util, sys
+spec = importlib.util.spec_from_file_location("spec_decode", sys.argv[1])
+module = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(module)
+before, after = (open(path).read() for path in sys.argv[2:])
+reading = module.READERS["sglang"](module.increase({"s": before}, {"s": after}))
+if not reading or not reading[1]:
+    print("N/A")
+else:
+    accepted, verifications = reading
+    print(f"{1 + accepted / verifications:.2f} {int(accepted)} {int(verifications)}")
+EOF
+}
+
+SERVER_PID=""
+_descendants() {
+    local pid="$1" child
+    for child in $(pgrep -P "$pid" 2>/dev/null || true); do
+        echo "$child"
+        _descendants "$child"
+    done
+}
+cleanup_server() {
+    if [[ -n "$SERVER_PID" ]]; then
+        local descendants
+        descendants=$(_descendants "$SERVER_PID")
+        kill "$SERVER_PID" 2>/dev/null || true
+        wait "$SERVER_PID" 2>/dev/null || true
+        local pid
+        for pid in $descendants; do
+            kill -9 "$pid" 2>/dev/null || true
+        done
+        local waited=0
+        while [[ $waited -lt 120 ]]; do
+            local used
+            used=$(nvidia-smi --query-gpu=memory.used --format=csv,noheader,nounits 2>/dev/null | sort -rn | head -1)
+            if [[ -z "$used" || "$used" -lt 2000 ]]; then break; fi
+            sleep 3; waited=$((waited + 3))
+        done
+        SERVER_PID=""
+    fi
+}
+trap 'cleanup_server' EXIT
+
+declare -A AL_RESULT
+
+run_cell() {
+    local mtp="$1"
+
+    echo ""
+    echo "=========================================="
+    echo "  Cell: thinking=on  DFLASH=$mtp  category=$CATEGORY"
+    echo "=========================================="
+
+    # Server flags follow the draft card's B300 TP8 block-verification command; DFLASH's
+    # --speculative-num-draft-tokens is the verification width, the drafts plus one.
+    # ReplaySSM keeps one KDA state per request instead of one per draft token, which lets
+    # 64 running requests fit at the widest widths.
+    local serve_args=(
+        --model-path "$SERVE_MODEL"
+        --host 0.0.0.0 --port "$PORT"
+        --tp-size 8
+        --trust-remote-code
+        --weight-loader-prefetch-checkpoints
+        --model-loader-extra-config '{"enable_multithread_load": true}'
+        --mem-fraction-static 0.85
+        --mamba-full-memory-ratio 1.0
+        --mamba-ssm-dtype float32
+        --kv-cache-dtype fp8_e4m3
+        --disable-radix-cache
+        --max-running-requests "$CONCURRENCY"
+        --context-length 131072
+        --reasoning-parser kimi_k3
+        --tool-call-parser kimi_k3
+        --enable-metrics
+        --speculative-algorithm DFLASH
+        --speculative-draft-model-path "$DRAFT_MODEL"
+        --speculative-draft-attention-backend cutedsl_mla
+        --speculative-draft-kv-cache-dtype fp8_e4m3
+        --speculative-num-draft-tokens "$((mtp + 1))"
+        --speculative-use-block-verification
+        --enable-linear-replayssm-spec
+    )
+
+    local server_log="$RESULTS_DIR/server_on_mtp${mtp}.log"
+    python3 -m sglang.launch_server "${serve_args[@]}" > "$server_log" 2>&1 &
+    SERVER_PID=$!
+
+    if ! PYTHONSAFEPATH=1 PYTHONPATH="$repo_root${PYTHONPATH:+:$PYTHONPATH}" python3 -m infx.bench wait \
+            --url "http://0.0.0.0:${PORT}/health" --pid "$SERVER_PID" --log "$server_log"; then
+        echo "  -> server failed to start (dflash=$mtp), recording N/A"
+        AL_RESULT["$mtp"]="N/A"
+        cleanup_server
+        return
+    fi
+
+    local before="$RESULTS_DIR/metrics_on_mtp${mtp}_before.txt"
+    local after="$RESULTS_DIR/metrics_on_mtp${mtp}_after.txt"
+    if ! scrape_metrics "$before"; then
+        echo "  -> no /metrics before the pass (dflash=$mtp), recording N/A"
+        AL_RESULT["$mtp"]="N/A"
+        cleanup_server
+        return
+    fi
+
+    PYTHONSAFEPATH=1 PYTHONPATH="$repo_root${PYTHONPATH:+:$PYTHONPATH}" python3 "$BENCH_CLIENT" \
+        "$SPEEDBENCH_DIR/qualitative.jsonl" "$CATEGORY" "$SERVE_MODEL" \
+        "http://localhost:${PORT}/v1/completions" "$CONCURRENCY" "$SPEEDBENCH_OUTPUT_LEN" \
+        "$CHAT_TEMPLATE_KWARGS" "$SAMPLING" 2>&1 | tee "$RESULTS_DIR/client_on_mtp${mtp}.log"
+    local bench_rc=${PIPESTATUS[0]}
+    if [[ $bench_rc -ne 0 ]]; then
+        echo "  -> benchmark client exited rc=$bench_rc (dflash=$mtp); cell will be N/A"
+        AL_RESULT["$mtp"]="N/A"
+        cleanup_server
+        return
+    fi
+
+    # The engine counts the last verifications after the responses close, so scrape until
+    # the reading settles, as the AL gate does.
+    local reading="N/A" previous="" settle
+    for settle in $(seq 30); do
+        if ! scrape_metrics "$after"; then
+            reading="N/A"
+            break
+        fi
+        reading=$(acceptance_length "$before" "$after" || echo "N/A")
+        [[ "$reading" == "$previous" ]] && break
+        previous="$reading"
+        sleep 2
+    done
+    local al="${reading%% *}"
+    echo "  -> thinking=on DFLASH=$mtp AL=$al (accepted verifications: ${reading#* })"
+    AL_RESULT["$mtp"]="$al"
+
+    cleanup_server
+}
+
+for mtp in $MTP_LIST; do
+    run_cell "$mtp"
+done
+
+{
+    echo "# Acceptance Length (AL) reference values measured with SPEED-Bench."
+    echo "# dataset: $CATEGORY | top_p: 0.95 | output_len: $SPEEDBENCH_OUTPUT_LEN"
+    echo "# thinking_on: temperature=1.0, chat_template_kwargs: $CHAT_TEMPLATE_KWARGS"
+    echo "# speculative: DFLASH, draft $DRAFT_MODEL, block verification"
+    echo "# Measured on $MODEL_KEY ($GPU_NAME, SGLang DFLASH), per num_speculative_tokens."
+    echo "# Auto-generated by benchmarks/single_node/speedbench/kimik3.1_fp4_b300_sglang.sh (speedbench-al.yml)."
+    echo "#"
+    echo "# key = num_speculative_tokens (DFLASH draft tokens); value = golden AL"
+    echo "${MODEL_KEY}:"
+    echo "  thinking_on:"
+    for mtp in $MTP_LIST; do
+        echo "    $mtp: ${AL_RESULT[$mtp]:-N/A}"
+    done
+} > "$OUT_YAML"
+
+echo ""
+echo "=========================================="
+echo "  SPEED-Bench AL matrix written to: $OUT_YAML"
+echo "=========================================="
+cat "$OUT_YAML"
+
+MEASURED=0
+for mtp in $MTP_LIST; do
+    [[ "${AL_RESULT[$mtp]:-N/A}" != "N/A" ]] && MEASURED=$((MEASURED + 1))
+done
+if [[ "$MEASURED" -eq 0 ]]; then
+    echo "CRITICAL: no cell produced an AL value — see the server logs and the"
+    echo "benchmark client output above."
+    exit 1
+fi
diff --git a/inferencex-e2e/benchmarks/single_node/speedbench/kimik3_fp4_b300_vllm.sh b/inferencex-e2e/benchmarks/single_node/speedbench/kimik3_fp4_b300_vllm.sh
index 6a31fcd1b4..12896fccec 100755
--- a/inferencex-e2e/benchmarks/single_node/speedbench/kimik3_fp4_b300_vllm.sh
+++ b/inferencex-e2e/benchmarks/single_node/speedbench/kimik3_fp4_b300_vllm.sh
@@ -28,6 +28,9 @@ MAX_MODEL_LEN="16384"
 MAX_NUM_SEQS="512"
 
 DRAFT_MODEL="Inferact/Kimi-K3-DSpark"
+# Variant wrappers source this script and may set SPEC_EXTRA, extra speculative-config
+# members such as ', "draft_sample_method": "probabilistic"'; $0 is then the wrapper.
+COLLECTOR="benchmarks/single_node/speedbench/$(basename "$0")"
 
 MODEL_KEY="$(basename "$SERVE_MODEL" | tr '[:upper:]' '[:lower:]')"
 # AL is concurrency-independent (per-token accept/reject; no spec-disable-by-batch is
@@ -101,8 +104,17 @@ if [[ ! -d "$DRAFT_MODEL_PATH" || -z "$(ls -A "$DRAFT_MODEL_PATH" 2>/dev/null)"
     hf download "$DRAFT_MODEL" --local-dir "$DRAFT_MODEL_PATH"
 fi
 
+# Some nodes run another service on the default port; serve on a free one instead.
+if ! python3 -c 'import socket, sys; socket.socket().bind(("0.0.0.0", int(sys.argv[1])))' "$PORT" 2>/dev/null; then
+    busy_port="$PORT"
+    PORT="$(python3 -c 'import socket; s = socket.socket(); s.bind(("0.0.0.0", 0)); print(s.getsockname()[1])')"
+    echo "Port $busy_port is in use on $(hostname); serving on $PORT"
+fi
+
 echo "=== Downloading SPEED-Bench dataset ==="
-pip install -q datasets tiktoken
+# Pin the image's Hugging Face stack: an unconstrained install can pull huggingface-hub 2.x,
+# which transformers 5.x rejects, and then no server starts.
+pip install -q -c <(pip freeze | grep -iE '^(huggingface[-_]hub|transformers|tokenizers)==') datasets tiktoken
 curl -LsSf https://raw.githubusercontent.com/NVIDIA-NeMo/Skills/refs/heads/main/nemo_skills/dataset/speed-bench/prepare.py \
   | python3 - --config qualitative --output_dir "$SPEEDBENCH_DIR"
 
@@ -212,7 +224,7 @@ run_cell() {
         --max-model-len "$MAX_MODEL_LEN"
         --max-cudagraph-capture-size 256
         --attention-config '{"mla_prefill_backend":"FLASHINFER","use_prefill_query_quantization":true}'
-        --speculative-config "{\"method\": \"dspark\", \"model\": \"$DRAFT_MODEL_PATH\", \"num_speculative_tokens\": $mtp, \"attention_backend\": \"FLASHINFER_MLA\"}"
+        --speculative-config "{\"method\": \"dspark\", \"model\": \"$DRAFT_MODEL_PATH\", \"num_speculative_tokens\": $mtp, \"attention_backend\": \"FLASHINFER_MLA\"$SPEC_EXTRA}"
     )
 
     local server_log="$RESULTS_DIR/server_${mode}_mtp${mtp}.log"
@@ -291,7 +303,8 @@ emit_mode_block() {
         echo "# thinking_off: temperature=0.6, chat_template_kwargs: $CHAT_TEMPLATE_KWARGS_OFF"
     fi
     echo "# Measured on $MODEL_KEY (B300, vLLM DSpark, draft: $DRAFT_MODEL), per num_speculative_tokens."
-    echo "# Auto-generated by benchmarks/single_node/speedbench/kimik3_fp4_b300_vllm.sh (speedbench-al.yml)."
+    if [[ -n "$SPEC_EXTRA" ]]; then echo "# speculative-config extras: {${SPEC_EXTRA#, }}"; fi
+    echo "# Auto-generated by $COLLECTOR (speedbench-al.yml)."
     echo "#"
     echo "# key = num_speculative_tokens (DSpark level); value = golden AL"
     echo "${MODEL_KEY}:"
diff --git a/inferencex-e2e/benchmarks/single_node/speedbench/kimik3_fp4_b300_vllm_probabilistic_sample_method.sh b/inferencex-e2e/benchmarks/single_node/speedbench/kimik3_fp4_b300_vllm_probabilistic_sample_method.sh
new file mode 100755
index 0000000000..8fd73e9a16
--- /dev/null
+++ b/inferencex-e2e/benchmarks/single_node/speedbench/kimik3_fp4_b300_vllm_probabilistic_sample_method.sh
@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+
+SPEC_EXTRA=', "draft_sample_method": "probabilistic"'
+source "$(dirname "$0")/kimik3_fp4_b300_vllm.sh"
diff --git a/inferencex-e2e/benchmarks/single_node/speedbench/kimik3_fp4_b300_vllm_probabilistic_sample_method_block_rejection_sample_method.sh b/inferencex-e2e/benchmarks/single_node/speedbench/kimik3_fp4_b300_vllm_probabilistic_sample_method_block_rejection_sample_method.sh
index 1aa5b5124f..1f8351b905 100755
--- a/inferencex-e2e/benchmarks/single_node/speedbench/kimik3_fp4_b300_vllm_probabilistic_sample_method_block_rejection_sample_method.sh
+++ b/inferencex-e2e/benchmarks/single_node/speedbench/kimik3_fp4_b300_vllm_probabilistic_sample_method_block_rejection_sample_method.sh
@@ -105,8 +105,17 @@ if [[ ! -d "$DRAFT_MODEL_PATH" || -z "$(ls -A "$DRAFT_MODEL_PATH" 2>/dev/null)"
     hf download "$DRAFT_MODEL" --local-dir "$DRAFT_MODEL_PATH"
 fi
 
+# Some nodes run another service on the default port; serve on a free one instead.
+if ! python3 -c 'import socket, sys; socket.socket().bind(("0.0.0.0", int(sys.argv[1])))' "$PORT" 2>/dev/null; then
+    busy_port="$PORT"
+    PORT="$(python3 -c 'import socket; s = socket.socket(); s.bind(("0.0.0.0", 0)); print(s.getsockname()[1])')"
+    echo "Port $busy_port is in use on $(hostname); serving on $PORT"
+fi
+
 echo "=== Downloading SPEED-Bench dataset ==="
-pip install -q datasets tiktoken
+# Pin the image's Hugging Face stack: an unconstrained install can pull huggingface-hub 2.x,
+# which transformers 5.x rejects, and then no server starts.
+pip install -q -c <(pip freeze | grep -iE '^(huggingface[-_]hub|transformers|tokenizers)==') datasets tiktoken
 curl -LsSf https://raw.githubusercontent.com/NVIDIA-NeMo/Skills/refs/heads/main/nemo_skills/dataset/speed-bench/prepare.py \
   | python3 - --config qualitative --output_dir "$SPEEDBENCH_DIR"
 
diff --git a/inferencex-e2e/benchmarks/single_node/speedbench/minimaxm31flash_fp4_b300_vllm.sh b/inferencex-e2e/benchmarks/single_node/speedbench/minimaxm31flash_fp4_b300_vllm.sh
index f8de6f22bc..679ab89df3 100755
--- a/inferencex-e2e/benchmarks/single_node/speedbench/minimaxm31flash_fp4_b300_vllm.sh
+++ b/inferencex-e2e/benchmarks/single_node/speedbench/minimaxm31flash_fp4_b300_vllm.sh
@@ -98,8 +98,17 @@ else
     if [[ "$SERVE_MODEL" != /* ]]; then hf download "$SERVE_MODEL"; fi
 fi
 
+# Some nodes run another service on the default port; serve on a free one instead.
+if ! python3 -c 'import socket, sys; socket.socket().bind(("0.0.0.0", int(sys.argv[1])))' "$PORT" 2>/dev/null; then
+    busy_port="$PORT"
+    PORT="$(python3 -c 'import socket; s = socket.socket(); s.bind(("0.0.0.0", 0)); print(s.getsockname()[1])')"
+    echo "Port $busy_port is in use on $(hostname); serving on $PORT"
+fi
+
 echo "=== Downloading SPEED-Bench dataset ==="
-pip install -q datasets tiktoken
+# Pin the image's Hugging Face stack: an unconstrained install can pull huggingface-hub 2.x,
+# which transformers 5.x rejects, and then no server starts.
+pip install -q -c <(pip freeze | grep -iE '^(huggingface[-_]hub|transformers|tokenizers)==') datasets tiktoken
 curl -LsSf https://raw.githubusercontent.com/NVIDIA-NeMo/Skills/refs/heads/main/nemo_skills/dataset/speed-bench/prepare.py \
   | python3 - --config qualitative --output_dir "$SPEEDBENCH_DIR"
 
diff --git a/inferencex-e2e/benchmarks/single_node/speedbench/minimaxm3_fp4_b300_vllm.sh b/inferencex-e2e/benchmarks/single_node/speedbench/minimaxm3_fp4_b300_vllm.sh
index 82b7df39b8..4c684cb1fc 100755
--- a/inferencex-e2e/benchmarks/single_node/speedbench/minimaxm3_fp4_b300_vllm.sh
+++ b/inferencex-e2e/benchmarks/single_node/speedbench/minimaxm3_fp4_b300_vllm.sh
@@ -32,7 +32,11 @@ check_env_vars \
 SERVE_MODEL="${MODEL_PATH}"
 GPU_MEM_UTIL="0.90"
 
-DRAFT_MODEL="Inferact/MiniMax-M3-EAGLE3"
+# Variant wrappers source this script and may set DRAFT_SUFFIX (e.g. -GQA) and SPEC_EXTRA,
+# extra speculative-config members such as ', "rejection_sample_method": "block"'; $0 is
+# then the wrapper.
+DRAFT_MODEL="Inferact/MiniMax-M3-EAGLE3${DRAFT_SUFFIX}"
+COLLECTOR="benchmarks/single_node/speedbench/$(basename "$0")"
 
 MODEL_KEY="$(basename "$SERVE_MODEL" | tr '[:upper:]' '[:lower:]')"
 CONCURRENCY="1"
@@ -63,8 +67,17 @@ if [[ ! -d "$DRAFT_MODEL_PATH" || -z "$(ls -A "$DRAFT_MODEL_PATH" 2>/dev/null)"
     hf download "$DRAFT_MODEL" --local-dir "$DRAFT_MODEL_PATH"
 fi
 
+# Some nodes run another service on the default port; serve on a free one instead.
+if ! python3 -c 'import socket, sys; socket.socket().bind(("0.0.0.0", int(sys.argv[1])))' "$PORT" 2>/dev/null; then
+    busy_port="$PORT"
+    PORT="$(python3 -c 'import socket; s = socket.socket(); s.bind(("0.0.0.0", 0)); print(s.getsockname()[1])')"
+    echo "Port $busy_port is in use on $(hostname); serving on $PORT"
+fi
+
 echo "=== Downloading SPEED-Bench dataset ==="
-pip install -q datasets tiktoken
+# Pin the image's Hugging Face stack: an unconstrained install can pull huggingface-hub 2.x,
+# which transformers 5.x rejects, and then no server starts.
+pip install -q -c <(pip freeze | grep -iE '^(huggingface[-_]hub|transformers|tokenizers)==') datasets tiktoken
 curl -LsSf https://raw.githubusercontent.com/NVIDIA-NeMo/Skills/refs/heads/main/nemo_skills/dataset/speed-bench/prepare.py \
   | python3 - --config qualitative --output_dir "$SPEEDBENCH_DIR"
 
@@ -148,7 +161,7 @@ run_cell() {
         --max-model-len 16384
         --max-num-batched-tokens 16384
         --stream-interval 30
-        --speculative-config "{\"method\": \"eagle3\", \"model\": \"$DRAFT_MODEL_PATH\", \"num_speculative_tokens\": $mtp, \"attention_backend\": \"FLASH_ATTN\"}"
+        --speculative-config "{\"method\": \"eagle3\", \"model\": \"$DRAFT_MODEL_PATH\", \"num_speculative_tokens\": $mtp, \"attention_backend\": \"FLASH_ATTN\"$SPEC_EXTRA}"
     )
 
     local server_log="$RESULTS_DIR/server_${mode}_mtp${mtp}.log"
@@ -222,7 +235,9 @@ emit_mode_block() {
     echo "# thinking_on chat_template_kwargs: $CHAT_TEMPLATE_KWARGS_ON"
     echo "# thinking_off chat_template_kwargs: $CHAT_TEMPLATE_KWARGS_OFF"
     echo "# Measured on $MODEL_KEY (B300, vLLM EAGLE3), per num_speculative_tokens."
-    echo "# Auto-generated by benchmarks/single_node/speedbench/minimaxm3_fp4_b300_vllm.sh (speedbench-al.yml)."
+    echo "# draft: $DRAFT_MODEL"
+    if [[ -n "$SPEC_EXTRA" ]]; then echo "# speculative-config extras: {${SPEC_EXTRA#, }}"; fi
+    echo "# Auto-generated by $COLLECTOR (speedbench-al.yml)."
     echo "#"
     echo "# key = num_speculative_tokens (EAGLE3 level); value = golden AL"
     echo "${MODEL_KEY}:"
diff --git a/inferencex-e2e/benchmarks/single_node/speedbench/minimaxm3_fp4_b300_vllm_gqa_block_rejection_sample_method.sh b/inferencex-e2e/benchmarks/single_node/speedbench/minimaxm3_fp4_b300_vllm_gqa_block_rejection_sample_method.sh
new file mode 100755
index 0000000000..de669dec53
--- /dev/null
+++ b/inferencex-e2e/benchmarks/single_node/speedbench/minimaxm3_fp4_b300_vllm_gqa_block_rejection_sample_method.sh
@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+
+DRAFT_SUFFIX=-GQA
+SPEC_EXTRA=', "rejection_sample_method": "block"'
+source "$(dirname "$0")/minimaxm3_fp4_b300_vllm.sh"
diff --git a/inferencex-e2e/benchmarks/single_node/speedbench/musespark_fp4_b300_sglang.sh b/inferencex-e2e/benchmarks/single_node/speedbench/musespark_fp4_b300_sglang.sh
index c7ce8b45b8..209cb49fca 100755
--- a/inferencex-e2e/benchmarks/single_node/speedbench/musespark_fp4_b300_sglang.sh
+++ b/inferencex-e2e/benchmarks/single_node/speedbench/musespark_fp4_b300_sglang.sh
@@ -59,8 +59,17 @@ if [[ ! -d "$MODEL_PATH" || -z "$(ls -A "$MODEL_PATH" 2>/dev/null)" ]]; then
 fi
 hf download "$DRAFT_MODEL"
 
+# Some nodes run another service on the default port; serve on a free one instead.
+if ! python3 -c 'import socket, sys; socket.socket().bind(("0.0.0.0", int(sys.argv[1])))' "$PORT" 2>/dev/null; then
+    busy_port="$PORT"
+    PORT="$(python3 -c 'import socket; s = socket.socket(); s.bind(("0.0.0.0", 0)); print(s.getsockname()[1])')"
+    echo "Port $busy_port is in use on $(hostname); serving on $PORT"
+fi
+
 echo "=== Downloading SPEED-Bench dataset ==="
-pip install -q datasets tiktoken
+# Pin the image's Hugging Face stack: an unconstrained install can pull huggingface-hub 2.x,
+# which transformers 5.x rejects, and then no server starts.
+pip install -q -c <(pip freeze | grep -iE '^(huggingface[-_]hub|transformers|tokenizers)==') datasets tiktoken
 curl -LsSf https://raw.githubusercontent.com/NVIDIA-NeMo/Skills/refs/heads/main/nemo_skills/dataset/speed-bench/prepare.py \
   | python3 - --config qualitative --output_dir "$SPEEDBENCH_DIR"
 
diff --git a/inferencex-e2e/benchmarks/single_node/speedbench/qwen3.5_fp4_b300_vllm.sh b/inferencex-e2e/benchmarks/single_node/speedbench/qwen3.5_fp4_b300_vllm.sh
index f62b279992..5376d5e334 100755
--- a/inferencex-e2e/benchmarks/single_node/speedbench/qwen3.5_fp4_b300_vllm.sh
+++ b/inferencex-e2e/benchmarks/single_node/speedbench/qwen3.5_fp4_b300_vllm.sh
@@ -52,8 +52,17 @@ mkdir -p "$RESULTS_DIR"
 nvidia-smi
 if [[ "$SERVE_MODEL" != /* ]]; then hf download "$SERVE_MODEL"; fi
 
+# Some nodes run another service on the default port; serve on a free one instead.
+if ! python3 -c 'import socket, sys; socket.socket().bind(("0.0.0.0", int(sys.argv[1])))' "$PORT" 2>/dev/null; then
+    busy_port="$PORT"
+    PORT="$(python3 -c 'import socket; s = socket.socket(); s.bind(("0.0.0.0", 0)); print(s.getsockname()[1])')"
+    echo "Port $busy_port is in use on $(hostname); serving on $PORT"
+fi
+
 echo "=== Downloading SPEED-Bench dataset ==="
-pip install -q datasets tiktoken
+# Pin the image's Hugging Face stack: an unconstrained install can pull huggingface-hub 2.x,
+# which transformers 5.x rejects, and then no server starts.
+pip install -q -c <(pip freeze | grep -iE '^(huggingface[-_]hub|transformers|tokenizers)==') datasets tiktoken
 curl -LsSf https://raw.githubusercontent.com/NVIDIA-NeMo/Skills/refs/heads/main/nemo_skills/dataset/speed-bench/prepare.py \
   | python3 - --config qualitative --output_dir "$SPEEDBENCH_DIR"
 
diff --git a/inferencex-e2e/benchmarks/single_node/speedbench/qwen3.8next_fp4_b300_vllm.sh b/inferencex-e2e/benchmarks/single_node/speedbench/qwen3.8next_fp4_b300_vllm.sh
index e1fe0c7a3f..99f42d5ca0 100755
--- a/inferencex-e2e/benchmarks/single_node/speedbench/qwen3.8next_fp4_b300_vllm.sh
+++ b/inferencex-e2e/benchmarks/single_node/speedbench/qwen3.8next_fp4_b300_vllm.sh
@@ -96,8 +96,17 @@ else
     if [[ "$SERVE_MODEL" != /* ]]; then hf download "$SERVE_MODEL"; fi
 fi
 
+# Some nodes run another service on the default port; serve on a free one instead.
+if ! python3 -c 'import socket, sys; socket.socket().bind(("0.0.0.0", int(sys.argv[1])))' "$PORT" 2>/dev/null; then
+    busy_port="$PORT"
+    PORT="$(python3 -c 'import socket; s = socket.socket(); s.bind(("0.0.0.0", 0)); print(s.getsockname()[1])')"
+    echo "Port $busy_port is in use on $(hostname); serving on $PORT"
+fi
+
 echo "=== Downloading SPEED-Bench dataset ==="
-pip install -q datasets tiktoken
+# Pin the image's Hugging Face stack: an unconstrained install can pull huggingface-hub 2.x,
+# which transformers 5.x rejects, and then no server starts.
+pip install -q -c <(pip freeze | grep -iE '^(huggingface[-_]hub|transformers|tokenizers)==') datasets tiktoken
 curl -LsSf https://raw.githubusercontent.com/NVIDIA-NeMo/Skills/refs/heads/main/nemo_skills/dataset/speed-bench/prepare.py \
   | python3 - --config qualitative --output_dir "$SPEEDBENCH_DIR"
 
diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/dsv41flash/atom/mi355x-fp4-mtp/agentic.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/dsv41flash/atom/mi355x-fp4-mtp/agentic.yaml
index 881ce3cb68..7f9b8da792 100644
--- a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/dsv41flash/atom/mi355x-fp4-mtp/agentic.yaml
+++ b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/dsv41flash/atom/mi355x-fp4-mtp/agentic.yaml
@@ -33,7 +33,7 @@ base:
         cudagraph-mode: FULL
         cudagraph-capture-sizes: '[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,48,64,128]'
         # The checkpoint's bundled DSpark head. Throughput runs get the golden
-        # AL (dsv41flash_dspark thinking_on, K5) from infx/srt_slurm/synthetic_acceptance.py;
+        # AL (deepseek-v4.1-flash__dspark__native__probabilistic-block thinking_on, K5) from infx/srt_slurm/synthetic_acceptance.py;
         # evals keep real acceptance.
         method: dspark
         num-speculative-tokens: 5
diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/dsv41flash/sglang/gb300-fp4-mtp/agentic.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/dsv41flash/sglang/gb300-fp4-mtp/agentic.yaml
index 1d56ebd861..aba988f354 100644
--- a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/dsv41flash/sglang/gb300-fp4-mtp/agentic.yaml
+++ b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/dsv41flash/sglang/gb300-fp4-mtp/agentic.yaml
@@ -64,6 +64,8 @@ override_tp2_c16:
       args:
         tensor-parallel-size: 2
         expert-parallel-size: 2
+        # auto resolves to MegaAttention, which zero-pads per-rank heads to 64 (2x at TP2, 4x at TP4).
+        dsv4-attn-backend: flashmla
         <<: &tp2_bounded_replay
           chunked-prefill-size: 16384
           enable-decoder-swa-bounded-replay: true
@@ -90,6 +92,7 @@ override_tp2_c32:
       args:
         tensor-parallel-size: 2
         expert-parallel-size: 2
+        dsv4-attn-backend: flashmla
         <<: *tp2_bounded_replay
         prefill-decode-interval: 48
         tokenizer-worker-num: 4
@@ -187,14 +190,31 @@ override_tp4_c1:
       args:
         tensor-parallel-size: 4
         expert-parallel-size: 1
-        chunked-prefill-size: 16384
-        prefill-decode-interval: 0
-        max-running-requests: 1
+        mem-fraction-static: 0.91
+        kv-cache-dtype: fp8_e4m3
+        dsv4-attn-backend: flashmla
+        moe-a2a-backend: none
+        enable-nvidia-megakernel: true
+        startup-weight-load-mode: serial
         enable-decoder-swa-bounded-replay: true
-        cuda-graph-backend-prefill: disabled
+        context-length: 1048576
+        max-running-requests: 1
+        cuda-graph-max-bs-decode: 1
+        prefill-decode-interval: 16
+        schedule-policy: lpm
+        swa-prefix-tails: 128
+        chunked-prefill-size: 16384
+        enable-metrics-for-all-schedulers: true
       env:
-        SGLANG_ENABLE_DSV41_ENGRAM_HOST_TABLE: '0'
-        SGLANG_RAGGED_VERIFY_MODE: static
+        SGLANG_SPEC_TP_SYNC: rng,-dspark-accept-sample
+        SGLANG_ENABLE_DSV41_ENGRAM_HOST_TABLE: '1'
+        SGLANG_DSV41_ENGRAM_HOST_TABLE_LAYOUT: per_rank
+        SGLANG_NVIDIA_MEGAKERNEL_SLOTS: hop_a,moe,gate,attn,embed,two_shot,markov,draft_lm_head,aux_mean_stats,gate_wide,shared_ll,hop_a_batch2,engram,attn_qkv_a,attn_qkv_a_bf16,index_q_mxfp8_in,attn_indexer,hc_prenorm,hop_b,hop_b_wide,early_trigger,hop_b_start_trigger,draft,draft_moe,draft_gate,draft_tail,draft_post,draft_seam,draft_attn,draft_qfront,draft_wo_a,draft_swapab,draft_qkv_a,draft_prenorm,draft_qkv_a_ll,draft_wo_b_ll,sched_ahead,req_pos_once,kv_before_wait,target_lm_head,hop_b_quad_trigger,lm_head_pinned_tactic
+        SGLANG_ENABLE_NV_MEGA_RUNTIME_OPTIMIZATION: '1'
+        SGLANG_SIMULATE_ACC_GREEDY: '0'
+        SGLANG_OPT_DSV41_DSPARK_SIM_DRAW_AHEAD: '1'
+        NCCL_CUMEM_ENABLE: '0'
+        NCCL_MNNVL_ENABLE: '0'
   benchmark:
     env:
       CONC: '1'
@@ -207,6 +227,7 @@ override_tp4_c4:
       args:
         tensor-parallel-size: 4
         expert-parallel-size: 1
+        dsv4-attn-backend: flashmla
         chunked-prefill-size: 16384
         prefill-decode-interval: 0
         swa-prefix-tails: 4096
@@ -228,6 +249,7 @@ override_tp4_c16:
       args:
         tensor-parallel-size: 4
         expert-parallel-size: 1
+        dsv4-attn-backend: flashmla
         chunked-prefill-size: 16384
         prefill-decode-interval: 192
         tokenizer-worker-num: 4
diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/dsv41flash/vllm/mi355x-fp4-mtp/agentic.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/dsv41flash/vllm/mi355x-fp4-mtp/agentic.yaml
index 066b350e0f..e600332084 100644
--- a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/dsv41flash/vllm/mi355x-fp4-mtp/agentic.yaml
+++ b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/dsv41flash/vllm/mi355x-fp4-mtp/agentic.yaml
@@ -54,9 +54,8 @@ base:
       env:
         VLLM_ROCM_USE_AITER: '1'
         VLLM_ROCM_USE_AITER_MOE: '1'
-        # INT4 quick all-reduce above its size threshold
-        # (vllm-project/recipes#1061).
-        VLLM_ROCM_QUICK_REDUCE_QUANTIZATION: INT4
+        # Disable integer QuickReduce for every variant, including TP8.
+        VLLM_ROCM_QUICK_REDUCE_QUANTIZATION: NONE
         AITER_TRITON_LOG_LEVEL: ERROR
         VLLM_ROCM_USE_AITER_TRITON_SPARSE_MLA: 'True'
         # DeepseekV41ForCausalLM is not torch-compiled upstream; breakable
@@ -174,6 +173,21 @@ override_tp4_c64:
     env:
       CONC: '64'
 
+# TP8 c1 mirrors TP4 c1: one sequence at a time, Engram tables GPU-resident.
+override_tp8_c1:
+  roles:
+    agg:
+      gpus: 8
+      args:
+        tensor-parallel-size: 8
+        engram-config: '{"cpu_offload":false}'
+        max-cudagraph-capture-size: 8
+        max-num-batched-tokens: 32768
+        max-num-seqs: 1
+  benchmark:
+    env:
+      CONC: '1'
+
 override_tp2_c1:
   roles:
     agg:
diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/glm5.2/sglang/mi355x-fp4-mtp/agentic.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/glm5.2/sglang/mi355x-fp4-mtp/agentic.yaml
index 5e3e101597..fb52811040 100644
--- a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/glm5.2/sglang/mi355x-fp4-mtp/agentic.yaml
+++ b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/glm5.2/sglang/mi355x-fp4-mtp/agentic.yaml
@@ -152,6 +152,67 @@ override_tp4_c16_hicache:
       CONC: '16'
       KV_OFFLOADING: dram
 
+# DSA DCP rejects HiCache; DCP4 stripes the latent KV across the TP4 ranks instead.
+override_tp4_dcp4_c16:
+  roles:
+    agg:
+      gpus: 4
+      args:
+        tensor-parallel-size: 4
+        expert-parallel-size: 4
+        decode-context-parallel-size: 4
+        max-running-requests: 32
+        cuda-graph-max-bs-decode: 32
+  benchmark:
+    env:
+      CONC: '16'
+      KV_OFFLOADING: none
+
+override_tp4_dcp4_c24:
+  roles:
+    agg:
+      gpus: 4
+      args:
+        tensor-parallel-size: 4
+        expert-parallel-size: 4
+        decode-context-parallel-size: 4
+        max-running-requests: 48
+        cuda-graph-max-bs-decode: 48
+  benchmark:
+    env:
+      CONC: '24'
+      KV_OFFLOADING: none
+
+override_tp4_dcp4_c40:
+  roles:
+    agg:
+      gpus: 4
+      args:
+        tensor-parallel-size: 4
+        expert-parallel-size: 4
+        decode-context-parallel-size: 4
+        max-running-requests: 80
+        cuda-graph-max-bs-decode: 64
+  benchmark:
+    env:
+      CONC: '40'
+      KV_OFFLOADING: none
+
+override_tp4_dcp4_c48:
+  roles:
+    agg:
+      gpus: 4
+      args:
+        tensor-parallel-size: 4
+        expert-parallel-size: 4
+        decode-context-parallel-size: 4
+        max-running-requests: 96
+        cuda-graph-max-bs-decode: 64
+  benchmark:
+    env:
+      CONC: '48'
+      KV_OFFLOADING: none
+
 override_tp8_c1:
   roles:
     agg:
diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/glm5.3/sglang/b300-fp4-mtp/agentic.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/glm5.3/sglang/b300-fp4-mtp/agentic.yaml
index 2bc1e71481..4b07608c40 100644
--- a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/glm5.3/sglang/b300-fp4-mtp/agentic.yaml
+++ b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/glm5.3/sglang/b300-fp4-mtp/agentic.yaml
@@ -35,7 +35,7 @@ base:
         mem-fraction-static: 0.86
         max-running-requests: 256
         cuda-graph-max-bs-decode: 64
-        # The connector selects golden AL 2.99 for K=3 from glm5.3_mtp.yaml.
+        # The connector selects golden AL 2.94 for K=3 from glm-5.3-nvfp4__mtp__native__default-default.yaml.
         speculative-algorithm: NEXTN
         speculative-num-steps: 3
         speculative-eagle-topk: 1
diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/glm5.3flash/sglang/gb300-fp4-mtp/agentic.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/glm5.3flash/sglang/gb300-fp4-mtp/agentic.yaml
new file mode 100644
index 0000000000..6fc8305bf6
--- /dev/null
+++ b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/glm5.3flash/sglang/gb300-fp4-mtp/agentic.yaml
@@ -0,0 +1,71 @@
+base:
+  schema: 2
+  name: glm5.3flash-fp4-gb300-sglang-agentic-mtp
+  identity:
+    model:
+      revision: 1d00738646cbb0c6d0a9eb403dac5f366f1473a7
+    container: {}
+  resources:
+    gpu_type: gb300
+    gpus_per_node: 4
+  slurm:
+    time_limit: '4:00:00'
+  frontend:
+    type: sglang
+    enable_multiple_frontends: false
+  observability:
+    enabled: false
+    tachometer:
+      enabled: false
+  engine: sglang
+  roles:
+    agg:
+      nodes: 1
+      workers: 1
+      gpus: 4
+      args:
+        served-model-name: nvidia/GLM-5.3-Flash-NVFP4
+        tensor-parallel-size: 4
+        expert-parallel-size: 1
+        quantization: modelopt_fp4
+        context-length: 1048576
+        dsa-prefill-backend: trtllm
+        dsa-decode-backend: trtllm
+        kv-cache-dtype: fp8_e4m3
+        moe-runner-backend: flashinfer_trtllm
+        speculative-algorithm: EAGLE
+        speculative-num-steps: 5
+        speculative-eagle-topk: 1
+        speculative-num-draft-tokens: 6
+        reasoning-parser: auto
+        tool-call-parser: auto
+        watchdog-timeout: 1800
+        enable-metrics: true
+      env:
+        PYTHONNOUSERSITE: '1'
+        PYTHONUNBUFFERED: '1'
+        HF_HUB_OFFLINE: '1'
+        SGLANG_TIMEOUT_KEEP_ALIVE: '900'
+  health_check:
+    max_attempts: 1440
+    interval_seconds: 5
+  benchmark:
+    env:
+      AIPERF_HTTP_TCP_USER_TIMEOUT: '900000'
+      AIPERF_REQUIRED_SERVER_METRIC_PREFIX: 'sglang:'
+
+override_gpu_kv:
+  benchmark:
+    env:
+      KV_OFFLOADING: none
+
+override_hicache:
+  roles:
+    agg:
+      args:
+        enable-hierarchical-cache: true
+        # The 0.8 default sizes the host pool at about 1.0x the device KV pool on GB300.
+        hicache-host-memory-fraction: 0.90
+  benchmark:
+    env:
+      KV_OFFLOADING: dram
diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/glm5.3flash/sglang/gb300-fp8-mtp/agentic.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/glm5.3flash/sglang/gb300-fp8-mtp/agentic.yaml
index 7f4253b855..53e68a3168 100644
--- a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/glm5.3flash/sglang/gb300-fp8-mtp/agentic.yaml
+++ b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/glm5.3flash/sglang/gb300-fp8-mtp/agentic.yaml
@@ -1,50 +1,66 @@
-schema: 2
-name: glm5.3flash-fp8-gb300-sglang-agentic-mtp
-resources:
-  gpu_type: gb300
-  gpus_per_node: 4
-slurm:
-  time_limit: '4:00:00'
-frontend:
-  type: sglang
-  enable_multiple_frontends: false
-observability:
-  enabled: false
-  tachometer:
+base:
+  schema: 2
+  name: glm5.3flash-fp8-gb300-sglang-agentic-mtp
+  resources:
+    gpu_type: gb300
+    gpus_per_node: 4
+  slurm:
+    time_limit: '4:00:00'
+  frontend:
+    type: sglang
+    enable_multiple_frontends: false
+  observability:
     enabled: false
-engine: sglang
-roles:
-  agg:
-    nodes: 1
-    workers: 1
-    gpus: 4
-    args:
-      served-model-name: zai-org/GLM-5.3-Flash
-      trust-remote-code: true
-      tensor-parallel-size: 4
-      expert-parallel-size: 1
-      context-length: 1048576
-      dsa-prefill-backend: trtllm
-      dsa-decode-backend: trtllm
-      kv-cache-dtype: fp8_e4m3
-      moe-runner-backend: flashinfer_trtllm
-      speculative-algorithm: EAGLE
-      speculative-num-steps: 5
-      speculative-eagle-topk: 1
-      speculative-num-draft-tokens: 6
-      reasoning-parser: auto
-      tool-call-parser: auto
-      watchdog-timeout: 3600
-      enable-metrics: true
+    tachometer:
+      enabled: false
+  engine: sglang
+  roles:
+    agg:
+      nodes: 1
+      workers: 1
+      gpus: 4
+      args:
+        served-model-name: zai-org/GLM-5.3-Flash
+        tensor-parallel-size: 4
+        expert-parallel-size: 1
+        context-length: 1048576
+        dsa-prefill-backend: trtllm
+        dsa-decode-backend: trtllm
+        kv-cache-dtype: fp8_e4m3
+        moe-runner-backend: flashinfer_trtllm
+        speculative-algorithm: EAGLE
+        speculative-num-steps: 5
+        speculative-eagle-topk: 1
+        speculative-num-draft-tokens: 6
+        reasoning-parser: auto
+        tool-call-parser: auto
+        watchdog-timeout: 1800
+        enable-metrics: true
+      env:
+        PYTHONNOUSERSITE: '1'
+        PYTHONUNBUFFERED: '1'
+        HF_HUB_OFFLINE: '1'
+        SGLANG_TIMEOUT_KEEP_ALIVE: '900'
+  health_check:
+    max_attempts: 1440
+    interval_seconds: 5
+  benchmark:
     env:
-      PYTHONNOUSERSITE: '1'
-      PYTHONUNBUFFERED: '1'
-      HF_HUB_OFFLINE: '1'
-      SGLANG_TIMEOUT_KEEP_ALIVE: '900'
-health_check:
-  max_attempts: 1440
-  interval_seconds: 5
-benchmark:
-  env:
-    AIPERF_HTTP_TCP_USER_TIMEOUT: '900000'
-    AIPERF_REQUIRED_SERVER_METRIC_PREFIX: 'sglang:'
+      AIPERF_HTTP_TCP_USER_TIMEOUT: '900000'
+      AIPERF_REQUIRED_SERVER_METRIC_PREFIX: 'sglang:'
+
+override_gpu_kv:
+  benchmark:
+    env:
+      KV_OFFLOADING: none
+
+override_hicache:
+  roles:
+    agg:
+      args:
+        enable-hierarchical-cache: true
+        # The 0.8 default sizes the host pool at about 1.0x the device KV pool on GB300.
+        hicache-host-memory-fraction: 0.90
+  benchmark:
+    env:
+      KV_OFFLOADING: dram
diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/kimik3.1/sglang/b300-fp4-mtp/agentic.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/kimik3.1/sglang/b300-fp4-mtp/agentic.yaml
new file mode 100644
index 0000000000..e597d4de58
--- /dev/null
+++ b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/kimik3.1/sglang/b300-fp4-mtp/agentic.yaml
@@ -0,0 +1,230 @@
+base:
+  schema: 2
+  name: kimik3.1-fp4-b300-sglang-agentic
+  resources:
+    gpu_type: b300
+    gpus_per_node: 8
+  frontend:
+    type: sglang
+    enable_multiple_frontends: false
+  observability:
+    enabled: false
+    tachometer:
+      enabled: false
+  engine: sglang
+  roles:
+    agg:
+      nodes: 1
+      workers: 1
+      gpus: 8
+      args:
+        served-model-name: moonshotai/Kimi-K3.1-Pro
+        trust-remote-code: true
+        tensor-parallel-size: 8
+        expert-parallel-size: 1
+        weight-loader-prefetch-checkpoints: true
+        model-loader-extra-config: '{"enable_multithread_load": true}'
+        kv-cache-dtype: fp8_e4m3
+        page-size: 64
+        # Week-1 AgentX precision rules require FP32 KDA recurrent state.
+        mamba-ssm-dtype: float32
+        mamba-radix-cache-strategy: extra_buffer
+        mamba-track-interval: 256
+        chunked-prefill-size: 16384
+        max-prefill-tokens: 16384
+        mem-fraction-static: 0.85
+        reasoning-parser: kimi_k3
+        tool-call-parser: kimi_k3
+        speculative-algorithm: DFLASH
+        speculative-draft-model-path: RadixArk/Kimi-K3.1-Dflash2-Preview
+        speculative-draft-attention-backend: cutedsl_mla
+        speculative-draft-kv-cache-dtype: fp8_e4m3
+        speculative-use-block-verification: true
+        # Without ReplaySSM DFLASH keeps one KDA state per draft token and the KV pool collapses.
+        enable-linear-replayssm-spec: true
+        # 8 x 230 GB leaves room for the DSA indexer and KDA host pools beside hicache-size
+        # inside the 2249 GB TOTAL_CPU_DRAM_GB budget.
+        enable-hierarchical-cache: true
+        hicache-size: 230
+        hicache-io-backend: direct
+        hicache-mem-layout: page_first_direct
+        mamba-max-states-per-path: 1
+        watchdog-timeout: 3600
+        enable-metrics: true
+      env:
+        PYTHONNOUSERSITE: '1'
+        # Outlast AIPerf's pooled connections past Uvicorn's keep-alive.
+        SGLANG_TIMEOUT_KEEP_ALIVE: '1800'
+  # ~1.56 TB of MXFP4 shards plus graph capture can outlast the default.
+  health_check:
+    interval_seconds: 10
+    max_attempts: 360
+  benchmark:
+    env:
+      # Warmup can leave bytes unacknowledged past AIPerf's 30 s default.
+      AIPERF_HTTP_TCP_USER_TIMEOUT: '900000'
+      AIPERF_REQUIRED_SERVER_METRIC_PREFIX: 'sglang:'
+      KV_OFFLOADING: dram
+      TOTAL_CPU_DRAM_GB: '2249'
+
+# One variant per point; admission is 2x CONC. DFLASH's speculative-num-draft-tokens is the
+# verification width, the drafts plus one: 7 drafts through c8, 6 at c16, then 5 and 4 as the
+# verify rows grow with the batch. The connector selects each variant's golden AL.
+override_c1:
+  roles:
+    agg:
+      args:
+        max-running-requests: 2
+        cuda-graph-max-bs-decode: 2
+        speculative-num-draft-tokens: 8
+  benchmark:
+    env:
+      CONC: '1'
+
+override_c2:
+  roles:
+    agg:
+      args:
+        max-running-requests: 4
+        cuda-graph-max-bs-decode: 4
+        speculative-num-draft-tokens: 8
+  benchmark:
+    env:
+      CONC: '2'
+
+override_c4:
+  roles:
+    agg:
+      args:
+        max-running-requests: 8
+        cuda-graph-max-bs-decode: 8
+        speculative-num-draft-tokens: 8
+  benchmark:
+    env:
+      CONC: '4'
+
+override_c8:
+  roles:
+    agg:
+      args:
+        max-running-requests: 16
+        cuda-graph-max-bs-decode: 16
+        speculative-num-draft-tokens: 8
+  benchmark:
+    env:
+      CONC: '8'
+
+override_c16:
+  roles:
+    agg:
+      args:
+        max-running-requests: 32
+        cuda-graph-max-bs-decode: 32
+        speculative-num-draft-tokens: 7
+  benchmark:
+    env:
+      CONC: '16'
+
+# DCP8 shards the TP-replicated MLA KV across the eight ranks; EP2 speeds up the decode
+# down-projection (the cookbook's B300 High-Concurrency cell).
+override_dcp8_c24:
+  roles:
+    agg:
+      args:
+        expert-parallel-size: 2
+        dcp-size: 8
+        dcp-comm-backend: fi_a2a
+        max-running-requests: 48
+        cuda-graph-max-bs-decode: 48
+        speculative-num-draft-tokens: 6
+      env:
+        SGLANG_DCP_PUSH_COMBINE_MAX_ROWS: '1536'
+        SGLANG_CUSTOM_ALL_REDUCE_V2_MAX_SIZE_KB: '32768'
+  benchmark:
+    env:
+      CONC: '24'
+
+override_dcp8_c32:
+  roles:
+    agg:
+      args:
+        expert-parallel-size: 2
+        dcp-size: 8
+        dcp-comm-backend: fi_a2a
+        max-running-requests: 64
+        cuda-graph-max-bs-decode: 64
+        speculative-num-draft-tokens: 6
+      env:
+        SGLANG_DCP_PUSH_COMBINE_MAX_ROWS: '1536'
+        SGLANG_CUSTOM_ALL_REDUCE_V2_MAX_SIZE_KB: '32768'
+  benchmark:
+    env:
+      CONC: '32'
+
+override_dcp8_c40:
+  roles:
+    agg:
+      args:
+        expert-parallel-size: 2
+        dcp-size: 8
+        dcp-comm-backend: fi_a2a
+        max-running-requests: 80
+        cuda-graph-max-bs-decode: 80
+        speculative-num-draft-tokens: 6
+      env:
+        SGLANG_DCP_PUSH_COMBINE_MAX_ROWS: '1536'
+        SGLANG_CUSTOM_ALL_REDUCE_V2_MAX_SIZE_KB: '32768'
+  benchmark:
+    env:
+      CONC: '40'
+
+override_dcp8_c48:
+  roles:
+    agg:
+      args:
+        expert-parallel-size: 2
+        dcp-size: 8
+        dcp-comm-backend: fi_a2a
+        max-running-requests: 96
+        cuda-graph-max-bs-decode: 96
+        speculative-num-draft-tokens: 5
+      env:
+        SGLANG_DCP_PUSH_COMBINE_MAX_ROWS: '1536'
+        SGLANG_CUSTOM_ALL_REDUCE_V2_MAX_SIZE_KB: '32768'
+  benchmark:
+    env:
+      CONC: '48'
+
+override_dcp8_c56:
+  roles:
+    agg:
+      args:
+        expert-parallel-size: 2
+        dcp-size: 8
+        dcp-comm-backend: fi_a2a
+        max-running-requests: 112
+        cuda-graph-max-bs-decode: 112
+        speculative-num-draft-tokens: 5
+      env:
+        SGLANG_DCP_PUSH_COMBINE_MAX_ROWS: '1536'
+        SGLANG_CUSTOM_ALL_REDUCE_V2_MAX_SIZE_KB: '32768'
+  benchmark:
+    env:
+      CONC: '56'
+
+override_dcp8_c70:
+  roles:
+    agg:
+      args:
+        expert-parallel-size: 2
+        dcp-size: 8
+        dcp-comm-backend: fi_a2a
+        max-running-requests: 140
+        cuda-graph-max-bs-decode: 140
+        speculative-num-draft-tokens: 5
+      env:
+        SGLANG_DCP_PUSH_COMBINE_MAX_ROWS: '1536'
+        SGLANG_CUSTOM_ALL_REDUCE_V2_MAX_SIZE_KB: '32768'
+  benchmark:
+    env:
+      CONC: '70'
diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/kimik3.1/sglang/mi355x-fp4-mtp/agentic.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/kimik3.1/sglang/mi355x-fp4-mtp/agentic.yaml
new file mode 100644
index 0000000000..26cc889b37
--- /dev/null
+++ b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/kimik3.1/sglang/mi355x-fp4-mtp/agentic.yaml
@@ -0,0 +1,193 @@
+base:
+  schema: 2
+  name: kimik3.1-fp4-mi355x-sglang-agentic
+  resources:
+    gpu_type: mi355x
+    gpus_per_node: 8
+  frontend:
+    type: sglang
+    enable_multiple_frontends: false
+  observability:
+    enabled: false
+    tachometer:
+      enabled: false
+  engine: sglang
+  # Loading the 1.56 TB checkpoint plus decode and prefill graph capture.
+  health_check:
+    max_attempts: 720
+    interval_seconds: 10
+  roles:
+    agg:
+      nodes: 1
+      workers: 1
+      gpus: 8
+      args:
+        served-model-name: moonshotai/Kimi-K3.1-Pro
+        trust-remote-code: true
+        tensor-parallel-size: 8
+        kv-cache-dtype: fp8_e4m3
+        mem-fraction-static: 0.85
+        chunked-prefill-size: 16384
+        schedule-policy: lpm
+        prefill-decode-interval: 16
+        mamba-radix-cache-strategy: extra_buffer_lazy
+        cuda-graph-backend-prefill: breakable
+        cuda-graph-bs-prefill: [256, 512, 768, 1024, 1536, 2048, 3072, 4096]
+        weight-loader-prefetch-checkpoints: true
+        model-loader-extra-config: '{"enable_multithread_load": true}'
+        reasoning-parser: kimi_k3
+        tool-call-parser: kimi_k3
+        enable-metrics: true
+        speculative-algorithm: DFLASH
+        speculative-draft-model-path: RadixArk/Kimi-K3.1-Dflash2-Preview
+        speculative-draft-model-revision: d0d8bc2e3c6d0a195d2e00a49017e71ca8d881f1
+        speculative-draft-attention-backend: triton
+        speculative-draft-kv-cache-dtype: fp8_e4m3
+        # The golden AL curve was collected with block verification.
+        speculative-use-block-verification: true
+        # DFlash2 verifies the current token plus 5 drafts.
+        speculative-num-draft-tokens: 6
+        # Without ReplaySSM, DFLASH keeps one KDA state per draft token and the KV pool collapses.
+        enable-linear-replayssm-spec: true
+        random-seed: 42
+      env:
+        PYTHONNOUSERSITE: '1'
+        # Outlast AIPerf's pooled connections past Uvicorn's keep-alive.
+        SGLANG_TIMEOUT_KEEP_ALIVE: '900'
+        SGLANG_USE_AITER: '1'
+        SGLANG_AITER_K3_OPT: '1'
+        AITER_FLYDSL_FORCE: '1'
+        AITER_SITUV2_A8W4: '1'
+        # BF16 MoE combine and all-reduce.
+        AITER_OPUS_STAGE2_FP8: '0'
+        ROCM_QUICK_REDUCE_QUANTIZATION: NONE
+        PYTORCH_HIP_ALLOC_CONF: garbage_collection_threshold:0.95
+        SGLANG_OPT_MAMBA_SKIP_DECODE_LOCK: '1'
+        # Pinned host pools; registered pageable pools stall every GPU queue on page migration.
+        HSA_USERPTR_FOR_PAGED_MEM: '0'
+        # The MI355X nodes report MEC firmware 38, below the 177 that fixes the
+        # RCCL memory reclaim issue.
+        HSA_NO_SCRATCH_RECLAIM: '1'
+  benchmark:
+    env:
+      # Warmup can leave bytes unacknowledged past AIPerf's 30 s default.
+      AIPERF_HTTP_TCP_USER_TIMEOUT: '900000'
+      AIPERF_REQUIRED_SERVER_METRIC_PREFIX: 'sglang:'
+
+override_tp8_c1:
+  roles:
+    agg:
+      args:
+        enable-amd-monokernel: true
+        max-running-requests: 4
+        cuda-graph-max-bs-decode: 4
+        max-mamba-cache-size: 60
+      env:
+        SGLANG_AMD_MONO_K31_WIDE: '1'
+        SGLANG_ROCM_RUNTIME_RESERVE_GB: '6'
+  benchmark:
+    env:
+      CONC: '1'
+      KV_OFFLOADING: none
+
+override_tp8_c4:
+  roles:
+    agg:
+      args:
+        enable-amd-monokernel: true
+        max-running-requests: 4
+        cuda-graph-max-bs-decode: 4
+        max-mamba-cache-size: 60
+      env:
+        SGLANG_AMD_MONO_K31_WIDE: '1'
+        SGLANG_ROCM_RUNTIME_RESERVE_GB: '6'
+  benchmark:
+    env:
+      CONC: '4'
+      KV_OFFLOADING: none
+
+override_tp8_dcp8_c8:
+  roles:
+    agg:
+      args:
+        dcp-size: 8
+        dcp-comm-backend: a2a
+        mamba-full-memory-ratio: 0.65
+        enable-hierarchical-cache: true
+        hicache-write-policy: write_back
+        hicache-ratio: 2.5
+        max-running-requests: 8
+        cuda-graph-max-bs-decode: 8
+      env:
+        SGLANG_ROCM_RUNTIME_RESERVE_GB: '10'
+        # About 190 GB of pinned host pools per GPU, within the node's 1511 GiB GTT limit.
+        SGLANG_HICACHE_MAMBA_HOST_RATIO: '12'
+        # Keeps every rank on the Rust TreeCore; write-back asserts on a mix with the Python one.
+        RUSTUP_TOOLCHAIN: stable
+  benchmark:
+    env:
+      CONC: '8'
+      KV_OFFLOADING: dram
+
+override_tp8_dcp8_c16:
+  roles:
+    agg:
+      args:
+        dcp-size: 8
+        dcp-comm-backend: a2a
+        mamba-full-memory-ratio: 0.65
+        enable-hierarchical-cache: true
+        hicache-write-policy: write_back
+        hicache-ratio: 2.5
+        max-running-requests: 16
+        cuda-graph-max-bs-decode: 16
+      env:
+        SGLANG_ROCM_RUNTIME_RESERVE_GB: '10'
+        SGLANG_HICACHE_MAMBA_HOST_RATIO: '12'
+        RUSTUP_TOOLCHAIN: stable
+  benchmark:
+    env:
+      CONC: '16'
+      KV_OFFLOADING: dram
+
+override_tp8_dcp8_c32:
+  roles:
+    agg:
+      args:
+        dcp-size: 8
+        dcp-comm-backend: a2a
+        mamba-full-memory-ratio: 0.65
+        enable-hierarchical-cache: true
+        hicache-write-policy: write_back
+        hicache-ratio: 2.5
+        max-running-requests: 32
+        cuda-graph-max-bs-decode: 32
+      env:
+        SGLANG_ROCM_RUNTIME_RESERVE_GB: '10'
+        SGLANG_HICACHE_MAMBA_HOST_RATIO: '12'
+        RUSTUP_TOOLCHAIN: stable
+  benchmark:
+    env:
+      CONC: '32'
+      KV_OFFLOADING: dram
+
+override_tp8_dcp8_c48:
+  roles:
+    agg:
+      args:
+        dcp-size: 8
+        dcp-comm-backend: a2a
+        mamba-full-memory-ratio: 0.65
+        enable-hierarchical-cache: true
+        hicache-write-policy: write_back
+        hicache-ratio: 2.5
+        max-running-requests: 48
+        cuda-graph-max-bs-decode: 48
+      env:
+        SGLANG_ROCM_RUNTIME_RESERVE_GB: '10'
+        SGLANG_HICACHE_MAMBA_HOST_RATIO: '12'
+        RUSTUP_TOOLCHAIN: stable
+  benchmark:
+    env:
+      CONC: '48'
+      KV_OFFLOADING: dram
diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/kimik3.1/vllm/b300-fp4-mtp/agentic.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/kimik3.1/vllm/b300-fp4-mtp/agentic.yaml
new file mode 100644
index 0000000000..a6ad375bbd
--- /dev/null
+++ b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/kimik3.1/vllm/b300-fp4-mtp/agentic.yaml
@@ -0,0 +1,182 @@
+base:
+  schema: 2
+  name: kimik3.1-fp4-b300-vllm-agentic
+  resources:
+    gpu_type: b300
+    gpus_per_node: 8
+  frontend:
+    type: vllm
+    enable_multiple_frontends: false
+  observability:
+    enabled: false
+    tachometer:
+      enabled: false
+  engine:
+    type: vllm
+    connector: null
+  # ~1.56 TB of MXFP4 shards may take the full VLLM_ENGINE_READY_TIMEOUT_S.
+  health_check:
+    interval_seconds: 10
+    max_attempts: 360
+  roles:
+    agg:
+      nodes: 1
+      workers: 1
+      gpus: 8
+      args:
+        served-model-name: moonshotai/Kimi-K3.1-Pro
+        tensor-parallel-size: 8
+        # Shards the MLA latent and indexer-key caches across the TP group: ~7x the KV tokens of plain TP8.
+        decode-context-parallel-size: 8
+        trust-remote-code: true
+        language-model-only: true
+        load-format: fastsafetensors
+        enable-auto-tool-choice: true
+        tool-call-parser: kimi_k3
+        reasoning-parser: kimi_k3
+        kv-cache-dtype: fp8
+        attention-config: '{"indexer_kv_dtype":"mxfp4"}'
+        # The K3.1 week-1 precision policy requires an FP32 KDA recurrent state.
+        mamba-ssm-cache-dtype: float32
+        enable-prefix-caching: true
+        max-num-batched-tokens: 16384
+        gpu-memory-utilization: 0.9
+        stream-interval: 10
+        disable-uvicorn-access-log: true
+        # TOTAL_CPU_DRAM_GB split across the 8 TP ranks.
+        kv-transfer-config: '{"kv_connector":"SimpleCPUOffloadConnector","kv_role":"kv_both","kv_connector_extra_config":{"cpu_bytes_to_use_per_rank":281125000000,"lazy_offload":false}}'
+      env:
+        VLLM_ENGINE_READY_TIMEOUT_S: '3600'
+        PYTHONUNBUFFERED: '1'
+        # Identical prefixes must hash to identical block keys run-to-run.
+        PYTHONHASHSEED: '42'
+        # Outlast AIPerf's pooled-connection idle gaps.
+        VLLM_HTTP_TIMEOUT_KEEP_ALIVE: '900'
+  benchmark:
+    env:
+      AIPERF_REQUIRED_SERVER_METRIC_PREFIX: 'vllm:'
+      KV_OFFLOADING: dram
+      TOTAL_CPU_DRAM_GB: '2249'
+
+# Admission is 2x CONC. The decode graphs cover max-num-seqs x (1 + draft tokens);
+# throughput runs replace block rejection with the golden acceptance length.
+override_c1:
+  roles:
+    agg:
+      args:
+        max-num-seqs: 2
+        max-cudagraph-capture-size: 12
+        speculative-config: '{"method":"dspark","model":"Inferact/Kimi-K3.1-Pro-DSpark-preview","num_speculative_tokens":5,"draft_sample_method":"probabilistic","rejection_sample_method":"block"}'
+  benchmark:
+    env:
+      CONC: '1'
+
+override_c2:
+  roles:
+    agg:
+      args:
+        max-num-seqs: 4
+        max-cudagraph-capture-size: 24
+        speculative-config: '{"method":"dspark","model":"Inferact/Kimi-K3.1-Pro-DSpark-preview","num_speculative_tokens":5,"draft_sample_method":"probabilistic","rejection_sample_method":"block"}'
+  benchmark:
+    env:
+      CONC: '2'
+
+override_c4:
+  roles:
+    agg:
+      args:
+        max-num-seqs: 8
+        max-cudagraph-capture-size: 48
+        speculative-config: '{"method":"dspark","model":"Inferact/Kimi-K3.1-Pro-DSpark-preview","num_speculative_tokens":5,"draft_sample_method":"probabilistic","rejection_sample_method":"block"}'
+  benchmark:
+    env:
+      CONC: '4'
+
+override_c8:
+  roles:
+    agg:
+      args:
+        max-num-seqs: 16
+        max-cudagraph-capture-size: 96
+        speculative-config: '{"method":"dspark","model":"Inferact/Kimi-K3.1-Pro-DSpark-preview","num_speculative_tokens":5,"draft_sample_method":"probabilistic","rejection_sample_method":"block"}'
+  benchmark:
+    env:
+      CONC: '8'
+
+override_c16:
+  roles:
+    agg:
+      args:
+        max-num-seqs: 32
+        max-cudagraph-capture-size: 160
+        speculative-config: '{"method":"dspark","model":"Inferact/Kimi-K3.1-Pro-DSpark-preview","num_speculative_tokens":4,"draft_sample_method":"probabilistic","rejection_sample_method":"block"}'
+  benchmark:
+    env:
+      CONC: '16'
+
+override_c24:
+  roles:
+    agg:
+      args:
+        max-num-seqs: 48
+        max-cudagraph-capture-size: 240
+        speculative-config: '{"method":"dspark","model":"Inferact/Kimi-K3.1-Pro-DSpark-preview","num_speculative_tokens":4,"draft_sample_method":"probabilistic","rejection_sample_method":"block"}'
+  benchmark:
+    env:
+      CONC: '24'
+
+override_c32:
+  roles:
+    agg:
+      args:
+        max-num-seqs: 64
+        max-cudagraph-capture-size: 256
+        speculative-config: '{"method":"dspark","model":"Inferact/Kimi-K3.1-Pro-DSpark-preview","num_speculative_tokens":3,"draft_sample_method":"probabilistic","rejection_sample_method":"block"}'
+  benchmark:
+    env:
+      CONC: '32'
+
+override_c40:
+  roles:
+    agg:
+      args:
+        max-num-seqs: 80
+        max-cudagraph-capture-size: 320
+        speculative-config: '{"method":"dspark","model":"Inferact/Kimi-K3.1-Pro-DSpark-preview","num_speculative_tokens":3,"draft_sample_method":"probabilistic","rejection_sample_method":"block"}'
+  benchmark:
+    env:
+      CONC: '40'
+
+override_c48:
+  roles:
+    agg:
+      args:
+        max-num-seqs: 96
+        max-cudagraph-capture-size: 384
+        speculative-config: '{"method":"dspark","model":"Inferact/Kimi-K3.1-Pro-DSpark-preview","num_speculative_tokens":3,"draft_sample_method":"probabilistic","rejection_sample_method":"block"}'
+  benchmark:
+    env:
+      CONC: '48'
+
+override_c56:
+  roles:
+    agg:
+      args:
+        max-num-seqs: 112
+        max-cudagraph-capture-size: 336
+        speculative-config: '{"method":"dspark","model":"Inferact/Kimi-K3.1-Pro-DSpark-preview","num_speculative_tokens":2,"draft_sample_method":"probabilistic","rejection_sample_method":"block"}'
+  benchmark:
+    env:
+      CONC: '56'
+
+override_c70:
+  roles:
+    agg:
+      args:
+        max-num-seqs: 140
+        max-cudagraph-capture-size: 420
+        speculative-config: '{"method":"dspark","model":"Inferact/Kimi-K3.1-Pro-DSpark-preview","num_speculative_tokens":2,"draft_sample_method":"probabilistic","rejection_sample_method":"block"}'
+  benchmark:
+    env:
+      CONC: '70'
diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/kimik3/atom/mi355x-fp4-mtp/agentic.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/kimik3/atom/mi355x-fp4-mtp/agentic.yaml
deleted file mode 100644
index 1884b3a997..0000000000
--- a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/kimik3/atom/mi355x-fp4-mtp/agentic.yaml
+++ /dev/null
@@ -1,217 +0,0 @@
-base:
-  schema: 2
-  name: kimik3-fp4-mi355x-atom-agentic
-  resources:
-    gpu_type: mi355x
-    gpus_per_node: 8
-  frontend:
-    type: atomesh
-    container_image: rocm/atom-dev@sha256:b78300a6caf6c1fec3b1f27b4f7333326c9d34911bfc7ae229d13d2ebbc43884
-    enable_multiple_frontends: false
-  observability:
-    enabled: false
-    tachometer:
-      enabled: false
-  engine: atom
-  setup_script: kimik3-atom-dspark-draft.sh
-  roles:
-    agg:
-      nodes: 1
-      workers: 1
-      gpus: 8
-      args:
-        served-model-name: moonshotai/Kimi-K3
-        trust-remote-code: true
-        # Fails closed if the chat template stops rendering a tools payload.
-        tool-call-parser: kimi_k3
-        decode-context-parallel-size: 1
-        kv_cache_dtype: fp8
-        block-size: 128
-        max-num-seqs: 32
-        max-num-batched-tokens: 8192
-        gpu-memory-utilization: 0.9
-        enable_prefix_caching: true
-        # -1 keeps the prompt-end checkpoint anchor without the fixed-interval grid.
-        state-checkpoint-interval-tokens: -1
-        level: 3
-        cudagraph-mode: FULL
-        # Global ptpc_fp8 online quantization; the trailing entries keep the BF16
-        # draft (unprefixed layers.* and context_proj) unquantized.
-        online_quant_config: '{"global_quant_config":"ptpc_fp8","exclude_layer":["lm_head","model.embed_tokens","*self_attn.[qkv]_conv1d*","*block_sparse_moe.experts*","*block_sparse_moe.routed_expert_*","*vision_tower*","*mm_projector*","layers.*.self_attn.fused_qkv_a_proj","layers.*.self_attn.q_b_proj","layers.*.self_attn.kv_b_proj","layers.*.self_attn.o_proj","layers.*.mlp.gate_up_proj","layers.*.mlp.down_proj","context_proj"]}'
-        method: dspark
-        draft-model: Inferact/Kimi-K3-DSpark
-        num-speculative-tokens: 7
-      env:
-        # The image bakes in a build-host proxy that nothing serves on a node.
-        HTTP_PROXY: ''
-        HTTPS_PROXY: ''
-        http_proxy: ''
-        https_proxy: ''
-        NO_PROXY: localhost,127.0.0.1,::1
-        no_proxy: localhost,127.0.0.1,::1
-        PYTHONNOUSERSITE: '1'
-        ATOM_ENABLE_REPLAYSSM: '0'
-        AITER_REUSE_IDENTICAL_COMM_GROUPS: '0'
-        AITER_LOG_LEVEL: WARNING
-        AITER_SITUV2_A4W4: '1'
-        AITER_QUICK_REDUCE_QUANTIZATION: INT4
-        AITER_FLYDSL_STAGE2_FP8: '1'
-        # Anchor-only state checkpointing.
-        ATOM_STATE_CHECKPOINT_DEMAND: '0'
-        ATOM_GDN_SSM_DTYPE: fp16
-        # FlyDSL FP8 prefill attention; ATOM defaults it off.
-        ATOM_USE_FLYDSL_FP8_PREFILL_ATTN: '1'
-  benchmark:
-    env:
-      HTTP_PROXY: ''
-      HTTPS_PROXY: ''
-      http_proxy: ''
-      https_proxy: ''
-      NO_PROXY: localhost,127.0.0.1,::1
-      no_proxy: localhost,127.0.0.1,::1
-      # Long agentic turns against a 1M context are prefill-bound on the server.
-      AIPERF_HTTP_TCP_USER_TIMEOUT: '900000'
-      AIPERF_REQUIRED_SERVER_METRIC_PREFIX: 'atom:'
-      AIPERF_APPLY_CHAT_TEMPLATE: 'true'
-
-override_tp8_c1:
-  roles:
-    agg:
-      args:
-        cudagraph-capture-sizes: '[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]'
-  benchmark:
-    env:
-      CONC: '1'
-
-override_tp8_c4:
-  roles:
-    agg:
-      args:
-        cudagraph-capture-sizes: '[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64]'
-  benchmark:
-    env:
-      CONC: '4'
-
-override_tp8_dcp8_c14_lmcache:
-  roles:
-    agg:
-      args:
-        decode-context-parallel-size: 8
-        num-speculative-tokens: 4
-        cudagraph-capture-sizes: '[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112]'
-        extra-kv-connectors: &lmcache_offload
-          - kv_connector: lmcache_offload
-            kv_role: offload
-      env:
-        <<: &lmcache_env
-          PYTHONHASHSEED: '0'
-          LMCACHE_LOCAL_CPU: 'True'
-          # The offload hash block is block-size 128 x DCP 8, so the KV and the
-          # state-checkpoint grids coincide.
-          LMCACHE_CHUNK_SIZE: '1024'
-          # K3 is a hybrid; without this the paged KV never reaches the CPU tier.
-          OFFLOAD_KV_FOR_HYBRID: '1'
-          # Pin the eight ranks to the two sockets explicitly.
-          LMCACHE_NUMA_MODE: auto
-          ATOM_NUMA_BIND: '1'
-          ATOM_NUMA_NODE: 0,0,0,0,1,1,1,1
-          ATOM_AUTO_NUMA_BIND: '0'
-          OFFLOAD_PROFILE: '1'
-          # One K3 state entry is 54.78 MiB; the default 8 MiB staging buffer
-          # cannot hold it.
-          OFFLOAD_GPU_STAGING_CHUNKS: '32'
-        LMCACHE_MAX_LOCAL_CPU_SIZE: '128'
-        ATOM_ENABLE_REPLAYSSM: '1'
-  benchmark:
-    env:
-      CONC: '14'
-      KV_OFFLOADING: dram
-      TOTAL_CPU_DRAM_GB: '1028'
-
-override_tp8_dcp8_c16_lmcache:
-  roles:
-    agg:
-      args:
-        decode-context-parallel-size: 8
-        num-speculative-tokens: 4
-        cudagraph-capture-sizes: '[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128]'
-        extra-kv-connectors: *lmcache_offload
-      env:
-        <<: *lmcache_env
-        LMCACHE_MAX_LOCAL_CPU_SIZE: '128'
-        ATOM_ENABLE_REPLAYSSM: '1'
-        ATOM_PREFILL_DECODE_INTERVAL: '4'
-        ATOM_PREFILL_DELAYER_MAX_QUEUE_MS: '5000'
-  benchmark:
-    env:
-      CONC: '16'
-      KV_OFFLOADING: dram
-      TOTAL_CPU_DRAM_GB: '1028'
-
-override_tp8_dcp8_c48_lmcache:
-  roles:
-    agg:
-      args:
-        decode-context-parallel-size: 8
-        num-speculative-tokens: 4
-        max-num-seqs: 96
-        cudagraph-capture-sizes: '[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96]'
-        extra-kv-connectors: *lmcache_offload
-      env:
-        <<: *lmcache_env
-        LMCACHE_MAX_LOCAL_CPU_SIZE: '128'
-        ATOM_ENABLE_REPLAYSSM: '1'
-        ATOM_PREFILL_DECODE_INTERVAL: '4'
-        ATOM_PREFILL_DELAYER_MAX_QUEUE_MS: '5000'
-  benchmark:
-    env:
-      CONC: '48'
-      SPEC_DECODING: mtp
-      KV_OFFLOADING: dram
-      TOTAL_CPU_DRAM_GB: '1028'
-
-override_tp8_dcp8_c56_lmcache:
-  roles:
-    agg:
-      args:
-        decode-context-parallel-size: 8
-        num-speculative-tokens: 4
-        max-num-seqs: 112
-        cudagraph-capture-sizes: '[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112]'
-        extra-kv-connectors: *lmcache_offload
-      env:
-        <<: *lmcache_env
-        LMCACHE_MAX_LOCAL_CPU_SIZE: '192'
-        ATOM_ENABLE_REPLAYSSM: '1'
-        AITER_REUSE_IDENTICAL_COMM_GROUPS: '1'
-        ATOM_PREFILL_DECODE_INTERVAL: '4'
-        ATOM_PREFILL_DELAYER_MAX_QUEUE_MS: '5000'
-  benchmark:
-    env:
-      CONC: '56'
-      SPEC_DECODING: mtp
-      KV_OFFLOADING: dram
-      TOTAL_CPU_DRAM_GB: '1538'
-
-override_tp8_dcp8_c72_lmcache:
-  roles:
-    agg:
-      args:
-        decode-context-parallel-size: 8
-        num-speculative-tokens: 4
-        max-num-seqs: 144
-        cudagraph-capture-sizes: '[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144]'
-        extra-kv-connectors: *lmcache_offload
-      env:
-        <<: *lmcache_env
-        LMCACHE_MAX_LOCAL_CPU_SIZE: '192'
-        ATOM_ENABLE_REPLAYSSM: '1'
-        AITER_REUSE_IDENTICAL_COMM_GROUPS: '1'
-        ATOM_PREFILL_DECODE_INTERVAL: '4'
-        ATOM_PREFILL_DELAYER_MAX_QUEUE_MS: '5000'
-  benchmark:
-    env:
-      CONC: '72'
-      SPEC_DECODING: mtp
-      KV_OFFLOADING: dram
-      TOTAL_CPU_DRAM_GB: '1538'
diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/kimik3/vllm/b300-fp4-mtp/agentic.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/kimik3/vllm/b300-fp4-mtp/agentic.yaml
deleted file mode 100644
index 95c66e148f..0000000000
--- a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/kimik3/vllm/b300-fp4-mtp/agentic.yaml
+++ /dev/null
@@ -1,233 +0,0 @@
-base:
-  schema: 2
-  name: kimik3-fp4-b300-vllm-agentic
-  resources:
-    gpu_type: b300
-    gpus_per_node: 8
-  frontend:
-    type: vllm
-    enable_multiple_frontends: false
-  observability:
-    enabled: false
-    tachometer:
-      enabled: false
-  engine:
-    type: vllm
-    connector: null
-  # ~1.5 TB of MXFP4 shards may take the full VLLM_ENGINE_READY_TIMEOUT_S.
-  health_check:
-    interval_seconds: 10
-    max_attempts: 360
-  # Embedded Mooncake: each TP rank contributes TOTAL_CPU_DRAM_GB / 8 GB. The
-  # setup script installs the master config's Mooncake and fills in the node's
-  # active RDMA rail. DSXE rails are InfiniBand without a netdev, so the transfer
-  # engine picks its own GID (a RoCE v2 index 3 does not exist).
-  setup_script: kimik3-b300-mooncake.sh
-  services:
-    - name: mooncake-master
-      type: mooncake-master
-      preamble: bash /configs/vllm-mooncake.sh
-      args: ["--eviction_high_watermark_ratio=0.95", "--eviction_ratio=0.10"]
-      options:
-        store_config:
-          mode: embedded
-          metadata_server: P2PHANDSHAKE
-          global_segment_size: 281GB
-          local_buffer_size: 4GB
-          protocol: rdma
-          device_name: ""
-          enable_offload: false
-  roles:
-    agg:
-      nodes: 1
-      workers: 1
-      gpus: 8
-      args:
-        served-model-name: moonshotai/Kimi-K3
-        tensor-parallel-size: 8
-        decode-context-parallel-size: 8
-        dcp-comm-backend: a2a
-        max-num-batched-tokens: 16384
-        trust-remote-code: true
-        language-model-only: true
-        enable-auto-tool-choice: true
-        tool-call-parser: kimi_k3
-        reasoning-parser: kimi_k3
-        load-format: fastsafetensors
-        moe-backend: auto
-        no-enable-flashinfer-autotune: true
-        enable-cumem-allocator: true
-        enable-prefix-caching: true
-        prefix-match-unit: 128
-        kv-cache-dtype: fp8
-        stream-interval: 10
-        attention-backend: TOKENSPEED_MLA
-        attention-config: '{"mla_prefill_backend":"TRTLLM_RAGGED","use_prefill_query_quantization":true}'
-        disable-uvicorn-access-log: true
-        kv-transfer-config: '{"kv_connector":"MooncakeStoreConnector","kv_role":"kv_both","kv_load_failure_policy":"recompute","kv_connector_extra_config":{"load_async":true,"lookup_async":true,"enable_offload":false}}'
-      env:
-        VLLM_ALLREDUCE_USE_FLASHINFER: '1'
-        VLLM_ENABLE_K3_LATENT_MOE_TAIL_FUSION: '1'
-        VLLM_USE_V2_MODEL_RUNNER: '1'
-        # These default to auto; name them so the measured DCP a2a path runs.
-        VLLM_USE_DIRECT_DCP_A2A: '1'
-        VLLM_USE_DIRECT_DCP_Q_GATHER: '1'
-        VLLM_USE_DIRECT_DCP_KV_GATHER: '1'
-        VLLM_RPC_TIMEOUT: '600000'
-        VLLM_PREFIX_CACHE_RETENTION_INTERVAL: '0'
-        VLLM_MEMORY_PROFILER_ESTIMATE_CUDAGRAPHS: '0'
-        PYTHONNOUSERSITE: '1'
-        TORCH_CUDA_ARCH_LIST: '10.0'
-        # Identical prefixes must hash to identical block keys run-to-run.
-        PYTHONHASHSEED: '42'
-        # Outlast AIPerf's pooled-connection idle gaps.
-        VLLM_HTTP_TIMEOUT_KEEP_ALIVE: '900'
-        MC_STORE_MEMCPY: '1'
-        MC_ENABLE_DEST_DEVICE_AFFINITY: '1'
-        MC_SLICE_SIZE: '1048576'
-        MC_WORKERS_PER_CTX: '4'
-        WITH_NVIDIA_PEERMEM: '0'
-        VLLM_MOONCAKE_LOAD_RECV_THREADS: '4'
-  benchmark:
-    env:
-      AIPERF_REQUIRED_SERVER_METRIC_PREFIX: 'vllm:'
-      AIPERF_HTTP_TCP_USER_TIMEOUT: '900000'
-      KV_OFFLOADING: dram
-      TOTAL_CPU_DRAM_GB: '2249'
-
-# One variant per point. Admission is 2x CONC; CONC 56 and 70 keep more memory
-# headroom. Graphs capture (1 + drafts) x 1..min(2x CONC, 128) tokens, then the
-# larger powers of two to 8192. Throughput runs switch DSpark to synthetic
-# rejection at the golden acceptance length; points above CONC 16 do not draft
-# and keep the matrix's mtp label.
-override_c1:
-  roles:
-    agg:
-      args:
-        max-num-seqs: 2
-        gpu-memory-utilization: 0.92
-        compilation-config: '{"cudagraph_mode":"FULL_AND_PIECEWISE","cudagraph_capture_sizes":[8,16,64,128,256,512,1024,2048,4096,8192]}'
-        speculative-config: '{"method":"dspark","model":"Inferact/Kimi-K3-DSpark","num_speculative_tokens":7,"attention_backend":"TOKENSPEED_MLA","draft_sample_method":"probabilistic","rejection_sample_method":"block"}'
-  benchmark:
-    env:
-      CONC: '1'
-
-override_c2:
-  roles:
-    agg:
-      args:
-        max-num-seqs: 4
-        gpu-memory-utilization: 0.92
-        compilation-config: '{"cudagraph_mode":"FULL_AND_PIECEWISE","cudagraph_capture_sizes":[8,16,24,32,64,128,256,512,1024,2048,4096,8192]}'
-        speculative-config: '{"method":"dspark","model":"Inferact/Kimi-K3-DSpark","num_speculative_tokens":7,"attention_backend":"TOKENSPEED_MLA","draft_sample_method":"probabilistic","rejection_sample_method":"block"}'
-  benchmark:
-    env:
-      CONC: '2'
-
-override_c4:
-  roles:
-    agg:
-      args:
-        max-num-seqs: 8
-        gpu-memory-utilization: 0.92
-        compilation-config: '{"cudagraph_mode":"FULL_AND_PIECEWISE","cudagraph_capture_sizes":[8,16,24,32,40,48,56,64,128,256,512,1024,2048,4096,8192]}'
-        speculative-config: '{"method":"dspark","model":"Inferact/Kimi-K3-DSpark","num_speculative_tokens":7,"attention_backend":"TOKENSPEED_MLA","draft_sample_method":"probabilistic","rejection_sample_method":"block"}'
-  benchmark:
-    env:
-      CONC: '4'
-
-override_c8:
-  roles:
-    agg:
-      args:
-        max-num-seqs: 16
-        gpu-memory-utilization: 0.92
-        compilation-config: '{"cudagraph_mode":"FULL_AND_PIECEWISE","cudagraph_capture_sizes":[8,16,24,32,40,48,56,64,72,80,88,96,104,112,120,128,256,512,1024,2048,4096,8192]}'
-        speculative-config: '{"method":"dspark","model":"Inferact/Kimi-K3-DSpark","num_speculative_tokens":7,"attention_backend":"TOKENSPEED_MLA","draft_sample_method":"probabilistic","rejection_sample_method":"block"}'
-  benchmark:
-    env:
-      CONC: '8'
-
-override_c16:
-  roles:
-    agg:
-      args:
-        max-num-seqs: 32
-        gpu-memory-utilization: 0.92
-        compilation-config: '{"cudagraph_mode":"FULL_AND_PIECEWISE","cudagraph_capture_sizes":[4,8,12,16,20,24,28,32,36,40,44,48,52,56,60,64,68,72,76,80,84,88,92,96,100,104,108,112,116,120,124,128,256,512,1024,2048,4096,8192]}'
-        speculative-config: '{"method":"dspark","model":"Inferact/Kimi-K3-DSpark","num_speculative_tokens":3,"attention_backend":"TOKENSPEED_MLA","draft_sample_method":"probabilistic","rejection_sample_method":"block"}'
-  benchmark:
-    env:
-      CONC: '16'
-
-override_c24:
-  roles:
-    agg:
-      args:
-        max-num-seqs: 48
-        gpu-memory-utilization: 0.92
-        compilation-config: '{"cudagraph_mode":"FULL_AND_PIECEWISE","cudagraph_capture_sizes":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,64,128,256,512,1024,2048,4096,8192]}'
-  benchmark:
-    env:
-      CONC: '24'
-      SPEC_DECODING: mtp
-
-override_c32:
-  roles:
-    agg:
-      args:
-        max-num-seqs: 64
-        gpu-memory-utilization: 0.92
-        compilation-config: '{"cudagraph_mode":"FULL_AND_PIECEWISE","cudagraph_capture_sizes":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,128,256,512,1024,2048,4096,8192]}'
-  benchmark:
-    env:
-      CONC: '32'
-      SPEC_DECODING: mtp
-
-override_c40:
-  roles:
-    agg:
-      args:
-        max-num-seqs: 80
-        gpu-memory-utilization: 0.92
-        compilation-config: '{"cudagraph_mode":"FULL_AND_PIECEWISE","cudagraph_capture_sizes":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,128,256,512,1024,2048,4096,8192]}'
-  benchmark:
-    env:
-      CONC: '40'
-      SPEC_DECODING: mtp
-
-override_c48:
-  roles:
-    agg:
-      args:
-        max-num-seqs: 96
-        gpu-memory-utilization: 0.92
-        compilation-config: '{"cudagraph_mode":"FULL_AND_PIECEWISE","cudagraph_capture_sizes":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,128,256,512,1024,2048,4096,8192]}'
-  benchmark:
-    env:
-      CONC: '48'
-      SPEC_DECODING: mtp
-
-override_c56:
-  roles:
-    agg:
-      args:
-        max-num-seqs: 112
-        gpu-memory-utilization: 0.9
-        compilation-config: '{"cudagraph_mode":"FULL_AND_PIECEWISE","cudagraph_capture_sizes":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,128,256,512,1024,2048,4096,8192]}'
-  benchmark:
-    env:
-      CONC: '56'
-      SPEC_DECODING: mtp
-
-override_c70:
-  roles:
-    agg:
-      args:
-        max-num-seqs: 140
-        gpu-memory-utilization: 0.9
-        compilation-config: '{"cudagraph_mode":"FULL_AND_PIECEWISE","cudagraph_capture_sizes":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,256,512,1024,2048,4096,8192]}'
-  benchmark:
-    env:
-      CONC: '70'
-      SPEC_DECODING: mtp
diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/kimik3/vllm/mi355x-fp4-mtp/agentic.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/kimik3/vllm/mi355x-fp4-mtp/agentic.yaml
deleted file mode 100644
index 9b620416c6..0000000000
--- a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/kimik3/vllm/mi355x-fp4-mtp/agentic.yaml
+++ /dev/null
@@ -1,323 +0,0 @@
-# Kimi-K3 MXFP4 AgentX on MI355X with vLLM DSpark
-# (https://recipes.vllm.ai/moonshotai/Kimi-K3). TP8 only: the 1.56 TB checkpoint
-# is ~195 GB per GPU. Every point shards the KV read across all 8 GPUs (dcp8).
-# The KV cache is GPU-resident at c1 and c4 and backed by vLLM's
-# SimpleCPUOffloadConnector (dram) from the offload c4 point. Three bands, driven
-# by kimik3-fp4-mi355x-vllm-agentic-mtp: interactive c1 and c4 (GPU-resident),
-# mid c4-c32 and throughput c48-c60 (DRAM offload, DSpark draft with synthetic
-# acceptance). The 1799 GB DRAM budget splits evenly across the eight ranks.
-base:
-  schema: 2
-  name: kimik3-fp4-mi355x-vllm-agentic
-  resources:
-    gpu_type: mi355x
-    gpus_per_node: 8
-  frontend:
-    type: vllm
-    enable_multiple_frontends: false
-  observability:
-    enabled: false
-    tachometer:
-      enabled: false
-  engine:
-    type: vllm
-    connector: null
-  # Weights load for up to VLLM_ENGINE_READY_TIMEOUT_S.
-  health_check:
-    interval_seconds: 10
-    max_attempts: 720
-  roles:
-    agg:
-      nodes: 1
-      workers: 1
-      gpus: 8
-      args:
-        served-model-name: moonshotai/Kimi-K3
-        trust-remote-code: true
-        moe-backend: auto
-        tensor-parallel-size: 8
-        gpu-memory-utilization: 0.9
-        language-model-only: true
-        enable-auto-tool-choice: true
-        tool-call-parser: kimi_k3
-        reasoning-parser: kimi_k3
-        max-model-len: 1048576
-        enable-prefix-caching: true
-        kv-cache-dtype: fp8
-        attention-config: '{"mla_prefill_backend":"ROCM_AITER_FA"}'
-        stream-interval: 10
-      env:
-        # Upstream AMD recipe environment.
-        VLLM_ROCM_AITER_MLA_ASM_PADDING: asm
-        VLLM_ROCM_USE_AITER: '1'
-        SAFETENSORS_FAST_GPU: '1'
-        VLLM_ROCM_USE_AITER_MOE_SITUV2: '1'
-        AITER_BF16_FP8_MOE_BOUND: '0'
-        AITER_FLYDSL_STAGE2_FP8: '1'
-        VLLM_ROCM_QUICK_REDUCE_QUANTIZATION: INT4
-        VLLM_ROCM_QUICK_REDUCE_MIN_SIZE_BYTES_MB: '16'
-        # The MI355X nodes report MEC firmware 38, below the 177 that fixes the
-        # RCCL memory reclaim issue.
-        HSA_NO_SCRATCH_RECLAIM: '1'
-        # 2.8 TB of weights off a shared mount takes far longer than the default.
-        VLLM_ENGINE_READY_TIMEOUT_S: '7200'
-        PYTHONNOUSERSITE: '1'
-        VLLM_EXECUTE_MODEL_TIMEOUT_SECONDS: '1200'
-        VLLM_USE_DIRECT_DCP_A2A: '0'
-        VLLM_USE_DIRECT_DCP_Q_GATHER: '0'
-        VLLM_USE_DIRECT_DCP_KV_GATHER: '0'
-        # Route DCP multi-token verify through the AITER ASM round-robin decode.
-        VLLM_ROCM_AITER_MLA_DCP_VERIFY: asm
-  benchmark:
-    env:
-      # Long agentic turns against a 1M context are prefill-bound on the server.
-      AIPERF_HTTP_TCP_USER_TIMEOUT: '900000'
-      AIPERF_REQUIRED_SERVER_METRIC_PREFIX: 'vllm:'
-
-# One variant per point. The DSpark draft length descends with concurrency
-# (7 at GPU-resident c1 and c4, 5 at offload c4, 4 from c10) and stays at 4 for the throughput
-# band; agentic runs replace block rejection with the golden acceptance length
-# for that draft length. Graph capture covers every even size up to
-# max-num-seqs x (1 + drafts). c1 admits one and c48-c60 admit 2x CONC, which
-# never binds. c4-c32 cap admission below the in-flight tail (2 at c4, 6 at c10,
-# 10 at c16, 16 at c24, 24 at c32): the slowest decodes run in the largest
-# batches, and capping them raises p90 interactivity, while the excess waits
-# for a slot (23-41% of arrivals in run 40037005947). Every point
-# requests FULL_AND_PIECEWISE; the AMD K3 model has no torch.compile
-# submodule, so without breakable graphs vLLM falls back to FULL_DECODE_ONLY.
-# The offload points split the 1799 GB DRAM budget evenly across the eight ranks;
-# identical prefixes must hash to identical block keys on every rank.
-# c1 runs vLLM's Kimi-K3 specialized decode (vllm-project/vllm#60683,
-# additional-config decode_backend=latency_specialized): pure spec-verify steps of
-# at most 8 rows run each MoE layer as FlyDSL MonoKernels; c1 (k=7) verifies 8 rows
-# per step. At dcp8 the decode attends with AITER's asm MLA (M1); the fused M1c
-# attention is dcp1-only. The kernels need Model Runner V2, no KV connector and BF16 in_proj /
-# o_proj / shared-expert weights, so c1 does not quantize online.
-# Every point prefills KDA layers with the fused gfx950 chunk kernel
-# (additional-config kda_prefill_backend=fused).
-override_tp8_c1:
-  roles:
-    agg:
-      args:
-        decode-context-parallel-size: 8
-        dcp-comm-backend: a2a
-        max-num-seqs: 1
-        max-num-batched-tokens: 16384
-        compilation-config: '{"mode":3,"cudagraph_mode":"FULL_AND_PIECEWISE","max_cudagraph_capture_size":16,"custom_ops":["+fused_rms_norm_gated"],"cudagraph_capture_sizes":[2,4,6,8,10,12,14,16]}'
-        speculative-config: '{"model":"Inferact/Kimi-K3-DSpark","num_speculative_tokens":7,"method":"dspark","attention_backend":"ROCM_AITER_MLA","kv_cache_dtype":"fp8","draft_sample_method":"probabilistic","rejection_sample_method":"block"}'
-        additional-config: '{"decode_backend":"latency_specialized","kda_prefill_backend":"fused"}'
-      env:
-        VLLM_USE_BREAKABLE_CUDAGRAPH: '0'
-        VLLM_USE_V2_MODEL_RUNNER: '1'
-  benchmark:
-    env:
-      CONC: '1'
-      KV_OFFLOADING: 'none'
-
-override_tp8_c4:
-  roles:
-    agg:
-      args:
-        decode-context-parallel-size: 8
-        dcp-comm-backend: a2a
-        max-num-seqs: 2
-        max-num-batched-tokens: 8192
-        compilation-config: '{"mode":3,"cudagraph_mode":"FULL_AND_PIECEWISE","max_cudagraph_capture_size":16,"custom_ops":["+fused_rms_norm_gated"],"cudagraph_capture_sizes":[2,4,6,8,10,12,14,16]}'
-        speculative-config: '{"model":"Inferact/Kimi-K3-DSpark","num_speculative_tokens":7,"method":"dspark","attention_backend":"ROCM_AITER_MLA","kv_cache_dtype":"fp8","draft_sample_method":"probabilistic","rejection_sample_method":"block"}'
-        additional-config: '{"kda_prefill_backend":"fused"}'
-        quantization-config: '{"targets":{"*in_proj_qkvgfab":"fp8_per_channel"}}'
-      env:
-        VLLM_USE_BREAKABLE_CUDAGRAPH: '0'
-  benchmark:
-    env:
-      CONC: '4'
-      KV_OFFLOADING: 'none'
-
-override_tp8_c4_dcp8_simple:
-  roles:
-    agg:
-      args:
-        decode-context-parallel-size: 8
-        dcp-comm-backend: a2a
-        max-num-seqs: 2
-        max-num-batched-tokens: 8192
-        compilation-config: '{"mode":3,"cudagraph_mode":"FULL_AND_PIECEWISE","max_cudagraph_capture_size":12,"custom_ops":["+fused_rms_norm_gated"],"cudagraph_capture_sizes":[2,4,6,8,10,12]}'
-        speculative-config: '{"model":"Inferact/Kimi-K3-DSpark","num_speculative_tokens":5,"method":"dspark","attention_backend":"ROCM_AITER_MLA","kv_cache_dtype":"fp8","draft_sample_method":"probabilistic","rejection_sample_method":"block"}'
-        additional-config: '{"kda_prefill_backend":"fused"}'
-        quantization-config: '{"targets":{"*in_proj_qkvgfab":"fp8_per_channel"}}'
-        kv-transfer-config: '{"kv_connector":"SimpleCPUOffloadConnector","kv_role":"kv_both","kv_connector_extra_config":{"cpu_bytes_to_use_per_rank":224875000000,"lazy_offload":false}}'
-      env:
-        VLLM_USE_BREAKABLE_CUDAGRAPH: '0'
-        PYTHONHASHSEED: '42'
-  benchmark:
-    env:
-      CONC: '4'
-      KV_OFFLOADING: 'dram'
-      TOTAL_CPU_DRAM_GB: '1799'
-
-override_tp8_c10_dcp8_simple:
-  roles:
-    agg:
-      args:
-        decode-context-parallel-size: 8
-        dcp-comm-backend: a2a
-        max-num-seqs: 6
-        max-num-batched-tokens: 8192
-        gpu-memory-utilization: 0.9
-        compilation-config: '{"mode":3,"cudagraph_mode":"FULL_AND_PIECEWISE","max_cudagraph_capture_size":30,"custom_ops":["+fused_rms_norm_gated"],"cudagraph_capture_sizes":[2,4,6,8,10,12,14,16,18,20,22,24,26,28,30]}'
-        speculative-config: '{"model":"Inferact/Kimi-K3-DSpark","num_speculative_tokens":4,"method":"dspark","attention_backend":"ROCM_AITER_MLA","kv_cache_dtype":"fp8","draft_sample_method":"probabilistic","rejection_sample_method":"block"}'
-        additional-config: '{"kda_prefill_backend":"fused"}'
-        quantization-config: '{"targets":{"*in_proj_qkvgfab":"fp8_per_channel"}}'
-        kv-transfer-config: '{"kv_connector":"SimpleCPUOffloadConnector","kv_role":"kv_both","kv_connector_extra_config":{"cpu_bytes_to_use_per_rank":224875000000,"lazy_offload":false}}'
-      env:
-        VLLM_USE_BREAKABLE_CUDAGRAPH: '0'
-        PYTHONHASHSEED: '42'
-  benchmark:
-    env:
-      CONC: '10'
-      KV_OFFLOADING: 'dram'
-      TOTAL_CPU_DRAM_GB: '1799'
-
-override_tp8_c16_dcp8_simple:
-  roles:
-    agg:
-      args:
-        decode-context-parallel-size: 8
-        dcp-comm-backend: a2a
-        max-num-seqs: 10
-        max-num-batched-tokens: 8192
-        gpu-memory-utilization: 0.9
-        compilation-config: '{"mode":3,"cudagraph_mode":"FULL_AND_PIECEWISE","max_cudagraph_capture_size":50,"custom_ops":["+fused_rms_norm_gated"],"cudagraph_capture_sizes":[2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36,38,40,42,44,46,48,50]}'
-        speculative-config: '{"model":"Inferact/Kimi-K3-DSpark","num_speculative_tokens":4,"method":"dspark","attention_backend":"ROCM_AITER_MLA","kv_cache_dtype":"fp8","draft_sample_method":"probabilistic","rejection_sample_method":"block"}'
-        additional-config: '{"kda_prefill_backend":"fused"}'
-        quantization-config: '{"targets":{"*in_proj_qkvgfab":"fp8_per_channel"}}'
-        kv-transfer-config: '{"kv_connector":"SimpleCPUOffloadConnector","kv_role":"kv_both","kv_connector_extra_config":{"cpu_bytes_to_use_per_rank":224875000000,"lazy_offload":false}}'
-      env:
-        VLLM_USE_BREAKABLE_CUDAGRAPH: '0'
-        PYTHONHASHSEED: '42'
-  benchmark:
-    env:
-      CONC: '16'
-      KV_OFFLOADING: 'dram'
-      TOTAL_CPU_DRAM_GB: '1799'
-
-override_tp8_c24_dcp8_simple:
-  roles:
-    agg:
-      args:
-        decode-context-parallel-size: 8
-        dcp-comm-backend: a2a
-        max-num-seqs: 16
-        max-num-batched-tokens: 8192
-        gpu-memory-utilization: 0.9
-        compilation-config: '{"mode":3,"cudagraph_mode":"FULL_AND_PIECEWISE","max_cudagraph_capture_size":80,"custom_ops":["+fused_rms_norm_gated"],"cudagraph_capture_sizes":[2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36,38,40,42,44,46,48,50,52,54,56,58,60,62,64,66,68,70,72,74,76,78,80]}'
-        speculative-config: '{"model":"Inferact/Kimi-K3-DSpark","num_speculative_tokens":4,"method":"dspark","attention_backend":"ROCM_AITER_MLA","kv_cache_dtype":"fp8","draft_sample_method":"probabilistic","rejection_sample_method":"block"}'
-        additional-config: '{"kda_prefill_backend":"fused"}'
-        quantization-config: '{"targets":{"*in_proj_qkvgfab":"fp8_per_channel"}}'
-        kv-transfer-config: '{"kv_connector":"SimpleCPUOffloadConnector","kv_role":"kv_both","kv_connector_extra_config":{"cpu_bytes_to_use_per_rank":224875000000,"lazy_offload":false}}'
-      env:
-        VLLM_USE_BREAKABLE_CUDAGRAPH: '0'
-        PYTHONHASHSEED: '42'
-  benchmark:
-    env:
-      CONC: '24'
-      KV_OFFLOADING: 'dram'
-      TOTAL_CPU_DRAM_GB: '1799'
-
-override_tp8_c32_dcp8_simple:
-  roles:
-    agg:
-      args:
-        decode-context-parallel-size: 8
-        dcp-comm-backend: a2a
-        max-num-seqs: 24
-        max-num-batched-tokens: 8192
-        gpu-memory-utilization: 0.9
-        compilation-config: '{"mode":3,"cudagraph_mode":"FULL_AND_PIECEWISE","max_cudagraph_capture_size":120,"custom_ops":["+fused_rms_norm_gated"],"cudagraph_capture_sizes":[2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36,38,40,42,44,46,48,50,52,54,56,58,60,62,64,66,68,70,72,74,76,78,80,82,84,86,88,90,92,94,96,98,100,102,104,106,108,110,112,114,116,118,120]}'
-        speculative-config: '{"model":"Inferact/Kimi-K3-DSpark","num_speculative_tokens":4,"method":"dspark","attention_backend":"ROCM_AITER_MLA","kv_cache_dtype":"fp8","draft_sample_method":"probabilistic","rejection_sample_method":"block"}'
-        additional-config: '{"kda_prefill_backend":"fused"}'
-        quantization-config: '{"targets":{"*in_proj_qkvgfab":"fp8_per_channel"}}'
-        kv-transfer-config: '{"kv_connector":"SimpleCPUOffloadConnector","kv_role":"kv_both","kv_connector_extra_config":{"cpu_bytes_to_use_per_rank":224875000000,"lazy_offload":false}}'
-      env:
-        VLLM_USE_BREAKABLE_CUDAGRAPH: '0'
-        PYTHONHASHSEED: '42'
-  benchmark:
-    env:
-      CONC: '32'
-      KV_OFFLOADING: 'dram'
-      TOTAL_CPU_DRAM_GB: '1799'
-
-# Throughput band: same dcp8 DRAM-offload layout with a 4-token DSpark draft.
-# Synthetic acceptance replaces block rejection with the golden acceptance
-# length. FULL_AND_PIECEWISE graphs cover every even size up to 2x CONC x 5.
-override_tp8_c48_dcp8_simple:
-  roles:
-    agg:
-      args:
-        decode-context-parallel-size: 8
-        dcp-comm-backend: a2a
-        max-num-seqs: 96
-        max-num-batched-tokens: 8192
-        gpu-memory-utilization: 0.9
-        compilation-config: '{"mode":3,"cudagraph_mode":"FULL_AND_PIECEWISE","max_cudagraph_capture_size":480,"custom_ops":["+fused_rms_norm_gated"],"cudagraph_capture_sizes":[2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36,38,40,42,44,46,48,50,52,54,56,58,60,62,64,66,68,70,72,74,76,78,80,82,84,86,88,90,92,94,96,98,100,102,104,106,108,110,112,114,116,118,120,122,124,126,128,130,132,134,136,138,140,142,144,146,148,150,152,154,156,158,160,162,164,166,168,170,172,174,176,178,180,182,184,186,188,190,192,194,196,198,200,202,204,206,208,210,212,214,216,218,220,222,224,226,228,230,232,234,236,238,240,242,244,246,248,250,252,254,256,258,260,262,264,266,268,270,272,274,276,278,280,282,284,286,288,290,292,294,296,298,300,302,304,306,308,310,312,314,316,318,320,322,324,326,328,330,332,334,336,338,340,342,344,346,348,350,352,354,356,358,360,362,364,366,368,370,372,374,376,378,380,382,384,386,388,390,392,394,396,398,400,402,404,406,408,410,412,414,416,418,420,422,424,426,428,430,432,434,436,438,440,442,444,446,448,450,452,454,456,458,460,462,464,466,468,470,472,474,476,478,480]}'
-        speculative-config: '{"model":"Inferact/Kimi-K3-DSpark","num_speculative_tokens":4,"method":"dspark","attention_backend":"ROCM_AITER_MLA","kv_cache_dtype":"fp8","draft_sample_method":"probabilistic","rejection_sample_method":"block"}'
-        additional-config: '{"kda_prefill_backend":"fused"}'
-        quantization-config: '{"targets":{"*in_proj_qkvgfab":"fp8_per_channel"}}'
-        kv-transfer-config: '{"kv_connector":"SimpleCPUOffloadConnector","kv_role":"kv_both","kv_connector_extra_config":{"cpu_bytes_to_use_per_rank":224875000000,"lazy_offload":false}}'
-      env:
-        VLLM_USE_BREAKABLE_CUDAGRAPH: '0'
-        PYTHONHASHSEED: '42'
-  benchmark:
-    env:
-      CONC: '48'
-      KV_OFFLOADING: 'dram'
-      TOTAL_CPU_DRAM_GB: '1799'
-      SPEC_DECODING: 'mtp'
-
-override_tp8_c52_dcp8_simple:
-  roles:
-    agg:
-      args:
-        decode-context-parallel-size: 8
-        dcp-comm-backend: a2a
-        max-num-seqs: 104
-        max-num-batched-tokens: 8192
-        gpu-memory-utilization: 0.9
-        compilation-config: '{"mode":3,"cudagraph_mode":"FULL_AND_PIECEWISE","max_cudagraph_capture_size":520,"custom_ops":["+fused_rms_norm_gated"],"cudagraph_capture_sizes":[2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36,38,40,42,44,46,48,50,52,54,56,58,60,62,64,66,68,70,72,74,76,78,80,82,84,86,88,90,92,94,96,98,100,102,104,106,108,110,112,114,116,118,120,122,124,126,128,130,132,134,136,138,140,142,144,146,148,150,152,154,156,158,160,162,164,166,168,170,172,174,176,178,180,182,184,186,188,190,192,194,196,198,200,202,204,206,208,210,212,214,216,218,220,222,224,226,228,230,232,234,236,238,240,242,244,246,248,250,252,254,256,258,260,262,264,266,268,270,272,274,276,278,280,282,284,286,288,290,292,294,296,298,300,302,304,306,308,310,312,314,316,318,320,322,324,326,328,330,332,334,336,338,340,342,344,346,348,350,352,354,356,358,360,362,364,366,368,370,372,374,376,378,380,382,384,386,388,390,392,394,396,398,400,402,404,406,408,410,412,414,416,418,420,422,424,426,428,430,432,434,436,438,440,442,444,446,448,450,452,454,456,458,460,462,464,466,468,470,472,474,476,478,480,482,484,486,488,490,492,494,496,498,500,502,504,506,508,510,512,514,516,518,520]}'
-        speculative-config: '{"model":"Inferact/Kimi-K3-DSpark","num_speculative_tokens":4,"method":"dspark","attention_backend":"ROCM_AITER_MLA","kv_cache_dtype":"fp8","draft_sample_method":"probabilistic","rejection_sample_method":"block"}'
-        additional-config: '{"kda_prefill_backend":"fused"}'
-        quantization-config: '{"targets":{"*in_proj_qkvgfab":"fp8_per_channel"}}'
-        kv-transfer-config: '{"kv_connector":"SimpleCPUOffloadConnector","kv_role":"kv_both","kv_connector_extra_config":{"cpu_bytes_to_use_per_rank":224875000000,"lazy_offload":false}}'
-      env:
-        VLLM_USE_BREAKABLE_CUDAGRAPH: '0'
-        PYTHONHASHSEED: '42'
-  benchmark:
-    env:
-      CONC: '52'
-      KV_OFFLOADING: 'dram'
-      TOTAL_CPU_DRAM_GB: '1799'
-      SPEC_DECODING: 'mtp'
-
-override_tp8_c60_dcp8_simple:
-  roles:
-    agg:
-      args:
-        decode-context-parallel-size: 8
-        dcp-comm-backend: a2a
-        max-num-seqs: 120
-        max-num-batched-tokens: 8192
-        gpu-memory-utilization: 0.9
-        compilation-config: '{"mode":3,"cudagraph_mode":"FULL_AND_PIECEWISE","max_cudagraph_capture_size":600,"custom_ops":["+fused_rms_norm_gated"],"cudagraph_capture_sizes":[2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36,38,40,42,44,46,48,50,52,54,56,58,60,62,64,66,68,70,72,74,76,78,80,82,84,86,88,90,92,94,96,98,100,102,104,106,108,110,112,114,116,118,120,122,124,126,128,130,132,134,136,138,140,142,144,146,148,150,152,154,156,158,160,162,164,166,168,170,172,174,176,178,180,182,184,186,188,190,192,194,196,198,200,202,204,206,208,210,212,214,216,218,220,222,224,226,228,230,232,234,236,238,240,242,244,246,248,250,252,254,256,258,260,262,264,266,268,270,272,274,276,278,280,282,284,286,288,290,292,294,296,298,300,302,304,306,308,310,312,314,316,318,320,322,324,326,328,330,332,334,336,338,340,342,344,346,348,350,352,354,356,358,360,362,364,366,368,370,372,374,376,378,380,382,384,386,388,390,392,394,396,398,400,402,404,406,408,410,412,414,416,418,420,422,424,426,428,430,432,434,436,438,440,442,444,446,448,450,452,454,456,458,460,462,464,466,468,470,472,474,476,478,480,482,484,486,488,490,492,494,496,498,500,502,504,506,508,510,512,514,516,518,520,522,524,526,528,530,532,534,536,538,540,542,544,546,548,550,552,554,556,558,560,562,564,566,568,570,572,574,576,578,580,582,584,586,588,590,592,594,596,598,600]}'
-        speculative-config: '{"model":"Inferact/Kimi-K3-DSpark","num_speculative_tokens":4,"method":"dspark","attention_backend":"ROCM_AITER_MLA","kv_cache_dtype":"fp8","draft_sample_method":"probabilistic","rejection_sample_method":"block"}'
-        additional-config: '{"kda_prefill_backend":"fused"}'
-        quantization-config: '{"targets":{"*in_proj_qkvgfab":"fp8_per_channel"}}'
-        kv-transfer-config: '{"kv_connector":"SimpleCPUOffloadConnector","kv_role":"kv_both","kv_connector_extra_config":{"cpu_bytes_to_use_per_rank":224875000000,"lazy_offload":false}}'
-      env:
-        VLLM_USE_BREAKABLE_CUDAGRAPH: '0'
-        PYTHONHASHSEED: '42'
-  benchmark:
-    env:
-      CONC: '60'
-      KV_OFFLOADING: 'dram'
-      TOTAL_CPU_DRAM_GB: '1799'
-      SPEC_DECODING: 'mtp'
diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/minimaxm31flash/sglang/b300-fp4-mtp/agentic-tp2-spf-extra.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/minimaxm31flash/sglang/b300-fp4-mtp/agentic-tp2-spf-extra.yaml
new file mode 100644
index 0000000000..9169dfb96b
--- /dev/null
+++ b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/minimaxm31flash/sglang/b300-fp4-mtp/agentic-tp2-spf-extra.yaml
@@ -0,0 +1,117 @@
+base:
+  schema: 2
+  name: minimaxm31flash-fp4-b300-sglang-agentic-tp2-spf-extra
+  resources:
+    gpu_type: b300
+    gpus_per_node: 8
+  frontend:
+    type: sglang
+    enable_multiple_frontends: false
+  observability:
+    enabled: false
+    tachometer:
+      enabled: false
+  engine: sglang
+  # Cold loads of the 250 GB checkpoint plus JIT MSA kernel builds and graph capture outlast the default.
+  health_check:
+    max_attempts: 1440
+    interval_seconds: 5
+  roles:
+    agg:
+      nodes: 1
+      workers: 1
+      gpus: 2
+      # Serve flags follow the cookbook's B300 cells at
+      # https://docs.sglang.io/cookbook/autoregressive/MiniMax/MiniMax-M3.1.
+      args:
+        served-model-name: MiniMaxAI/MiniMax-M3.1-Flash
+        trust-remote-code: true
+        reasoning-parser: minimax-m3
+        tool-call-parser: minimax-m3
+        # Seven-token DSpark, the bundled draft's dspark_block_size. Throughput runs
+        # switch to synthetic acceptance at the golden acceptance length.
+        speculative-algorithm: DSPARK
+        speculative-dspark-block-size: 7
+        speculative-use-block-verification: true
+        # FP8 draft KV, as vLLM's DSpark drafter uses; bf16 costs ~10 GB of HBM per rank.
+        speculative-draft-kv-cache-dtype: fp8_e4m3
+        cuda-graph-backend-prefill: breakable
+        tokenizer-worker-num: 8
+        watchdog-timeout: 3600
+        enable-metrics: true
+      env:
+        PYTHONNOUSERSITE: '1'
+        PYTHONUNBUFFERED: '1'
+        SGLANG_TIMEOUT_KEEP_ALIVE: '1800'
+        FMHA_SM100_ALLOW_JIT: '1'
+  benchmark:
+    env:
+      # Warmup can leave bytes unacknowledged past AIPerf's 30 s default.
+      AIPERF_HTTP_TCP_USER_TIMEOUT: '900000'
+      AIPERF_REQUIRED_SERVER_METRIC_PREFIX: 'sglang:'
+
+# 2x CONC (AgentX subagent fan-out); the decode graph batch matches it.
+override_tp2_c44_spf_interval32:
+  roles:
+    agg:
+      args:
+        tensor-parallel-size: 2
+        moe-runner-backend: flashinfer_trtllm_routed
+        chunked-prefill-size: 8192
+        max-running-requests: 88
+        cuda-graph-max-bs-decode: 88
+        mem-fraction-static: 0.92
+        enable-hierarchical-cache: true
+        hicache-size: 370
+        hicache-write-policy: write_back
+        schedule-policy: shortest-prefill-first
+        prefill-decode-interval: 32
+        stream-interval: 20
+  benchmark:
+    env:
+      CONC: '44'
+      KV_OFFLOADING: dram
+
+# A larger HBM KV pool keeps more of the reused prefixes on device, so fewer are
+# reloaded from host DRAM.
+override_tp2_c50_spf_interval20_mem093:
+  roles:
+    agg:
+      args:
+        tensor-parallel-size: 2
+        moe-runner-backend: flashinfer_trtllm_routed
+        chunked-prefill-size: 8192
+        max-running-requests: 100
+        cuda-graph-max-bs-decode: 100
+        mem-fraction-static: 0.93
+        enable-hierarchical-cache: true
+        hicache-size: 370
+        hicache-write-policy: write_back
+        schedule-policy: shortest-prefill-first
+        prefill-decode-interval: 20
+        stream-interval: 20
+  benchmark:
+    env:
+      CONC: '50'
+      KV_OFFLOADING: dram
+
+override_tp2_c52_spf_interval20_mem093:
+  roles:
+    agg:
+      args:
+        tensor-parallel-size: 2
+        moe-runner-backend: flashinfer_trtllm_routed
+        chunked-prefill-size: 8192
+        max-running-requests: 104
+        cuda-graph-max-bs-decode: 104
+        mem-fraction-static: 0.93
+        enable-hierarchical-cache: true
+        hicache-size: 370
+        hicache-write-policy: write_back
+        schedule-policy: shortest-prefill-first
+        prefill-decode-interval: 20
+        stream-interval: 20
+  benchmark:
+    env:
+      CONC: '52'
+      KV_OFFLOADING: dram
diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/minimaxm31flash/sglang/b300-fp4-mtp/agentic-tp4-spf-extra.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/minimaxm31flash/sglang/b300-fp4-mtp/agentic-tp4-spf-extra.yaml
new file mode 100644
index 0000000000..9ce5df5a62
--- /dev/null
+++ b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/minimaxm31flash/sglang/b300-fp4-mtp/agentic-tp4-spf-extra.yaml
@@ -0,0 +1,95 @@
+base:
+  schema: 2
+  name: minimaxm31flash-fp4-b300-sglang-agentic-tp4-spf-extra
+  resources:
+    gpu_type: b300
+    gpus_per_node: 8
+  frontend:
+    type: sglang
+    enable_multiple_frontends: false
+  observability:
+    enabled: false
+    tachometer:
+      enabled: false
+  engine: sglang
+  # Cold loads of the 250 GB checkpoint plus JIT MSA kernel builds and graph capture outlast the default.
+  health_check:
+    max_attempts: 1440
+    interval_seconds: 5
+  roles:
+    agg:
+      nodes: 1
+      workers: 1
+      gpus: 4
+      # Serve flags follow the cookbook's B300 cells at
+      # https://docs.sglang.io/cookbook/autoregressive/MiniMax/MiniMax-M3.1.
+      args:
+        served-model-name: MiniMaxAI/MiniMax-M3.1-Flash
+        trust-remote-code: true
+        reasoning-parser: minimax-m3
+        tool-call-parser: minimax-m3
+        # Seven-token DSpark, the bundled draft's dspark_block_size. Throughput runs
+        # switch to synthetic acceptance at the golden acceptance length.
+        speculative-algorithm: DSPARK
+        speculative-dspark-block-size: 7
+        speculative-use-block-verification: true
+        # FP8 draft KV, as vLLM's DSpark drafter uses; bf16 costs ~10 GB of HBM per rank.
+        speculative-draft-kv-cache-dtype: fp8_e4m3
+        cuda-graph-backend-prefill: breakable
+        tokenizer-worker-num: 8
+        watchdog-timeout: 3600
+        enable-metrics: true
+      env:
+        PYTHONNOUSERSITE: '1'
+        PYTHONUNBUFFERED: '1'
+        SGLANG_TIMEOUT_KEEP_ALIVE: '1800'
+        FMHA_SM100_ALLOW_JIT: '1'
+  benchmark:
+    env:
+      # Warmup can leave bytes unacknowledged past AIPerf's 30 s default.
+      AIPERF_HTTP_TCP_USER_TIMEOUT: '900000'
+      AIPERF_REQUIRED_SERVER_METRIC_PREFIX: 'sglang:'
+
+# Shortest-prefill-first with a decode interval of 32 on TP4 with DRAM KV offload,
+# filling the curve between the TP2 and TP4 points.
+# 2x CONC (AgentX subagent fan-out); the decode graph batch matches it.
+zip_override_tp4_dram_spf_interval32:
+  roles:
+    agg:
+      args:
+        tensor-parallel-size: 4
+        moe-runner-backend: flashinfer_trtllm_routed
+        chunked-prefill-size: 8192
+        max-running-requests: [40, 88, 104, 120]
+        cuda-graph-max-bs-decode: [40, 88, 104, 120]
+        mem-fraction-static: 0.90
+        enable-hierarchical-cache: true
+        hicache-size: 290
+        hicache-write-policy: write_back
+        schedule-policy: shortest-prefill-first
+        prefill-decode-interval: 32
+        stream-interval: 20
+  benchmark:
+    env:
+      CONC: ['20', '44', '52', '60']
+      KV_OFFLOADING: dram
+      TOTAL_CPU_DRAM_GB: '1199'
+
+# At conc 16 the working set fits in HBM; host offload only adds overhead.
+override_tp4_c16_spf_interval32:
+  roles:
+    agg:
+      args:
+        tensor-parallel-size: 4
+        moe-runner-backend: flashinfer_trtllm_routed
+        chunked-prefill-size: 8192
+        max-running-requests: 32
+        cuda-graph-max-bs-decode: 32
+        mem-fraction-static: 0.90
+        schedule-policy: shortest-prefill-first
+        prefill-decode-interval: 32
+        stream-interval: 20
+  benchmark:
+    env:
+      CONC: '16'
+      KV_OFFLOADING: none
diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/minimaxm31flash/sglang/mi355x-fp4-mtp/agentic.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/minimaxm31flash/sglang/mi355x-fp4-mtp/agentic.yaml
index a0a8f10207..ff4c25706f 100644
--- a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/minimaxm31flash/sglang/mi355x-fp4-mtp/agentic.yaml
+++ b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/minimaxm31flash/sglang/mi355x-fp4-mtp/agentic.yaml
@@ -40,6 +40,9 @@ base:
         fp8-gemm-backend: aiter
       env:
         PYTHONNOUSERSITE: '1'
+        # srtctl pre-downloads the hf: model only when HF_HOME is set; the download fills in
+        # files the shared HF_HUB_CACHE lacks (the processor's preprocessor_config.json)
+        HF_HOME: /tmp/hf_home
         PYTHONUNBUFFERED: '1'
         SGLANG_TIMEOUT_KEEP_ALIVE: '1800'
         SGLANG_USE_AITER: '1'
@@ -139,12 +142,13 @@ override_tp4_c32:
       CONC: '32'
       KV_OFFLOADING: none
 
-# The cookbook's High-Throughput cell (HiCache) crashes on MI355X with this image: the
-# first prefill's HiCache write backup hits a HIP illegal memory access with either a
-# fixed hicache-size or hicache-ratio 1.5. Concurrency 48 and 64 run the Low-Latency
-# cell GPU-resident instead, like the vLLM MI355X recipe's TP4 c64.
+# The cookbook's High-Throughput cell: HiCache keeps evicted prefixes in host memory,
+# 180 GB per rank across the main KV, index K and draft KV pools, written back on GPU
+# eviction. HSA_USERPTR_FOR_PAGED_MEM=0 backs the host pools with hipHostMalloc instead of
+# registering pageable memory (sgl-project/sglang#42553); the registered pools hit a HIP
+# illegal memory access at the first HiCache write on MI355X with this image.
 
-override_tp4_c48:
+override_tp4_hicache_c48:
   roles:
     agg:
       args:
@@ -153,12 +157,17 @@ override_tp4_c48:
         max-running-requests: 96
         cuda-graph-max-bs-decode: 96
         mem-fraction-static: 0.8
+        enable-hierarchical-cache: true
+        hicache-size: 180
+        hicache-write-policy: write_back
+      env:
+        HSA_USERPTR_FOR_PAGED_MEM: '0'
   benchmark:
     env:
       CONC: '48'
-      KV_OFFLOADING: none
+      KV_OFFLOADING: dram
 
-override_tp4_c64:
+override_tp4_hicache_c64:
   roles:
     agg:
       args:
@@ -167,7 +176,12 @@ override_tp4_c64:
         max-running-requests: 128
         cuda-graph-max-bs-decode: 128
         mem-fraction-static: 0.8
+        enable-hierarchical-cache: true
+        hicache-size: 180
+        hicache-write-policy: write_back
+      env:
+        HSA_USERPTR_FOR_PAGED_MEM: '0'
   benchmark:
     env:
       CONC: '64'
-      KV_OFFLOADING: none
+      KV_OFFLOADING: dram
diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/minimaxm31flash/vllm/gb300-fp4-mtp/agentic.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/minimaxm31flash/vllm/gb300-fp4-mtp/agentic.yaml
index 94332f36cf..204ded2d81 100644
--- a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/minimaxm31flash/vllm/gb300-fp4-mtp/agentic.yaml
+++ b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/minimaxm31flash/vllm/gb300-fp4-mtp/agentic.yaml
@@ -57,12 +57,133 @@ zip_override_tp4:
       gpus: 4
       args:
         tensor-parallel-size: 4
-        max-num-seqs: [2, 8, 16, 32, 64]
+        max-num-seqs: [2, 8, 64]
         # Golden AL 4.04. FlashInfer PrimiTS drafter, per the vLLM blog's GB300 runs.
         speculative-config: '{"method":"dspark","num_speculative_tokens":7,"attention_backend":"FLASHINFER_TS","kv_cache_dtype":"fp8","draft_sample_method":"probabilistic","rejection_sample_method":"block"}'
   benchmark:
     env:
-      CONC: ['1', '4', '8', '16', '32']
+      CONC: ['1', '4', '32']
+
+# CUDA graphs captured up to max-num-batched-tokens.
+override_tp4_c8_cudagraph:
+  roles:
+    agg:
+      gpus: 4
+      args:
+        tensor-parallel-size: 4
+        max-num-seqs: 16
+        speculative-config: '{"method":"dspark","num_speculative_tokens":7,"attention_backend":"FLASHINFER_TS","kv_cache_dtype":"fp8","draft_sample_method":"probabilistic","rejection_sample_method":"block"}'
+        compilation-config: '{"cudagraph_mode":"FULL_AND_PIECEWISE","cudagraph_capture_sizes":[1,2,4,8,16,24,32,40,48,56,64,72,80,88,96,104,112,120,128,136,144,152,160,168,176,184,192,200,208,216,224,232,240,248,256,264,272,280,288,296,304,312,320,328,336,344,352,360,368,376,384,392,400,408,416,424,432,440,448,456,464,472,480,488,496,504,512,640,768,896,1024,1152,1280,1408,1536,1664,1792,1920,2048,2304,2560,2816,3072,3328,3584,3840,4096,4608,5120,5632,6144,6656,7168,7680,8192]}'
+  benchmark:
+    env:
+      CONC: '8'
+
+override_tp4_c16_cudagraph:
+  roles:
+    agg:
+      gpus: 4
+      args:
+        tensor-parallel-size: 4
+        max-num-seqs: 64
+        speculative-config: '{"method":"dspark","num_speculative_tokens":7,"attention_backend":"FLASHINFER_TS","kv_cache_dtype":"fp8","draft_sample_method":"probabilistic","rejection_sample_method":"block"}'
+        compilation-config: '{"cudagraph_mode":"FULL_AND_PIECEWISE","cudagraph_capture_sizes":[1,2,4,8,16,24,32,40,48,56,64,72,80,88,96,104,112,120,128,136,144,152,160,168,176,184,192,200,208,216,224,232,240,248,256,264,272,280,288,296,304,312,320,328,336,344,352,360,368,376,384,392,400,408,416,424,432,440,448,456,464,472,480,488,496,504,512,640,768,896,1024,1152,1280,1408,1536,1664,1792,1920,2048,2304,2560,2816,3072,3328,3584,3840,4096,4608,5120,5632,6144,6656,7168,7680,8192]}'
+  benchmark:
+    env:
+      CONC: '16'
+
+override_tp4_c24_batched32k:
+  roles:
+    agg:
+      gpus: 4
+      args:
+        tensor-parallel-size: 4
+        max-num-seqs: 64
+        max-num-batched-tokens: 32768
+        long-prefill-token-threshold: 8192
+        prefill-schedule-interval: 16
+        speculative-config: '{"method":"dspark","num_speculative_tokens":7,"attention_backend":"FLASHINFER_TS","kv_cache_dtype":"fp8","draft_sample_method":"probabilistic","rejection_sample_method":"block"}'
+        cudagraph-capture-sizes: [1,2,4,8,16,24,32,40,48,56,64,72,80,88,96,104,112,120,128,136,144,152,160,168,176,184,192,200,208,216,224,232,240,248,256,272,288,304,320,336,352,368,384,400,416,432,448,464,480,496,512,528,544,560,576,592,608,624,640,656,672,688,704,720,736,752,768,784,800,816,832,848,864,880,896,912,928,944,960,976,992,1008,1024,1280,1536,1792,2048,2304,2560,2816,3072,3328,3584,3840,4096,4608,5120,5632,6144,6656,7168,7680,8192]
+      env:
+        VLLM_HTTP_TIMEOUT_KEEP_ALIVE: '600'
+  benchmark:
+    env:
+      CONC: '24'
+
+override_tp4_c40_batched8k:
+  roles:
+    agg:
+      gpus: 4
+      args:
+        tensor-parallel-size: 4
+        max-num-seqs: 64
+        max-num-batched-tokens: 8192
+        long-prefill-token-threshold: 8192
+        gpu-memory-utilization: 0.95
+        watermark: 0.05
+        speculative-config: '{"method":"dspark","num_speculative_tokens":7,"attention_backend":"FLASHINFER_TS","kv_cache_dtype":"fp8","draft_sample_method":"probabilistic","rejection_sample_method":"block"}'
+        cudagraph-capture-sizes: [1,2,4,8,16,24,32,40,48,56,64,72,80,88,96,104,112,120,128,136,144,152,160,168,176,184,192,200,208,216,224,232,240,248,256,272,288,304,320,336,352,368,384,400,416,432,448,464,480,496,512,528,544,560,576,592,608,624,640,656,672,688,704,720,736,752,768,784,800,816,832,848,864,880,896,912,928,944,960,976,992,1008,1024,1280,1536,1792,2048,2304,2560,2816,3072,3328,3584,3840,4096,4608,5120,5632,6144,6656,7168,7680,8192]
+      env:
+        VLLM_HTTP_TIMEOUT_KEEP_ALIVE: '600'
+  benchmark:
+    env:
+      CONC: '40'
+
+override_tp2_c28_cpu_offload:
+  roles:
+    agg:
+      gpus: 2
+      args:
+        tensor-parallel-size: 2
+        max-num-seqs: 42
+        max-num-batched-tokens: 32768
+        speculative-config: '{"method":"dspark","num_speculative_tokens":7,"attention_backend":"FLASHINFER_TS","kv_cache_dtype":"fp8","draft_sample_method":"probabilistic","rejection_sample_method":"block"}'
+        compilation-config: '{"cudagraph_mode":"FULL_AND_PIECEWISE","cudagraph_capture_sizes":[1,2,4,8,16,24,32,40,48,56,64,72,80,88,96,104,112,120,128,136,144,152,160,168,176,184,192,200,208,216,224,232,240,248,256,264,272,280,288,296,304,312,320,328,336,344,352,360,368,376,384,392,400,408,416,424,432,440,448,456,464,472,480,488,496,504,512,640,768,896,1024,1152,1280,1408,1536,1664,1792,1920,2048,2304,2560,2816,3072,3328,3584,3840,4096,4608,5120,5632,6144,6656,7168,7680,8192]}'
+        # Half of the GB300 node's 920,000 MiB CPU DRAM, the matrix's TP2 share.
+        kv-transfer-config: '{"kv_connector":"SimpleCPUOffloadConnector","kv_role":"kv_both","kv_connector_extra_config":{"cpu_bytes_to_use":482000000000,"lazy_offload":true}}'
+      env:
+        VLLM_USE_SIMPLE_KV_OFFLOAD: '1'
+        VLLM_HTTP_TIMEOUT_KEEP_ALIVE: '600'
+  benchmark:
+    env:
+      CONC: '28'
+
+override_tp2_c32_cpu_offload:
+  roles:
+    agg:
+      gpus: 2
+      args:
+        tensor-parallel-size: 2
+        max-num-seqs: 48
+        max-num-batched-tokens: 32768
+        speculative-config: '{"method":"dspark","num_speculative_tokens":7,"attention_backend":"FLASHINFER_TS","kv_cache_dtype":"fp8","draft_sample_method":"probabilistic","rejection_sample_method":"block"}'
+        compilation-config: '{"cudagraph_mode":"FULL_AND_PIECEWISE","cudagraph_capture_sizes":[1,2,4,8,16,24,32,40,48,56,64,72,80,88,96,104,112,120,128,136,144,152,160,168,176,184,192,200,208,216,224,232,240,248,256,264,272,280,288,296,304,312,320,328,336,344,352,360,368,376,384,392,400,408,416,424,432,440,448,456,464,472,480,488,496,504,512,640,768,896,1024,1152,1280,1408,1536,1664,1792,1920,2048,2304,2560,2816,3072,3328,3584,3840,4096,4608,5120,5632,6144,6656,7168,7680,8192]}'
+        # Half of the GB300 node's 920,000 MiB CPU DRAM, the matrix's TP2 share.
+        kv-transfer-config: '{"kv_connector":"SimpleCPUOffloadConnector","kv_role":"kv_both","kv_connector_extra_config":{"cpu_bytes_to_use":482000000000,"lazy_offload":true}}'
+      env:
+        VLLM_USE_SIMPLE_KV_OFFLOAD: '1'
+        VLLM_HTTP_TIMEOUT_KEEP_ALIVE: '600'
+  benchmark:
+    env:
+      CONC: '32'
+
+override_tp2_c36_cpu_offload:
+  roles:
+    agg:
+      gpus: 2
+      args:
+        tensor-parallel-size: 2
+        max-num-seqs: 54
+        max-num-batched-tokens: 32768
+        speculative-config: '{"method":"dspark","num_speculative_tokens":7,"attention_backend":"FLASHINFER_TS","kv_cache_dtype":"fp8","draft_sample_method":"probabilistic","rejection_sample_method":"block"}'
+        compilation-config: '{"cudagraph_mode":"FULL_AND_PIECEWISE","cudagraph_capture_sizes":[1,2,4,8,16,24,32,40,48,56,64,72,80,88,96,104,112,120,128,136,144,152,160,168,176,184,192,200,208,216,224,232,240,248,256,264,272,280,288,296,304,312,320,328,336,344,352,360,368,376,384,392,400,408,416,424,432,440,448,456,464,472,480,488,496,504,512,640,768,896,1024,1152,1280,1408,1536,1664,1792,1920,2048,2304,2560,2816,3072,3328,3584,3840,4096,4608,5120,5632,6144,6656,7168,7680,8192]}'
+        # Half of the GB300 node's 920,000 MiB CPU DRAM, the matrix's TP2 share.
+        kv-transfer-config: '{"kv_connector":"SimpleCPUOffloadConnector","kv_role":"kv_both","kv_connector_extra_config":{"cpu_bytes_to_use":482000000000,"lazy_offload":true}}'
+      env:
+        VLLM_USE_SIMPLE_KV_OFFLOAD: '1'
+        VLLM_HTTP_TIMEOUT_KEEP_ALIVE: '600'
+  benchmark:
+    env:
+      CONC: '36'
 
 zip_override_dep4:
   frontend:
@@ -81,9 +202,9 @@ zip_override_dep4:
         tensor-parallel-size: 1
         data-parallel-size: 4
         enable-expert-parallel: true
-        max-num-seqs: [32, 48, 64]
+        max-num-seqs: [32]
         # Golden AL 2.88. FlashInfer PrimiTS drafter, per the vLLM blog's GB300 runs.
         speculative-config: '{"method":"dspark","num_speculative_tokens":3,"attention_backend":"FLASHINFER_TS","kv_cache_dtype":"fp8","draft_sample_method":"probabilistic","rejection_sample_method":"block"}'
   benchmark:
     env:
-      CONC: ['64', '96', '128']
+      CONC: ['64']
diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/minimaxm31flash/vllm/h100-fp4-mtp/agentic.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/minimaxm31flash/vllm/h100-fp4-mtp/agentic.yaml
index 5a2a7bdee7..4283c4fb41 100644
--- a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/minimaxm31flash/vllm/h100-fp4-mtp/agentic.yaml
+++ b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/minimaxm31flash/vllm/h100-fp4-mtp/agentic.yaml
@@ -39,7 +39,7 @@ base:
         attention-config: '{"indexer_kv_dtype":"fp8"}'
         moe-backend: marlin
         # Three-token DSpark with probabilistic drafting and block rejection, as
-        # measured for minimaxm31flash_dspark. Throughput runs switch to synthetic
+        # measured for minimax-m3.1-flash__dspark__native__probabilistic-block. Throughput runs switch to synthetic
         # rejection at the golden acceptance length.
         speculative-config: '{"method":"dspark","num_speculative_tokens":3,"draft_sample_method":"probabilistic","attention_backend":"FLASH_ATTN","kv_cache_dtype":"fp8","rejection_sample_method":"block"}'
         disable-hybrid-kv-cache-manager: true
diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/minimaxm31flash/vllm/h200-fp4-mtp/agentic.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/minimaxm31flash/vllm/h200-fp4-mtp/agentic.yaml
index ea5c2d0e8c..ea72155e5f 100644
--- a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/minimaxm31flash/vllm/h200-fp4-mtp/agentic.yaml
+++ b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/minimaxm31flash/vllm/h200-fp4-mtp/agentic.yaml
@@ -39,7 +39,7 @@ base:
         attention-config: '{"indexer_kv_dtype":"fp8"}'
         moe-backend: marlin
         # Three-token DSpark with probabilistic drafting and block rejection, as
-        # measured for minimaxm31flash_dspark. Throughput runs switch to synthetic
+        # measured for minimax-m3.1-flash__dspark__native__probabilistic-block. Throughput runs switch to synthetic
         # rejection at the golden acceptance length.
         speculative-config: '{"method":"dspark","num_speculative_tokens":3,"draft_sample_method":"probabilistic","attention_backend":"FLASH_ATTN","kv_cache_dtype":"fp8","rejection_sample_method":"block"}'
         disable-hybrid-kv-cache-manager: true
diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/minimaxm31flash/vllm/mi355x-fp4/agentic.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/minimaxm31flash/vllm/mi355x-fp4/agentic.yaml
index 676c7bf633..3d91e78cee 100644
--- a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/minimaxm31flash/vllm/mi355x-fp4/agentic.yaml
+++ b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/minimaxm31flash/vllm/mi355x-fp4/agentic.yaml
@@ -36,7 +36,8 @@ base:
       args:
         served-model-name: amd/MiniMax-M3.1-Flash-Quark-MXFP4
         tensor-parallel-size: 4
-        gpu-memory-utilization: 0.9
+        # Reserve headroom for DBO prefill and allocations after memory profiling.
+        gpu-memory-utilization: 0.85
         language-model-only: true
         trust-remote-code: true
         reasoning-parser: minimax_m3
@@ -115,14 +116,39 @@ zip_override_tp4_dspark7_mono:
     env:
       CONC: ['1', '2', '4', '8']
 
-# c16-c64: DSpark 3 (the blog's MI355X draft length from c8) on the NVFP4 KV
-# cache with DBO.
-zip_override_tp4_dspark3:
+# c16-c32: DSpark 7 on the NVFP4 KV cache with DBO, at the base 0.85 memory
+# budget (headroom for DBO prefill). Admission is 2x CONC.
+zip_override_tp4_dspark7:
   roles:
     agg:
       args:
+        speculative-config: '{"method":"dspark","num_speculative_tokens":7,"attention_backend":"TRITON_ATTN","kv_cache_dtype":"fp8","draft_sample_method":"probabilistic","rejection_sample_method":"block"}'
+        max-num-seqs: [32, 64]
+  benchmark:
+    env:
+      CONC: ['16', '32']
+
+# c64: DSpark 3 (the blog's MI355X draft length from c8) on the NVFP4 KV cache
+# with DBO, sequence-parallel prefill, 0.90 memory utilization, and a CPU KV tier. The c64 working set
+# outgrows the 14.2M-token GPU KV cache; SimpleCPUOffloadConnector (eager)
+# holds about 24M tokens in 1349 GB of host memory (dram-utilization 0.9 of the
+# TP4 lane) and serves the misses.
+override_tp4_dspark3_c64_offload:
+  roles:
+    agg:
+      args:
+        gpu-memory-utilization: 0.9
         speculative-config: '{"method":"dspark","num_speculative_tokens":3,"attention_backend":"TRITON_ATTN","kv_cache_dtype":"fp8","draft_sample_method":"probabilistic","rejection_sample_method":"block"}'
-        max-num-seqs: [32, 64, 128]
+        max-num-seqs: 128
+        kv-transfer-config: '{"kv_connector":"SimpleCPUOffloadConnector","kv_role":"kv_both","kv_connector_extra_config":{"cpu_bytes_to_use":1349000000000,"lazy_offload":false}}'
+      env:
+        # Sequence-parallel prefill, from #4463. Upstream (vllm#63491) supports
+        # the MXFP4 W4A4 MoE; whether the Quark export's dense layers reach its
+        # MXFP8 kernel is untested, so this arm is the first check.
+        VLLM_ROCM_MINIMAX_M3_SP_PREFILL: '1'
+        PYTHONHASHSEED: '42'
   benchmark:
     env:
-      CONC: ['16', '32', '64']
+      CONC: '64'
+      KV_OFFLOADING: 'dram'
+      TOTAL_CPU_DRAM_GB: '1349'
diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/musespark/sglang/b300-fp4-mtp/agentic.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/musespark/sglang/b300-fp4-mtp/agentic.yaml
index 7eaf2be186..81fd797765 100644
--- a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/musespark/sglang/b300-fp4-mtp/agentic.yaml
+++ b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/musespark/sglang/b300-fp4-mtp/agentic.yaml
@@ -29,7 +29,6 @@ base:
         kv-cache-dtype: fp8_e4m3
         attention-backend: trtllm_mha
         page-size: 128
-        cuda-graph-backend-prefill: breakable
         # DFlash2 verifies 8 tokens per step: the current token plus 7 drafts.
         speculative-algorithm: DFLASH
         speculative-draft-model-path: RadixArk/Muse-Spark-Open-DFlash2
@@ -75,6 +74,7 @@ override_tp8_c1:
       args:
         tensor-parallel-size: 8
         expert-parallel-size: 8
+        cuda-graph-backend-prefill: breakable
         mem-fraction-static: 0.88
         max-running-requests: 1
         cuda-graph-max-bs-decode: 1
@@ -94,12 +94,14 @@ override_tp8_c4:
       args:
         tensor-parallel-size: 8
         expert-parallel-size: 8
+        cuda-graph-backend-prefill: breakable
         mem-fraction-static: 0.88
-        max-running-requests: 2
-        cuda-graph-max-bs-decode: 2
-        prefill-decode-interval: 64
+        max-running-requests: 1
+        cuda-graph-max-bs-decode: 1
         swa-full-tokens-ratio: 0.3
-        stream-interval: 20
+        stream-interval: 40
+        schedule-policy: shortest-prefill-first
+        speculative-draft-attention-backend: fa4
       env:
         PYTORCH_CUDA_ALLOC_CONF: expandable_segments:True
   benchmark:
@@ -107,78 +109,44 @@ override_tp8_c4:
       CONC: '4'
       KV_OFFLOADING: none
 
-override_tp8_c8:
-  roles:
-    agg:
-      gpus: 8
-      args:
-        tensor-parallel-size: 8
-        expert-parallel-size: 8
-        mem-fraction-static: 0.88
-        max-running-requests: 2
-        cuda-graph-max-bs-decode: 2
-        prefill-decode-interval: 64
-        swa-full-tokens-ratio: 0.3
-      env:
-        PYTORCH_CUDA_ALLOC_CONF: expandable_segments:True
-  benchmark:
-    env:
-      CONC: '8'
-      KV_OFFLOADING: none
-
-override_tp8_c10:
+override_tp8_c7:
   roles:
     agg:
       gpus: 8
       args:
         tensor-parallel-size: 8
         expert-parallel-size: 8
+        cuda-graph-backend-prefill: breakable
         mem-fraction-static: 0.88
         max-running-requests: 2
         cuda-graph-max-bs-decode: 2
         prefill-decode-interval: 64
         swa-full-tokens-ratio: 0.3
+        stream-interval: 40
         schedule-policy: shortest-prefill-first
       env:
         PYTORCH_CUDA_ALLOC_CONF: expandable_segments:True
   benchmark:
     env:
-      CONC: '10'
+      CONC: '7'
       KV_OFFLOADING: none
 
-override_tp8_c14:
+override_tp8_c16:
   roles:
     agg:
       gpus: 8
       args:
         tensor-parallel-size: 8
         expert-parallel-size: 8
+        cuda-graph-backend-prefill: breakable
         mem-fraction-static: 0.88
         max-running-requests: 3
         cuda-graph-max-bs-decode: 3
-        prefill-decode-interval: 64
-        swa-full-tokens-ratio: 0.3
-        schedule-policy: shortest-prefill-first
-      env:
-        PYTORCH_CUDA_ALLOC_CONF: expandable_segments:True
-  benchmark:
-    env:
-      CONC: '14'
-      KV_OFFLOADING: none
-
-override_tp8_c16:
-  roles:
-    agg:
-      gpus: 8
-      args:
-        tensor-parallel-size: 8
-        expert-parallel-size: 8
-        mem-fraction-static: 0.88
-        max-running-requests: 4
-        cuda-graph-max-bs-decode: 4
-        prefill-decode-interval: 64
+        prefill-decode-interval: 88
         swa-full-tokens-ratio: 0.3
         schedule-policy: shortest-prefill-first
+        stream-interval: 40
+        incremental-streaming-output: true
       env:
         PYTORCH_CUDA_ALLOC_CONF: expandable_segments:True
   benchmark:
@@ -193,10 +161,11 @@ override_tp8_c20:
       args:
         tensor-parallel-size: 8
         expert-parallel-size: 8
+        cuda-graph-backend-prefill: breakable
         mem-fraction-static: 0.88
         max-running-requests: 6
         cuda-graph-max-bs-decode: 6
-        prefill-decode-interval: 64
+        prefill-decode-interval: 48
         swa-full-tokens-ratio: 0.3
         schedule-policy: shortest-prefill-first
         stream-interval: 20
@@ -214,10 +183,11 @@ override_tp8_c24:
       args:
         tensor-parallel-size: 8
         expert-parallel-size: 8
+        cuda-graph-backend-prefill: breakable
         mem-fraction-static: 0.88
         max-running-requests: 8
         cuda-graph-max-bs-decode: 8
-        prefill-decode-interval: 64
+        prefill-decode-interval: 80
         swa-full-tokens-ratio: 0.3
         schedule-policy: shortest-prefill-first
         stream-interval: 20
@@ -232,7 +202,7 @@ override_tp4_c16:
   roles:
     agg:
       args:
-        mem-fraction-static: 0.95
+        mem-fraction-static: 0.92
         max-running-requests: 12
         cuda-graph-max-bs-decode: 12
         chunked-prefill-size: 8192
@@ -244,6 +214,9 @@ override_tp4_c16:
         enable-megamoe-for-layernorm-sp: true
         enable-hierarchical-cache: true
         hicache-size: 120
+        scheduler-recv-interval: 20
+        stream-interval: 20
+        disable-prefill-cuda-graph: true
       env:
         SGLANG_OPT_DEEPGEMM_MEGA_MOE_NUM_MAX_TOKENS_PER_RANK: '2048'
   benchmark:
@@ -255,19 +228,20 @@ override_tp4_c28:
   roles:
     agg:
       args:
-        mem-fraction-static: 0.95
+        mem-fraction-static: 0.92
         max-running-requests: 56
         cuda-graph-max-bs-decode: 56
         chunked-prefill-size: 16384
         max-prefill-tokens: 16384
         schedule-policy: shortest-prefill-first
-        prefill-decode-interval: 128
+        prefill-decode-interval: 104
         swa-full-tokens-ratio: 0.1
         enable-layernorm-sp: true
         enable-megamoe-for-layernorm-sp: true
         enable-hierarchical-cache: true
         hicache-size: 170
         stream-interval: 20
+        disable-prefill-cuda-graph: true
       env:
         SGLANG_OPT_DEEPGEMM_MEGA_MOE_NUM_MAX_TOKENS_PER_RANK: '4096'
   benchmark:
@@ -279,80 +253,60 @@ override_tp4_c32:
   roles:
     agg:
       args:
-        mem-fraction-static: 0.95
+        mem-fraction-static: 0.92
         max-running-requests: 64
         cuda-graph-max-bs-decode: 64
         chunked-prefill-size: 16384
         max-prefill-tokens: 16384
         schedule-policy: shortest-prefill-first
-        prefill-decode-interval: 128
-        swa-full-tokens-ratio: 0.1
-        enable-layernorm-sp: true
-        enable-megamoe-for-layernorm-sp: true
-        enable-hierarchical-cache: true
-        hicache-size: 170
-        stream-interval: 20
-      env:
-        SGLANG_OPT_DEEPGEMM_MEGA_MOE_NUM_MAX_TOKENS_PER_RANK: '4096'
-  benchmark:
-    env:
-      CONC: '32'
-      KV_OFFLOADING: dram
-
-override_tp4_c40:
-  roles:
-    agg:
-      args:
-        mem-fraction-static: 0.95
-        max-running-requests: 80
-        cuda-graph-max-bs-decode: 80
-        chunked-prefill-size: 16384
-        max-prefill-tokens: 16384
-        schedule-policy: shortest-prefill-first
         prefill-decode-interval: 96
         swa-full-tokens-ratio: 0.2
         enable-layernorm-sp: true
         enable-megamoe-for-layernorm-sp: true
         enable-hierarchical-cache: true
-        hicache-size: 170
+        hicache-size: 250
         stream-interval: 20
+        disable-prefill-cuda-graph: true
       env:
         SGLANG_OPT_DEEPGEMM_MEGA_MOE_NUM_MAX_TOKENS_PER_RANK: '4096'
         SGLANG_TRTLLM_MHA_DECODE_SEQ_LEN_SPLITS: '4'
   benchmark:
     env:
-      CONC: '40'
+      CONC: '32'
       KV_OFFLOADING: dram
 
-override_tp4_c44:
+override_tp4_c38:
   roles:
     agg:
       args:
-        mem-fraction-static: 0.95
-        max-running-requests: 24
-        cuda-graph-max-bs-decode: 24
+        mem-fraction-static: 0.92
+        max-running-requests: 16
+        cuda-graph-max-bs-decode: 76
         chunked-prefill-size: 16384
         max-prefill-tokens: 16384
-        swa-full-tokens-ratio: 0.1
+        schedule-policy: shortest-prefill-first
+        prefill-decode-interval: 56
+        swa-full-tokens-ratio: 0.2
         enable-layernorm-sp: true
         enable-megamoe-for-layernorm-sp: true
         enable-hierarchical-cache: true
-        hicache-size: 170
-        hicache-write-policy: write_back
+        hicache-size: 250
         stream-interval: 20
+        disable-prefill-cuda-graph: true
       env:
         SGLANG_OPT_DEEPGEMM_MEGA_MOE_NUM_MAX_TOKENS_PER_RANK: '4096'
         SGLANG_TRTLLM_MHA_DECODE_SEQ_LEN_SPLITS: '4'
+        SGLANG_DFLASH_EAGER_DRAFT_SAMPLER: '0'
   benchmark:
     env:
-      CONC: '44'
+      CONC: '38'
       KV_OFFLOADING: dram
 
 override_tp4_c48:
   roles:
     agg:
       args:
-        mem-fraction-static: 0.95
+        mem-fraction-static: 0.92
         max-running-requests: 26
         cuda-graph-max-bs-decode: 26
         chunked-prefill-size: 16384
@@ -364,6 +318,7 @@ override_tp4_c48:
         hicache-size: 170
         hicache-write-policy: write_back
         stream-interval: 20
+        disable-prefill-cuda-graph: true
       env:
         SGLANG_OPT_DEEPGEMM_MEGA_MOE_NUM_MAX_TOKENS_PER_RANK: '4096'
         SGLANG_TRTLLM_MHA_DECODE_SEQ_LEN_SPLITS: '4'
diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/musespark/sglang/gb300-fp4-mtp/agentic.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/musespark/sglang/gb300-fp4-mtp/agentic.yaml
index d10a5a9e50..116b0b20fc 100644
--- a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/musespark/sglang/gb300-fp4-mtp/agentic.yaml
+++ b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/musespark/sglang/gb300-fp4-mtp/agentic.yaml
@@ -76,27 +76,29 @@ override_tp4_c1:
     env:
       CONC: '1'
 
-override_tp4_c5:
+override_tp4_c4:
   roles:
     agg:
       args:
-        max-running-requests: 2
-        cuda-graph-max-bs-decode: 2
+        max-running-requests: 1
+        cuda-graph-max-bs-decode: 1
         mem-fraction-static: 0.88
-        prefill-decode-interval: 64
-        speculative-draft-attention-backend: fa4
+        schedule-policy: shortest-prefill-first
   benchmark:
     env:
-      CONC: '5'
+      CONC: '4'
 
 override_tp4_c8:
   roles:
     agg:
       args:
-        max-running-requests: 3
-        cuda-graph-max-bs-decode: 3
+        max-running-requests: 2
+        cuda-graph-max-bs-decode: 2
         mem-fraction-static: 0.88
-        prefill-decode-interval: 64
+        prefill-decode-interval: 128
+        prefill-decode-interval-min-bs: 1
+        schedule-policy: shortest-prefill-first
+        speculative-draft-attention-backend: fa4
   benchmark:
     env:
       CONC: '8'
@@ -109,6 +111,7 @@ override_tp4_c10:
         cuda-graph-max-bs-decode: 3
         mem-fraction-static: 0.88
         prefill-decode-interval: 64
+        schedule-policy: shortest-prefill-first
         speculative-draft-attention-backend: fa4
         tokenizer-worker-num: 4
         incremental-streaming-output: true
@@ -143,6 +146,7 @@ override_tp4_c24:
         max-prefill-tokens: 8192
         schedule-policy: shortest-prefill-first
         prefill-decode-interval: 96
+        prefill-decode-interval-min-bs: 2
         enable-hierarchical-cache: true
         hicache-size: 120
         hicache-write-policy: write_through
@@ -152,27 +156,6 @@ override_tp4_c24:
     env:
       CONC: '24'
 
-override_tp4_c28:
-  roles:
-    agg:
-      args:
-        max-running-requests: 48
-        cuda-graph-max-bs-decode: 48
-        mem-fraction-static: 0.95
-        swa-full-tokens-ratio: 0.1
-        cuda-graph-backend-prefill: breakable
-        max-prefill-tokens: 8192
-        schedule-policy: shortest-prefill-first
-        prefill-decode-interval: 32
-        enable-hierarchical-cache: true
-        hicache-size: 160
-        hicache-write-policy: write_back
-      env:
-        SGLANG_OPT_DEEPGEMM_MEGA_MOE_NUM_MAX_TOKENS_PER_RANK: '2048'
-  benchmark:
-    env:
-      CONC: '28'
-
 override_tp4_c30:
   roles:
     agg:
@@ -185,8 +168,9 @@ override_tp4_c30:
         max-prefill-tokens: 8192
         schedule-policy: shortest-prefill-first
         prefill-decode-interval: 64
+        prefill-decode-interval-min-bs: 3
         enable-hierarchical-cache: true
-        hicache-size: 160
+        hicache-size: 150
         hicache-write-policy: write_back
       env:
         SGLANG_OPT_DEEPGEMM_MEGA_MOE_NUM_MAX_TOKENS_PER_RANK: '2048'
@@ -194,46 +178,45 @@ override_tp4_c30:
     env:
       CONC: '30'
 
-override_tp4_c34:
+override_tp4_c40:
   roles:
     agg:
       args:
-        max-running-requests: 96
-        cuda-graph-max-bs-decode: 96
+        max-running-requests: 18
+        cuda-graph-max-bs-decode: 18
         mem-fraction-static: 0.95
-        swa-full-tokens-ratio: 0.1
-        cuda-graph-backend-prefill: breakable
         chunked-prefill-size: 16384
         max-prefill-tokens: 16384
+        cuda-graph-backend-prefill: breakable
         schedule-policy: shortest-prefill-first
         prefill-decode-interval: 48
         enable-hierarchical-cache: true
-        hicache-size: 160
+        hicache-size: 150
         hicache-write-policy: write_back
       env:
         SGLANG_OPT_DEEPGEMM_MEGA_MOE_NUM_MAX_TOKENS_PER_RANK: '4096'
         SGLANG_TRTLLM_MHA_DECODE_SEQ_LEN_SPLITS: '4'
   benchmark:
     env:
-      CONC: '34'
+      CONC: '40'
 
 override_tp4_c44:
   roles:
     agg:
       args:
-        max-running-requests: 24
-        cuda-graph-max-bs-decode: 24
-        mem-fraction-static: 0.9
-        swa-full-tokens-ratio: 0.1
-        chunked-prefill-size: null
-        speculative-draft-attention-backend: trtllm_mha
-        speculative-draft-kv-cache-dtype: fp8_e4m3
+        max-running-requests: 20
+        cuda-graph-max-bs-decode: 20
+        mem-fraction-static: 0.95
+        chunked-prefill-size: 16384
+        max-prefill-tokens: 16384
+        cuda-graph-backend-prefill: breakable
+        schedule-policy: shortest-prefill-first
+        prefill-decode-interval: 48
         enable-hierarchical-cache: true
-        hicache-size: 149
+        hicache-size: 150
         hicache-write-policy: write_back
-        tokenizer-worker-num: 4
-        incremental-streaming-output: true
       env:
+        SGLANG_OPT_DEEPGEMM_MEGA_MOE_NUM_MAX_TOKENS_PER_RANK: '4096'
         SGLANG_TRTLLM_MHA_DECODE_SEQ_LEN_SPLITS: '4'
   benchmark:
     env:
diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/atom/mi355x-fp4/8k1k.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/atom/mi355x-fp4/8k1k.yaml
deleted file mode 100644
index 4d7eed503f..0000000000
--- a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/atom/mi355x-fp4/8k1k.yaml
+++ /dev/null
@@ -1,40 +0,0 @@
-base:
-  schema: 2
-  name: qwen3.5-fp4-mi355x-atom-8k1k
-  resources:
-    gpu_type: mi355x
-    gpus_per_node: 8
-  frontend:
-    type: atomesh
-    container_image: rocm/atom-dev@sha256:f00a9dc588a380038fdad54cd57a956043cb316ddda54ebb1b62a24f8caa343b
-    enable_multiple_frontends: false
-  observability:
-    enabled: false
-    tachometer:
-      enabled: false
-  engine: atom
-  roles:
-    agg:
-      nodes: 1
-      workers: 1
-      gpus: 2
-      args:
-        kv_cache_dtype: fp8
-        max-model-len: 10240
-        gpu-memory-utilization: 0.9
-        trust-remote-code: true
-      env:
-        OMP_NUM_THREADS: '1'
-  benchmark:
-    command: bash /infmax-workspace/benchmarks/single_node/srt_fixed_sequence.sh --trust-remote-code
-zip_override_tp2_ep1:
-  benchmark:
-    env:
-      CONC: ['4', '8', '16', '32', '64', '128', '256']
-zip_override_tp4_ep1:
-  roles:
-    agg:
-      gpus: 4
-  benchmark:
-    env:
-      CONC: ['4', '8', '16']
diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/atom/mi355x-fp8-mtp/8k1k.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/atom/mi355x-fp8-mtp/8k1k.yaml
deleted file mode 100644
index 5748844c78..0000000000
--- a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/atom/mi355x-fp8-mtp/8k1k.yaml
+++ /dev/null
@@ -1,43 +0,0 @@
-base:
-  schema: 2
-  name: qwen3.5-fp8-mi355x-atom-mtp-8k1k
-  resources:
-    gpu_type: mi355x
-    gpus_per_node: 8
-  frontend:
-    type: atomesh
-    container_image: rocm/atom-dev@sha256:f00a9dc588a380038fdad54cd57a956043cb316ddda54ebb1b62a24f8caa343b
-    enable_multiple_frontends: false
-  observability:
-    enabled: false
-    tachometer:
-      enabled: false
-  engine: atom
-  roles:
-    agg:
-      nodes: 1
-      workers: 1
-      gpus: 4
-      args:
-        kv_cache_dtype: fp8
-        max-model-len: 10240
-        gpu-memory-utilization: 0.9
-        method: mtp
-        num-speculative-tokens: 3
-        trust-remote-code: true
-        no-enable_prefix_caching: true
-      env:
-        OMP_NUM_THREADS: '1'
-  benchmark:
-    command: bash /infmax-workspace/benchmarks/single_node/srt_fixed_sequence.sh --trust-remote-code
-zip_override_tp4_ep1:
-  benchmark:
-    env:
-      CONC: ['4', '8', '16', '32', '64', '128', '256']
-zip_override_tp8_ep1:
-  roles:
-    agg:
-      gpus: 8
-  benchmark:
-    env:
-      CONC: ['4', '8', '16', '32', '64', '128', '256']
diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/atom/mi355x-fp8/8k1k.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/atom/mi355x-fp8/8k1k.yaml
deleted file mode 100644
index 18f4ac2cb7..0000000000
--- a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/atom/mi355x-fp8/8k1k.yaml
+++ /dev/null
@@ -1,47 +0,0 @@
-base:
-  schema: 2
-  name: qwen3.5-fp8-mi355x-atom-8k1k
-  resources:
-    gpu_type: mi355x
-    gpus_per_node: 8
-  frontend:
-    type: atomesh
-    container_image: rocm/atom-dev@sha256:f00a9dc588a380038fdad54cd57a956043cb316ddda54ebb1b62a24f8caa343b
-    enable_multiple_frontends: false
-  observability:
-    enabled: false
-    tachometer:
-      enabled: false
-  engine: atom
-  roles:
-    agg:
-      nodes: 1
-      workers: 1
-      gpus: 2
-      args:
-        kv_cache_dtype: fp8
-        max-model-len: 10240
-        gpu-memory-utilization: 0.9
-        trust-remote-code: true
-      env:
-        OMP_NUM_THREADS: '1'
-  benchmark:
-    command: bash /infmax-workspace/benchmarks/single_node/srt_fixed_sequence.sh --trust-remote-code
-zip_override_tp2_ep1:
-  benchmark:
-    env:
-      CONC: ['4', '8', '16', '32', '64', '128', '256']
-zip_override_tp4_ep1:
-  roles:
-    agg:
-      gpus: 4
-  benchmark:
-    env:
-      CONC: ['4', '8', '16', '32', '64', '128', '256']
-zip_override_tp8_ep1:
-  roles:
-    agg:
-      gpus: 8
-  benchmark:
-    env:
-      CONC: ['4', '8', '16', '32', '64', '128', '256']
diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/b200-fp4-mtp/8k1k.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/b200-fp4-mtp/8k1k.yaml
deleted file mode 100644
index d67ef61280..0000000000
--- a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/b200-fp4-mtp/8k1k.yaml
+++ /dev/null
@@ -1,82 +0,0 @@
-base:
-  schema: 2
-  name: qwen3.5-fp4-b200-sglang-mtp-8k1k
-  resources:
-    gpu_type: b200
-    gpus_per_node: 8
-  frontend:
-    type: sglang
-    enable_multiple_frontends: false
-  observability:
-    enabled: false
-    tachometer:
-      enabled: false
-  engine: sglang
-  roles:
-    agg:
-      nodes: 1
-      workers: 1
-      gpus: 4
-      args:
-        trust-remote-code: true
-        tensor-parallel-size: 4
-        data-parallel-size: 1
-        expert-parallel-size: 1
-        enable-symm-mem: true
-        disable-radix-cache: true
-        quantization: modelopt_fp4
-        kv-cache-dtype: fp8_e4m3
-        mamba-ssm-dtype: bfloat16
-        attention-backend: trtllm_mha
-        moe-runner-backend: flashinfer_trtllm
-        cuda-graph-max-bs-decode: 4
-        max-running-requests: 4
-        max-prefill-tokens: 16384
-        chunked-prefill-size: 16384
-        mem-fraction-static: 0.8
-        stream-interval: 50
-        scheduler-recv-interval: 10
-        tokenizer-worker-num: 6
-        tokenizer-path: nvidia/Qwen3.5-397B-A17B-NVFP4-V2
-        speculative-algorithm: EAGLE
-        speculative-num-steps: 3
-        speculative-eagle-topk: 1
-        speculative-num-draft-tokens: 4
-        context-length: 9236
-        served-model-name: nvidia/Qwen3.5-397B-A17B-NVFP4-V2
-        enable-metrics: false
-      env:
-        SGLANG_ENABLE_SPEC_V2: '1'
-        PYTHONNOUSERSITE: '1'
-zip_override_tp4_ep1:
-  benchmark:
-    env:
-      CONC: ['4']
-zip_override_tp2_ep1:
-  roles:
-    agg:
-      gpus: 2
-      args:
-        cuda-graph-max-bs-decode: [4, 8, 16, 32, 64]
-        max-running-requests: [4, 8, 16, 32, 64]
-        scheduler-recv-interval: [10, 30, 30, 30, 30]
-        tensor-parallel-size: 2
-  benchmark:
-    env:
-      CONC: ['4', '8', '16', '32', '64']
-zip_override_tp2_ep2:
-  roles:
-    agg:
-      gpus: 2
-      args:
-        cuda-graph-max-bs-decode: [16, 32, 64]
-        expert-parallel-size: 2
-        linear-attn-backend: triton
-        linear-attn-decode-backend: flashinfer
-        linear-attn-prefill-backend: flashinfer
-        max-running-requests: [16, 32, 64]
-        scheduler-recv-interval: 30
-        tensor-parallel-size: 2
-  benchmark:
-    env:
-      CONC: ['16', '32', '64']
diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/b200-fp4/8k1k.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/b200-fp4/8k1k.yaml
deleted file mode 100644
index f6fa999b7b..0000000000
--- a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/b200-fp4/8k1k.yaml
+++ /dev/null
@@ -1,59 +0,0 @@
-base:
-  schema: 2
-  name: qwen3.5-fp4-b200-sglang-8k1k
-  resources:
-    gpu_type: b200
-    gpus_per_node: 8
-  frontend:
-    type: sglang
-    enable_multiple_frontends: false
-  observability:
-    enabled: false
-    tachometer:
-      enabled: false
-  engine: sglang
-  roles:
-    agg:
-      nodes: 1
-      workers: 1
-      gpus: 4
-      args:
-        trust-remote-code: true
-        tensor-parallel-size: 4
-        data-parallel-size: 1
-        expert-parallel-size: 1
-        enable-symm-mem: true
-        disable-radix-cache: true
-        quantization: modelopt_fp4
-        kv-cache-dtype: fp8_e4m3
-        mamba-ssm-dtype: bfloat16
-        attention-backend: trtllm_mha
-        moe-runner-backend: flashinfer_trtllm
-        cuda-graph-max-bs-decode: 4
-        max-prefill-tokens: 16384
-        chunked-prefill-size: 16384
-        mem-fraction-static: 0.8
-        stream-interval: 50
-        scheduler-recv-interval: 10
-        tokenizer-worker-num: 6
-        tokenizer-path: nvidia/Qwen3.5-397B-A17B-NVFP4-V2
-        context-length: 9236
-        served-model-name: nvidia/Qwen3.5-397B-A17B-NVFP4-V2
-        enable-metrics: false
-      env:
-        PYTHONNOUSERSITE: '1'
-zip_override_tp4_ep1:
-  benchmark:
-    env:
-      CONC: ['4']
-zip_override_tp2_ep1:
-  roles:
-    agg:
-      gpus: 2
-      args:
-        cuda-graph-max-bs-decode: [4, 8, 16, 32, 64, 128]
-        scheduler-recv-interval: [10, 30, 30, 30, 30, 30]
-        tensor-parallel-size: 2
-  benchmark:
-    env:
-      CONC: ['4', '8', '16', '32', '64', '128']
diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/b200-fp8-mtp/8k1k.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/b200-fp8-mtp/8k1k.yaml
deleted file mode 100644
index d9305f18fe..0000000000
--- a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/b200-fp8-mtp/8k1k.yaml
+++ /dev/null
@@ -1,68 +0,0 @@
-base:
-  schema: 2
-  name: qwen3.5-fp8-b200-sglang-mtp-8k1k
-  resources:
-    gpu_type: b200
-    gpus_per_node: 8
-  frontend:
-    type: sglang
-    enable_multiple_frontends: false
-  observability:
-    enabled: false
-    tachometer:
-      enabled: false
-  engine: sglang
-  roles:
-    agg:
-      nodes: 1
-      workers: 1
-      gpus: 8
-      args:
-        trust-remote-code: true
-        tensor-parallel-size: 8
-        data-parallel-size: 1
-        expert-parallel-size: 1
-        enable-symm-mem: true
-        disable-radix-cache: true
-        quantization: fp8
-        kv-cache-dtype: fp8_e4m3
-        mamba-ssm-dtype: bfloat16
-        attention-backend: trtllm_mha
-        moe-runner-backend: flashinfer_trtllm
-        cuda-graph-max-bs-decode: 4
-        max-running-requests: 4
-        max-prefill-tokens: 32768
-        chunked-prefill-size: 32768
-        mamba-full-memory-ratio: 0.37
-        linear-attn-prefill-backend: flashinfer
-        mem-fraction-static: 0.8
-        stream-interval: 50
-        scheduler-recv-interval: 10
-        tokenizer-worker-num: 6
-        tokenizer-path: Qwen/Qwen3.5-397B-A17B-FP8
-        speculative-algorithm: EAGLE
-        speculative-num-steps: 3
-        speculative-eagle-topk: 1
-        speculative-num-draft-tokens: 4
-        context-length: 9236
-        served-model-name: Qwen/Qwen3.5-397B-A17B-FP8
-        enable-metrics: false
-      env:
-        SGLANG_ENABLE_SPEC_V2: '1'
-        PYTHONNOUSERSITE: '1'
-zip_override_tp8_ep1:
-  benchmark:
-    env:
-      CONC: ['4']
-zip_override_tp4_ep1:
-  roles:
-    agg:
-      gpus: 4
-      args:
-        cuda-graph-max-bs-decode: [4, 8, 16, 32, 64, 128, 256]
-        max-running-requests: [4, 8, 16, 32, 64, 128, 256]
-        scheduler-recv-interval: [10, 30, 30, 30, 30, 30, 30]
-        tensor-parallel-size: 4
-  benchmark:
-    env:
-      CONC: ['4', '8', '16', '32', '64', '128', '256']
diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/b200-fp8/8k1k.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/b200-fp8/8k1k.yaml
deleted file mode 100644
index 3df962d073..0000000000
--- a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/b200-fp8/8k1k.yaml
+++ /dev/null
@@ -1,64 +0,0 @@
-base:
-  schema: 2
-  name: qwen3.5-fp8-b200-sglang-8k1k
-  resources:
-    gpu_type: b200
-    gpus_per_node: 8
-  frontend:
-    type: sglang
-    enable_multiple_frontends: false
-  observability:
-    enabled: false
-    tachometer:
-      enabled: false
-  engine: sglang
-  roles:
-    agg:
-      nodes: 1
-      workers: 1
-      gpus: 8
-      args:
-        trust-remote-code: true
-        tensor-parallel-size: 8
-        data-parallel-size: 1
-        expert-parallel-size: 1
-        enable-symm-mem: true
-        disable-radix-cache: true
-        quantization: fp8
-        kv-cache-dtype: fp8_e4m3
-        mamba-ssm-dtype: bfloat16
-        mamba-full-memory-ratio: 0.37
-        linear-attn-prefill-backend: flashinfer
-        attention-backend: trtllm_mha
-        moe-runner-backend: flashinfer_trtllm
-        cuda-graph-max-bs-decode: 1
-        max-prefill-tokens: 32768
-        chunked-prefill-size: 32768
-        mem-fraction-static: 0.86
-        stream-interval: 50
-        scheduler-recv-interval: 10
-        tokenizer-worker-num: 6
-        context-length: 9236
-        served-model-name: Qwen/Qwen3.5-397B-A17B-FP8
-        enable-metrics: false
-      env:
-        PYTHONNOUSERSITE: '1'
-zip_override_tp8_ep1:
-  roles:
-    agg:
-      args:
-        cuda-graph-max-bs-decode: [1, 2, 4]
-  benchmark:
-    env:
-      CONC: ['1', '2', '4']
-zip_override_tp4_ep1:
-  roles:
-    agg:
-      gpus: 4
-      args:
-        cuda-graph-max-bs-decode: [2, 4, 8, 16, 32, 64, 128, 256, 512, 320, 384, 448, 640]
-        scheduler-recv-interval: [10, 10, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30]
-        tensor-parallel-size: 4
-  benchmark:
-    env:
-      CONC: ['2', '4', '8', '16', '32', '64', '128', '256', '512', '320', '384', '448', '640']
diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/b300-fp4-mtp/8k1k.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/b300-fp4-mtp/8k1k.yaml
deleted file mode 100644
index 51e93b86b6..0000000000
--- a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/b300-fp4-mtp/8k1k.yaml
+++ /dev/null
@@ -1,77 +0,0 @@
-base:
-  schema: 2
-  name: qwen3.5-fp4-b300-sglang-mtp-8k1k
-  resources:
-    gpu_type: b300
-    gpus_per_node: 8
-  frontend:
-    type: sglang
-    enable_multiple_frontends: false
-  observability:
-    enabled: false
-    tachometer:
-      enabled: false
-  engine: sglang
-  roles:
-    agg:
-      nodes: 1
-      workers: 1
-      gpus: 4
-      args:
-        served-model-name: nvidia/Qwen3.5-397B-A17B-NVFP4-V2
-        trust-remote-code: true
-        tensor-parallel-size: 4
-        data-parallel-size: 1
-        expert-parallel-size: 1
-        reasoning-parser: qwen3
-        tool-call-parser: qwen3_coder
-        mamba-radix-cache-strategy: no_buffer
-        quantization: modelopt_fp4
-        fp4-gemm-backend: flashinfer_cutlass
-        kv-cache-dtype: fp8_e4m3
-        mamba-ssm-dtype: bfloat16
-        cuda-graph-max-bs-decode: 4
-        max-running-requests: 128
-        mem-fraction-static: 0.8
-        chunked-prefill-size: 32768
-        max-prefill-tokens: 32768
-        context-length: 9236
-        disable-radix-cache: true
-        attention-backend: trtllm_mha
-        mm-attention-backend: triton_attn
-        moe-runner-backend: flashinfer_trtllm
-        scheduler-recv-interval: 10
-        tokenizer-worker-num: 6
-        stream-interval: 30
-        speculative-algorithm: EAGLE
-        speculative-num-steps: 3
-        speculative-eagle-topk: 1
-        speculative-num-draft-tokens: 4
-        enable-metrics: false
-      env:
-        NCCL_NVLS_ENABLE: '1'
-        SGL_ENABLE_JIT_DEEPGEMM: 'false'
-        SGLANG_ENABLE_FLASHINFER_GEMM: 'true'
-        PYTHONUNBUFFERED: '1'
-        PYTHONNOUSERSITE: '1'
-zip_override_tp4_ep1:
-  roles:
-    agg:
-      args:
-        cuda-graph-max-bs-decode: [4, 8, 16, 32, 64, 128]
-        scheduler-recv-interval: [10, 10, 30, 30, 30, 30]
-  benchmark:
-    env:
-      CONC: ['4', '8', '16', '32', '64', '128']
-zip_override_tp2_ep2:
-  roles:
-    agg:
-      gpus: 2
-      args:
-        cuda-graph-max-bs-decode: [4, 8, 16, 32, 64, 128]
-        expert-parallel-size: 2
-        scheduler-recv-interval: [10, 10, 30, 30, 30, 30]
-        tensor-parallel-size: 2
-  benchmark:
-    env:
-      CONC: ['4', '8', '16', '32', '64', '128']
diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/b300-fp4/8k1k.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/b300-fp4/8k1k.yaml
deleted file mode 100644
index 740f93fea9..0000000000
--- a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/b300-fp4/8k1k.yaml
+++ /dev/null
@@ -1,73 +0,0 @@
-base:
-  schema: 2
-  name: qwen3.5-fp4-b300-sglang-8k1k
-  resources:
-    gpu_type: b300
-    gpus_per_node: 8
-  frontend:
-    type: sglang
-    enable_multiple_frontends: false
-  observability:
-    enabled: false
-    tachometer:
-      enabled: false
-  engine: sglang
-  roles:
-    agg:
-      nodes: 1
-      workers: 1
-      gpus: 4
-      args:
-        served-model-name: nvidia/Qwen3.5-397B-A17B-NVFP4-V2
-        trust-remote-code: true
-        tensor-parallel-size: 4
-        data-parallel-size: 1
-        expert-parallel-size: 1
-        reasoning-parser: qwen3
-        tool-call-parser: qwen3_coder
-        mamba-scheduler-strategy: no_buffer
-        quantization: modelopt_fp4
-        fp4-gemm-backend: flashinfer_cutlass
-        kv-cache-dtype: fp8_e4m3
-        mamba-ssm-dtype: bfloat16
-        cuda-graph-max-bs: 4
-        max-running-requests: 128
-        mem-fraction-static: 0.8
-        chunked-prefill-size: 32768
-        max-prefill-tokens: 32768
-        context-length: 9236
-        disable-radix-cache: true
-        attention-backend: trtllm_mha
-        mm-attention-backend: triton_attn
-        moe-runner-backend: flashinfer_trtllm
-        scheduler-recv-interval: 10
-        tokenizer-worker-num: 6
-        stream-interval: 30
-        enable-metrics: false
-      env:
-        NCCL_NVLS_ENABLE: '1'
-        SGL_ENABLE_JIT_DEEPGEMM: 'false'
-        SGLANG_ENABLE_FLASHINFER_GEMM: 'true'
-        PYTHONUNBUFFERED: '1'
-        PYTHONNOUSERSITE: '1'
-zip_override_tp4_ep1:
-  roles:
-    agg:
-      args:
-        cuda-graph-max-bs: [4, 8, 16, 32, 64, 128]
-        scheduler-recv-interval: [10, 10, 30, 30, 30, 30]
-  benchmark:
-    env:
-      CONC: ['4', '8', '16', '32', '64', '128']
-zip_override_tp2_ep2:
-  roles:
-    agg:
-      gpus: 2
-      args:
-        cuda-graph-max-bs: [4, 8, 16, 32, 64, 128]
-        expert-parallel-size: 2
-        scheduler-recv-interval: [10, 10, 30, 30, 30, 30]
-        tensor-parallel-size: 2
-  benchmark:
-    env:
-      CONC: ['4', '8', '16', '32', '64', '128']
diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/b300-fp8-mtp/8k1k.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/b300-fp8-mtp/8k1k.yaml
deleted file mode 100644
index 3a80ae9808..0000000000
--- a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/b300-fp8-mtp/8k1k.yaml
+++ /dev/null
@@ -1,60 +0,0 @@
-base:
-  schema: 2
-  name: qwen3.5-fp8-b300-sglang-mtp-8k1k
-  resources:
-    gpu_type: b300
-    gpus_per_node: 8
-  frontend:
-    type: sglang
-    enable_multiple_frontends: false
-  observability:
-    enabled: false
-    tachometer:
-      enabled: false
-  engine: sglang
-  roles:
-    agg:
-      nodes: 1
-      workers: 1
-      gpus: 4
-      args:
-        served-model-name: Qwen/Qwen3.5-397B-A17B-FP8
-        trust-remote-code: true
-        tensor-parallel-size: 4
-        data-parallel-size: 1
-        expert-parallel-size: 1
-        enable-symm-mem: true
-        disable-radix-cache: true
-        quantization: fp8
-        kv-cache-dtype: fp8_e4m3
-        mamba-ssm-dtype: bfloat16
-        attention-backend: trtllm_mha
-        mm-attention-backend: triton_attn
-        moe-runner-backend: flashinfer_trtllm
-        cuda-graph-max-bs-decode: 4
-        max-running-requests: 4
-        max-prefill-tokens: 16384
-        chunked-prefill-size: 16384
-        mem-fraction-static: 0.8
-        stream-interval: 50
-        scheduler-recv-interval: 10
-        tokenizer-worker-num: 6
-        tokenizer-path: Qwen/Qwen3.5-397B-A17B-FP8
-        speculative-algorithm: EAGLE
-        speculative-num-steps: 3
-        speculative-eagle-topk: 1
-        speculative-num-draft-tokens: 4
-        context-length: 9236
-        enable-metrics: false
-      env:
-        SGLANG_ENABLE_SPEC_V2: '1'
-        PYTHONNOUSERSITE: '1'
-zip_override_concurrency:
-  roles:
-    agg:
-      args:
-        cuda-graph-max-bs-decode: [4, 8, 16, 32, 64, 128, 256]
-        max-running-requests: [4, 8, 16, 32, 64, 128, 256]
-  benchmark:
-    env:
-      CONC: ['4', '8', '16', '32', '64', '128', '256']
diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/b300-fp8/8k1k.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/b300-fp8/8k1k.yaml
deleted file mode 100644
index 15951f8058..0000000000
--- a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/b300-fp8/8k1k.yaml
+++ /dev/null
@@ -1,55 +0,0 @@
-base:
-  schema: 2
-  name: qwen3.5-fp8-b300-sglang-8k1k
-  resources:
-    gpu_type: b300
-    gpus_per_node: 8
-  frontend:
-    type: sglang
-    enable_multiple_frontends: false
-  observability:
-    enabled: false
-    tachometer:
-      enabled: false
-  engine: sglang
-  roles:
-    agg:
-      nodes: 1
-      workers: 1
-      gpus: 4
-      args:
-        served-model-name: Qwen/Qwen3.5-397B-A17B-FP8
-        trust-remote-code: true
-        tensor-parallel-size: 4
-        data-parallel-size: 1
-        expert-parallel-size: 1
-        enable-symm-mem: true
-        disable-radix-cache: true
-        quantization: fp8
-        kv-cache-dtype: fp8_e4m3
-        mamba-ssm-dtype: bfloat16
-        attention-backend: trtllm_mha
-        mm-attention-backend: triton_attn
-        moe-runner-backend: flashinfer_trtllm
-        cuda-graph-max-bs-decode: 4
-        max-running-requests: 4
-        max-prefill-tokens: 16384
-        chunked-prefill-size: 16384
-        mem-fraction-static: 0.8
-        stream-interval: 50
-        scheduler-recv-interval: 10
-        tokenizer-worker-num: 6
-        tokenizer-path: Qwen/Qwen3.5-397B-A17B-FP8
-        context-length: 9236
-        enable-metrics: false
-      env:
-        PYTHONNOUSERSITE: '1'
-zip_override_concurrency:
-  roles:
-    agg:
-      args:
-        cuda-graph-max-bs-decode: [4, 8, 16, 32, 64, 128, 256]
-        max-running-requests: [4, 8, 16, 32, 64, 128, 256]
-  benchmark:
-    env:
-      CONC: ['4', '8', '16', '32', '64', '128', '256']
diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/h100-fp8-mtp/8k1k.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/h100-fp8-mtp/8k1k.yaml
deleted file mode 100644
index 70702aee37..0000000000
--- a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/h100-fp8-mtp/8k1k.yaml
+++ /dev/null
@@ -1,56 +0,0 @@
-base:
-  schema: 2
-  name: qwen3.5-fp8-h100-sglang-mtp-8k1k
-  resources:
-    gpu_type: h100
-    gpus_per_node: 8
-  frontend:
-    type: sglang
-    enable_multiple_frontends: false
-  observability:
-    enabled: false
-    tachometer:
-      enabled: false
-  engine: sglang
-  roles:
-    agg:
-      nodes: 1
-      workers: 1
-      gpus: 8
-      args:
-        tensor-parallel-size: 8
-        expert-parallel-size: 8
-        reasoning-parser: qwen3
-        tool-call-parser: qwen3_coder
-        enable-flashinfer-allreduce-fusion: true
-        max-running-requests: 64
-        chunked-prefill-size: 8192
-        decode-log-interval: 1
-        mem-fraction-static: 0.75
-        cuda-graph-max-bs-decode: 4
-        context-length: 9236
-        kv-cache-dtype: fp8_e4m3
-        quantization: fp8
-        attention-backend: flashinfer
-        stream-interval: 50
-        tokenizer-worker-num: 6
-        mamba-ssm-dtype: bfloat16
-        disable-radix-cache: true
-        trust-remote-code: true
-        speculative-algorithm: EAGLE
-        speculative-num-steps: 3
-        speculative-eagle-topk: 1
-        speculative-num-draft-tokens: 4
-        data-parallel-size: 1
-        served-model-name: Qwen/Qwen3.5-397B-A17B-FP8
-        enable-metrics: false
-      env:
-        SGLANG_ENABLE_SPEC_V2: '1'
-zip_override_concurrency:
-  roles:
-    agg:
-      args:
-        cuda-graph-max-bs-decode: [4, 8, 16, 32]
-  benchmark:
-    env:
-      CONC: ['4', '8', '16', '32']
diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/h100-fp8/8k1k.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/h100-fp8/8k1k.yaml
deleted file mode 100644
index e2e59ef8c7..0000000000
--- a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/h100-fp8/8k1k.yaml
+++ /dev/null
@@ -1,63 +0,0 @@
-base:
-  schema: 2
-  name: qwen3.5-fp8-h100-sglang-8k1k
-  resources:
-    gpu_type: h100
-    gpus_per_node: 8
-  frontend:
-    type: sglang
-    enable_multiple_frontends: false
-  observability:
-    enabled: false
-    tachometer:
-      enabled: false
-  engine: sglang
-  roles:
-    agg:
-      nodes: 1
-      workers: 1
-      gpus: 8
-      args:
-        tensor-parallel-size: 8
-        reasoning-parser: qwen3
-        tool-call-parser: qwen3_coder
-        enable-flashinfer-allreduce-fusion: true
-        max-running-requests: 256
-        chunked-prefill-size: 16384
-        decode-log-interval: 1
-        mem-fraction-static: 0.8
-        cuda-graph-max-bs: 1
-        context-length: 9236
-        kv-cache-dtype: fp8_e4m3
-        quantization: fp8
-        attention-backend: flashinfer
-        stream-interval: 50
-        tokenizer-worker-num: 6
-        mamba-ssm-dtype: bfloat16
-        disable-radix-cache: true
-        enable-symm-mem: true
-        trust-remote-code: true
-        scheduler-recv-interval: 2
-        data-parallel-size: 1
-        expert-parallel-size: 1
-        served-model-name: Qwen/Qwen3.5-397B-A17B-FP8
-        enable-metrics: false
-zip_override_tp8_ep1:
-  roles:
-    agg:
-      args:
-        cuda-graph-max-bs: [1, 2, 4, 8]
-        scheduler-recv-interval: [2, 2, 2, 60]
-  benchmark:
-    env:
-      CONC: ['1', '2', '4', '8']
-zip_override_tp8_ep8:
-  roles:
-    agg:
-      args:
-        cuda-graph-max-bs: [16, 32, 64, 128, 256]
-        expert-parallel-size: 8
-        scheduler-recv-interval: [30, 1200, 600, 1920, 1920]
-  benchmark:
-    env:
-      CONC: ['16', '32', '64', '128', '256']
diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/h200-fp8-mtp/8k1k.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/h200-fp8-mtp/8k1k.yaml
deleted file mode 100644
index 3f7e3c8dc1..0000000000
--- a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/h200-fp8-mtp/8k1k.yaml
+++ /dev/null
@@ -1,55 +0,0 @@
-base:
-  schema: 2
-  name: qwen3.5-fp8-h200-sglang-mtp-8k1k
-  resources:
-    gpu_type: h200
-    gpus_per_node: 8
-  frontend:
-    type: sglang
-    enable_multiple_frontends: false
-  observability:
-    enabled: false
-    tachometer:
-      enabled: false
-  engine: sglang
-  roles:
-    agg:
-      nodes: 1
-      workers: 1
-      gpus: 8
-      args:
-        tensor-parallel-size: 8
-        expert-parallel-size: 8
-        reasoning-parser: qwen3
-        tool-call-parser: qwen3_coder
-        enable-flashinfer-allreduce-fusion: true
-        max-running-requests: 128
-        chunked-prefill-size: 16384
-        mem-fraction-static: 0.8
-        cuda-graph-max-bs: 4
-        context-length: 9472
-        kv-cache-dtype: fp8_e4m3
-        quantization: fp8
-        attention-backend: flashinfer
-        stream-interval: 50
-        tokenizer-worker-num: 6
-        mamba-ssm-dtype: bfloat16
-        disable-radix-cache: true
-        trust-remote-code: true
-        speculative-algorithm: EAGLE
-        speculative-num-steps: 3
-        speculative-num-draft-tokens: 4
-        speculative-eagle-topk: 1
-        data-parallel-size: 1
-        served-model-name: Qwen/Qwen3.5-397B-A17B-FP8
-        enable-metrics: false
-      env:
-        SGLANG_ENABLE_SPEC_V2: '1'
-zip_override_concurrency:
-  roles:
-    agg:
-      args:
-        cuda-graph-max-bs: [4, 8, 16, 32, 64, 128]
-  benchmark:
-    env:
-      CONC: ['4', '8', '16', '32', '64', '128']
diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/h200-fp8/8k1k.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/h200-fp8/8k1k.yaml
deleted file mode 100644
index 5c8b24c9d0..0000000000
--- a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/h200-fp8/8k1k.yaml
+++ /dev/null
@@ -1,50 +0,0 @@
-base:
-  schema: 2
-  name: qwen3.5-fp8-h200-sglang-8k1k
-  resources:
-    gpu_type: h200
-    gpus_per_node: 8
-  frontend:
-    type: sglang
-    enable_multiple_frontends: false
-  observability:
-    enabled: false
-    tachometer:
-      enabled: false
-  engine: sglang
-  roles:
-    agg:
-      nodes: 1
-      workers: 1
-      gpus: 8
-      args:
-        tensor-parallel-size: 8
-        expert-parallel-size: 8
-        reasoning-parser: qwen3
-        tool-call-parser: qwen3_coder
-        enable-flashinfer-allreduce-fusion: true
-        max-running-requests: 128
-        chunked-prefill-size: 16384
-        decode-log-interval: 1
-        mem-fraction-static: 0.8
-        cuda-graph-max-bs: 4
-        context-length: 9236
-        kv-cache-dtype: fp8_e4m3
-        quantization: fp8
-        attention-backend: flashinfer
-        stream-interval: 50
-        tokenizer-worker-num: 6
-        mamba-ssm-dtype: bfloat16
-        disable-radix-cache: true
-        trust-remote-code: true
-        data-parallel-size: 1
-        served-model-name: Qwen/Qwen3.5-397B-A17B-FP8
-        enable-metrics: false
-zip_override_concurrency:
-  roles:
-    agg:
-      args:
-        cuda-graph-max-bs: [4, 8, 16, 32, 64]
-  benchmark:
-    env:
-      CONC: ['4', '8', '16', '32', '64']
diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/mi300x-fp8/8k1k.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/mi300x-fp8/8k1k.yaml
deleted file mode 100644
index e2684e2c88..0000000000
--- a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/mi300x-fp8/8k1k.yaml
+++ /dev/null
@@ -1,43 +0,0 @@
-base:
-  schema: 2
-  name: qwen3.5-fp8-mi300x-sglang-8k1k
-  resources:
-    gpu_type: mi300x
-    gpus_per_node: 8
-  frontend:
-    type: sglang
-    enable_multiple_frontends: false
-  observability:
-    enabled: false
-    tachometer:
-      enabled: false
-  engine: sglang
-  roles:
-    agg:
-      nodes: 1
-      workers: 1
-      gpus: 8
-      args:
-        attention-backend: aiter
-        tensor-parallel-size: 8
-        data-parallel-size: 1
-        trust-remote-code: true
-        tokenizer-worker-num: 6
-        enable-aiter-allreduce-fusion: true
-        cuda-graph-max-bs: 4
-        disable-radix-cache: true
-        max-prefill-tokens: 32768
-        scheduler-recv-interval: 30
-        mem-fraction-static: 0.75
-        context-length: 9236
-        expert-parallel-size: 1
-        served-model-name: Qwen/Qwen3.5-397B-A17B-FP8
-        enable-metrics: false
-zip_override_concurrency:
-  roles:
-    agg:
-      args:
-        cuda-graph-max-bs: [4, 8, 16, 32, 64]
-  benchmark:
-    env:
-      CONC: ['4', '8', '16', '32', '64']
diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/mi325x-fp8-mtp/8k1k.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/mi325x-fp8-mtp/8k1k.yaml
deleted file mode 100644
index 7a8f7294b1..0000000000
--- a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/mi325x-fp8-mtp/8k1k.yaml
+++ /dev/null
@@ -1,47 +0,0 @@
-base:
-  schema: 2
-  name: qwen3.5-fp8-mi325x-sglang-mtp-8k1k
-  resources:
-    gpu_type: mi325x
-    gpus_per_node: 8
-  frontend:
-    type: sglang
-    enable_multiple_frontends: false
-  observability:
-    enabled: false
-    tachometer:
-      enabled: false
-  engine: sglang
-  roles:
-    agg:
-      nodes: 1
-      workers: 1
-      gpus: 8
-      args:
-        attention-backend: aiter
-        tensor-parallel-size: 8
-        expert-parallel-size: 1
-        trust-remote-code: true
-        tokenizer-worker-num: 6
-        enable-aiter-allreduce-fusion: true
-        cuda-graph-max-bs: 4
-        disable-radix-cache: true
-        max-prefill-tokens: 32768
-        scheduler-recv-interval: 30
-        speculative-algorithm: EAGLE
-        speculative-num-steps: 3
-        speculative-eagle-topk: 1
-        speculative-num-draft-tokens: 4
-        mem-fraction-static: 0.75
-        context-length: 9236
-        data-parallel-size: 1
-        served-model-name: Qwen/Qwen3.5-397B-A17B-FP8
-        enable-metrics: false
-zip_override_concurrency:
-  roles:
-    agg:
-      args:
-        cuda-graph-max-bs: [4, 8, 16, 32, 64]
-  benchmark:
-    env:
-      CONC: ['4', '8', '16', '32', '64']
diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/mi325x-fp8/8k1k.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/mi325x-fp8/8k1k.yaml
deleted file mode 100644
index f37f51e582..0000000000
--- a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/mi325x-fp8/8k1k.yaml
+++ /dev/null
@@ -1,43 +0,0 @@
-base:
-  schema: 2
-  name: qwen3.5-fp8-mi325x-sglang-8k1k
-  resources:
-    gpu_type: mi325x
-    gpus_per_node: 8
-  frontend:
-    type: sglang
-    enable_multiple_frontends: false
-  observability:
-    enabled: false
-    tachometer:
-      enabled: false
-  engine: sglang
-  roles:
-    agg:
-      nodes: 1
-      workers: 1
-      gpus: 8
-      args:
-        attention-backend: aiter
-        tensor-parallel-size: 8
-        data-parallel-size: 1
-        trust-remote-code: true
-        tokenizer-worker-num: 6
-        enable-aiter-allreduce-fusion: true
-        cuda-graph-max-bs-decode: 4
-        disable-radix-cache: true
-        max-prefill-tokens: 32768
-        scheduler-recv-interval: 30
-        mem-fraction-static: 0.75
-        context-length: 9236
-        expert-parallel-size: 1
-        served-model-name: Qwen/Qwen3.5-397B-A17B-FP8
-        enable-metrics: false
-zip_override_concurrency:
-  roles:
-    agg:
-      args:
-        cuda-graph-max-bs-decode: [4, 8, 16, 32, 64]
-  benchmark:
-    env:
-      CONC: ['4', '8', '16', '32', '64']
diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/mi355x-fp4-mtp/8k1k.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/mi355x-fp4-mtp/8k1k.yaml
deleted file mode 100644
index b0d66cbc28..0000000000
--- a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/mi355x-fp4-mtp/8k1k.yaml
+++ /dev/null
@@ -1,62 +0,0 @@
-base:
-  schema: 2
-  name: qwen3.5-fp4-mi355x-sglang-mtp-8k1k
-  resources:
-    gpu_type: mi355x
-    gpus_per_node: 8
-  frontend:
-    type: sglang
-    enable_multiple_frontends: false
-  observability:
-    enabled: false
-    tachometer:
-      enabled: false
-  engine: sglang
-  roles:
-    agg:
-      nodes: 1
-      workers: 1
-      gpus: 2
-      args:
-        trust-remote-code: true
-        tensor-parallel-size: 2
-        attention-backend: aiter
-        mem-fraction-static: 0.8
-        model-loader-extra-config: '{"enable_multithread_load": true}'
-        watchdog-timeout: 1200
-        disable-radix-cache: true
-        max-running-requests: 4
-        page-size: 16
-        speculative-algorithm: EAGLE
-        speculative-num-steps: 3
-        speculative-eagle-topk: 1
-        speculative-num-draft-tokens: 4
-        kv-cache-dtype: fp8_e4m3
-        data-parallel-size: 1
-        expert-parallel-size: 1
-        served-model-name: amd/Qwen3.5-397B-A17B-MXFP4-AttnFP8-V2
-        enable-metrics: false
-      env:
-        SGLANG_USE_AITER: '1'
-        SGLANG_USE_AITER_UNIFIED_ATTN: '1'
-        AITER_FLYDSL_FORCE: '1'
-        SGLANG_MAMBA_SSM_DTYPE: bfloat16
-        ROCM_QUICK_REDUCE_QUANTIZATION: INT8
-zip_override_tp2_ep1:
-  roles:
-    agg:
-      args:
-        max-running-requests: [4, 8, 16, 32, 64, 128]
-  benchmark:
-    env:
-      CONC: ['4', '8', '16', '32', '64', '128']
-zip_override_tp4_ep1:
-  roles:
-    agg:
-      gpus: 4
-      args:
-        max-running-requests: [4, 8, 16]
-        tensor-parallel-size: 4
-  benchmark:
-    env:
-      CONC: ['4', '8', '16']
diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/mi355x-fp4/8k1k.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/mi355x-fp4/8k1k.yaml
deleted file mode 100644
index 84393ab02e..0000000000
--- a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/mi355x-fp4/8k1k.yaml
+++ /dev/null
@@ -1,58 +0,0 @@
-base:
-  schema: 2
-  name: qwen3.5-fp4-mi355x-sglang-8k1k
-  resources:
-    gpu_type: mi355x
-    gpus_per_node: 8
-  frontend:
-    type: sglang
-    enable_multiple_frontends: false
-  observability:
-    enabled: false
-    tachometer:
-      enabled: false
-  engine: sglang
-  roles:
-    agg:
-      nodes: 1
-      workers: 1
-      gpus: 2
-      args:
-        trust-remote-code: true
-        tensor-parallel-size: 2
-        attention-backend: aiter
-        mem-fraction-static: 0.8
-        model-loader-extra-config: '{"enable_multithread_load": true}'
-        watchdog-timeout: 1200
-        disable-radix-cache: true
-        max-running-requests: 4
-        page-size: 16
-        kv-cache-dtype: fp8_e4m3
-        data-parallel-size: 1
-        expert-parallel-size: 1
-        served-model-name: amd/Qwen3.5-397B-A17B-MXFP4-AttnFP8-V2
-        enable-metrics: false
-      env:
-        SGLANG_USE_AITER: '1'
-        SGLANG_USE_AITER_UNIFIED_ATTN: '1'
-        AITER_FLYDSL_FORCE: '1'
-        SGLANG_MAMBA_SSM_DTYPE: bfloat16
-        ROCM_QUICK_REDUCE_QUANTIZATION: INT8
-zip_override_tp2_ep1:
-  roles:
-    agg:
-      args:
-        max-running-requests: [4, 8, 16, 32, 64, 128, 256]
-  benchmark:
-    env:
-      CONC: ['4', '8', '16', '32', '64', '128', '256']
-zip_override_tp4_ep1:
-  roles:
-    agg:
-      gpus: 4
-      args:
-        max-running-requests: [4, 8, 16]
-        tensor-parallel-size: 4
-  benchmark:
-    env:
-      CONC: ['4', '8', '16']
diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/mi355x-fp8-mtp/8k1k.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/mi355x-fp8-mtp/8k1k.yaml
deleted file mode 100644
index d0f343a373..0000000000
--- a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/mi355x-fp8-mtp/8k1k.yaml
+++ /dev/null
@@ -1,54 +0,0 @@
-base:
-  schema: 2
-  name: qwen3.5-fp8-mi355x-sglang-mtp-8k1k
-  resources:
-    gpu_type: mi355x
-    gpus_per_node: 8
-  frontend:
-    type: sglang
-    enable_multiple_frontends: false
-  observability:
-    enabled: false
-    tachometer:
-      enabled: false
-  engine: sglang
-  roles:
-    agg:
-      nodes: 1
-      workers: 1
-      gpus: 4
-      args:
-        attention-backend: aiter
-        tensor-parallel-size: 4
-        expert-parallel-size: 1
-        trust-remote-code: true
-        tokenizer-worker-num: 6
-        enable-aiter-allreduce-fusion: true
-        max-running-requests: 4
-        cuda-graph-max-bs-decode: 4
-        disable-radix-cache: true
-        chunked-prefill-size: 32768
-        scheduler-recv-interval: 30
-        mem-fraction-static: 0.8
-        model-loader-extra-config: '{"enable_multithread_load": true}'
-        page-size: 16
-        speculative-algorithm: EAGLE
-        speculative-num-steps: 3
-        speculative-eagle-topk: 1
-        speculative-num-draft-tokens: 4
-        context-length: 9236
-        data-parallel-size: 1
-        served-model-name: Qwen/Qwen3.5-397B-A17B-FP8
-        enable-metrics: false
-      env:
-        SGLANG_USE_AITER_UNIFIED_ATTN: '1'
-        SGLANG_USE_AITER: '1'
-zip_override_concurrency:
-  roles:
-    agg:
-      args:
-        cuda-graph-max-bs-decode: [4, 8, 16, 32, 64, 128, 256]
-        max-running-requests: [4, 8, 16, 32, 64, 128, 256]
-  benchmark:
-    env:
-      CONC: ['4', '8', '16', '32', '64', '128', '256']
diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/mi355x-fp8/8k1k.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/mi355x-fp8/8k1k.yaml
deleted file mode 100644
index f578a6a9f0..0000000000
--- a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/sglang/mi355x-fp8/8k1k.yaml
+++ /dev/null
@@ -1,50 +0,0 @@
-base:
-  schema: 2
-  name: qwen3.5-fp8-mi355x-sglang-8k1k
-  resources:
-    gpu_type: mi355x
-    gpus_per_node: 8
-  frontend:
-    type: sglang
-    enable_multiple_frontends: false
-  observability:
-    enabled: false
-    tachometer:
-      enabled: false
-  engine: sglang
-  roles:
-    agg:
-      nodes: 1
-      workers: 1
-      gpus: 4
-      args:
-        attention-backend: aiter
-        tensor-parallel-size: 4
-        expert-parallel-size: 1
-        trust-remote-code: true
-        tokenizer-worker-num: 6
-        enable-aiter-allreduce-fusion: true
-        max-running-requests: 4
-        cuda-graph-max-bs-decode: 4
-        disable-radix-cache: true
-        chunked-prefill-size: 32768
-        scheduler-recv-interval: 30
-        mem-fraction-static: 0.8
-        model-loader-extra-config: '{"enable_multithread_load": true}'
-        page-size: 16
-        context-length: 9236
-        data-parallel-size: 1
-        served-model-name: Qwen/Qwen3.5-397B-A17B-FP8
-        enable-metrics: false
-      env:
-        SGLANG_USE_AITER_UNIFIED_ATTN: '1'
-        SGLANG_USE_AITER: '1'
-zip_override_concurrency:
-  roles:
-    agg:
-      args:
-        cuda-graph-max-bs-decode: [4, 8, 16, 32, 64, 128, 256]
-        max-running-requests: [4, 8, 16, 32, 64, 128, 256]
-  benchmark:
-    env:
-      CONC: ['4', '8', '16', '32', '64', '128', '256']
diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/trtllm/b200-fp4-mtp/8k1k.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/trtllm/b200-fp4-mtp/8k1k.yaml
deleted file mode 100644
index a0cc9a38e2..0000000000
--- a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/trtllm/b200-fp4-mtp/8k1k.yaml
+++ /dev/null
@@ -1,141 +0,0 @@
-base:
-  schema: 2
-  name: qwen3.5-fp4-b200-trt-mtp-8k1k
-  resources:
-    gpu_type: b200
-    gpus_per_node: 8
-  frontend:
-    type: trtllm_serve
-    enable_multiple_frontends: false
-  observability:
-    enabled: false
-    tachometer:
-      enabled: false
-  engine:
-    type: trtllm
-    served_model_name: nvidia/Qwen3.5-397B-A17B-NVFP4
-  roles:
-    agg:
-      nodes: 1
-      workers: 1
-      gpus: 2
-      args:
-        backend: pytorch
-        print_iter_log: true
-        enable_layerwise_nvtx_marker: false
-        disable_overlap_scheduler: false
-        enable_iter_perf_stats: true
-        enable_chunked_prefill: false
-        stream_interval: 20
-        num_postprocess_workers: 4
-        scheduler_config:
-          capacity_scheduler_policy: MAX_UTILIZATION
-          context_chunking_policy: FIRST_COME_FIRST_SERVED
-        kv_cache_config:
-          enable_block_reuse: false
-          dtype: fp8
-        cuda_graph_config:
-          enable_padding: true
-          batch_sizes: [1, 2, 4, 8, 16, 32, 64, 128]
-        moe_config:
-          use_low_precision_moe_combine: true
-        speculative_config:
-          decoding_type: MTP
-          num_nextn_predict_layers: 3
-        trust_remote_code: true
-        max_seq_len: 9472
-        max_num_tokens: 32768
-        pipeline_parallel_size: 1
-        return_perf_metrics: false
-      env:
-        TLLM_USE_FLASHINFER_GDN_PREFILL: '0'
-zip_override_tp2_ep1:
-  roles:
-    agg:
-      args:
-        kv_cache_config:
-          free_gpu_memory_fraction: 0.7
-        moe_config:
-          backend: TRTLLM
-        batch_wait_timeout_iters: 50
-        batch_wait_max_tokens_ratio: 0.45
-        max_batch_size: 4
-        tensor_parallel_size: 2
-        moe_expert_parallel_size: 1
-        enable_attention_dp: false
-  benchmark:
-    env:
-      CONC: ['4']
-zip_override_tp2_ep2:
-  roles:
-    agg:
-      args:
-        kv_cache_config:
-          free_gpu_memory_fraction: 0.6
-        moe_config:
-          backend: TRTLLM
-        batch_wait_timeout_iters: 50
-        batch_wait_max_tokens_ratio: 0.45
-        max_batch_size: [8, 16]
-        tensor_parallel_size: 2
-        moe_expert_parallel_size: 2
-        enable_attention_dp: false
-  benchmark:
-    env:
-      CONC: ['8', '16']
-zip_override_tp4_ep4:
-  roles:
-    agg:
-      args:
-        kv_cache_config:
-          free_gpu_memory_fraction: 0.75
-        moe_config:
-          backend: TRTLLM
-        batch_wait_timeout_iters: 50
-        batch_wait_max_tokens_ratio: 0.45
-        max_batch_size: 4
-        tensor_parallel_size: 4
-        moe_expert_parallel_size: 4
-        enable_attention_dp: false
-      gpus: 4
-  benchmark:
-    env:
-      CONC: ['4']
-zip_override_tp8_ep8:
-  roles:
-    agg:
-      args:
-        kv_cache_config:
-          free_gpu_memory_fraction: 0.8
-        moe_config:
-          backend: TRTLLM
-        batch_wait_timeout_iters: 50
-        batch_wait_max_tokens_ratio: 0.45
-        max_batch_size: 4
-        tensor_parallel_size: 8
-        moe_expert_parallel_size: 8
-        enable_attention_dp: false
-      gpus: 8
-  benchmark:
-    env:
-      CONC: ['4']
-zip_override_tp8_ep8_dpa:
-  roles:
-    agg:
-      args:
-        kv_cache_config:
-          free_gpu_memory_fraction: [0.9, 0.9, 0.8]
-        moe_config:
-          backend: CUTEDSL
-        enable_attention_dp: true
-        attention_dp_config:
-          enable_balance: true
-          batching_wait_iters: 10
-          timeout_iters: 500
-        max_batch_size: [16, 32, 128]
-        tensor_parallel_size: 8
-        moe_expert_parallel_size: 8
-      gpus: 8
-  benchmark:
-    env:
-      CONC: ['128', '256', '1024']
diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/trtllm/b200-fp4/8k1k.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/trtllm/b200-fp4/8k1k.yaml
deleted file mode 100644
index 127fc1abbb..0000000000
--- a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.5/trtllm/b200-fp4/8k1k.yaml
+++ /dev/null
@@ -1,156 +0,0 @@
-base:
-  schema: 2
-  name: qwen3.5-fp4-b200-trt-8k1k
-  resources:
-    gpu_type: b200
-    gpus_per_node: 8
-  frontend:
-    type: trtllm_serve
-    enable_multiple_frontends: false
-  observability:
-    enabled: false
-    tachometer:
-      enabled: false
-  engine:
-    type: trtllm
-    served_model_name: nvidia/Qwen3.5-397B-A17B-NVFP4
-  roles:
-    agg:
-      nodes: 1
-      workers: 1
-      gpus: 2
-      args:
-        backend: pytorch
-        print_iter_log: true
-        enable_layerwise_nvtx_marker: false
-        disable_overlap_scheduler: false
-        enable_iter_perf_stats: true
-        enable_chunked_prefill: false
-        stream_interval: 20
-        num_postprocess_workers: 4
-        scheduler_config:
-          capacity_scheduler_policy: MAX_UTILIZATION
-          context_chunking_policy: FIRST_COME_FIRST_SERVED
-        kv_cache_config:
-          free_gpu_memory_fraction: 0.9
-          enable_block_reuse: false
-          dtype: fp8
-        cuda_graph_config:
-          enable_padding: true
-        moe_config:
-          use_low_precision_moe_combine: true
-        trust_remote_code: true
-        max_seq_len: 9472
-        max_num_tokens: 32768
-        pipeline_parallel_size: 1
-        return_perf_metrics: false
-zip_override_tp2_ep1:
-  roles:
-    agg:
-      args:
-        enable_attention_dp: false
-        cuda_graph_config:
-          max_batch_size: 256
-        moe_config:
-          backend: TRTLLM
-        batch_wait_timeout_iters: 50
-        batch_wait_max_tokens_ratio: 0.45
-        max_batch_size: 256
-        tensor_parallel_size: 2
-        moe_expert_parallel_size: 1
-  benchmark:
-    env:
-      CONC: ['4', '16']
-zip_override_tp4_ep1:
-  roles:
-    agg:
-      args:
-        enable_attention_dp: false
-        cuda_graph_config:
-          max_batch_size: 512
-        moe_config:
-          backend: TRTLLM
-        batch_wait_timeout_iters: 50
-        batch_wait_max_tokens_ratio: 0.45
-        max_batch_size: 512
-        tensor_parallel_size: 4
-        moe_expert_parallel_size: 1
-      gpus: 4
-  benchmark:
-    env:
-      CONC: ['4']
-zip_override_tp2_ep2:
-  roles:
-    agg:
-      args:
-        enable_attention_dp: false
-        cuda_graph_config:
-          max_batch_size: [256, 32]
-        moe_config:
-          backend: TRTLLM
-        batch_wait_timeout_iters: 50
-        batch_wait_max_tokens_ratio: 0.45
-        max_batch_size: [256, 32]
-        tensor_parallel_size: 2
-        moe_expert_parallel_size: 2
-  benchmark:
-    env:
-      CONC: ['8', '32']
-zip_override_tp8_ep8:
-  roles:
-    agg:
-      args:
-        enable_attention_dp: false
-        cuda_graph_config:
-          max_batch_size: 512
-        moe_config:
-          backend: TRTLLM
-        batch_wait_timeout_iters: 50
-        batch_wait_max_tokens_ratio: 0.45
-        max_batch_size: 512
-        tensor_parallel_size: 8
-        moe_expert_parallel_size: 8
-      gpus: 8
-  benchmark:
-    env:
-      CONC: ['4']
-zip_override_tp4_ep4_dpa:
-  roles:
-    agg:
-      args:
-        enable_attention_dp: true
-        cuda_graph_config:
-          max_batch_size: 256
-        moe_config:
-          backend: CUTEDSL
-        attention_dp_config:
-          enable_balance: true
-          batching_wait_iters: 10
-          timeout_iters: 500
-        max_batch_size: 256
-        tensor_parallel_size: 4
-        moe_expert_parallel_size: 4
-      gpus: 4
-  benchmark:
-    env:
-      CONC: ['1024']
-zip_override_tp8_ep8_dpa:
-  roles:
-    agg:
-      args:
-        enable_attention_dp: true
-        cuda_graph_config:
-          max_batch_size: 128
-        moe_config:
-          backend: CUTEDSL
-        attention_dp_config:
-          enable_balance: true
-          batching_wait_iters: 10
-          timeout_iters: 500
-        max_batch_size: 128
-        tensor_parallel_size: 8
-        moe_expert_parallel_size: 8
-      gpus: 8
-  benchmark:
-    env:
-      CONC: ['256', '512', '1024']
diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.8next/sglang/b300-fp4-mtp/agentic.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.8next/sglang/b300-fp4-mtp/agentic.yaml
index 3c5032cbbb..39f872beb3 100644
--- a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.8next/sglang/b300-fp4-mtp/agentic.yaml
+++ b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.8next/sglang/b300-fp4-mtp/agentic.yaml
@@ -1,9 +1,18 @@
 base:
   schema: 2
   name: qwen3.8next-fp4-b300-sglang-agentic
+  identity:
+    model:
+      revision: fc694b54fb0174e0913e6adf86691ef85a4ead47
+    container: {}
   resources:
     gpu_type: b300
     gpus_per_node: 8
+  slurm:
+    time_limit: '6:00:00'
+  health_check:
+    max_attempts: 1440
+    interval_seconds: 5
   frontend:
     type: sglang
     enable_multiple_frontends: false
@@ -17,94 +26,207 @@ base:
       nodes: 1
       workers: 1
       gpus: 1
+      env:
+        PYTHONNOUSERSITE: '1'
+        PYTHONUNBUFFERED: '1'
+        NO_COLOR: '1'
+        # Outlast AIPerf's 300 s client connection pool.
+        SGLANG_TIMEOUT_KEEP_ALIVE: '1800'
+        # Explicitly disable the prohibited draft precision conversion path.
+        SGLANG_NVFP4_CKPT_FP8_NEXTN_MOE: '0'
+        # Samples verify tokens on the top-k support before temperature and top-p; same distribution.
+        SGLANG_Q35MF_EDGE_SPARSE_VERIFY_SAMPLING: '1'
       args:
-        served-model-name: RadixArk/Qwen3.8-Flash-Next-NVFP4
+        served-model-name: nvidia/Qwen3.8-Flash-Next-NVFP4
+        revision: fc694b54fb0174e0913e6adf86691ef85a4ead47
+        speculative-draft-model-revision: fc694b54fb0174e0913e6adf86691ef85a4ead47
         trust-remote-code: true
+        quantization: modelopt_mixed
+        context-length: 262144
         tensor-parallel-size: 1
+        pipeline-parallel-size: 1
         data-parallel-size: 1
         expert-parallel-size: 1
-        # Quantization is read from the checkpoint; the hybrid GDN
-        # linear-attention layers take their own backends.
+        attention-backend: trtllm_mha
         linear-attn-prefill-backend: flashinfer
         linear-attn-decode-backend: flashinfer
-        # SM100+ flashinfer linear-attn decode requires a bf16 SSM state.
+        linear-attn-verify-backend: triton
         mamba-ssm-dtype: bfloat16
+        mamba-radix-cache-strategy: extra_buffer_lazy
+        mamba-track-interval: 256
+        max-mamba-cache-size: 480
+        mem-fraction-static: 0.88
+        max-running-requests: 96
+        page-size: 64
+        chunked-prefill-size: 16384
+        max-prefill-tokens: 16384
+        moe-runner-backend: flashinfer_trtllm
+        moe-a2a-backend: none
+        disable-shared-experts-fusion: true
         speculative-algorithm: NEXTN
         speculative-num-steps: 3
         speculative-eagle-topk: 1
         speculative-num-draft-tokens: 4
-        reasoning-parser: auto
-        mem-fraction-static: 0.8
-        stream-interval: 50
-        scheduler-recv-interval: 10
-        tokenizer-path: RadixArk/Qwen3.8-Flash-Next-NVFP4
+        speculative-moe-runner-backend: flashinfer_trtllm
+        # The native connector injects model-specific golden AL for throughput;
+        # quality evaluations use real verification. No manual AL override.
+        enable-linear-replayssm-spec: true
+        cuda-graph-backend-prefill: breakable
+        cuda-graph-backend-decode: full
+        cuda-graph-max-bs-decode: 96
+        cuda-graph-bs-decode: [1, 2, 4, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 96]
+        kv-cache-dtype: bfloat16
+        speculative-draft-kv-cache-dtype: bfloat16
+        enable-hierarchical-cache: true
+        # One combined packed target/draft KV + Mamba host-pool budget: 298 of the
+        # 299 GB generated allowance, keeping 1 GB of page-alignment headroom.
+        hicache-size: 298
+        hicache-io-backend: kernel
+        hicache-mem-layout: page_first
+        hicache-write-policy: write_back
+        ple-offload-embedding: true
+        ple-offload-backend: pinned
         enable-metrics: true
         enable-cache-report: true
-      env:
-        TORCH_CUDA_ARCH_LIST: '10.0'
-        PYTHONNOUSERSITE: '1'
-        NCCL_NVLS_ENABLE: '1'
-        SGL_ENABLE_JIT_DEEPGEMM: 'false'
-        SGLANG_ENABLE_FLASHINFER_GEMM: 'true'
-        # Outlast AIPerf's 300 s client connection pool.
-        SGLANG_TIMEOUT_KEEP_ALIVE: '1800'
-  # The checkpoint loads from the shared HF cache on Lustre, which took over
-  # 30 minutes on a cold node.
-  health_check:
-    max_attempts: 1440
-    interval_seconds: 5
+        reasoning-parser: auto
+        tokenizer-worker-num: 1
+        scheduler-recv-interval: 1
+        decode-log-interval: 10
+        stream-interval: 20
+        watchdog-timeout: 1800
+        random-seed: 35
   benchmark:
     env:
       AIPERF_REQUIRED_SERVER_METRIC_PREFIX: 'sglang:'
+      # Native single-node binding verifies these against the generated point.
+      TOTAL_CPU_DRAM_GB: '299'
+      KV_OFFLOADING: dram
 
-# One variant per point: admission is 2x CONC and the graph batch is CONC. NEXTN
-# resets an unset admission limit to 48, so it stays explicit.
-override_c1:
+override_tp4_c1:
   roles:
     agg:
+      gpus: 4
       args:
+        <<: &gpu_only_args
+          # null drops the base setting, so SGLang's default applies.
+          enable-hierarchical-cache: null
+          hicache-size: null
+          hicache-io-backend: null
+          hicache-mem-layout: null
+          hicache-write-policy: null
+          mamba-radix-cache-strategy: null
+          mamba-track-interval: null
+          max-mamba-cache-size: null
+          # Dense small sizes: decode batches up to 16 pad by at most one request.
+          cuda-graph-bs-decode: [1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 96]
+          tokenizer-worker-num: 6
+        tensor-parallel-size: 4
+        expert-parallel-size: 4
+        flashinfer-allreduce-fusion-backend: trtllm
         max-running-requests: 2
-        cuda-graph-max-bs-decode: 1
   benchmark:
     env:
+      <<: &gpu_only_client
+        KV_OFFLOADING: none
+        TOTAL_CPU_DRAM_GB: '0'
       CONC: '1'
 
-override_c4:
+override_tp4_c2:
   roles:
     agg:
+      gpus: 4
       args:
-        max-running-requests: 8
-        cuda-graph-max-bs-decode: 4
+        <<: *gpu_only_args
+        tensor-parallel-size: 4
+        expert-parallel-size: 4
+        flashinfer-allreduce-fusion-backend: trtllm
+        max-running-requests: 4
   benchmark:
     env:
-      CONC: '4'
+      <<: *gpu_only_client
+      CONC: '2'
 
-override_c8:
-  roles:
+override_c2:
+  roles: &tp1_low_conc_roles
     agg:
-      args:
-        max-running-requests: 16
-        cuda-graph-max-bs-decode: 8
+      env:
+        # Graphs the speculative post-verify step (sampling, acceptance, Mamba commit); the rest are its fast paths.
+        SGLANG_ENABLE_EAGLE_POST_VERIFY_CUDA_GRAPH: '1'
+        SGLANG_Q35MF_MKH_N3B: '1'
+        SGLANG_Q35MF_MKH_N3C: '1'
+        SGLANG_Q35MF_BK_VEC_COPY: '1'
+        SGLANG_Q35MF_EDGE_SHM_SYNC: '1'
+        SGLANG_Q35MF_EDGE_PACKED_VERIFY_BCAST: '1'
+        SGLANG_OPT_CUDA_GRAPH_FILL_FAST_PATH: '1'
+      args: *gpu_only_args
   benchmark:
     env:
-      CONC: '8'
+      <<: *gpu_only_client
+      CONC: '2'
+
+override_c1:
+  roles: *tp1_low_conc_roles
+  benchmark:
+    env:
+      <<: *gpu_only_client
+      CONC: '1'
 
 override_c12:
   roles:
     agg:
-      args:
-        max-running-requests: 24
-        cuda-graph-max-bs-decode: 12
+      args: &gpu_fp8_kv_args
+        <<: *gpu_only_args
+        kv-cache-dtype: fp8_e4m3
+        speculative-draft-kv-cache-dtype: fp8_e4m3
+        # Context length: no decode-time Mamba checkpoints; the AgentX replay never re-sends model output.
+        mamba-track-interval: 262144
+        cuda-graph-bs-decode: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 96]
   benchmark:
     env:
+      <<: *gpu_only_client
       CONC: '12'
 
-override_c16:
+override_c24:
+  roles:
+    agg:
+      args:
+        <<: *gpu_fp8_kv_args
+        max-mamba-cache-size: 960
+        # Every size to 32, so decode batches at this concurrency never pad.
+        cuda-graph-bs-decode: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 40, 48, 56, 64, 72, 80, 88, 96]
+  benchmark:
+    env:
+      <<: *gpu_only_client
+      CONC: '24'
+
+override_c48:
+  roles:
+    agg:
+      args: &hicache_fp8_kv_args
+        kv-cache-dtype: fp8_e4m3
+        speculative-draft-kv-cache-dtype: fp8_e4m3
+        # Context length: no decode-time Mamba checkpoints; the AgentX replay never re-sends model output.
+        mamba-track-interval: 262144
+        max-mamba-cache-size: 720
+        cuda-graph-bs-decode: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 60, 64, 72, 80, 88, 96]
+  benchmark:
+    env:
+      CONC: '48'
+
+override_c80:
   roles:
     agg:
       args:
-        max-running-requests: 32
-        cuda-graph-max-bs-decode: 16
+        <<: *hicache_fp8_kv_args
+        max-mamba-cache-size: 640
+        max-running-requests: 128
+        cuda-graph-max-bs-decode: 128
+        # Every size to 80, so decode batches at this concurrency never pad.
+        cuda-graph-bs-decode: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 88, 92, 96, 100, 104, 108, 112, 116, 120, 124, 128]
+        # Cache only the prompt on finish; the AgentX replay never re-sends model output.
+        strip-thinking-cache: true
+        # At most two Mamba states per conversation path; stale interior states skip host write-back.
+        mamba-max-states-per-path: 2
   benchmark:
     env:
-      CONC: '16'
+      CONC: '80'
diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.8next/sglang/mi355x-fp4-mtp/agentic.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.8next/sglang/mi355x-fp4-mtp/agentic.yaml
index ac332a6345..d62b70a742 100644
--- a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.8next/sglang/mi355x-fp4-mtp/agentic.yaml
+++ b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/qwen3.8next/sglang/mi355x-fp4-mtp/agentic.yaml
@@ -43,7 +43,6 @@ base:
         scheduler-recv-interval: 10
         stream-interval: 50
         reasoning-parser: qwen3
-        default-chat-template-kwargs: '{"enable_thinking": false}'
         tool-call-parser: qwen3_coder
         speculative-algorithm: NEXTN
         speculative-num-steps: 3
@@ -67,18 +66,26 @@ base:
       AIPERF_REQUIRED_SERVER_METRIC_PREFIX: 'sglang:'
       AIPERF_APPLY_CHAT_TEMPLATE: 'true'
 
-# One variant per point. Every point keeps ReplaySSM, the PLE table offload and the
-# default path, admits 2x CONC requests and captures decode graphs up to that
-# admission, so bursts past CONC stay in a graph; mem-fraction-static is used as
-# given instead of the aiter backend's 0.85 scaling.
+# c1, c2, c4 and c8 run the FlyDSL monokernel (--enable-amd-monokernel) for MTP
+# target verify and draft. Its verify writes the per-draft intermediate SSM
+# states, so ReplaySSM is off, and its prelude reads the PLE table on the GPU,
+# so the table is not offloaded. Admission equals the concurrency. These points
+# also set SGLANG_USE_AITER, which the monokernel requires (the image sets it
+# too), so they form their own GSM8K eval group. c12 and c16 keep ReplaySSM,
+# the PLE offload and 2x CONC admission. Every point uses mem-fraction-static
+# as given instead of the aiter backend's 0.85 scaling.
 override_c1:
   roles:
     agg:
       args:
-        max-running-requests: 2
-        cuda-graph-max-bs-decode: 2
+        enable-linear-replayssm-spec: null
+        ple-offload-embedding: null
+        enable-amd-monokernel: true
+        max-running-requests: 1
+        cuda-graph-max-bs-decode: 1
       env:
         SGLANG_AITER_HONOR_EXPLICIT_MEM_FRACTION: '1'
+        SGLANG_USE_AITER: '1'
   benchmark:
     env:
       CONC: '1'
@@ -88,10 +95,14 @@ override_c2:
   roles:
     agg:
       args:
-        max-running-requests: 4
-        cuda-graph-max-bs-decode: 4
+        enable-linear-replayssm-spec: null
+        ple-offload-embedding: null
+        enable-amd-monokernel: true
+        max-running-requests: 2
+        cuda-graph-max-bs-decode: 2
       env:
         SGLANG_AITER_HONOR_EXPLICIT_MEM_FRACTION: '1'
+        SGLANG_USE_AITER: '1'
   benchmark:
     env:
       CONC: '2'
@@ -101,10 +112,14 @@ override_c4:
   roles:
     agg:
       args:
-        max-running-requests: 8
-        cuda-graph-max-bs-decode: 8
+        enable-linear-replayssm-spec: null
+        ple-offload-embedding: null
+        enable-amd-monokernel: true
+        max-running-requests: 4
+        cuda-graph-max-bs-decode: 4
       env:
         SGLANG_AITER_HONOR_EXPLICIT_MEM_FRACTION: '1'
+        SGLANG_USE_AITER: '1'
   benchmark:
     env:
       CONC: '4'
@@ -114,10 +129,14 @@ override_c8:
   roles:
     agg:
       args:
-        max-running-requests: 16
-        cuda-graph-max-bs-decode: 16
+        enable-linear-replayssm-spec: null
+        ple-offload-embedding: null
+        enable-amd-monokernel: true
+        max-running-requests: 8
+        cuda-graph-max-bs-decode: 8
       env:
         SGLANG_AITER_HONOR_EXPLICIT_MEM_FRACTION: '1'
+        SGLANG_USE_AITER: '1'
   benchmark:
     env:
       CONC: '8'
diff --git a/inferencex-e2e/benchmarks/single_node/srt_eval.sh b/inferencex-e2e/benchmarks/single_node/srt_eval.sh
index 8e61a3798d..e0bb5cbd11 100644
--- a/inferencex-e2e/benchmarks/single_node/srt_eval.sh
+++ b/inferencex-e2e/benchmarks/single_node/srt_eval.sh
@@ -10,6 +10,11 @@ fi
 SRT_EVAL_STATUS_FILE="$2"
 trap 'rc=$?; printf "%s\n" "$rc" > "$SRT_EVAL_STATUS_FILE"' EXIT
 
+# An agentic eval's acceptance gate ran as this job's benchmark stage, which srt-slurm runs only
+# without EVAL_ONLY; the eval itself is still eval-only.
+if [[ "${EVAL_AL_GATE:-}" == true ]]; then
+    export EVAL_ONLY=true RUN_EVAL=false
+fi
 root="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
 source "$root/benchmarks/check_env.sh"
 check_env_vars MODEL MODEL_NAME CONC TP EP_SIZE DP_ATTENTION IS_MULTINODE IS_AGENTIC
diff --git a/inferencex-e2e/benchmarks/srt_al_gate.sh b/inferencex-e2e/benchmarks/srt_al_gate.sh
new file mode 100644
index 0000000000..5d43761b98
--- /dev/null
+++ b/inferencex-e2e/benchmarks/srt_al_gate.sh
@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+# srt-slurm benchmark stage of an agentic eval job: the report-only SPEED-Bench acceptance gate.
+# srt-slurm runs the post-benchmark eval only after a zero exit, so a failed gate exits 0;
+# its result document records the error. The eval shares this job's time limit, so the gate
+# is capped: timeout signals its whole process group, AIPerf included, and the gate records
+# the stop as an error.
+root="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)" || exit 0
+export AL_GATE_TIMEOUT_S="${AL_GATE_TIMEOUT_S:-1800}"
+timeout --kill-after=60 "$AL_GATE_TIMEOUT_S" \
+    env PYTHONSAFEPATH=1 PYTHONDONTWRITEBYTECODE=1 PYTHONPATH="$root${PYTHONPATH:+:$PYTHONPATH}" \
+    python3 -m infx.bench al-gate "$@" || echo "AL gate exited $? (report-only)" >&2
+exit 0
diff --git a/inferencex-e2e/configs/CONFIGS.md b/inferencex-e2e/configs/CONFIGS.md
index c329222f93..6d0963d56f 100644
--- a/inferencex-e2e/configs/CONFIGS.md
+++ b/inferencex-e2e/configs/CONFIGS.md
@@ -104,7 +104,7 @@ The below list describes what each field is:
     - `osl`: An integer representing the output sequence length, e.g., `1024`
     - PR sweeps run only `isl`/`osl` pairs 1024/1024 and 8192/1024; the changelog planner rejects any other pair.
     - `search-space`: A list of configurations to run with respective `isl` and `osl`, each entry must be a dict with the following fields:
-      - `tp`: A positive integer representing the tensor parallelism level that the configuration will be served at.
+      - `tp`: A positive integer representing the benchmark's parallel width. In native single-node SRT recipes, its mapping depends on the engine: TokenSpeed and vLLM use attention TP/TP times data parallelism, while SGLang and TensorRT-LLM compare their TP fields directly. See [single-node parallelism validation](../benchmarks/multi_node/srt-slurm-recipes/RECIPES.md#single-node-parallelism-validation) for the full mapping and mismatch behavior.
       - `conc-start`: An integer representing the starting level of concurrency e.g., `4`
       - `conc-end`: An integer representing the ending level of concurrency (inclusive) e.g., `128`
       - Note: the step factor between `conc-start` and `conc-end` is 2, so if `conc-start` is 4 and `conc-end` is 128, all concurrencies `4, 8, 16, 32, ..., 128` will be run.
@@ -153,7 +153,8 @@ input.
 
 Notes:
 - The fields above are the common ones, not the full schema. The Pydantic models in [`infx/matrix/validation.py`](../infx/matrix/validation.py) are the authoritative contract; they also accept fields such as `spec-decoding`, `num-nodes`, `require-power` and `power`, and they reject any field they do not define, which fails matrix generation.
-- A multinode search-space entry with `power: true` measures DCGM power: its rows carry `power: true`, the launcher merges the shared telemetry block into the recipe and rejects lanes without a power rule.
+- Every multinode benchmark point on a cluster with a GPU exporter measures GPU power (DCGM where the cluster sets `srt-slurm.power-exporter-port`, its `default_gpu_exporter` elsewhere), and CPU power where the cluster declares a `cpu-power-exporter`, unless its recipe runs etcd and NATS on a dedicated node; it keeps its result when telemetry fails. A search-space entry with `power: true` makes failed telemetry or invalid AgentX power fail the point, and is rejected on a cluster without a GPU exporter.
+- A multinode entry with `cpu-power: true` beside `power: true` also measures CPU power: its rows carry `cpu-power: true` and the launcher binds the cluster's `cpu-power-exporter` record beside the GPU telemetry block. Native single-node points measure CPU power by default on a cluster that declares a `cpu-power-exporter`; a single-node fixed-sequence entry sets `cpu-power: true` alone to count a missing CPU leg as invalid.
 - srt-slurm entries require `srt-recipe-dir`. Every row requires `srt-recipe: <file>[:<selector>]` under it (selector: `base`, `override_<name>` or `zip_override_<name>[<i>]`). Multinode rows may add `eval-srt-recipe`. Validation rejects missing files or variants, and `CONFIG_FILE`/`EVAL_CONFIG_FILE` settings. Only `llmd-vllm` keeps `CONFIG_FILE`. Generated rows carry the path from `inferencex-e2e/`.
 - Setting the fields above only guarantees that their values are passed as environment variables to benchmark scripts. Single-node jobs receive `PP_SIZE`, `DCP_SIZE`, and `PCP_SIZE`. Multinode jobs receive `PREFILL_PP_SIZE`, `PREFILL_DCP_SIZE`, `PREFILL_PCP_SIZE`, `DECODE_PP_SIZE`, `DECODE_DCP_SIZE`, and `DECODE_PCP_SIZE`. Actually using those variables is an implementation detail of the benchmark Bash script.
 
@@ -265,7 +266,11 @@ schema; unknown keys fail.
   volumes every job mounts to container paths, `mounts` does the same for host
   paths outside the volumes (devices), `agentic-volume-mounts` adds world-writable
   volumes for multi-node AgentX jobs, `power-exporter-port` is the DCGM exporter port
-  of power points, `env` is the environment of the srt-slurm
+  of multi-node power points (without it they use `extra.default_gpu_exporter`), `cpu-power-exporter` (`source: acpi` or `rapl`) is the CPU power exporter native
+  single-node points and `cpu-power` rows bind beside it (`make setup` installs it from the pinned srt-slurm
+  release; a RAPL job's host setup gives the job user the RAPL counters until teardown, so `rapl`
+  needs `slurm.exclusive` and `single-node-exclusive`),
+  `env` is the environment of the srt-slurm
   launch, `container-aliases` and `nginx-aliases` name the recipe containers that
   resolve to the main image and to the staged nginx, and `outputs`,
   `shared-run-root` and `uv-cache-root` are the directories the srt-slurm launcher
@@ -281,13 +286,15 @@ schema; unknown keys fail.
   same way; they resolve when the record loads, and `env` still rejects the commas of a
   list.
 - `slurm.srt-slurm.extra.default_gpu_exporter` is the cluster's native power exporter.
-  Native single-node throughput and AgentX jobs inherit it when the bound recipe
-  enables telemetry without selecting its own exporter; eval-only jobs collect no power.
-  A cluster without the block stops preparation before the benchmark starts. An invalid
+  Native single-node throughput and AgentX jobs, and multi-node points on a cluster
+  without `power-exporter-port`, inherit it when the bound recipe enables telemetry
+  without selecting its own exporter; eval-only jobs collect no power. A single-node job
+  on a cluster without the block stops preparation before the benchmark starts; a
+  multi-node point measures no GPU power and keeps its result. An invalid
   measurement fails the job under `REQUIRE_POWER=1` and otherwise records an invalid
   verdict without energy metrics. NVIDIA clusters run `dcgm-exporter`; AMD clusters use
   srt-slurm's
-  [`kind: custom` schema](https://github.com/NVIDIA/srt-slurm/blob/59920ea16a13017a990e449d034a495c0b05bc57/docs/power-telemetry.md#gpu-exporter-labels-and-metrics),
+  [`kind: custom` schema](https://github.com/NVIDIA/srt-slurm/blob/acfb4dcc3bd48fd6a1e7b615e849e7954c0c3852/docs/power-telemetry.md#gpu-exporter-labels-and-metrics),
   which requires `gpu_labels` and `gpu_metrics` and rejects unknown keys such as the
   former `power_profile`. The AMD exporter reads
   [`runners/srt-slurm/exporters/amd-power.json`](../runners/srt-slurm/exporters/amd-power.json);
diff --git a/inferencex-e2e/configs/amd-master.yaml b/inferencex-e2e/configs/amd-master.yaml
index fbaaa07287..6adb2713a6 100644
--- a/inferencex-e2e/configs/amd-master.yaml
+++ b/inferencex-e2e/configs/amd-master.yaml
@@ -107,6 +107,7 @@ dsr1-fp8-mi300x-sglang:
         conc-start: 4
         conc-end: 64
         srt-recipe: 8k1k.yaml
+        cpu-power: true
 
 dsr1-fp8-mi325x-sglang:
   image: lmsysorg/sglang:v0.5.22-rocm720-mi30x@sha256:58b6bc333f527c88fe5ff1b4bd8d17e82214eabcb3044549117159878967c930
@@ -126,6 +127,7 @@ dsr1-fp8-mi325x-sglang:
         conc-start: 4
         conc-end: 64
         srt-recipe: 8k1k.yaml
+        cpu-power: true
 
 dsr1-fp8-mi355x-sglang:
   image: lmsysorg/sglang:v0.5.22-rocm720-mi35x@sha256:c4b61360b251d62bb17da63f175d571ab22479eb46a144548d79f3ed3998ea11
@@ -170,66 +172,7 @@ dsr1-fp8-mi355x-sglang-mtp:
         conc-end: 64
         spec-decoding: mtp
         srt-recipe: 8k1k.yaml
-
-qwen3.5-fp8-mi325x-sglang:
-  image: lmsysorg/sglang:v0.5.22-rocm720-mi30x@sha256:58b6bc333f527c88fe5ff1b4bd8d17e82214eabcb3044549117159878967c930
-  model: Qwen/Qwen3.5-397B-A17B-FP8
-  model-prefix: qwen3.5
-  runner: mi325x
-  precision: fp8
-  framework: sglang
-  multinode: false
-  srt-recipe-dir: qwen3.5/sglang/mi325x-fp8
-  scenarios:
-    fixed-seq-len:
-    - isl: 8192
-      osl: 1024
-      search-space:
-      - tp: 8
-        conc-start: 4
-        conc-end: 64
-        srt-recipe: 8k1k.yaml
-
-qwen3.5-fp8-mi355x-sglang:
-  image: lmsysorg/sglang-rocm:v0.5.20-rocm720-mi35x-20260924
-  model: Qwen/Qwen3.5-397B-A17B-FP8
-  model-prefix: qwen3.5
-  runner: mi355x
-  precision: fp8
-  framework: sglang
-  multinode: false
-  srt-recipe-dir: qwen3.5/sglang/mi355x-fp8
-  scenarios:
-    fixed-seq-len:
-    - isl: 8192
-      osl: 1024
-      search-space:
-      - tp: 4
-        ep: 1
-        conc-start: 4
-        conc-end: 256
-        srt-recipe: 8k1k.yaml
-
-qwen3.5-fp8-mi355x-sglang-mtp:
-  image: lmsysorg/sglang-rocm:v0.5.20-rocm720-mi35x-20260924
-  model: Qwen/Qwen3.5-397B-A17B-FP8
-  model-prefix: qwen3.5
-  runner: mi355x
-  precision: fp8
-  framework: sglang
-  multinode: false
-  srt-recipe-dir: qwen3.5/sglang/mi355x-fp8-mtp
-  scenarios:
-    fixed-seq-len:
-    - isl: 8192
-      osl: 1024
-      search-space:
-      - tp: 4
-        ep: 1
-        conc-start: 4
-        conc-end: 256
-        spec-decoding: mtp
-        srt-recipe: 8k1k.yaml
+        cpu-power: true
 
 # MI355X FP8 AgentX, TP4 only. The grid follows the TP4 band of the B200 FP8
 # AgentX arm so the two SKUs are directly comparable point for point, with the
@@ -276,63 +219,6 @@ qwen3.5-fp8-mi325x-sglang-agentic-mtp:
       - { tp: 8, ep: 1, spec-decoding: mtp, kv-offloading: none, conc-list: [1, 4, 8, 12, 16, 24, 32, 40, 48, 64, 80], srt-recipe: agentic.yaml }
       - { tp: 8, ep: 8, spec-decoding: mtp, kv-offloading: none, conc-list: [4, 16, 24, 32, 40, 48, 64], srt-recipe: agentic.yaml }
 
-qwen3.5-fp8-mi355x-atom:
-  image: rocm/atom-dev:nightly_202610190554@sha256:9765777e2f56c5c17fefc9e141b37c51f1ab2dea009b158bcf1823f10030cea3
-  model: Qwen/Qwen3.5-397B-A17B-FP8
-  model-prefix: qwen3.5
-  runner: mi355x
-  precision: fp8
-  framework: atom
-  multinode: false
-  srt-recipe-dir: qwen3.5/atom/mi355x-fp8
-  scenarios:
-    fixed-seq-len:
-    - isl: 8192
-      osl: 1024
-      search-space:
-      - tp: 2
-        ep: 1
-        conc-start: 4
-        conc-end: 256
-        srt-recipe: 8k1k.yaml
-      - tp: 4
-        ep: 1
-        conc-start: 4
-        conc-end: 256
-        srt-recipe: 8k1k.yaml
-      - tp: 8
-        ep: 1
-        conc-start: 4
-        conc-end: 256
-        srt-recipe: 8k1k.yaml
-
-qwen3.5-fp8-mi355x-atom-mtp:
-  image: rocm/atom-dev:nightly_202610080328@sha256:9c3070bb7d2600d2e1bcfd03cf5f71e4dc0941f3e1d20d3a5845056aae2334eb
-  model: Qwen/Qwen3.5-397B-A17B-FP8
-  model-prefix: qwen3.5
-  runner: mi355x
-  precision: fp8
-  framework: atom
-  multinode: false
-  srt-recipe-dir: qwen3.5/atom/mi355x-fp8-mtp
-  scenarios:
-    fixed-seq-len:
-    - isl: 8192
-      osl: 1024
-      search-space:
-      - tp: 4
-        ep: 1
-        conc-start: 4
-        conc-end: 256
-        spec-decoding: mtp
-        srt-recipe: 8k1k.yaml
-      - tp: 8
-        ep: 1
-        conc-start: 4
-        conc-end: 256
-        spec-decoding: mtp
-        srt-recipe: 8k1k.yaml
-
 # MI355X FP8 AgentX via ATOM with MTP (3 draft tokens), TP4 only, following the
 # standalone recipe (ROCm/ATOM PR 2592). CONC 1-40 serve off the GPU prefix
 # cache; CONC 48-80 add the LMCache DRAM tier at 363 GB per rank (253 GB KV +
@@ -353,121 +239,6 @@ qwen3.5-fp8-mi355x-atom-agentic-mtp:
       - { tp: 4, ep: 1, kv-offloading: none, conc-list: [1, 4, 8, 16, 24, 32, 40], spec-decoding: mtp, srt-recipe: agentic.yaml }
       - { tp: 4, ep: 1, kv-offloading: dram, kv-offload-backend: { name: lmcache, version: "0.5.6.dev139+gf22dec28" }, conc-list: [48, 56, 64, 80], spec-decoding: mtp, srt-recipe: agentic.yaml }
 
-qwen3.5-fp8-mi355x-sglang-disagg:
-  image: lmsysorg/sglang:v0.5.16-rocm720-mi35x
-  model: Qwen/Qwen3.5-397B-A17B-FP8
-  model-prefix: qwen3.5
-  runner: cluster:mi355x-amds
-  precision: fp8
-  framework: sglang-disagg
-  router: { name: sglang-router, version: "0.3.2" }
-  kv-p2p-transfer: mori
-  multinode: true
-  disagg: true
-  srt-recipe-dir: qwen3.5/sglang/mi355x-fp8/8k1k
-  scenarios:
-    fixed-seq-len:
-    - isl: 8192
-      osl: 1024
-      search-space:
-      # The srt-slurm recipe owns the complete c8-c128 sweep in one Slurm
-      # allocation so model initialization is paid once instead of per point.
-      # 1P+1D TP4P+TP8D/EP1 remains the current baseline: TP4 prefill saves
-      # four GPUs without changing the TP8 decode service.
-      # dp-attn intentionally false: with --enable-dp-attention +
-      # --moe-a2a-backend mori, sglang auto-promotes moe_ep_size=tp_size,
-      # but is_deepep_class_backend() excludes MoRI, so
-      # num_shared_slots stays at the global value (1) and the
-      # (num_experts - num_shared_slots) % moe_ep_size assertion in
-      # fused_moe_triton/layer.py fires for Qwen3.5 (512 routed + 1 shared).
-      - spec-decoding: "none"
-        conc-list: [8, 16, 32, 64, 128]
-        srt-recipe: disagg-1p1d-p-tp4-d-tp8.yaml
-        prefill:
-          num-worker: 1
-          tp: 4
-          ep: 1
-          dp-attn: false
-        decode:
-          num-worker: 1
-          tp: 8
-          ep: 1
-          dp-attn: false
-          additional-settings:
-          - "DECODE_NODES=1"
-          - "DECODE_MTP_SIZE=0"
-
-qwen3.5-fp4-mi355x-sglang:
-  image: lmsysorg/sglang-rocm:v0.5.20-rocm720-mi35x-20260927
-  model: amd/Qwen3.5-397B-A17B-MXFP4-AttnFP8-V2
-  model-prefix: qwen3.5
-  runner: mi355x
-  precision: fp4
-  framework: sglang
-  multinode: false
-  srt-recipe-dir: qwen3.5/sglang/mi355x-fp4
-  scenarios:
-    fixed-seq-len:
-    - isl: 8192
-      osl: 1024
-      search-space:
-      - tp: 2
-        conc-start: 4
-        conc-end: 256
-        srt-recipe: 8k1k.yaml
-      - tp: 4
-        conc-start: 4
-        conc-end: 16
-        srt-recipe: 8k1k.yaml
-
-qwen3.5-fp4-mi355x-atom:
-  image: rocm/atom-dev:nightly_202610080328
-  model: amd/Qwen3.5-397B-A17B-MXFP4
-  model-prefix: qwen3.5
-  runner: mi355x
-  precision: fp4
-  framework: atom
-  multinode: false
-  srt-recipe-dir: qwen3.5/atom/mi355x-fp4
-  scenarios:
-    fixed-seq-len:
-    - isl: 8192
-      osl: 1024
-      search-space:
-      - tp: 2
-        conc-start: 4
-        conc-end: 256
-        srt-recipe: 8k1k.yaml
-      - tp: 4
-        conc-start: 4
-        conc-end: 16
-        srt-recipe: 8k1k.yaml
-
-qwen3.5-fp4-mi355x-sglang-mtp:
-  image: lmsysorg/sglang-rocm:v0.5.20-rocm720-mi35x-20260927
-  model: amd/Qwen3.5-397B-A17B-MXFP4-AttnFP8-V2
-  model-prefix: qwen3.5
-  runner: mi355x
-  precision: fp4
-  framework: sglang
-  multinode: false
-  srt-recipe-dir: qwen3.5/sglang/mi355x-fp4-mtp
-  scenarios:
-    fixed-seq-len:
-    - isl: 8192
-      osl: 1024
-      search-space:
-      - tp: 2
-        conc-start: 4
-        conc-end: 128
-        spec-decoding: mtp
-        srt-recipe: 8k1k.yaml
-      - tp: 4
-        conc-start: 4
-        conc-end: 16
-        spec-decoding: mtp
-        srt-recipe: 8k1k.yaml
-
 qwen3.5-fp4-mi355x-sglang-agentic-mtp:
   image: lmsysorg/sglang-rocm:v0.5.20-rocm720-mi35x-20260927
   model: amd/Qwen3.5-397B-A17B-MXFP4-AttnFP8-V2
@@ -489,7 +260,7 @@ qwen3.5-fp4-mi355x-sglang-agentic-mtp:
 # FP8 PLE, AgentX on MI355X via SGLang with native NEXTN MTP (3 steps,
 # eagle-topk 1, 4 draft tokens). TP1: the ~116 GiB checkpoint fits on one MI355X.
 qwen3.8next-fp4-mi355x-sglang-agentic-mtp:
-  image: lmsysorg/sglang-rocm:v0.5.23-rocm10-mi35x-20261030@sha256:1ff42c238adfca9a55e8d3d3dc859a4e4e88b23e7f9340e86d17ff042b933bda
+  image: lmsysorg/sglang-rocm:v0.5.23-rocm10-mi35x-20261031@sha256:3867dc07ba2530f914e1f210ed829f7a572a75286c8c362dbc22cbecf9b5a7e6
   model: amd/Qwen3.8-Flash-Next-Quark-MXFP4-AttnFP8-PLEFP8
   model-prefix: qwen3.8next
   runner: cluster:mi355x-amds
@@ -503,57 +274,6 @@ qwen3.8next-fp4-mi355x-sglang-agentic-mtp:
       search-space:
       - { tp: 1, ep: 1, spec-decoding: mtp, kv-offloading: none, conc-list: [1, 2, 4, 8, 12, 16], srt-recipe: agentic.yaml }
 
-qwen3.5-fp4-mi355x-sglang-disagg:
-  image: lmsysorg/sglang-rocm:v0.5.17-rocm720-mi35x-20260809
-  model: amd/Qwen3.5-397B-A17B-MXFP4
-  model-prefix: qwen3.5
-  runner: cluster:mi355x-amds
-  precision: fp4
-  framework: sglang-disagg
-  router: { name: sglang-router, version: "0.3.2" }
-  kv-p2p-transfer: mori
-  multinode: true
-  disagg: true
-  srt-recipe-dir: qwen3.5/sglang/mi355x-fp4/8k1k
-  scenarios:
-    fixed-seq-len:
-    - isl: 8192
-      osl: 1024
-      search-space:
-      - spec-decoding: "none"
-        # The recipe owns the complete production search in one allocation.
-        conc-list: [8, 16, 32, 64, 128, 256, 512]
-        srt-recipe: disagg-1p1d-tp8.yaml
-        prefill:
-          num-worker: 1
-          tp: 8
-          ep: 1
-          dp-attn: false
-        decode:
-          num-worker: 1
-          tp: 8
-          ep: 1
-          dp-attn: false
-
-qwen3.5-fp8-mi300x-sglang:
-  image: lmsysorg/sglang:v0.5.12-rocm720-mi30x
-  model: Qwen/Qwen3.5-397B-A17B-FP8
-  model-prefix: qwen3.5
-  runner: mi300x
-  precision: fp8
-  framework: sglang
-  multinode: false
-  srt-recipe-dir: qwen3.5/sglang/mi300x-fp8
-  scenarios:
-    fixed-seq-len:
-    - isl: 8192
-      osl: 1024
-      search-space:
-      - tp: 8
-        conc-start: 4
-        conc-end: 64
-        srt-recipe: 8k1k.yaml
-
 # AgentX Pareto sweep for Qwen3.5 FP8 on MI300X. The fast discovery run peaks
 # at c24; c32 records the post-knee throughput and latency cliff.
 qwen3.5-fp8-mi300x-sglang-agentic-mtp:
@@ -731,72 +451,6 @@ dsr1-fp8-mi355x-sglang-disagg-mtp:
           ep: 1
           dp-attn: false
 
-# Kimi-K3 MXFP4 agentic-coding benchmark on MI355X via ATOM with DSpark
-# speculative decoding. Acceptance is pinned to the committed golden curve in
-# infx/golden_al_distribution/kimik3_dspark_probabilistic_sample_method_block_rejection_sample_method.yaml
-# at both draft lengths used here: 7 draft tokens -> AL 3.84 at concurrency 1 and 4,
-# 4 draft tokens -> AL 3.36 from concurrency 14 up.
-# Companion to kimik3-fp4-mi355x-vllm-agentic-mtp: same checkpoint, same runner.
-# TP8 only -- the 1.56 TB MXFP4 checkpoint is ~195 GB/GPU and TP4 cannot load,
-# which is also why there is no DP-attention arm.
-# Three serving bands, tracking the ATOM recipe:
-#   interactive (1, 4)        the latency floor, GPU-resident, dcp 1.
-#   mid         (14, 16)      decode is KV-bandwidth-bound over 100k+ token
-#                             contexts, so dcp-size 8 shards the KV read across
-#                             all 8 GPUs and the LMCache DRAM tier backs the
-#                             paged KV.
-#   throughput  (48, 56, 72)  same shape, with the draft model.
-# Two utilization blocks because the per-rank LMCache pool differs, and the
-# launcher divides the aggregate budget by TP:
-#   0.343 -> 1028 GB aggregate -> 128 GB/rank (conc 14 through 48).
-#   0.513 -> 1538 GB aggregate -> 192 GB/rank (conc 56 and 72), where the
-#            wider in-flight window needs the deeper pool to keep the paged KV
-#            resident.
-kimik3-fp4-mi355x-atom-agentic-mtp:
-  image: rocm/atom-dev:nightly_202610131505
-  model: moonshotai/Kimi-K3
-  model-prefix: kimik3
-  runner: cluster:mi355x-amds
-  precision: fp4
-  framework: atom
-  multinode: false
-  srt-recipe-dir: kimik3/atom/mi355x-fp4-mtp
-  scenarios:
-    agentic-coding:
-    - dram-utilization: 0.343
-      search-space:
-      - { tp: 8, kv-offloading: none, conc-list: [1, 4], spec-decoding: mtp, srt-recipe: agentic.yaml }
-      - { tp: 8, dcp-size: 8, kv-offloading: dram, kv-offload-backend: { name: lmcache, version: "0.4.5" }, conc-list: [14, 16, 48], spec-decoding: mtp, srt-recipe: agentic.yaml }
-    - dram-utilization: 0.513
-      search-space:
-      - { tp: 8, dcp-size: 8, kv-offloading: dram, kv-offload-backend: { name: lmcache, version: "0.4.5" }, conc-list: [56, 72], spec-decoding: mtp, srt-recipe: agentic.yaml }
-
-# Kimi-K3 MXFP4 agentic-coding on MI355X via vLLM with DSpark speculative
-# decoding. Companion to kimik3-fp4-mi355x-atom-agentic-mtp: same checkpoint and
-# runner. TP8 only -- the 1.56 TB MXFP4 checkpoint is ~195 GB/GPU. Three bands:
-#   interactive (1, 4)   GPU-resident, dcp 8, DSpark draft; 1 runs the
-#                        latency_specialized decode (vllm-project/vllm#60683).
-#   mid         (4-32)   dcp 8, DSpark draft, SimpleCPUOffload DRAM tier.
-#   throughput  (48-60)  dcp 8 shards the KV read across all 8 GPUs, DRAM
-#                        offload, 4-token DSpark draft with synthetic acceptance.
-# dram-utilization 0.6 -> TOTAL_CPU_DRAM_GB 1799 at TP8 (node cap 2861022 MiB),
-# split evenly across the eight ranks by the launcher.
-kimik3-fp4-mi355x-vllm-agentic-mtp:
-  image: vllm/vllm-openai-rocm:nightly-rocm100-df6603f0583375f244d1ac6d36265462b7490392
-  model: moonshotai/Kimi-K3
-  model-prefix: kimik3
-  runner: cluster:mi355x-amds
-  precision: fp4
-  framework: vllm
-  multinode: false
-  srt-recipe-dir: kimik3/vllm/mi355x-fp4-mtp
-  scenarios:
-    agentic-coding:
-    - dram-utilization: 0.6
-      search-space:
-      - { tp: 8, ep: 1, dcp-size: 8, kv-offloading: none, conc-list: [1, 4], spec-decoding: mtp, srt-recipe: agentic.yaml }
-      - { tp: 8, ep: 1, dcp-size: 8, kv-offloading: dram, kv-offload-backend: { name: vllm-simple }, conc-list: [4, 10, 16, 24, 32, 48, 52, 60], spec-decoding: mtp, srt-recipe: agentic.yaml }
-
 dsr1-fp4-mi355x-sglang-disagg:
   image: lmsysorg/sglang-rocm:v0.5.17-rocm720-mi35x-20260809
   model: amd/DeepSeek-R1-0528-MXFP4-v2
@@ -935,27 +589,6 @@ dsr1-fp8-mi325x-sglang-mtp:
         spec-decoding: mtp
         srt-recipe: 8k1k.yaml
 
-qwen3.5-fp8-mi325x-sglang-mtp:
-  image: lmsysorg/sglang:v0.5.12-rocm720-mi30x
-  model: Qwen/Qwen3.5-397B-A17B-FP8
-  model-prefix: qwen3.5
-  runner: mi325x
-  precision: fp8
-  framework: sglang
-  multinode: false
-  srt-recipe-dir: qwen3.5/sglang/mi325x-fp8-mtp
-  scenarios:
-    fixed-seq-len:
-    - isl: 8192
-      osl: 1024
-      search-space:
-      - tp: 8
-        ep: 1
-        conc-start: 4
-        conc-end: 64
-        spec-decoding: mtp
-        srt-recipe: 8k1k.yaml
-
 dsr1-fp4-mi355x-sglang-disagg-mtp:
   image: lmsysorg/sglang-rocm:v0.5.17-rocm720-mi35x-20260809
   model: amd/DeepSeek-R1-0528-MXFP4-v2
@@ -1088,16 +721,19 @@ dsv41flash-fp4-mi325x-vllm-agentic-dspark:
       - { tp: 2, kv-offloading: none, spec-decoding: mtp, conc-list: [1, 2, 4, 8, 16, 32], srt-recipe: agentic.yaml }
 
 # GLM-5.2 FP4 agentic-coding benchmark on MI355X via SGLang with MTP speculative
-# decoding. Two arms:
+# decoding. Three arms:
 # (1) TP4/EP4 with HiCache KV offloading to DRAM at concurrency [4, 8, 10, 12, 14, 16];
 #     serves the high-concurrency, throughput-dominant regime.
-# (2) TP8/EP1 without KV offloading, concurrency sweep [1, 2, 4];
+# (2) TP4/EP4 with DCP4 at concurrency [16, 24, 40, 48]; striping the latent KV
+#     across the four ranks holds the working set on device without HiCache,
+#     which DSA DCP rejects.
+# (3) TP8/EP1 without KV offloading, concurrency sweep [1, 2, 4];
 #     EP=1 eliminates the MoE all-to-all collective, reducing ITL at low-to-mid
 #     concurrency; GPU-resident KV keeps latency independent of DRAM bandwidth.
-#     c4 intentionally overlaps both arms to compare the topology crossover.
+#     c4 intentionally overlaps arms (1) and (3) to compare the topology crossover.
 # SA selects the Pareto-optimal arm per concurrency point.
 glm5.2-fp4-mi355x-sglang-agentic-mtp:
-  image: lmsysorg/sglang:v0.5.22-rocm720-mi35x@sha256:c4b61360b251d62bb17da63f175d571ab22479eb46a144548d79f3ed3998ea11
+  image: lmsysorg/sglang-rocm:v0.5.22-rocm720-mi35x-20261028
   model: amd/GLM-5.2-MXFP4
   model-prefix: glm5.2
   runner: cluster:mi355x-amds
@@ -1110,13 +746,14 @@ glm5.2-fp4-mi355x-sglang-agentic-mtp:
     - dram-utilization: 0.85
       search-space:
       - { tp: 4, ep: 4, kv-offloading: dram, kv-offload-backend: { name: hicache }, conc-list: [4, 8, 10, 12, 14, 16], spec-decoding: mtp, srt-recipe: agentic.yaml }
+      - { tp: 4, ep: 4, dcp-size: 4, kv-offloading: none, conc-list: [16, 24, 40, 48], spec-decoding: mtp, srt-recipe: agentic.yaml }
       - { tp: 8, ep: 1, kv-offloading: none, conc-list: [1, 2, 4], spec-decoding: mtp, srt-recipe: agentic.yaml }
 
 # GLM-5.2 FP8 agentic-coding benchmark on MI355X via SGLang with MTP speculative
 # decoding: the FP8 precision sibling of glm5.2-fp4-mi355x-sglang-agentic-mtp,
 # serving the upstream zai-org/GLM-5.2-FP8 checkpoint (~756 GB block-FP8).
 # Same EAGLE shape as the MXFP4 sibling (num-steps 5, 6 draft tokens) with
-# acceptance pinned to the golden AL 3.61 (glm5.2_mtp.yaml, thinking_on, K=5,
+# acceptance pinned to the golden AL 3.61 (glm-5.2-fp8__mtp__native__default-default.yaml, thinking_on, K=5,
 # measured on glm-5.2-fp8). TP8-only: ~94.5 GB/rank of weights leaves a ~150
 # GB/rank fp8 KV pool at --mem-fraction-static 0.85; TP4 would leave ~56 GB/rank
 # and is not attempted on day zero (the MI325X FP8 sibling is TP8-only too).
@@ -1220,12 +857,31 @@ dsv41flash-fp4-mi355x-vllm-agentic-dspark:
       - { tp: 4, kv-offloading: none, spec-decoding: mtp, conc-list: [1, 2], srt-recipe: agentic.yaml }
       - { tp: 2, kv-offloading: none, spec-decoding: mtp, conc-list: [1, 2, 4, 8, 16, 32, 64], srt-recipe: agentic.yaml }
 
+# Single-point TP8 c1 scan of DeepSeek-V4.1-Flash on MI355X with mono decode
+# (--monokernel) on the latest vLLM ROCm 10.0 nightly (2026-10-30), which carries
+# vllm-project/vllm#64101 (mono decode at TP8; earlier builds refuse --monokernel
+# outside TP2/TP4). Kept as its own key so the TP4/TP2 grid above does not rerun.
+dsv41flash-fp4-mi355x-vllm-agentic-dspark-tp8-c1:
+  image: vllm/vllm-openai-rocm:nightly-335dd77b09161c5d63139b4e7ae51bb9928305b1@sha256:3c634cc2c51eda7eb840a236b1f09a5ecf6a4b0cb92c4b8486e2158770507291
+  model: deepseek-ai/DeepSeek-V4.1-Flash
+  model-prefix: dsv41flash
+  runner: cluster:mi355x-amds
+  precision: fp4
+  framework: vllm
+  multinode: false
+  srt-recipe-dir: dsv41flash/vllm/mi355x-fp4-mtp
+  scenarios:
+    agentic-coding:
+    - dram-utilization: 0.60
+      search-space:
+      - { tp: 8, kv-offloading: none, spec-decoding: mtp, conc-list: [1], srt-recipe: agentic.yaml }
+
 # MiniMax-M3.1-Flash AgentX on MI355X: day-zero vLLM ROCm image from
 # https://vllm.ai/blog/2026-10-23-minimax-m31-flash, verified 2026-10-23.
 # AMD's Quark MXFP4 export (routed experts in MXFP4, W4A4 on the AITER MoE)
 # at TP4 with native DSpark: 7 drafts, mono decode and an FP8 KV cache at
-# c1-c8; 3 drafts, an NVFP4 KV cache and DBO from c16. Throughput runs use the
-# minimaxm31flash_dspark golden AL.
+# c1-c8; 7 drafts, an NVFP4 KV cache and DBO at c16-c32; 3 drafts, DBO and a
+# CPU KV tier at c64. Throughput runs use the minimax-m3.1-flash__dspark__native__probabilistic-block golden AL.
 minimaxm31flash-fp4-mi355x-vllm-agentic-dspark:
   image: vllm/vllm-openai-rocm:minimax-m31-flash@sha256:ae8681212aa5291d8c27f06e90016435e3fca144a68fd5c439231f6475f74569
   model: amd/MiniMax-M3.1-Flash-Quark-MXFP4
@@ -1237,9 +893,10 @@ minimaxm31flash-fp4-mi355x-vllm-agentic-dspark:
   srt-recipe-dir: minimaxm31flash/vllm/mi355x-fp4
   scenarios:
     agentic-coding:
-    - dram-utilization: 0.80
+    - dram-utilization: 0.90
       search-space:
-      - { tp: 4, kv-offloading: none, spec-decoding: mtp, conc-list: [1, 2, 4, 8, 16, 32, 64], srt-recipe: agentic.yaml }
+      - { tp: 4, kv-offloading: none, spec-decoding: mtp, conc-list: [1, 2, 4, 8, 16, 32], srt-recipe: agentic.yaml }
+      - { tp: 4, kv-offloading: dram, kv-offload-backend: { name: vllm-simple }, spec-decoding: mtp, conc-list: [64], srt-recipe: agentic.yaml:override_tp4_dspark3_c64_offload }
 
 # MiniMax-M3.1-Flash AgentX on MI355X with SGLang: day-zero image from the SGLang
 # cookbook (https://docs.sglang.io/cookbook/autoregressive/MiniMax/MiniMax-M3.1),
@@ -1247,7 +904,7 @@ minimaxm31flash-fp4-mi355x-vllm-agentic-dspark:
 # MI355X Low-Latency (TP4) cell. Its High-Throughput cell (HiCache) crashes on MI355X
 # with this image, so concurrency 48-64 stays GPU-resident on the Low-Latency cell.
 # Seven-token DSpark (bundled draft); synthetic acceptance follows
-# infx/golden_al_distribution/minimaxm31flash_dspark.yaml.
+# infx/golden_al_distribution/minimax-m3.1-flash__dspark__native__probabilistic-block.yaml.
 minimaxm31flash-fp4-mi355x-sglang-agentic-dspark:
   image: lmsysorg/sglang:dev-minimax-m31-flash-mi35x@sha256:2d74f6ea339964befdfc97f8d74d9ce5bbecd4a29b343f2868a29d13d51ec3f8
   model: MiniMaxAI/MiniMax-M3.1-Flash
@@ -1261,7 +918,11 @@ minimaxm31flash-fp4-mi355x-sglang-agentic-dspark:
     agentic-coding:
     - search-space:
       # Low-Latency: TP4, GPU-resident.
-      - { tp: 4, spec-decoding: mtp, kv-offloading: none, conc-list: [1, 2, 4, 8, 16, 32, 48, 64], srt-recipe: agentic.yaml }
+      - { tp: 4, spec-decoding: mtp, kv-offloading: none, conc-list: [1, 2, 4, 8, 16, 32], srt-recipe: agentic.yaml }
+    - dram-utilization: 0.49
+      search-space:
+      # High-Throughput: TP4 + HiCache, 180 GB of host KV per rank (720 of 735 GB).
+      - { tp: 4, spec-decoding: mtp, kv-offloading: dram, kv-offload-backend: { name: hicache }, conc-list: [48, 64], srt-recipe: agentic.yaml }
 
 # DeepSeek-V4.1-Flash on ATOM, following the upstream TP2 / TP4 AgentX recipe.
 # Five-token DSpark uses golden AL 3.51 for throughput and real acceptance for eval.
@@ -1280,8 +941,8 @@ dsv41flash-fp4-mi355x-atom-agentic-dspark:
       - { tp: 2, ep: 1, dp-attn: false, kv-offloading: none, spec-decoding: draft_model, conc-list: [1, 2, 4, 6, 8, 16, 32, 64], srt-recipe: agentic.yaml }
       - { tp: 4, ep: 1, dp-attn: false, kv-offloading: none, spec-decoding: draft_model, conc-list: [1, 8, 32], srt-recipe: agentic.yaml }
 
-# The golden acceptance curve remains the provisional GLM-5.2-derived curve
-# documented in infx/golden_al_distribution/glm5.3_mtp.yaml.
+# The golden acceptance curve is the GLM-5.3 NVFP4 SGLang curve in
+# infx/golden_al_distribution/glm-5.3-nvfp4__mtp__native__default-default.yaml.
 glm5.3-fp8-mi355x-tilert-agentic:
   image: ghcr.io/tile-ai/tilert-rocm-decode:0.1.6
   model: zai-org/GLM-5.3
@@ -1348,106 +1009,18 @@ musespark-fp4-mi355x-sglang-agentic-dflash:
       - { tp: 8, ep: 8, kv-offloading: none, spec-decoding: draft_model, conc-list: [1, 4, 8, 13], srt-recipe: agentic.yaml }
       - { tp: 4, ep: 4, kv-offloading: dram, kv-offload-backend: { name: hicache }, spec-decoding: draft_model, conc-list: [10, 16, 24, 28, 36, 40], srt-recipe: agentic.yaml }
 
-# Native Kimi-K3 PD with TP8 workers and MoRIIO READ.
-kimik3-fp4-mi355x-vllm-disagg-agentic:
-  image: vllm/vllm-openai-rocm:nightly-81198e97ba7eee2a22540caaa756b7fdddcb4d93@sha256:a401e4f46872dcde77e07ae3d7fa2d3a71b7f2773714316116532e2b39deb179
-  model: moonshotai/Kimi-K3
-  model-prefix: kimik3
+kimik3.1-fp4-mi355x-sglang-agentic-dflash:
+  image: lmsysorg/sglang:dev-kimi-k31-pro-mi35x@sha256:6af91676b98cb98246aab7da6ab5a8cdaa0f30d9e0f4a9d44e6b19c9f99e87a0
+  model: moonshotai/Kimi-K3.1-Pro
+  model-prefix: kimik3.1
   runner: cluster:mi355x-amds
   precision: fp4
-  framework: vllm-disagg
-  router: { name: vllm-router, version: nightly-20260913-83944c4 }
-  kv-p2p-transfer: moriio
-  multinode: true
-  disagg: true
-  srt-recipe-dir: kimik3/vllm/mi355x-fp4/agentx
+  framework: sglang
+  multinode: false
+  srt-recipe-dir: kimik3.1/sglang/mi355x-fp4-mtp
   scenarios:
     agentic-coding:
-    - dram-utilization: 0.6
+    - dram-utilization: 0.513
       search-space:
-      - spec-decoding: mtp
-        conc-list: [12]
-        kv-offloading: dram
-        kv-offload-backend: { name: vllm-simple }
-        srt-recipe: disagg-variants.yaml:override_1p3d_c12
-        prefill:
-          num-worker: 1
-          tp: 8
-          dcp-size: 1
-          ep: 1
-          dp-attn: false
-          additional-settings:
-          - TOTAL_CPU_DRAM_GB=1799
-        decode: { num-worker: 3, tp: 8, dcp-size: 1, ep: 1, dp-attn: false }
-      - spec-decoding: mtp
-        conc-list: [24]
-        kv-offloading: dram
-        kv-offload-backend: { name: vllm-simple }
-        srt-recipe: disagg-variants.yaml:override_1p3d_c24
-        prefill:
-          num-worker: 1
-          tp: 8
-          dcp-size: 8
-          ep: 1
-          dp-attn: false
-          additional-settings:
-          - TOTAL_CPU_DRAM_GB=1799
-        decode: { num-worker: 3, tp: 8, dcp-size: 8, ep: 1, dp-attn: false }
-      - spec-decoding: mtp
-        conc-list: [24]
-        kv-offloading: dram
-        kv-offload-backend: { name: vllm-simple }
-        srt-recipe: disagg-variants.yaml:override_1p2d_c24
-        prefill:
-          num-worker: 1
-          tp: 8
-          dcp-size: 8
-          ep: 1
-          dp-attn: false
-          additional-settings:
-          - TOTAL_CPU_DRAM_GB=1799
-        decode: { num-worker: 2, tp: 8, dcp-size: 8, ep: 1, dp-attn: false }
-      - spec-decoding: mtp
-        conc-list: [48]
-        kv-offloading: dram
-        kv-offload-backend: { name: vllm-simple }
-        srt-recipe: disagg-variants.yaml:override_1p1d_c48
-        prefill:
-          num-worker: 1
-          tp: 8
-          dcp-size: 8
-          ep: 1
-          dp-attn: false
-          additional-settings:
-          # Recipe enables P-only scratch reclaim; D and GMU0.90 are unchanged.
-          - TOTAL_CPU_DRAM_GB=1799
-        decode: { num-worker: 1, tp: 8, dcp-size: 8, ep: 1, dp-attn: false }
-      - spec-decoding: mtp
-        conc-list: [56]
-        kv-offloading: dram
-        kv-offload-backend: { name: vllm-simple }
-        srt-recipe: disagg-variants.yaml:override_1p1d_c56
-        prefill:
-          num-worker: 1
-          tp: 8
-          dcp-size: 8
-          ep: 1
-          dp-attn: false
-          additional-settings:
-          - TOTAL_CPU_DRAM_GB=1799
-        decode: { num-worker: 1, tp: 8, dcp-size: 8, ep: 1, dp-attn: false }
-      - spec-decoding: mtp
-        conc-list: [48]
-        kv-offloading: dram
-        kv-offload-backend: { name: vllm-simple }
-        srt-recipe: disagg-variants.yaml:override_1p2d_c48
-        prefill:
-          num-worker: 1
-          tp: 8
-          dcp-size: 8
-          ep: 1
-          dp-attn: false
-          additional-settings:
-          # Inherits the same P-only scratch-reclaim setting as 1P1D c48.
-          - TOTAL_CPU_DRAM_GB=1799
-        decode: { num-worker: 2, tp: 8, dcp-size: 8, ep: 1, dp-attn: false }
+      - { tp: 8, ep: 1, kv-offloading: none, spec-decoding: draft_model, conc-list: [1, 4], srt-recipe: agentic.yaml }
+      - { tp: 8, ep: 1, dcp-size: 8, kv-offloading: dram, kv-offload-backend: { name: hicache }, spec-decoding: draft_model, conc-list: [8, 16, 32, 48], srt-recipe: agentic.yaml }
diff --git a/inferencex-e2e/configs/ci-priority.yaml b/inferencex-e2e/configs/ci-priority.yaml
index 0f74a08253..4469ba9b2d 100644
--- a/inferencex-e2e/configs/ci-priority.yaml
+++ b/inferencex-e2e/configs/ci-priority.yaml
@@ -28,8 +28,8 @@ adjustments:
     dynamo-sglang: 1.5
     dynamo-vllm: 1.5
   model-prefix:
+    kimik3.1: 100.0
     dsv41flash: 0.5
-    kimik3: 0.5
     glm5.3: 0.5
     glm5.2: 0.5
     minimaxm31flash: 0.3
diff --git a/inferencex-e2e/configs/nvidia-master.yaml b/inferencex-e2e/configs/nvidia-master.yaml
index bbb6d3fed4..0e860fc14b 100644
--- a/inferencex-e2e/configs/nvidia-master.yaml
+++ b/inferencex-e2e/configs/nvidia-master.yaml
@@ -1042,38 +1042,6 @@ dsr1-fp8-b300-sglang:
         conc-end: 32
         srt-recipe: 8k1k.yaml
 
-qwen3.5-fp8-b200-sglang:
-  image: lmsysorg/sglang:nightly-dev-cu13-20260918-20518d85
-  model: Qwen/Qwen3.5-397B-A17B-FP8
-  model-prefix: qwen3.5
-  runner: cluster:b200-nscale
-  precision: fp8
-  framework: sglang
-  multinode: false
-  srt-recipe-dir: qwen3.5/sglang/b200-fp8
-  scenarios:
-    fixed-seq-len:
-    - isl: 8192
-      osl: 1024
-      search-space:
-      - tp: 8
-        conc-start: 1
-        conc-end: 4
-        srt-recipe: 8k1k.yaml
-      - tp: 4
-        ep: 1
-        conc-start: 2
-        conc-end: 512
-        srt-recipe: 8k1k.yaml
-      - tp: 4
-        ep: 1
-        conc-list:
-        - 320
-        - 384
-        - 448
-        - 640
-        srt-recipe: 8k1k.yaml
-
 qwen3.5-fp8-b200-sglang-agentic-mtp:
   image: lmsysorg/sglang:v0.5.22-cu130@sha256:e3a4f06001a29542fc4a8638536d9ffc5eb9c9942b08603c09b19a56eae4a1ae
   model: Qwen/Qwen3.5-397B-A17B-FP8
@@ -1092,279 +1060,6 @@ qwen3.5-fp8-b200-sglang-agentic-mtp:
       - { tp: 4, ep: 1, spec-decoding: mtp, kv-offloading: none, conc-list: [1, 4, 8, 12, 14], srt-recipe: agentic.yaml }
       - { tp: 4, ep: 1, spec-decoding: mtp, kv-offloading: dram, kv-offload-backend: { name: hicache }, conc-list: [16, 18, 20, 22, 24, 28, 32], srt-recipe: agentic.yaml }
 
-qwen3.5-fp4-b200-sglang:
-  image: lmsysorg/sglang:v0.5.21-cu130@sha256:b1259f3ea3275f66237c498ea388919729018bc9f01c3d638391e06e2cf3f469
-  model: nvidia/Qwen3.5-397B-A17B-NVFP4-V2
-  model-prefix: qwen3.5
-  runner: cluster:b200-nscale
-  precision: fp4
-  framework: sglang
-  multinode: false
-  srt-recipe-dir: qwen3.5/sglang/b200-fp4
-  scenarios:
-    fixed-seq-len:
-    - isl: 8192
-      osl: 1024
-      search-space:
-      - tp: 4
-        ep: 1
-        conc-start: 4
-        conc-end: 4
-        srt-recipe: 8k1k.yaml
-      - tp: 2
-        ep: 1
-        conc-start: 4
-        conc-end: 128
-        srt-recipe: 8k1k.yaml
-
-qwen3.5-fp4-b200-sglang-mtp:
-  image: lmsysorg/sglang:v0.5.21-cu130@sha256:b1259f3ea3275f66237c498ea388919729018bc9f01c3d638391e06e2cf3f469
-  model: nvidia/Qwen3.5-397B-A17B-NVFP4-V2
-  model-prefix: qwen3.5
-  runner: cluster:b200-nscale
-  precision: fp4
-  framework: sglang
-  multinode: false
-  srt-recipe-dir: qwen3.5/sglang/b200-fp4-mtp
-  scenarios:
-    fixed-seq-len:
-    - isl: 8192
-      osl: 1024
-      search-space:
-      - tp: 4
-        ep: 1
-        conc-start: 4
-        conc-end: 4
-        spec-decoding: mtp
-        srt-recipe: 8k1k.yaml
-      - tp: 2
-        ep: 1
-        conc-start: 4
-        conc-end: 64
-        spec-decoding: mtp
-        srt-recipe: 8k1k.yaml
-      - tp: 2
-        ep: 2
-        conc-list:
-        - 16
-        - 32
-        - 64
-        spec-decoding: mtp
-        srt-recipe: 8k1k.yaml
-
-qwen3.5-fp8-b200-sglang-mtp:
-  image: lmsysorg/sglang:nightly-dev-cu13-20260918-20518d85
-  model: Qwen/Qwen3.5-397B-A17B-FP8
-  model-prefix: qwen3.5
-  runner: cluster:b200-nscale
-  precision: fp8
-  framework: sglang
-  multinode: false
-  srt-recipe-dir: qwen3.5/sglang/b200-fp8-mtp
-  scenarios:
-    fixed-seq-len:
-    - isl: 8192
-      osl: 1024
-      search-space:
-      - tp: 8
-        ep: 1
-        conc-start: 4
-        conc-end: 4
-        spec-decoding: mtp
-        srt-recipe: 8k1k.yaml
-      - tp: 4
-        ep: 1
-        conc-start: 4
-        conc-end: 256
-        spec-decoding: mtp
-        srt-recipe: 8k1k.yaml
-
-qwen3.5-fp8-b300-sglang-mtp:
-  image: lmsysorg/sglang:v0.5.22-cu130@sha256:e3a4f06001a29542fc4a8638536d9ffc5eb9c9942b08603c09b19a56eae4a1ae
-  model: Qwen/Qwen3.5-397B-A17B-FP8
-  model-prefix: qwen3.5
-  runner: b300
-  precision: fp8
-  framework: sglang
-  multinode: false
-  srt-recipe-dir: qwen3.5/sglang/b300-fp8-mtp
-  scenarios:
-    fixed-seq-len:
-    - isl: 8192
-      osl: 1024
-      search-space:
-      - tp: 4
-        ep: 1
-        conc-start: 4
-        conc-end: 256
-        spec-decoding: mtp
-        srt-recipe: 8k1k.yaml
-
-qwen3.5-fp8-b300-sglang:
-  image: lmsysorg/sglang:v0.5.21-cu130@sha256:b1259f3ea3275f66237c498ea388919729018bc9f01c3d638391e06e2cf3f469
-  model: Qwen/Qwen3.5-397B-A17B-FP8
-  model-prefix: qwen3.5
-  runner: b300
-  precision: fp8
-  framework: sglang
-  multinode: false
-  srt-recipe-dir: qwen3.5/sglang/b300-fp8
-  scenarios:
-    fixed-seq-len:
-    - isl: 8192
-      osl: 1024
-      search-space:
-      - tp: 4
-        ep: 1
-        conc-start: 4
-        conc-end: 256
-        srt-recipe: 8k1k.yaml
-
-qwen3.5-fp4-b300-sglang:
-  image: lmsysorg/sglang:v0.5.14-cu130
-  model: nvidia/Qwen3.5-397B-A17B-NVFP4-V2
-  model-prefix: qwen3.5
-  runner: b300
-  precision: fp4
-  framework: sglang
-  multinode: false
-  srt-recipe-dir: qwen3.5/sglang/b300-fp4
-  scenarios:
-    fixed-seq-len:
-    - isl: 8192
-      osl: 1024
-      search-space:
-      - tp: 4
-        ep: 1
-        conc-start: 4
-        conc-end: 128
-        srt-recipe: 8k1k.yaml
-      - tp: 2
-        ep: 2
-        conc-start: 4
-        conc-end: 128
-        srt-recipe: 8k1k.yaml
-
-qwen3.5-fp4-b300-sglang-mtp:
-  image: lmsysorg/sglang:v0.5.22-cu130@sha256:e3a4f06001a29542fc4a8638536d9ffc5eb9c9942b08603c09b19a56eae4a1ae
-  model: nvidia/Qwen3.5-397B-A17B-NVFP4-V2
-  model-prefix: qwen3.5
-  runner: b300
-  precision: fp4
-  framework: sglang
-  multinode: false
-  srt-recipe-dir: qwen3.5/sglang/b300-fp4-mtp
-  scenarios:
-    fixed-seq-len:
-    - isl: 8192
-      osl: 1024
-      search-space:
-      - tp: 4
-        ep: 1
-        conc-start: 4
-        conc-end: 128
-        spec-decoding: mtp
-        srt-recipe: 8k1k.yaml
-      - tp: 2
-        ep: 2
-        conc-start: 4
-        conc-end: 128
-        spec-decoding: mtp
-        srt-recipe: 8k1k.yaml
-
-# Kimi K3 is a 2.8T MXFP4 MoE served on H200 nodes.
-# These are the three aggregated strategy classes from the official H200
-# recipe (https://recipes.vllm.ai/moonshotai/Kimi-K3?hardware=h200):
-# Wider TP is latency-oriented, while progressively wider DP is balanced or
-# throughput-oriented. EP32 keeps the model shards within HBM and preserves
-# the native 1M context on four H200 nodes. All arms use probabilistic DSpark K2
-# with synthetic acceptance pinned to the committed golden AL of 2.51.
-# The existing `mtp` matrix label covers speculative-decoding methods; the
-# checked-in recipes select DSpark explicitly. The H200 runner supplies
-# cluster paths while srt-slurm owns allocation, direct vLLM startup,
-# readiness, and log capture. P/D disaggregation is intentionally deferred.
-kimik3-fp4-h200-vllm-agentic-latency:
-  image: vllm/vllm-openai:kimi-k3
-  model: moonshotai/Kimi-K3
-  model-prefix: kimik3
-  runner: cluster:h200-dgxc
-  precision: fp4
-  framework: vllm
-  multinode: true
-  disagg: false
-  srt-recipe-dir: kimik3/vllm/h200-fp4/agentx
-  scenarios:
-    agentic-coding:
-    - dram-utilization: 0.80
-      search-space:
-      # Latency-oriented: TP16 x DP2 with EP32 across four H200 nodes.
-      - spec-decoding: mtp
-        kv-offloading: none
-        conc-list: [1, 2, 3, 4, 5, 6, 7, 8, 10, 12]
-        num-nodes: 4
-        srt-recipe: agg-tp16dp2ep32-latency.yaml
-        power: true
-        worker:
-          num-worker: 2
-          tp: 16
-          ep: 32
-          dp-attn: true
-
-kimik3-fp4-h200-vllm-agentic-balanced:
-  image: vllm/vllm-openai:kimi-k3
-  model: moonshotai/Kimi-K3
-  model-prefix: kimik3
-  runner: cluster:h200-dgxc
-  precision: fp4
-  framework: vllm
-  multinode: true
-  disagg: false
-  srt-recipe-dir: kimik3/vllm/h200-fp4/agentx
-  scenarios:
-    agentic-coding:
-    - dram-utilization: 0.80
-      search-space:
-      # Balanced: TP8 x DP4 with EP32 across four H200 nodes.
-      - spec-decoding: mtp
-        kv-offloading: none
-        conc-list: [1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16]
-        num-nodes: 4
-        srt-recipe: agg-tp8dp4ep32-balanced.yaml
-        power: true
-        worker:
-          num-worker: 4
-          tp: 8
-          ep: 32
-          dp-attn: true
-
-kimik3-fp4-h200-vllm-agentic-simple:
-  image: vllm/vllm-openai:kimi-k3
-  model: moonshotai/Kimi-K3
-  model-prefix: kimik3
-  runner: cluster:h200-dgxc
-  precision: fp4
-  framework: vllm
-  multinode: true
-  disagg: false
-  srt-recipe-dir: kimik3/vllm/h200-fp4/agentx
-  scenarios:
-    agentic-coding:
-    - dram-utilization: 0.80
-      search-space:
-      # Throughput-oriented hybrid TP/DEP/EP with vLLM's host-DRAM KV tier.
-      - spec-decoding: mtp
-        kv-offloading: dram
-        kv-offload-backend: { name: vllm-simple }
-        conc-list: [8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32]
-        num-nodes: 4
-        srt-recipe: agg-tp8dp4ep32-vllm-simple.yaml
-        power: true
-        worker:
-          num-worker: 4
-          tp: 8
-          ep: 32
-          dp-attn: true
-
 dsr1-fp8-b200-sglang-mtp:
   image: lmsysorg/sglang:v0.5.12-cu130
   model: deepseek-ai/DeepSeek-R1-0528
@@ -1410,36 +1105,6 @@ dsr1-fp8-b300-sglang-mtp:
         spec-decoding: mtp
         srt-recipe: 8k1k.yaml
 
-kimik3-fp4-b300-vllm-agentic-dspark:
-  # TP8 x DCP8 with Mooncake as the external KV tier. The recipe drafts with
-  # DSpark level 7 at conc <= 8 and stops above it; synthetic acceptance is
-  # pinned to the committed golden AL 3.84 (infx/golden_al_distribution/
-  # kimik3_dspark_probabilistic_sample_method_block_rejection_sample_method.yaml),
-  # and EVAL_ONLY switches to real block verification.
-  #
-  # Kimi-K3 runtime from vllm-project/vllm @ 3696c772aae308f2420a8f307b0971e6986c4818.
-  # This replaces the unavailable 5894fdf build; new results use a new runtime baseline.
-  image: vllm/vllm-openai:nightly-dev-x86_64-cu13-3696c77
-  model: moonshotai/Kimi-K3
-  model-prefix: kimik3
-  runner: cluster:b300-dsxe
-  precision: fp4
-  framework: vllm
-  multinode: false
-  srt-recipe-dir: kimik3/vllm/b300-fp4-mtp
-  scenarios:
-    # Agentic-coding only: no fixed-seq-len (1k1k / 8k1k) arms for this recipe.
-    agentic-coding:
-      # Sizes the Mooncake segment: this resolves to total-cpu-dram-gb, which
-      # the recipe divides across the 8 TP ranks.
-    - dram-utilization: 0.75
-      search-space:
-      # TP8-only: a ~1.5 TB MXFP4 checkpoint does not fit below 8 GPUs.
-      # One entry for every arm: the recipe drafts at DSpark 7 up to conc 8,
-      # DSpark 3 at conc 16, and not at all above. Keep the concurrencies
-      # disjoint across arms so exp-names stay unique.
-      - { tp: 8, ep: 1, dcp-size: 8, spec-decoding: mtp, kv-offloading: dram, kv-offload-backend: { name: mooncake, version: "0.3.11.post1" }, conc-list: [1, 2, 4, 8, 16, 24, 32, 40, 48, 56, 70], srt-recipe: agentic.yaml }
-
 dsr1-fp8-b200-trt:
   image: nvcr.io#nvidia/tensorrt-llm/release:1.3.0rc14
   model: deepseek-ai/DeepSeek-R1-0528
@@ -1532,54 +1197,13 @@ dsr1-fp8-h200-sglang-mtp:
         spec-decoding: mtp
         srt-recipe: 8k1k.yaml
 
-qwen3.5-fp8-h200-sglang:
-  image: lmsysorg/sglang:v0.5.14-cu130
-  model: Qwen/Qwen3.5-397B-A17B-FP8
-  model-prefix: qwen3.5
+dsr1-fp8-h200-trt:
+  image: nvcr.io/nvidia/tensorrt-llm/release:1.4.0rc1@sha256:3bedbe0321e7eb5430f3177d88894a3cf2dc2f6a087d0e85c13fc882667c75c0
+  model: deepseek-ai/DeepSeek-R1-0528
+  model-prefix: dsr1
   runner: h200
   precision: fp8
-  framework: sglang
-  multinode: false
-  srt-recipe-dir: qwen3.5/sglang/h200-fp8
-  scenarios:
-    fixed-seq-len:
-    - isl: 8192
-      osl: 1024
-      search-space:
-      - tp: 8
-        ep: 8
-        conc-start: 4
-        conc-end: 64
-        srt-recipe: 8k1k.yaml
-
-qwen3.5-fp8-h200-sglang-mtp:
-  image: lmsysorg/sglang:v0.5.14-cu130
-  model: Qwen/Qwen3.5-397B-A17B-FP8
-  model-prefix: qwen3.5
-  runner: h200
-  precision: fp8
-  framework: sglang
-  multinode: false
-  srt-recipe-dir: qwen3.5/sglang/h200-fp8-mtp
-  scenarios:
-    fixed-seq-len:
-    - isl: 8192
-      osl: 1024
-      search-space:
-      - tp: 8
-        ep: 8
-        conc-start: 4
-        conc-end: 128
-        spec-decoding: mtp
-        srt-recipe: 8k1k.yaml
-
-dsr1-fp8-h200-trt:
-  image: nvcr.io/nvidia/tensorrt-llm/release:1.4.0rc1@sha256:3bedbe0321e7eb5430f3177d88894a3cf2dc2f6a087d0e85c13fc882667c75c0
-  model: deepseek-ai/DeepSeek-R1-0528
-  model-prefix: dsr1
-  runner: h200
-  precision: fp8
-  framework: trt
+  framework: trt
   multinode: false
   srt-recipe-dir: dsr1/trtllm/h200-fp8
   # For all sequence lengths, EP=TP
@@ -3581,174 +3205,127 @@ dsr1-fp4-b200-dynamo-sglang-mtp:
           ep: 8
           dp-attn: true
 
-qwen3.5-fp8-gb200-dynamo-sglang:
-  image: lmsysorg/sglang:v0.5.21-cu130@sha256:b1259f3ea3275f66237c498ea388919729018bc9f01c3d638391e06e2cf3f469
-  model: Qwen/Qwen3.5-397B-A17B-FP8
+qwen3.5-fp4-gb300-dynamo-trt-agentic-disagg:
+  image: nvcr.io/nvidia/tensorrt-llm/release:1.3.0a0.dev202610151219
+  model: nvidia/Qwen3.5-397B-A17B-NVFP4-V2
   model-prefix: qwen3.5
-  runner: gb200
-  precision: fp8
-  framework: dynamo-sglang
-  router: { name: dynamo-router, version: "1.5.0.dev20260917" }
-  kv-p2p-transfer: mooncake
+  runner: cluster:gb300-nv
+  precision: fp4
+  framework: dynamo-trt
+  router: { name: dynamo-router, version: "1.6.0.dev20261010" }
+  kv-p2p-transfer: nixl
   multinode: true
   disagg: true
-  srt-recipe-dir: qwen3.5/sglang/gb200-fp8/8k1k
+  srt-recipe-dir: qwen3.5/trtllm/gb300-fp4/agentx
   scenarios:
-    fixed-seq-len:
-    - isl: 8192
-      osl: 1024
+    agentic-coding:
+    # Recipes reserve 128 GiB per rank; each node has 840 GiB and 4 GPUs.
+    - dram-utilization: 0.609524
       search-space:
-      # 1P1D STP: TP4 prefill + TP4 decode (pure tensor parallel). 2 nodes (1+1).
-      - spec-decoding: "none"
-        conc-list: [1, 2, 4, 8, 16, 32, 64, 128]
-        srt-recipe: disagg-1p1d-tp4-tp4-stp.yaml
-        power: true
+      # 1P1D: 1 prefill (TP1/EP1/dp-attn), 1 decode (TP2/EP2) on the same node, batch 8, conc=38, 48
+      - spec-decoding: "mtp"
+        kv-offloading: dram
+        kv-offload-backend: { name: native, version: "1.3.0a0.dev202610151219" }
+        conc-list: [38, 48]
+        srt-recipe: disagg-variants.yaml:override_1p1d_dep1_tep2_b8
         prefill:
           num-worker: 1
-          tp: 4
+          tp: 1
           ep: 1
-          dp-attn: false
+          dp-attn: true
         decode:
           num-worker: 1
-          tp: 4
-          ep: 1
+          tp: 2
+          ep: 2
           dp-attn: false
-      # 4P1D wide-EP: 4 prefill DEP4 + decode DEP16. 8 nodes (4+4).
-      - spec-decoding: "none"
-        conc-list: [1024]
-        srt-recipe: disagg-4p1d-dep4-dep16-stp.yaml
-        power: true
+      # 1P1D: 1 prefill (TP1/EP1/dp-attn), 1 decode (TP2/EP2) on the same node, batch 4, conc=45
+      - spec-decoding: "mtp"
+        kv-offloading: dram
+        kv-offload-backend: { name: native, version: "1.3.0a0.dev202610151219" }
+        conc-list: [45]
+        srt-recipe: disagg-variants.yaml:override_1p1d_dep1_tep2_c45_b4
         prefill:
-          num-worker: 4
-          tp: 4
-          ep: 4
+          num-worker: 1
+          tp: 1
+          ep: 1
           dp-attn: true
         decode:
           num-worker: 1
-          tp: 16
-          ep: 16
-          dp-attn: true
-      # 8P1D wide-EP: 8 prefill DEP4 + decode DEP16. 12 nodes (8+4).
-      - spec-decoding: "none"
-        conc-list: [2048, 4096]
-        srt-recipe: disagg-8p1d-dep4-dep16-stp.yaml
+          tp: 2
+          ep: 2
+          dp-attn: false
+      # 1P2D: 1 prefill (TP4/EP4), 2 decode (TP8/EP8), batch 4, conc=48
+      - spec-decoding: "mtp"
+        kv-offloading: dram
+        kv-offload-backend: { name: native, version: "1.3.0a0.dev202610151219" }
+        conc-list: [48]
+        srt-recipe: disagg-variants.yaml:override_1p2d_tep4_tep8_c48_b4
         prefill:
-          num-worker: 8
+          num-worker: 1
           tp: 4
           ep: 4
-          dp-attn: true
+          dp-attn: false
         decode:
-          num-worker: 1
-          tp: 16
-          ep: 16
-          dp-attn: true
-
-qwen3.5-fp8-h100-sglang:
-  image: lmsysorg/sglang:v0.5.14-cu130
-  model: Qwen/Qwen3.5-397B-A17B-FP8
-  model-prefix: qwen3.5
-  runner: h100
-  precision: fp8
-  framework: sglang
-  multinode: false
-  srt-recipe-dir: qwen3.5/sglang/h100-fp8
-  scenarios:
-    fixed-seq-len:
-    - isl: 8192
-      osl: 1024
-      search-space:
-      - tp: 8
-        ep: 1
-        conc-start: 1
-        conc-end: 8
-        srt-recipe: 8k1k.yaml
-      - tp: 8
-        ep: 8
-        conc-start: 16
-        conc-end: 256
-        srt-recipe: 8k1k.yaml
-
-qwen3.5-fp8-h100-sglang-mtp:
-  image: lmsysorg/sglang:v0.5.21-cu130@sha256:b1259f3ea3275f66237c498ea388919729018bc9f01c3d638391e06e2cf3f469
-  model: Qwen/Qwen3.5-397B-A17B-FP8
-  model-prefix: qwen3.5
-  runner: h100
-  precision: fp8
-  framework: sglang
-  multinode: false
-  srt-recipe-dir: qwen3.5/sglang/h100-fp8-mtp
-  scenarios:
-    fixed-seq-len:
-    - isl: 8192
-      osl: 1024
-      search-space:
-      - tp: 8
-        ep: 8
-        conc-start: 4
-        conc-end: 32
-        spec-decoding: mtp
-        srt-recipe: 8k1k.yaml
-
-qwen3.5-fp4-gb300-dynamo-sglang:
-  image: lmsysorg/sglang:v0.5.21-cu130@sha256:b1259f3ea3275f66237c498ea388919729018bc9f01c3d638391e06e2cf3f469
-  model: nvidia/Qwen3.5-397B-A17B-NVFP4-V2
-  model-prefix: qwen3.5
-  runner: gb300
-  precision: fp4
-  framework: dynamo-sglang
-  router: { name: dynamo-router, version: "1.1.0" }
-  multinode: true
-  disagg: true
-  srt-recipe-dir: qwen3.5/sglang/gb300-fp4/8k1k
-  scenarios:
-    fixed-seq-len:
-    - isl: 8192
-      osl: 1024
-      search-space:
-      # 1P1D TP4: 1 prefill worker at TP4 and 1 decode worker at TP4
-      # Pure tensor parallel (STP), 8k1k baseline-low-latency sweep.
-      # Total: 8 GB300 GPUs.
-      - spec-decoding: "none"
-        kv-p2p-transfer: mooncake
-        conc-list: [1, 4, 8, 16, 32, 64, 256]
-        srt-recipe: disagg-1p1d-p-tp4-d-tp4-b128-c1x4x8x16x32x64x256-stp.yaml
-        power: true
+          num-worker: 2
+          tp: 8
+          ep: 8
+          dp-attn: false
+      # 1P4D: 1 prefill (TP4/EP4), 4 decode (TP8/EP8), batch 1, conc=38
+      - spec-decoding: "mtp"
+        kv-offloading: dram
+        kv-offload-backend: { name: native, version: "1.3.0a0.dev202610151219" }
+        conc-list: [38]
+        srt-recipe: disagg-variants.yaml:override_1p4d_tep4_tep8_c38_b1
         prefill:
           num-worker: 1
           tp: 4
-          ep: 1
+          ep: 4
           dp-attn: false
         decode:
+          num-worker: 4
+          tp: 8
+          ep: 8
+          dp-attn: false
+      # 1P4D: 1 prefill (TP4/EP4), 4 decode (TP8/EP8), batch 4, conc=38
+      - spec-decoding: "mtp"
+        kv-offloading: dram
+        kv-offload-backend: { name: native, version: "1.3.0a0.dev202610151219" }
+        conc-list: [38]
+        srt-recipe: disagg-variants.yaml:override_1p4d_tep4_tep8_c38_b4
+        prefill:
           num-worker: 1
           tp: 4
-          ep: 1
+          ep: 4
           dp-attn: false
-      # 5P1D wide-EP: 5 prefill workers @ DEP4 + 1 decode worker @ DEP16.
-      # NIXL transfer. Total: 36 GB300 GPUs (5*4 + 4*4).
-      - spec-decoding: "none"
-        kv-p2p-transfer: nixl
-        conc-list: [2048]
-        srt-recipe: disagg-5p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b4096-c2048-stp.yaml
-        power: true
+        decode:
+          num-worker: 4
+          tp: 8
+          ep: 8
+          dp-attn: false
+      # 2P3D: 2 prefill (TP4/EP4), 3 decode (TP8/EP8), conc=136
+      - spec-decoding: "mtp"
+        kv-offloading: dram
+        kv-offload-backend: { name: native, version: "1.3.0a0.dev202610151219" }
+        conc-list: [136]
+        srt-recipe: disagg-variants.yaml:override_2p3d_tep4_tep8_c136_b4
         prefill:
-          num-worker: 5
+          num-worker: 2
           tp: 4
           ep: 4
-          dp-attn: true
+          dp-attn: false
         decode:
-          num-worker: 1
-          tp: 16
-          ep: 16
-          dp-attn: true
-      # 6P1D wide-EP: 6 prefill workers @ DEP4 + 1 decode worker @ DEP16.
-      # Mooncake transfer. Total: 40 GB300 GPUs (6*4 + 4*4).
-      - spec-decoding: "none"
-        kv-p2p-transfer: mooncake
-        conc-list: [5120]
-        srt-recipe: disagg-6p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b5120-c5120-stp.yaml
-        power: true
+          num-worker: 3
+          tp: 8
+          ep: 8
+          dp-attn: false
+      # 3P1D: 3 prefill (TP4/EP4/dp-attn), 1 decode (TP16/EP16/dp-attn), conc=565
+      - spec-decoding: "mtp"
+        kv-offloading: dram
+        kv-offload-backend: { name: native, version: "1.3.0a0.dev202610151219" }
+        conc-list: [565]
+        srt-recipe: disagg-variants.yaml:override_3p1d_dep4_dep16_c565_b8
         prefill:
-          num-worker: 6
+          num-worker: 3
           tp: 4
           ep: 4
           dp-attn: true
@@ -3757,480 +3334,296 @@ qwen3.5-fp4-gb300-dynamo-sglang:
           tp: 16
           ep: 16
           dp-attn: true
-      # 7P1D wide-EP: 7 prefill workers @ DEP4 + 1 decode worker @ DEP16.
-      # Mooncake transfer. Total: 44 GB300 GPUs (7*4 + 4*4).
-      - spec-decoding: "none"
-        kv-p2p-transfer: mooncake
-        conc-list: [5120]
-        srt-recipe: disagg-7p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b5120-c5120-stp.yaml
-        power: true
+      # 3P2D: 3 prefill (TP4/EP4/dp-attn), 2 decode (TP4/EP4/dp-attn), conc=704
+      - spec-decoding: "mtp"
+        kv-offloading: dram
+        kv-offload-backend: { name: native, version: "1.3.0a0.dev202610151219" }
+        conc-list: [704]
+        srt-recipe: disagg-variants.yaml:override_3p2d_dep4_dep4_c704_b32
         prefill:
-          num-worker: 7
+          num-worker: 3
           tp: 4
           ep: 4
           dp-attn: true
         decode:
-          num-worker: 1
-          tp: 16
-          ep: 16
+          num-worker: 2
+          tp: 4
+          ep: 4
           dp-attn: true
 
-qwen3.5-fp4-gb300-dynamo-trt:
-  image: nvcr.io/nvidia/tensorrt-llm/release:1.3.0rc24
-  model: nvidia/Qwen3.5-397B-A17B-NVFP4-V2
+qwen3.5-fp4-gb300-dynamo-sglang-agentic-agg:
+  image: lmsysorg/sglang:nightly-dev-cu13-20260724-433429b1
+  model: nvidia/Qwen3.5-397B-A17B-NVFP4
   model-prefix: qwen3.5
-  runner: gb300
+  runner: cluster:gb300-nv
   precision: fp4
-  framework: dynamo-trt
+  framework: dynamo-sglang
   multinode: true
-  disagg: true
-  kv-p2p-transfer: nixl
-  srt-recipe-dir: qwen3.5/trtllm/gb300-fp4/8k1k
+  disagg: false
+  srt-recipe-dir: qwen3.5/sglang/gb300-fp4/agentx
   scenarios:
-    fixed-seq-len:
-    - isl: 8192
-      osl: 1024
+    agentic-coding:
+    - dram-utilization: 0.90
       search-space:
-      # 1P2D: 1 prefill (TP1/EP1/dp-attn), 2 decode (TP8/EP8/no-dp-attn), conc=42
-      - conc-list: [42]
-        srt-recipe: disagg-stp-variants.yaml:override_1p2d_tep8_b16_c42
-        prefill:
+      - spec-decoding: mtp
+        kv-offloading: dram
+        kv-offload-backend: { name: hicache }
+        conc-list: [1]
+        num-nodes: 1
+        srt-recipe: agg-variants.yaml:override_c1
+        worker:
           num-worker: 1
-          tp: 1
+          tp: 2
           ep: 1
-          dp-attn: true
-        decode:
-          num-worker: 2
-          tp: 8
-          ep: 8
           dp-attn: false
-      # 1P4D: 1 prefill (TP2/EP2/dp-attn), 4 decode (TP8/EP8/no-dp-attn), conc=8
-      - conc-list: [8]
-        srt-recipe: disagg-stp-variants.yaml:override_1p4d_tep8_b1_c8
-        prefill:
+      - spec-decoding: mtp
+        kv-offloading: dram
+        kv-offload-backend: { name: hicache }
+        conc-list: [24]
+        num-nodes: 1
+        srt-recipe: agg-variants.yaml:override_c24
+        worker:
           num-worker: 1
           tp: 2
-          ep: 2
-          dp-attn: true
-        decode:
-          num-worker: 4
-          tp: 8
-          ep: 8
-          dp-attn: false
-      # 1P4D: 1 prefill (TP1/EP1/dp-attn), 4 decode (TP8/EP8/no-dp-attn), conc=24
-      - conc-list: [24]
-        srt-recipe: disagg-stp-variants.yaml:override_1p4d_tep8_b4_c24
-        prefill:
-          num-worker: 1
-          tp: 1
           ep: 1
-          dp-attn: true
-        decode:
-          num-worker: 4
-          tp: 8
-          ep: 8
           dp-attn: false
-      # 4P1D: 4 prefill (TP1/EP1/dp-attn), 1 decode (TP16/EP16/dp-attn), conc=282
-      - conc-list: [282]
-        srt-recipe: disagg-stp-variants.yaml:override_4p1d_dep16_b16_c282
-        prefill:
-          num-worker: 4
-          tp: 1
-          ep: 1
-          dp-attn: true
-        decode:
+      - spec-decoding: mtp
+        kv-offloading: dram
+        kv-offload-backend: { name: hicache }
+        conc-list: [32]
+        num-nodes: 1
+        srt-recipe: agg-variants.yaml:override_c32
+        worker:
           num-worker: 1
-          tp: 16
-          ep: 16
-          dp-attn: true
-      # 4P3D: 4 prefill (TP1/EP1/dp-attn), 3 decode (TP8/EP8/no-dp-attn), conc=210
-      - conc-list: [210]
-        srt-recipe: disagg-stp-variants.yaml:override_4p3d_tep8_b64_c210
-        prefill:
-          num-worker: 4
-          tp: 1
+          tp: 2
           ep: 1
-          dp-attn: true
-        decode:
-          num-worker: 3
-          tp: 8
-          ep: 8
           dp-attn: false
-      # 7P1D: 7 prefill (TP1/EP1/dp-attn), 1 decode (TP16/EP16/dp-attn), conc=563
-      - conc-list: [563]
-        srt-recipe: disagg-stp-variants.yaml:override_7p1d_dep16_b32_c563
-        prefill:
-          num-worker: 7
-          tp: 1
-          ep: 1
-          dp-attn: true
-        decode:
+      - spec-decoding: mtp
+        kv-offloading: dram
+        kv-offload-backend: { name: hicache }
+        conc-list: [40]
+        num-nodes: 1
+        srt-recipe: agg-variants.yaml:override_c40
+        worker:
           num-worker: 1
-          tp: 16
-          ep: 16
-          dp-attn: true
-      # 10P1D: 10 prefill (TP1/EP1/dp-attn), 1 decode (TP8/EP8/dp-attn), conc=2150
-      - conc-list: [2150]
-        srt-recipe: disagg-stp-variants.yaml:override_10p1d_dep8_b256_c2150
-        prefill:
-          num-worker: 10
-          tp: 1
+          tp: 2
           ep: 1
-          dp-attn: true
-        decode:
+          dp-attn: false
+      - spec-decoding: mtp
+        kv-offloading: dram
+        kv-offload-backend: { name: hicache }
+        conc-list: [48]
+        num-nodes: 1
+        srt-recipe: agg-variants.yaml:override_c48
+        worker:
           num-worker: 1
-          tp: 8
-          ep: 8
-          dp-attn: true
-      # 11P1D: 11 prefill (TP1/EP1/dp-attn), 1 decode (TP16/EP16/dp-attn), conc=1076
-      - conc-list: [1076]
-        srt-recipe: disagg-stp-variants.yaml:override_11p1d_dep16_b64_c1076
-        prefill:
-          num-worker: 11
-          tp: 1
+          tp: 2
           ep: 1
-          dp-attn: true
-        decode:
+          dp-attn: false
+      - spec-decoding: mtp
+        kv-offloading: dram
+        kv-offload-backend: { name: hicache }
+        conc-list: [52]
+        num-nodes: 1
+        srt-recipe: agg-variants.yaml:override_c52
+        worker:
           num-worker: 1
-          tp: 16
-          ep: 16
-          dp-attn: true
-      # 16P1D: 16 prefill (TP1/EP1/dp-attn), 1 decode (TP16/EP16/dp-attn), conc=2253
-      - conc-list: [2253]
-        srt-recipe: disagg-stp-variants.yaml:override_16p1d_dep16_b128_c2253
-        prefill:
-          num-worker: 16
-          tp: 1
+          tp: 2
           ep: 1
-          dp-attn: true
-        decode:
+          dp-attn: false
+      - spec-decoding: mtp
+        kv-offloading: dram
+        kv-offload-backend: { name: hicache }
+        conc-list: [64]
+        num-nodes: 1
+        srt-recipe: agg-variants.yaml:override_c64
+        worker:
           num-worker: 1
-          tp: 16
-          ep: 16
-          dp-attn: true
-      # 24P1D: 24 prefill (TP1/EP1/dp-attn), 1 decode (TP16/EP16/dp-attn), conc=8192
-      - conc-list: [8192]
-        srt-recipe: disagg-stp-variants.yaml:override_24p1d_dep16_b512_c8192_stp_sweep
-        prefill:
-          num-worker: 24
-          tp: 1
+          tp: 2
           ep: 1
-          dp-attn: true
-        decode:
-          num-worker: 1
-          tp: 16
-          ep: 16
-          dp-attn: true
-
-# GB300 SGLang AgentX, re-swept across low/mid/high concurrency after aiperf
-# restored real inter-tool-call pacing. The seven aggregate frontier points use
-# one TP2 worker with MTP/NEXTN + hierarchical KV cache. srt-recipe carries the
-# full srtctl recipe; the matrix topology stays in sync for naming/GPU accounting.
-qwen3.5-fp4-gb300-dynamo-trt-mtp:
-  image: nvcr.io/nvidia/tensorrt-llm/release:1.3.0rc24
-  model: nvidia/Qwen3.5-397B-A17B-NVFP4-V2
+          dp-attn: false
+# The seven disaggregated frontier points use six TP4 shapes plus one TP2
+# shape. Stable X-Dynamo-Session-ID affinity replaces the removed conv-aware
+# routing message path.
+qwen3.5-fp4-gb300-dynamo-sglang-agentic-disagg:
+  image: lmsysorg/sglang:nightly-dev-cu13-20260724-433429b1
+  model: nvidia/Qwen3.5-397B-A17B-NVFP4
   model-prefix: qwen3.5
-  runner: gb300
+  runner: cluster:gb300-nv
   precision: fp4
-  framework: dynamo-trt
+  framework: dynamo-sglang
+  router: { name: dynamo-router, version: "5a638087d82c990d35c69cb8e41c2c2582e9ef9a" }
+  kv-p2p-transfer: mooncake
   multinode: true
   disagg: true
-  kv-p2p-transfer: nixl
-  srt-recipe-dir: qwen3.5/trtllm/gb300-fp4/8k1k
+  srt-recipe-dir: qwen3.5/sglang/gb300-fp4/agentx
   scenarios:
-    fixed-seq-len:
-    - isl: 8192
-      osl: 1024
+    agentic-coding:
+    - dram-utilization: 0.90
       search-space:
-      # 1P2D: 1 prefill (TP1/EP1/dp-attn), 2 decode (TP8/EP8/no-dp-attn), conc=20
-      - spec-decoding: "mtp"
-        conc-list: [20]
-        srt-recipe: disagg-mtp-variants.yaml:override_1p2d_tep8_b8_mtp3_c20
+      - spec-decoding: mtp
+        kv-offloading: dram
+        kv-offload-backend: { name: hicache }
+        conc-list: [8]
+        srt-recipe: disagg-variants.yaml:override_tp4_tp4_c8
         prefill:
           num-worker: 1
-          tp: 1
+          tp: 4
           ep: 1
-          dp-attn: true
+          dp-attn: false
         decode:
-          num-worker: 2
-          tp: 8
-          ep: 8
+          num-worker: 1
+          tp: 4
+          ep: 1
           dp-attn: false
-      # 1P4D: 1 prefill (TP1/EP1/dp-attn), 4 decode (TP8/EP8/no-dp-attn), conc=12
-      - spec-decoding: "mtp"
-        conc-list: [12]
-        srt-recipe: disagg-mtp-variants.yaml:override_1p4d_tep8_b1_mtp3_c12
+      - spec-decoding: mtp
+        kv-offloading: dram
+        kv-offload-backend: { name: hicache }
+        conc-list: [16]
+        srt-recipe: disagg-variants.yaml:override_tp4_tp4_c16
         prefill:
           num-worker: 1
-          tp: 1
+          tp: 4
           ep: 1
-          dp-attn: true
+          dp-attn: false
         decode:
-          num-worker: 4
-          tp: 8
-          ep: 8
+          num-worker: 1
+          tp: 4
+          ep: 1
           dp-attn: false
-      # 1P4D: 1 prefill (TP1/EP1/dp-attn), 4 decode (TP8/EP8/no-dp-attn), conc=8
-      - spec-decoding: "mtp"
-        conc-list: [8]
-        srt-recipe: disagg-mtp-variants.yaml:override_1p4d_tep8_b2_mtp3_c8
+      - spec-decoding: mtp
+        kv-offloading: dram
+        kv-offload-backend: { name: hicache }
+        conc-list: [32]
+        srt-recipe: disagg-variants.yaml:override_tp4_tp4_c32
         prefill:
           num-worker: 1
-          tp: 1
+          tp: 4
           ep: 1
-          dp-attn: true
+          dp-attn: false
         decode:
-          num-worker: 4
-          tp: 8
-          ep: 8
+          num-worker: 1
+          tp: 4
+          ep: 1
           dp-attn: false
-      # 4P3D: 4 prefill (TP1/EP1/dp-attn), 3 decode (TP8/EP8/no-dp-attn), conc=126
-      - spec-decoding: "mtp"
-        conc-list: [126]
-        srt-recipe: disagg-mtp-variants.yaml:override_4p3d_tep8_b32_mtp3_c126
+      - spec-decoding: mtp
+        kv-offloading: dram
+        kv-offload-backend: { name: hicache }
+        conc-list: [64]
+        srt-recipe: disagg-variants.yaml:override_tp4_tp4_c64
         prefill:
-          num-worker: 4
-          tp: 1
+          num-worker: 1
+          tp: 4
           ep: 1
-          dp-attn: true
+          dp-attn: false
         decode:
-          num-worker: 3
-          tp: 8
-          ep: 8
+          num-worker: 1
+          tp: 4
+          ep: 1
           dp-attn: false
-      # 5P1D: 5 prefill (TP1/EP1/dp-attn), 1 decode (TP16/EP16/dp-attn), conc=154
-      - spec-decoding: "mtp"
-        conc-list: [154]
-        srt-recipe: disagg-mtp-variants.yaml:override_5p1d_dep16_b8_mtp3_c154
+      - spec-decoding: mtp
+        kv-offloading: dram
+        kv-offload-backend: { name: hicache }
+        conc-list: [96]
+        srt-recipe: disagg-variants.yaml:override_tp4_tp4_c96
         prefill:
-          num-worker: 5
-          tp: 1
+          num-worker: 1
+          tp: 4
           ep: 1
-          dp-attn: true
+          dp-attn: false
         decode:
           num-worker: 1
-          tp: 16
-          ep: 16
-          dp-attn: true
-      # 7P1D: 7 prefill (TP2/EP2/dp-attn), 1 decode (TP16/EP16/dp-attn), conc=666
-      - spec-decoding: "mtp"
-        conc-list: [666]
-        srt-recipe: disagg-mtp-variants.yaml:override_7p1d_dep16_b32_mtp3_c666
-        prefill:
-          num-worker: 7
-          tp: 2
-          ep: 2
-          dp-attn: true
-        decode:
-          num-worker: 1
-          tp: 16
-          ep: 16
-          dp-attn: true
-      # 11P1D: 11 prefill (TP1/EP1/dp-attn), 1 decode (TP8/EP8/dp-attn), conc=1229
-      - spec-decoding: "mtp"
-        conc-list: [1229]
-        srt-recipe: disagg-mtp-variants.yaml:override_11p1d_dep8_b128_mtp3_c1229
+          tp: 4
+          ep: 1
+          dp-attn: false
+      - spec-decoding: mtp
+        kv-offloading: dram
+        kv-offload-backend: { name: hicache }
+        conc-list: [128]
+        srt-recipe: disagg-variants.yaml:override_tp4_tp4_c128
         prefill:
-          num-worker: 11
-          tp: 1
+          num-worker: 1
+          tp: 4
           ep: 1
-          dp-attn: true
+          dp-attn: false
         decode:
           num-worker: 1
-          tp: 8
-          ep: 8
-          dp-attn: true
-      # 17P2D: 17 prefill (TP1/EP1/dp-attn), 2 decode (TP8/EP8/dp-attn), conc=1126
-      - spec-decoding: "mtp"
-        conc-list: [1126]
-        srt-recipe: disagg-mtp-variants.yaml:override_17p2d_dep8_b64_mtp3_c1126
-        prefill:
-          num-worker: 17
-          tp: 1
+          tp: 4
           ep: 1
-          dp-attn: true
-        decode:
-          num-worker: 2
-          tp: 8
-          ep: 8
-          dp-attn: true
-      # 26P1D: 26 prefill (TP1/EP1/dp-attn), 1 decode (TP16/EP16/dp-attn), conc=4301, MTP draft-len 2
-      - spec-decoding: "mtp"
-        conc-list: [4301]
-        srt-recipe: disagg-mtp-variants.yaml:override_26p1d_dep16_b256_mtp2_c4301
+          dp-attn: false
+      - spec-decoding: mtp
+        kv-offloading: dram
+        kv-offload-backend: { name: hicache }
+        conc-list: [72]
+        srt-recipe: disagg-variants.yaml:override_tp2_tp2_c72
         prefill:
-          num-worker: 26
-          tp: 1
-          ep: 1
-          dp-attn: true
-        decode:
           num-worker: 1
-          tp: 16
-          ep: 16
-          dp-attn: true
-      # 24P1D: 24 prefill (TP1/EP1/dp-attn), 1 decode (TP16/EP16/dp-attn), conc=8192, MTP curve tail (spec decoding disabled)
-      - spec-decoding: "none"
-        conc-list: [8192]
-        srt-recipe: disagg-mtp-variants.yaml:override_24p1d_dep16_b512_mtp0_c8192_mtp_sweep
-        prefill:
-          num-worker: 24
-          tp: 1
+          tp: 2
           ep: 1
-          dp-attn: true
+          dp-attn: false
         decode:
           num-worker: 1
-          tp: 16
-          ep: 16
-          dp-attn: true
+          tp: 2
+          ep: 1
+          dp-attn: false
 
-qwen3.5-fp4-gb300-dynamo-trt-agentic-disagg:
-  image: nvcr.io/nvidia/tensorrt-llm/release:1.3.0a0.dev202610151219
-  model: nvidia/Qwen3.5-397B-A17B-NVFP4-V2
+# Five-point Qwen3.5 AgentX Pareto refresh on the 2026-08-31 nightly. The
+# throughput and high-curve points use PP4 prefill workers; the two C44
+# fingerprints and C7 point below retain their measured aggregate TP shapes.
+# PR #36248 breakable prefill CUDA Graph settings are intentionally excluded.
+qwen3.5-fp4-gb300-dynamo-sglang-agentic-pp-pareto:
+  image: lmsysorg/sglang:nightly-dev-cu13-20260831-bb5e6198
+  model: nvidia/Qwen3.5-397B-A17B-NVFP4
   model-prefix: qwen3.5
   runner: cluster:gb300-nv
   precision: fp4
-  framework: dynamo-trt
-  router: { name: dynamo-router, version: "1.6.0.dev20261010" }
-  kv-p2p-transfer: nixl
+  framework: dynamo-sglang
+  router: { name: dynamo-router, version: "61c37bc33c3e88da3facaa39fa2b5caf616740ba" }
+  kv-p2p-transfer: mooncake
   multinode: true
   disagg: true
-  srt-recipe-dir: qwen3.5/trtllm/gb300-fp4/agentx
+  srt-recipe-dir: qwen3.5/sglang/gb300-fp4/agentx
   scenarios:
     agentic-coding:
-    # Recipes reserve 128 GiB per rank; each node has 840 GiB and 4 GPUs.
-    - dram-utilization: 0.609524
+    - dram-utilization: 0.90
       search-space:
-      # 1P1D: 1 prefill (TP1/EP1/dp-attn), 1 decode (TP2/EP2) on the same node, batch 8, conc=38, 48
-      - spec-decoding: "mtp"
-        kv-offloading: dram
-        kv-offload-backend: { name: native, version: "1.3.0a0.dev202610151219" }
-        conc-list: [38, 48]
-        srt-recipe: disagg-variants.yaml:override_1p1d_dep1_tep2_b8
-        prefill:
-          num-worker: 1
-          tp: 1
-          ep: 1
-          dp-attn: true
-        decode:
-          num-worker: 1
-          tp: 2
-          ep: 2
-          dp-attn: false
-      # 1P1D: 1 prefill (TP1/EP1/dp-attn), 1 decode (TP2/EP2) on the same node, batch 4, conc=45
-      - spec-decoding: "mtp"
+      - spec-decoding: mtp
         kv-offloading: dram
-        kv-offload-backend: { name: native, version: "1.3.0a0.dev202610151219" }
-        conc-list: [45]
-        srt-recipe: disagg-variants.yaml:override_1p1d_dep1_tep2_c45_b4
+        kv-offload-backend: { name: hicache }
+        conc-list: [704]
+        srt-recipe: disagg-pp-pareto-variants.yaml:override_3p2d_c704
         prefill:
-          num-worker: 1
+          num-worker: 3
           tp: 1
+          pp: 4
           ep: 1
-          dp-attn: true
-        decode:
-          num-worker: 1
-          tp: 2
-          ep: 2
-          dp-attn: false
-      # 1P2D: 1 prefill (TP4/EP4), 2 decode (TP8/EP8), batch 4, conc=48
-      - spec-decoding: "mtp"
-        kv-offloading: dram
-        kv-offload-backend: { name: native, version: "1.3.0a0.dev202610151219" }
-        conc-list: [48]
-        srt-recipe: disagg-variants.yaml:override_1p2d_tep4_tep8_c48_b4
-        prefill:
-          num-worker: 1
-          tp: 4
-          ep: 4
-          dp-attn: false
-        decode:
-          num-worker: 2
-          tp: 8
-          ep: 8
-          dp-attn: false
-      # 1P4D: 1 prefill (TP4/EP4), 4 decode (TP8/EP8), batch 1, conc=38
-      - spec-decoding: "mtp"
-        kv-offloading: dram
-        kv-offload-backend: { name: native, version: "1.3.0a0.dev202610151219" }
-        conc-list: [38]
-        srt-recipe: disagg-variants.yaml:override_1p4d_tep4_tep8_c38_b1
-        prefill:
-          num-worker: 1
-          tp: 4
-          ep: 4
-          dp-attn: false
-        decode:
-          num-worker: 4
-          tp: 8
-          ep: 8
-          dp-attn: false
-      # 1P4D: 1 prefill (TP4/EP4), 4 decode (TP8/EP8), batch 4, conc=38
-      - spec-decoding: "mtp"
-        kv-offloading: dram
-        kv-offload-backend: { name: native, version: "1.3.0a0.dev202610151219" }
-        conc-list: [38]
-        srt-recipe: disagg-variants.yaml:override_1p4d_tep4_tep8_c38_b4
-        prefill:
-          num-worker: 1
-          tp: 4
-          ep: 4
           dp-attn: false
         decode:
-          num-worker: 4
-          tp: 8
-          ep: 8
-          dp-attn: false
-      # 2P3D: 2 prefill (TP4/EP4), 3 decode (TP8/EP8), conc=136
-      - spec-decoding: "mtp"
-        kv-offloading: dram
-        kv-offload-backend: { name: native, version: "1.3.0a0.dev202610151219" }
-        conc-list: [136]
-        srt-recipe: disagg-variants.yaml:override_2p3d_tep4_tep8_c136_b4
-        prefill:
           num-worker: 2
           tp: 4
+          pp: 1
           ep: 4
-          dp-attn: false
-        decode:
-          num-worker: 3
-          tp: 8
-          ep: 8
-          dp-attn: false
-      # 3P1D: 3 prefill (TP4/EP4/dp-attn), 1 decode (TP16/EP16/dp-attn), conc=565
-      - spec-decoding: "mtp"
-        kv-offloading: dram
-        kv-offload-backend: { name: native, version: "1.3.0a0.dev202610151219" }
-        conc-list: [565]
-        srt-recipe: disagg-variants.yaml:override_3p1d_dep4_dep16_c565_b8
-        prefill:
-          num-worker: 3
-          tp: 4
-          ep: 4
-          dp-attn: true
-        decode:
-          num-worker: 1
-          tp: 16
-          ep: 16
           dp-attn: true
-      # 3P2D: 3 prefill (TP4/EP4/dp-attn), 2 decode (TP4/EP4/dp-attn), conc=704
-      - spec-decoding: "mtp"
+      - spec-decoding: mtp
         kv-offloading: dram
-        kv-offload-backend: { name: native, version: "1.3.0a0.dev202610151219" }
-        conc-list: [704]
-        srt-recipe: disagg-variants.yaml:override_3p2d_dep4_dep4_c704_b32
+        kv-offload-backend: { name: hicache }
+        conc-list: [565]
+        srt-recipe: disagg-pp-pareto-variants.yaml:override_3p4d_c565
         prefill:
           num-worker: 3
-          tp: 4
-          ep: 4
-          dp-attn: true
+          tp: 1
+          pp: 4
+          ep: 1
+          dp-attn: false
         decode:
-          num-worker: 2
+          num-worker: 4
           tp: 4
+          pp: 1
           ep: 4
           dp-attn: true
 
-qwen3.5-fp4-gb300-dynamo-sglang-agentic-agg:
-  image: lmsysorg/sglang:nightly-dev-cu13-20260724-433429b1
+qwen3.5-fp4-gb300-dynamo-sglang-agentic-agg-pareto:
+  image: lmsysorg/sglang:nightly-dev-cu13-20260831-bb5e6198
   model: nvidia/Qwen3.5-397B-A17B-NVFP4
   model-prefix: qwen3.5
   runner: cluster:gb300-nv
@@ -4246,221 +3639,135 @@ qwen3.5-fp4-gb300-dynamo-sglang-agentic-agg:
       - spec-decoding: mtp
         kv-offloading: dram
         kv-offload-backend: { name: hicache }
-        conc-list: [1]
+        conc-list: [44]
         num-nodes: 1
-        srt-recipe: agg-variants.yaml:override_c1
+        srt-recipe: agg-pareto-variants.yaml:override_tp2_c44_b2
         worker:
           num-worker: 1
           tp: 2
+          pp: 1
           ep: 1
           dp-attn: false
       - spec-decoding: mtp
         kv-offloading: dram
         kv-offload-backend: { name: hicache }
-        conc-list: [24]
+        conc-list: [44]
         num-nodes: 1
-        srt-recipe: agg-variants.yaml:override_c24
+        srt-recipe: agg-pareto-variants.yaml:override_tp2_c44_b1
         worker:
           num-worker: 1
           tp: 2
+          pp: 1
           ep: 1
           dp-attn: false
       - spec-decoding: mtp
         kv-offloading: dram
         kv-offload-backend: { name: hicache }
-        conc-list: [32]
-        num-nodes: 1
-        srt-recipe: agg-variants.yaml:override_c32
+        conc-list: [7]
+        num-nodes: 2
+        srt-recipe: agg-pareto-variants.yaml:override_tp8_c7_b1
         worker:
           num-worker: 1
-          tp: 2
+          tp: 8
+          pp: 1
           ep: 1
           dp-attn: false
+
+qwen3.5-fp8-gb300-dynamo-sglang-agentic-pp-pareto:
+  image: lmsysorg/sglang:nightly-dev-cu13-20260913-fa663e72
+  model: Qwen/Qwen3.5-397B-A17B-FP8
+  model-prefix: qwen3.5
+  runner: cluster:gb300-nv
+  precision: fp8
+  framework: dynamo-sglang
+  router: { name: dynamo-router, version: "ad6f7d54ce7b99c53576b10482755c93c921fbac" }
+  kv-p2p-transfer: mooncake
+  multinode: true
+  disagg: true
+  srt-recipe-dir: qwen3.5/sglang/gb300-fp8/agentx
+  scenarios:
+    agentic-coding:
+    - dram-utilization: 0.90
+      search-space:
       - spec-decoding: mtp
         kv-offloading: dram
         kv-offload-backend: { name: hicache }
-        conc-list: [40]
-        num-nodes: 1
-        srt-recipe: agg-variants.yaml:override_c40
-        worker:
-          num-worker: 1
-          tp: 2
-          ep: 1
-          dp-attn: false
-      - spec-decoding: mtp
-        kv-offloading: dram
-        kv-offload-backend: { name: hicache }
-        conc-list: [48]
-        num-nodes: 1
-        srt-recipe: agg-variants.yaml:override_c48
-        worker:
-          num-worker: 1
-          tp: 2
-          ep: 1
-          dp-attn: false
-      - spec-decoding: mtp
-        kv-offloading: dram
-        kv-offload-backend: { name: hicache }
-        conc-list: [52]
-        num-nodes: 1
-        srt-recipe: agg-variants.yaml:override_c52
-        worker:
-          num-worker: 1
-          tp: 2
-          ep: 1
-          dp-attn: false
-      - spec-decoding: mtp
-        kv-offloading: dram
-        kv-offload-backend: { name: hicache }
-        conc-list: [64]
-        num-nodes: 1
-        srt-recipe: agg-variants.yaml:override_c64
-        worker:
-          num-worker: 1
-          tp: 2
-          ep: 1
-          dp-attn: false
-# The seven disaggregated frontier points use six TP4 shapes plus one TP2
-# shape. Stable X-Dynamo-Session-ID affinity replaces the removed conv-aware
-# routing message path.
-qwen3.5-fp4-gb300-dynamo-sglang-agentic-disagg:
-  image: lmsysorg/sglang:nightly-dev-cu13-20260724-433429b1
-  model: nvidia/Qwen3.5-397B-A17B-NVFP4
-  model-prefix: qwen3.5
-  runner: cluster:gb300-nv
-  precision: fp4
-  framework: dynamo-sglang
-  router: { name: dynamo-router, version: "5a638087d82c990d35c69cb8e41c2c2582e9ef9a" }
-  kv-p2p-transfer: mooncake
-  multinode: true
-  disagg: true
-  srt-recipe-dir: qwen3.5/sglang/gb300-fp4/agentx
-  scenarios:
-    agentic-coding:
-    - dram-utilization: 0.90
-      search-space:
-      - spec-decoding: mtp
-        kv-offloading: dram
-        kv-offload-backend: { name: hicache }
-        conc-list: [8]
-        srt-recipe: disagg-variants.yaml:override_tp4_tp4_c8
-        prefill:
-          num-worker: 1
-          tp: 4
-          ep: 1
-          dp-attn: false
-        decode:
-          num-worker: 1
-          tp: 4
-          ep: 1
-          dp-attn: false
-      - spec-decoding: mtp
-        kv-offloading: dram
-        kv-offload-backend: { name: hicache }
-        conc-list: [16]
-        srt-recipe: disagg-variants.yaml:override_tp4_tp4_c16
-        prefill:
-          num-worker: 1
-          tp: 4
-          ep: 1
-          dp-attn: false
-        decode:
-          num-worker: 1
-          tp: 4
-          ep: 1
-          dp-attn: false
-      - spec-decoding: mtp
-        kv-offloading: dram
-        kv-offload-backend: { name: hicache }
-        conc-list: [32]
-        srt-recipe: disagg-variants.yaml:override_tp4_tp4_c32
+        conc-list: [1000]
+        srt-recipe: disagg-variants.yaml:override_5p3d_pp4_dep4_c1000
         prefill:
-          num-worker: 1
-          tp: 4
+          num-worker: 5
+          tp: 1
+          pp: 4
           ep: 1
           dp-attn: false
         decode:
-          num-worker: 1
+          num-worker: 3
           tp: 4
-          ep: 1
-          dp-attn: false
+          pp: 1
+          ep: 4
+          dp-attn: true
       - spec-decoding: mtp
         kv-offloading: dram
         kv-offload-backend: { name: hicache }
-        conc-list: [64]
-        srt-recipe: disagg-variants.yaml:override_tp4_tp4_c64
+        conc-list: [600]
+        srt-recipe: disagg-variants.yaml:override_3p2d_pp4_dep4_c600
         prefill:
-          num-worker: 1
-          tp: 4
+          num-worker: 3
+          tp: 1
+          pp: 4
           ep: 1
           dp-attn: false
         decode:
-          num-worker: 1
+          num-worker: 2
           tp: 4
-          ep: 1
-          dp-attn: false
+          pp: 1
+          ep: 4
+          dp-attn: true
       - spec-decoding: mtp
         kv-offloading: dram
         kv-offload-backend: { name: hicache }
-        conc-list: [96]
-        srt-recipe: disagg-variants.yaml:override_tp4_tp4_c96
+        conc-list: [200]
+        srt-recipe: disagg-variants.yaml:override_1p1d_pp4_dep4_c200
         prefill:
           num-worker: 1
-          tp: 4
+          tp: 1
+          pp: 4
           ep: 1
           dp-attn: false
         decode:
           num-worker: 1
           tp: 4
-          ep: 1
-          dp-attn: false
+          pp: 1
+          ep: 4
+          dp-attn: true
       - spec-decoding: mtp
         kv-offloading: dram
         kv-offload-backend: { name: hicache }
-        conc-list: [128]
-        srt-recipe: disagg-variants.yaml:override_tp4_tp4_c128
+        conc-list: [100]
+        srt-recipe: disagg-variants.yaml:override_1p1d_pp4_dep4_c100
         prefill:
           num-worker: 1
-          tp: 4
+          tp: 1
+          pp: 4
           ep: 1
           dp-attn: false
         decode:
           num-worker: 1
           tp: 4
-          ep: 1
-          dp-attn: false
-      - spec-decoding: mtp
-        kv-offloading: dram
-        kv-offload-backend: { name: hicache }
-        conc-list: [72]
-        srt-recipe: disagg-variants.yaml:override_tp2_tp2_c72
-        prefill:
-          num-worker: 1
-          tp: 2
-          ep: 1
-          dp-attn: false
-        decode:
-          num-worker: 1
-          tp: 2
-          ep: 1
-          dp-attn: false
+          pp: 1
+          ep: 4
+          dp-attn: true
 
-# Five-point Qwen3.5 AgentX Pareto refresh on the 2026-08-31 nightly. The
-# throughput and high-curve points use PP4 prefill workers; the two C44
-# fingerprints and C7 point below retain their measured aggregate TP shapes.
-# PR #36248 breakable prefill CUDA Graph settings are intentionally excluded.
-qwen3.5-fp4-gb300-dynamo-sglang-agentic-pp-pareto:
-  image: lmsysorg/sglang:nightly-dev-cu13-20260831-bb5e6198
-  model: nvidia/Qwen3.5-397B-A17B-NVFP4
+qwen3.5-fp8-gb300-dynamo-sglang-agentic-agg-pareto:
+  image: lmsysorg/sglang:nightly-dev-cu13-20260913-fa663e72
+  model: Qwen/Qwen3.5-397B-A17B-FP8
   model-prefix: qwen3.5
   runner: cluster:gb300-nv
-  precision: fp4
+  precision: fp8
   framework: dynamo-sglang
-  router: { name: dynamo-router, version: "61c37bc33c3e88da3facaa39fa2b5caf616740ba" }
-  kv-p2p-transfer: mooncake
   multinode: true
-  disagg: true
-  srt-recipe-dir: qwen3.5/sglang/gb300-fp4/agentx
+  disagg: false
+  srt-recipe-dir: qwen3.5/sglang/gb300-fp8/agentx
   scenarios:
     agentic-coding:
     - dram-utilization: 0.90
@@ -4468,82 +3775,57 @@ qwen3.5-fp4-gb300-dynamo-sglang-agentic-pp-pareto:
       - spec-decoding: mtp
         kv-offloading: dram
         kv-offload-backend: { name: hicache }
-        conc-list: [704]
-        srt-recipe: disagg-pp-pareto-variants.yaml:override_3p2d_c704
-        prefill:
-          num-worker: 3
-          tp: 1
-          pp: 4
-          ep: 1
-          dp-attn: false
-        decode:
-          num-worker: 2
+        conc-list: [44]
+        num-nodes: 1
+        srt-recipe: agg-variants.yaml:override_tp4_c44_b4
+        worker:
+          num-worker: 1
           tp: 4
           pp: 1
-          ep: 4
-          dp-attn: true
+          ep: 1
+          dp-attn: false
       - spec-decoding: mtp
         kv-offloading: dram
         kv-offload-backend: { name: hicache }
-        conc-list: [565]
-        srt-recipe: disagg-pp-pareto-variants.yaml:override_3p4d_c565
-        prefill:
-          num-worker: 3
-          tp: 1
-          pp: 4
-          ep: 1
-          dp-attn: false
-        decode:
-          num-worker: 4
+        conc-list: [44]
+        num-nodes: 1
+        srt-recipe: agg-variants.yaml:override_tp4_c44_b2
+        worker:
+          num-worker: 1
           tp: 4
           pp: 1
-          ep: 4
-          dp-attn: true
-
-qwen3.5-fp4-gb300-dynamo-sglang-agentic-agg-pareto:
-  image: lmsysorg/sglang:nightly-dev-cu13-20260831-bb5e6198
-  model: nvidia/Qwen3.5-397B-A17B-NVFP4
-  model-prefix: qwen3.5
-  runner: cluster:gb300-nv
-  precision: fp4
-  framework: dynamo-sglang
-  multinode: true
-  disagg: false
-  srt-recipe-dir: qwen3.5/sglang/gb300-fp4/agentx
-  scenarios:
-    agentic-coding:
-    - dram-utilization: 0.90
-      search-space:
+          ep: 1
+          dp-attn: false
       - spec-decoding: mtp
         kv-offloading: dram
         kv-offload-backend: { name: hicache }
         conc-list: [44]
         num-nodes: 1
-        srt-recipe: agg-pareto-variants.yaml:override_tp2_c44_b2
+        srt-recipe: agg-variants.yaml:override_tp4_c44_b1
         worker:
           num-worker: 1
-          tp: 2
+          tp: 4
           pp: 1
           ep: 1
           dp-attn: false
       - spec-decoding: mtp
         kv-offloading: dram
         kv-offload-backend: { name: hicache }
-        conc-list: [44]
+        conc-list: [1]
         num-nodes: 1
-        srt-recipe: agg-pareto-variants.yaml:override_tp2_c44_b1
+        srt-recipe: agg-variants.yaml:override_tp4_c1_b1
         worker:
           num-worker: 1
-          tp: 2
+          tp: 4
           pp: 1
           ep: 1
           dp-attn: false
       - spec-decoding: mtp
         kv-offloading: dram
         kv-offload-backend: { name: hicache }
-        conc-list: [7]
+        conc-list: [1]
         num-nodes: 2
-        srt-recipe: agg-pareto-variants.yaml:override_tp8_c7_b1
+        srt-recipe: agg-variants.yaml:override_tp8_c1_b1
         worker:
           num-worker: 1
           tp: 8
@@ -4551,171 +3833,11 @@ qwen3.5-fp4-gb300-dynamo-sglang-agentic-agg-pareto:
           ep: 1
           dp-attn: false
 
-qwen3.5-fp8-gb300-dynamo-sglang-agentic-pp-pareto:
-  image: lmsysorg/sglang:nightly-dev-cu13-20260913-fa663e72
+qwen3.5-fp8-b300-sglang-agentic-mtp:
+  image: lmsysorg/sglang:v0.5.16-cu130
   model: Qwen/Qwen3.5-397B-A17B-FP8
   model-prefix: qwen3.5
-  runner: cluster:gb300-nv
-  precision: fp8
-  framework: dynamo-sglang
-  router: { name: dynamo-router, version: "ad6f7d54ce7b99c53576b10482755c93c921fbac" }
-  kv-p2p-transfer: mooncake
-  multinode: true
-  disagg: true
-  srt-recipe-dir: qwen3.5/sglang/gb300-fp8/agentx
-  scenarios:
-    agentic-coding:
-    - dram-utilization: 0.90
-      search-space:
-      - spec-decoding: mtp
-        kv-offloading: dram
-        kv-offload-backend: { name: hicache }
-        conc-list: [1000]
-        srt-recipe: disagg-variants.yaml:override_5p3d_pp4_dep4_c1000
-        prefill:
-          num-worker: 5
-          tp: 1
-          pp: 4
-          ep: 1
-          dp-attn: false
-        decode:
-          num-worker: 3
-          tp: 4
-          pp: 1
-          ep: 4
-          dp-attn: true
-      - spec-decoding: mtp
-        kv-offloading: dram
-        kv-offload-backend: { name: hicache }
-        conc-list: [600]
-        srt-recipe: disagg-variants.yaml:override_3p2d_pp4_dep4_c600
-        prefill:
-          num-worker: 3
-          tp: 1
-          pp: 4
-          ep: 1
-          dp-attn: false
-        decode:
-          num-worker: 2
-          tp: 4
-          pp: 1
-          ep: 4
-          dp-attn: true
-      - spec-decoding: mtp
-        kv-offloading: dram
-        kv-offload-backend: { name: hicache }
-        conc-list: [200]
-        srt-recipe: disagg-variants.yaml:override_1p1d_pp4_dep4_c200
-        prefill:
-          num-worker: 1
-          tp: 1
-          pp: 4
-          ep: 1
-          dp-attn: false
-        decode:
-          num-worker: 1
-          tp: 4
-          pp: 1
-          ep: 4
-          dp-attn: true
-      - spec-decoding: mtp
-        kv-offloading: dram
-        kv-offload-backend: { name: hicache }
-        conc-list: [100]
-        srt-recipe: disagg-variants.yaml:override_1p1d_pp4_dep4_c100
-        prefill:
-          num-worker: 1
-          tp: 1
-          pp: 4
-          ep: 1
-          dp-attn: false
-        decode:
-          num-worker: 1
-          tp: 4
-          pp: 1
-          ep: 4
-          dp-attn: true
-
-qwen3.5-fp8-gb300-dynamo-sglang-agentic-agg-pareto:
-  image: lmsysorg/sglang:nightly-dev-cu13-20260913-fa663e72
-  model: Qwen/Qwen3.5-397B-A17B-FP8
-  model-prefix: qwen3.5
-  runner: cluster:gb300-nv
-  precision: fp8
-  framework: dynamo-sglang
-  multinode: true
-  disagg: false
-  srt-recipe-dir: qwen3.5/sglang/gb300-fp8/agentx
-  scenarios:
-    agentic-coding:
-    - dram-utilization: 0.90
-      search-space:
-      - spec-decoding: mtp
-        kv-offloading: dram
-        kv-offload-backend: { name: hicache }
-        conc-list: [44]
-        num-nodes: 1
-        srt-recipe: agg-variants.yaml:override_tp4_c44_b4
-        worker:
-          num-worker: 1
-          tp: 4
-          pp: 1
-          ep: 1
-          dp-attn: false
-      - spec-decoding: mtp
-        kv-offloading: dram
-        kv-offload-backend: { name: hicache }
-        conc-list: [44]
-        num-nodes: 1
-        srt-recipe: agg-variants.yaml:override_tp4_c44_b2
-        worker:
-          num-worker: 1
-          tp: 4
-          pp: 1
-          ep: 1
-          dp-attn: false
-      - spec-decoding: mtp
-        kv-offloading: dram
-        kv-offload-backend: { name: hicache }
-        conc-list: [44]
-        num-nodes: 1
-        srt-recipe: agg-variants.yaml:override_tp4_c44_b1
-        worker:
-          num-worker: 1
-          tp: 4
-          pp: 1
-          ep: 1
-          dp-attn: false
-      - spec-decoding: mtp
-        kv-offloading: dram
-        kv-offload-backend: { name: hicache }
-        conc-list: [1]
-        num-nodes: 1
-        srt-recipe: agg-variants.yaml:override_tp4_c1_b1
-        worker:
-          num-worker: 1
-          tp: 4
-          pp: 1
-          ep: 1
-          dp-attn: false
-      - spec-decoding: mtp
-        kv-offloading: dram
-        kv-offload-backend: { name: hicache }
-        conc-list: [1]
-        num-nodes: 2
-        srt-recipe: agg-variants.yaml:override_tp8_c1_b1
-        worker:
-          num-worker: 1
-          tp: 8
-          pp: 1
-          ep: 1
-          dp-attn: false
-
-qwen3.5-fp8-b300-sglang-agentic-mtp:
-  image: lmsysorg/sglang:v0.5.16-cu130
-  model: Qwen/Qwen3.5-397B-A17B-FP8
-  model-prefix: qwen3.5
-  runner: cluster:b300-dsxe
+  runner: cluster:b300-dsxe
   precision: fp8
   framework: sglang
   multinode: false
@@ -4822,12 +3944,9 @@ qwen3.5-fp4-b300-dynamo-sglang-agentic-pareto:
           ep: 1
           dp-attn: false
 
-# Qwen3.8-Flash-Next NVFP4 AgentX on B300 via SGLang with native NEXTN MTP.
-# Day-zero recipe; mirrors the B200 arm. TP1 per the cookbook's verified
-# single-node command: 126 GiB of NVFP4 weights fit on one B300.
 qwen3.8next-fp4-b300-sglang-agentic-mtp:
-  image: lmsysorg/sglang:v0.5.21-cu130@sha256:b1259f3ea3275f66237c498ea388919729018bc9f01c3d638391e06e2cf3f469
-  model: RadixArk/Qwen3.8-Flash-Next-NVFP4
+  image: lmsysorg/sglang:nightly-dev-cu13-20261028-586355a8@sha256:b4f09a2ccbcfcc262d49600c3cd7f8581a793ea7d104947257b6a95500953b90
+  model: nvidia/Qwen3.8-Flash-Next-NVFP4
   model-prefix: qwen3.8next
   runner: cluster:b300-dsxe
   precision: fp4
@@ -4836,9 +3955,12 @@ qwen3.8next-fp4-b300-sglang-agentic-mtp:
   srt-recipe-dir: qwen3.8next/sglang/b300-fp4-mtp
   scenarios:
     agentic-coding:
+    # HiCache rows take the 3 TB policy share per GPU (299 GB); the recipe's 298 GB keeps alignment headroom.
     - dram-utilization: 0.8
       search-space:
-      - { tp: 1, ep: 1, spec-decoding: mtp, kv-offloading: none, conc-list: [1, 4, 8, 12, 16], srt-recipe: agentic.yaml }
+      - { tp: 4, ep: 4, spec-decoding: mtp, kv-offloading: none, conc-list: [1, 2], srt-recipe: agentic.yaml }
+      - { tp: 1, ep: 1, spec-decoding: mtp, kv-offloading: none, conc-list: [1, 2, 12, 24], srt-recipe: agentic.yaml }
+      - { tp: 1, ep: 1, spec-decoding: mtp, kv-offloading: dram, kv-offload-backend: { name: hicache }, conc-list: [48, 80], srt-recipe: agentic.yaml }
 
 qwen3.5-fp8-h100-sglang-agentic:
   image: lmsysorg/sglang:v0.5.12-cu130
@@ -4860,7 +3982,7 @@ qwen3.5-fp8-h100-sglang-agentic:
 # qwen3.5-fp8-h100-sglang-agentic: same TP8/EP8 GPU-resident and HiCache arms,
 # plus SGLang EAGLE MTP (num-steps 3, eagle-topk 1, 4 draft tokens = 3
 # speculative tokens) with simulated acceptance pinned to the golden AL 3.39
-# (infx/golden_al_distribution/qwen3.5_mtp.yaml, thinking_on, K=3) -- the same value
+# (infx/golden_al_distribution/qwen3.5-397b-a17b-nvfp4__mtp__native__default-default.yaml, thinking_on, K=3) -- the same value
 # the GB300 Qwen3.5 AgentX srt-slurm recipes use. Image moves to
 # lmsysorg/sglang:v0.5.16-cu130 because SGLANG_SIMULATE_ACC_TOKEN_MODE only
 # exists from v0.5.16; v0.5.14 is the version the fixed-seq-len H100 MTP entry
@@ -4870,7 +3992,7 @@ qwen3.5-fp8-h100-sglang-agentic:
 # policy that new agentic arms enable speculative decoding rather than running a
 # separate STP baseline (docs/MODELS.md). SGLang EAGLE MTP (num-steps 3, eagle-topk 1,
 # 4 draft tokens = 3 speculative tokens) with simulated acceptance pinned to the
-# golden AL 3.39 (infx/golden_al_distribution/qwen3.5_mtp.yaml, thinking_on, K=3).
+# golden AL 3.39 (infx/golden_al_distribution/qwen3.5-397b-a17b-nvfp4__mtp__native__default-default.yaml, thinking_on, K=3).
 # Image is lmsysorg/sglang:v0.5.16-cu130: SGLANG_SIMULATE_ACC_TOKEN_MODE only
 # exists from v0.5.16, and v0.5.14 is what the fixed-seq-len H200 MTP entry runs.
 # Search space is the H100 AgentX shape widened for H200's 141 GB: the
@@ -4947,112 +4069,12 @@ qwen3.5-fp8-h100-sglang-agentic-mtp:
       search-space:
       - { tp: 8, ep: 8, spec-decoding: mtp, kv-offloading: none, conc-list: [1, 4, 8, 12, 16], srt-recipe: agentic.yaml }
       - { tp: 8, ep: 8, spec-decoding: mtp, kv-offloading: dram, kv-offload-backend: { name: hicache }, conc-list: [4, 8, 12, 16], srt-recipe: agentic.yaml }
-qwen3.5-fp4-b200-trt:
-  image: nvcr.io#nvidia/tensorrt-llm/release:1.3.0rc18
-  model: nvidia/Qwen3.5-397B-A17B-NVFP4
-  model-prefix: qwen3.5
-  runner: cluster:b200-nscale
-  precision: fp4
-  framework: trt
-  multinode: false
-  srt-recipe-dir: qwen3.5/trtllm/b200-fp4
-  scenarios:
-    fixed-seq-len:
-    - isl: 8192
-      osl: 1024
-      search-space:
-      - tp: 2
-        ep: 1
-        conc-list:
-        - 4
-        - 16
-        srt-recipe: 8k1k.yaml
-      - tp: 4
-        ep: 1
-        conc-list:
-        - 4
-        srt-recipe: 8k1k.yaml
-      - tp: 2
-        ep: 2
-        conc-list:
-        - 8
-        - 32
-        srt-recipe: 8k1k.yaml
-      - tp: 8
-        ep: 8
-        conc-list:
-        - 4
-        srt-recipe: 8k1k.yaml
-      - tp: 4
-        ep: 4
-        dp-attn: true
-        conc-list:
-        - 1024
-        srt-recipe: 8k1k.yaml
-      - tp: 8
-        ep: 8
-        dp-attn: true
-        conc-list:
-        - 256
-        - 512
-        - 1024
-        srt-recipe: 8k1k.yaml
-
-qwen3.5-fp4-b200-trt-mtp:
-  image: nvcr.io#nvidia/tensorrt-llm/release:1.3.0rc18
-  model: nvidia/Qwen3.5-397B-A17B-NVFP4
-  model-prefix: qwen3.5
-  runner: cluster:b200-nscale
-  precision: fp4
-  framework: trt
-  multinode: false
-  srt-recipe-dir: qwen3.5/trtllm/b200-fp4-mtp
-  scenarios:
-    fixed-seq-len:
-    - isl: 8192
-      osl: 1024
-      search-space:
-      - tp: 2
-        ep: 1
-        spec-decoding: mtp
-        conc-list:
-        - 4
-        srt-recipe: 8k1k.yaml
-      - tp: 2
-        ep: 2
-        spec-decoding: mtp
-        conc-list:
-        - 8
-        - 16
-        srt-recipe: 8k1k.yaml
-      - tp: 4
-        ep: 4
-        spec-decoding: mtp
-        conc-list:
-        - 4
-        srt-recipe: 8k1k.yaml
-      - tp: 8
-        ep: 8
-        spec-decoding: mtp
-        conc-list:
-        - 4
-        srt-recipe: 8k1k.yaml
-      - tp: 8
-        ep: 8
-        dp-attn: true
-        spec-decoding: mtp
-        conc-list:
-        - 128
-        - 256
-        - 1024
-        srt-recipe: 8k1k.yaml
-
 # MiniMax-M3.1-Flash AgentX on H100: day-zero vLLM image from
 # https://vllm.ai/blog/2026-10-23-minimax-m31-flash, multiarch manifest verified
 # 2026-10-23 (amd64 is minimax-m31-flash-x86_64-cu134). Serve flags follow the
 # Hopper TP8 recipe: FP8 KV and indexer caches, NVFP4 experts on Marlin MoE.
 # Upstream does not enable DSpark on Hopper; this adds the GB200 recipe's
-# three-token DSpark, with synthetic acceptance from minimaxm31flash_dspark.yaml.
+# three-token DSpark, with synthetic acceptance from minimax-m3.1-flash__dspark__native__probabilistic-block.yaml.
 minimaxm31flash-fp4-h100-vllm-agentic-dspark:
   image: vllm/vllm-openai:minimax-m31-flash@sha256:86f582dae25ea92802353727164ae4eb03b37b18baf9119b805ffaec2a7ef07c
   model: MiniMaxAI/MiniMax-M3.1-Flash
@@ -5075,7 +4097,7 @@ minimaxm31flash-fp4-h100-vllm-agentic-dspark:
 # 2026-10-23 (amd64 is minimax-m31-flash-x86_64-cu134). Serve flags follow the
 # Hopper TP8 recipe: FP8 KV and indexer caches, NVFP4 experts on Marlin MoE.
 # Upstream does not enable DSpark on Hopper; this adds the GB200 recipe's
-# three-token DSpark, with synthetic acceptance from minimaxm31flash_dspark.yaml.
+# three-token DSpark, with synthetic acceptance from minimax-m3.1-flash__dspark__native__probabilistic-block.yaml.
 minimaxm31flash-fp4-h200-vllm-agentic-dspark:
   image: vllm/vllm-openai:minimax-m31-flash@sha256:86f582dae25ea92802353727164ae4eb03b37b18baf9119b805ffaec2a7ef07c
   model: MiniMaxAI/MiniMax-M3.1-Flash
@@ -5235,7 +4257,7 @@ minimaxm31flash-fp4-b200-vllm-agentic-dspark:
 # cookbook (https://docs.sglang.io/cookbook/autoregressive/MiniMax/MiniMax-M3.1),
 # manifest digest verified 2026-10-24.
 # Seven-token DSpark (bundled draft); synthetic acceptance follows
-# infx/golden_al_distribution/minimaxm31flash_dspark.yaml.
+# infx/golden_al_distribution/minimax-m3.1-flash__dspark__native__probabilistic-block.yaml.
 minimaxm31flash-fp4-b200-sglang-agentic-dspark:
   image: lmsysorg/sglang:dev-minimax-m31-flash@sha256:614b1509bcb729c653528d448bff9850f8977fcad9d12ba56bd6dbe3d7985e87
   model: MiniMaxAI/MiniMax-M3.1-Flash
@@ -5278,7 +4300,7 @@ minimaxm31flash-fp4-gb200-vllm-agentic-dspark:
 minimaxm31flash-fp4-b300-vllm-agentic-dspark:
   # Day-0 vLLM image for MiniMax-M3.1-Flash (vllm.ai/blog/2026-10-23-minimax-m31-flash).
   # DSpark uses the checkpoint's built-in drafter; synthetic acceptance follows
-  # infx/golden_al_distribution/minimaxm31flash_dspark.yaml.
+  # infx/golden_al_distribution/minimax-m3.1-flash__dspark__native__probabilistic-block.yaml.
   image: vllm/vllm-openai:minimax-m31-flash@sha256:86f582dae25ea92802353727164ae4eb03b37b18baf9119b805ffaec2a7ef07c
   model: MiniMaxAI/MiniMax-M3.1-Flash
   model-prefix: minimaxm31flash
@@ -5310,7 +4332,7 @@ minimaxm31flash-fp4-b300-vllm-agentic-dspark:
 # cookbook (https://docs.sglang.io/cookbook/autoregressive/MiniMax/MiniMax-M3.1),
 # manifest digest verified 2026-10-24.
 # Seven-token DSpark (bundled draft); synthetic acceptance follows
-# infx/golden_al_distribution/minimaxm31flash_dspark.yaml.
+# infx/golden_al_distribution/minimax-m3.1-flash__dspark__native__probabilistic-block.yaml.
 minimaxm31flash-fp4-gb200-sglang-agentic-dspark:
   image: lmsysorg/sglang:dev-minimax-m31-flash@sha256:614b1509bcb729c653528d448bff9850f8977fcad9d12ba56bd6dbe3d7985e87
   model: MiniMaxAI/MiniMax-M3.1-Flash
@@ -5331,312 +4353,6 @@ minimaxm31flash-fp4-gb200-sglang-agentic-dspark:
       search-space:
       - { tp: 4, spec-decoding: mtp, kv-offloading: dram, kv-offload-backend: { name: hicache }, conc-list: [32, 40, 48, 56, 64], srt-recipe: agentic.yaml }
       - { tp: 4, ep: 4, spec-decoding: mtp, kv-offloading: dram, kv-offload-backend: { name: hicache }, conc-list: [72, 80], srt-recipe: agentic.yaml }
-
-# Day-0 Kimi K3 AgentX coverage on GB200. The three aggregate srt-slurm
-# profiles mirror the serving strategies synthesized by the official recipe:
-#   latency:    multi-node TP16       (4 GB200 nodes / 16 GPUs)
-#   balanced:   multi-node TEP16      (4 GB200 nodes / 16 GPUs)
-#   throughput: multi-node TP4 x DP4  (4 GB200 nodes / EP16)
-# All profiles enable Kimi K3 DSpark level 2 at the committed golden AL 2.51.
-# `spec-decoding: mtp` is the existing matrix label used for speculative
-# decoding methods; the checked-in recipes select DSpark explicitly.
-# https://recipes.vllm.ai/moonshotai/Kimi-K3?hardware=gb200
-kimik3-fp4-gb200-dynamo-vllm-agentic:
-  image: vllm/vllm-openai:kimi-k3
-  model: moonshotai/Kimi-K3
-  model-prefix: kimik3
-  runner: cluster:gb200-nv
-  precision: fp4
-  framework: dynamo-vllm
-  router: { name: dynamo-router, version: "1.3.0" }
-  multinode: true
-  disagg: false
-  srt-recipe-dir: kimik3/vllm/gb200-fp4/agentx
-  scenarios:
-    agentic-coding:
-    - dram-utilization: 0.61
-      search-space:
-      # Latency oriented: multi_node_tp strategy, TP16 across four GB200
-      # nodes.
-      # https://recipes.vllm.ai/moonshotai/Kimi-K3?hardware=gb200&nodes=4&strategy=multi_node_tp
-      - spec-decoding: mtp
-        conc-list: [1, 2, 4, 8]
-        num-nodes: 4
-        srt-recipe: agg-variants.yaml:override_tp16_latency
-        worker:
-          num-worker: 1
-          tp: 16
-          ep: 1
-          dp-attn: false
-      # Balanced: multi_node_tep strategy, TEP16 across four GB200 nodes.
-      # https://recipes.vllm.ai/moonshotai/Kimi-K3?hardware=gb200&nodes=4&strategy=multi_node_tep
-      - spec-decoding: mtp
-        conc-list: [8, 16, 24, 32]
-        num-nodes: 4
-        srt-recipe: agg-variants.yaml:override_tep16_balanced
-        worker:
-          num-worker: 1
-          tp: 16
-          ep: 16
-          dp-attn: false
-      # Throughput oriented: official multi_node_dep strategy, DEP16 across
-      # four GB200 nodes (TP4 x DP4 = EP16, one local DP rank per node).
-      # The recipe allows up to 3600s for full-context saturation warmup to drain.
-      # https://recipes.vllm.ai/moonshotai/Kimi-K3?hardware=gb200&nodes=4&strategy=multi_node_dep
-      - spec-decoding: mtp
-        conc-list: [32, 64, 96, 128, 192, 256]
-        num-nodes: 4
-        srt-recipe: agg-variants.yaml:override_dep16
-        worker:
-          num-worker: 1
-          tp: 4
-          ep: 16
-          dp-attn: true
-      # High-concurrency DEP16 with vLLM Simple CPU KV offloading. c384
-      # exercises 384 of the 393 AgentX trajectories and remains below the
-      # aggregate max-num-seqs capacity of 512 (128 per DP rank).
-      - spec-decoding: mtp
-        kv-offloading: dram
-        kv-offload-backend: { name: vllm-simple, version: "13c59a3" }
-        conc-list: [128, 192, 256, 384]
-        num-nodes: 4
-        srt-recipe: agg-variants.yaml:override_dep16_vllm_simple_offload
-        worker:
-          num-worker: 1
-          tp: 4
-          ep: 16
-          dp-attn: true
-# Kimi-K3 GB200 TP16/DCP16 profiles using Mooncake DRAM offload.
-kimik3-fp4-gb200-dynamo-vllm-agentic-dspark-mooncake-dcp16-agg:
-  image: vllm/vllm-openai:nightly-dev-arm64-cu13.0.1-75c2eef
-  model: moonshotai/Kimi-K3
-  model-prefix: kimik3
-  runner: cluster:gb200-nv
-  precision: fp4
-  framework: dynamo-vllm
-  multinode: true
-  disagg: false
-  srt-recipe-dir: kimik3/vllm/gb200-fp4/agentx
-  scenarios:
-    agentic-coding:
-    - dram-utilization: 0.1065
-      search-space:
-      - spec-decoding: mtp
-        kv-offloading: dram
-        kv-offload-backend: { name: mooncake, version: "0.3.12.post1" }
-        conc-list: [1, 2, 4, 8, 16]
-        num-nodes: 4
-        srt-recipe: agg-dcp16-dspark4-maxseq2-mooncake.yaml
-        power: true
-        worker:
-          num-worker: 1
-          tp: 16
-          dcp-size: 16
-          ep: 1
-          dp-attn: false
-
-kimik3-fp4-gb200-dynamo-vllm-agentic-mooncake-dcp16-agg:
-  image: vllm/vllm-openai:nightly-dev-arm64-cu13.0.1-75c2eef
-  model: moonshotai/Kimi-K3
-  model-prefix: kimik3
-  runner: cluster:gb200-nv
-  precision: fp4
-  framework: dynamo-vllm
-  multinode: true
-  disagg: false
-  srt-recipe-dir: kimik3/vllm/gb200-fp4/agentx
-  scenarios:
-    agentic-coding:
-    - dram-utilization: 0.1065
-      search-space:
-      - kv-offloading: dram
-        kv-offload-backend: { name: mooncake, version: "0.3.12.post1" }
-        conc-list: [8, 40, 48]
-        num-nodes: 4
-        srt-recipe: agg-dcp16-nospec-mooncake.yaml
-        power: true
-        worker:
-          num-worker: 1
-          tp: 16
-          dcp-size: 16
-          ep: 1
-          dp-attn: false
-# Add GB200 TP8 x PP2/DCP8 AgentX operating points. The runtime topology uses
-# 16 GPUs total, allocated across four 4-GPU GB200 nodes.
-kimik3-fp4-gb200-dynamo-vllm-agentic-dspark-mooncake-tp8pp2:
-  image: vllm/vllm-openai:nightly-e68efc685ab1e6f1eda004ced7157e3ca411da2f@sha256:1ff6716fe240a922d0d518b8884261e25b0c02eda8e2ce90888e364978249cad
-  model: moonshotai/Kimi-K3
-  model-prefix: kimik3
-  runner: cluster:gb200-nv
-  precision: fp4
-  framework: dynamo-vllm
-  multinode: true
-  disagg: false
-  srt-recipe-dir: kimik3/vllm/gb200-fp4/agentx
-  scenarios:
-    agentic-coding:
-    - dram-utilization: 0.8
-      search-space:
-      - spec-decoding: mtp
-        kv-offloading: dram
-        kv-offload-backend: { name: mooncake, version: "0.3.11.post1" }
-        conc-list: [1]
-        num-nodes: 4
-        srt-recipe: agg-tp8pp2-variants.yaml:override_tp8pp2_c1
-        power: true
-        worker:
-          num-worker: 1
-          tp: 8
-          pp: 2
-          dcp-size: 8
-          ep: 1
-          dp-attn: false
-      - spec-decoding: mtp
-        kv-offloading: dram
-        kv-offload-backend: { name: mooncake, version: "0.3.11.post1" }
-        conc-list: [4]
-        num-nodes: 4
-        srt-recipe: agg-tp8pp2-variants.yaml:override_tp8pp2_c4
-        power: true
-        worker:
-          num-worker: 1
-          tp: 8
-          pp: 2
-          dcp-size: 8
-          ep: 1
-          dp-attn: false
-      - spec-decoding: mtp
-        kv-offloading: dram
-        kv-offload-backend: { name: mooncake, version: "0.3.11.post1" }
-        conc-list: [8]
-        num-nodes: 4
-        srt-recipe: agg-tp8pp2-variants.yaml:override_tp8pp2_c8
-        power: true
-        worker:
-          num-worker: 1
-          tp: 8
-          pp: 2
-          dcp-size: 8
-          ep: 1
-          dp-attn: false
-      - spec-decoding: mtp
-        kv-offloading: dram
-        kv-offload-backend: { name: mooncake, version: "0.3.11.post1" }
-        conc-list: [24]
-        num-nodes: 4
-        srt-recipe: agg-tp8pp2-variants.yaml:override_tp8pp2_c24
-        power: true
-        worker:
-          num-worker: 1
-          tp: 8
-          pp: 2
-          dcp-size: 8
-          ep: 1
-          dp-attn: false
-      - spec-decoding: mtp
-        kv-offloading: dram
-        kv-offload-backend: { name: mooncake, version: "0.3.11.post1" }
-        conc-list: [32]
-        num-nodes: 4
-        srt-recipe: agg-tp8pp2-variants.yaml:override_tp8pp2_c32
-        power: true
-        worker:
-          num-worker: 1
-          tp: 8
-          pp: 2
-          dcp-size: 8
-          ep: 1
-          dp-attn: false
-      - spec-decoding: mtp
-        kv-offloading: dram
-        kv-offload-backend: { name: mooncake, version: "0.3.11.post1" }
-        conc-list: [48]
-        num-nodes: 4
-        srt-recipe: agg-tp8pp2-variants.yaml:override_tp8pp2_c48
-        power: true
-        worker:
-          num-worker: 1
-          tp: 8
-          pp: 2
-          dcp-size: 8
-          ep: 1
-          dp-attn: false
-      - spec-decoding: mtp
-        kv-offloading: dram
-        kv-offload-backend: { name: mooncake, version: "0.3.11.post1" }
-        conc-list: [56]
-        num-nodes: 4
-        srt-recipe: agg-tp8pp2-variants.yaml:override_tp8pp2_c56
-        power: true
-        worker:
-          num-worker: 1
-          tp: 8
-          pp: 2
-          dcp-size: 8
-          ep: 1
-          dp-attn: false
-qwen3.5-fp8-gb300-dynamo-sglang:
-  image: lmsysorg/sglang:v0.5.22-cu130@sha256:e3a4f06001a29542fc4a8638536d9ffc5eb9c9942b08603c09b19a56eae4a1ae
-  model: Qwen/Qwen3.5-397B-A17B-FP8
-  model-prefix: qwen3.5
-  runner: gb300
-  precision: fp8
-  framework: dynamo-sglang
-  router: { name: dynamo-router, version: "1.5.0.dev20260917" }
-  kv-p2p-transfer: mooncake
-  multinode: true
-  disagg: true
-  srt-recipe-dir: qwen3.5/sglang/gb300-fp8/8k1k
-  scenarios:
-    fixed-seq-len:
-    - isl: 8192
-      osl: 1024
-      search-space:
-      # 1P1D STP: TP4 prefill + TP4 decode (pure tensor parallel). 2 nodes (1+1).
-      - spec-decoding: "none"
-        conc-list: [1, 2, 4, 8, 16, 32, 64, 128]
-        srt-recipe: disagg-1p1d-tp4-tp4-stp.yaml
-        power: true
-        prefill:
-          num-worker: 1
-          tp: 4
-          ep: 1
-          dp-attn: false
-        decode:
-          num-worker: 1
-          tp: 4
-          ep: 1
-          dp-attn: false
-      # 4P1D wide-EP: 4 prefill DEP4 + decode DEP16. 8 nodes (4+4).
-      - spec-decoding: "none"
-        conc-list: [1024]
-        srt-recipe: disagg-4p1d-dep4-dep16-stp.yaml
-        power: true
-        prefill:
-          num-worker: 4
-          tp: 4
-          ep: 4
-          dp-attn: true
-        decode:
-          num-worker: 1
-          tp: 16
-          ep: 16
-          dp-attn: true
-      # 8P1D wide-EP: 8 prefill DEP4 + decode DEP16. 12 nodes (8+4).
-      - spec-decoding: "none"
-        conc-list: [2048, 4096]
-        srt-recipe: disagg-8p1d-dep4-dep16-stp.yaml
-        prefill:
-          num-worker: 8
-          tp: 4
-          ep: 4
-          dp-attn: true
-        decode:
-          num-worker: 1
-          tp: 16
-          ep: 16
-          dp-attn: true
-
 # GLM-5.2 FP8 full-context AgentX refresh on H200. This preserves the 2P2D
 # PCP8/TP8-DP8 topology and c8/c12/c16 curve from Actions run 30133535261 while
 # enabling native EAGLE MTP with golden AL and GPU-resident decode KV cache.
@@ -5859,7 +4575,7 @@ glm5.2-fp8-h200-dynamo-sglang-agentic-mtp-agg:
 # AgentX speculative-decoding policy in docs/MODELS.md. SGLang EAGLE runs off
 # GLM-5.2's built-in nextn head (eagle-topk 1): K=5 / 6 draft tokens at
 # c1/c4/c8/c20, K=3 / 4 draft tokens elsewhere. The connector selects golden
-# AL 3.61 or 2.99 respectively from infx/golden_al_distribution/glm5.2_mtp.yaml
+# AL 3.61 or 2.99 respectively from infx/golden_al_distribution/glm-5.2-fp8__mtp__native__default-default.yaml
 # for thinking_on; evals retain real verification. The pinned nightly includes FlashInfer
 # 0.6.18's BF16 TRTLLM MoE allocation fix for small-batch Blackwell execution
 # in GLM-5.2's unquantized EAGLE draft head.
@@ -5908,7 +4624,7 @@ glm5.2-fp8-b300-sglang-agentic-mtp:
 # policy that agentic arms enable speculative decoding rather than running a
 # separate STP baseline (docs/MODELS.md). SGLang EAGLE off GLM-5.2's built-in nextn
 # head (num-steps 3, eagle-topk 1, 4 draft tokens = 3 speculative tokens) with
-# acceptance pinned to the golden AL 2.99 (infx/golden_al_distribution/glm5.2_mtp.yaml,
+# acceptance pinned to the golden AL 2.99 (infx/golden_al_distribution/glm-5.2-fp8__mtp__native__default-default.yaml,
 # thinking_on, K=3) through SGLANG_SIMULATE_ACC_*. SGLang v0.5.16 is the first
 # release that reads SGLANG_SIMULATE_ACC_TOKEN_MODE. The pinned 2026-09-01
 # nightly includes FlashInfer 0.6.18's BF16 TRTLLM MoE allocation fix, which is
@@ -5952,7 +4668,7 @@ glm5.2-fp8-b200-sglang-agentic-mtp:
 
 # GLM-5.2 NVFP4 B200 AgentX on Dynamo + SGLang. EAGLE uses the model's
 # built-in nextn head, with acceptance pinned to the golden thinking-on AL in
-# infx/golden_al_distribution/glm5.2_mtp.yaml. Both arms use HiCache write-back
+# infx/golden_al_distribution/glm-5.2-fp8__mtp__native__default-default.yaml. Both arms use HiCache write-back
 # DRAM offload for the agentic working set.
 glm5.2-fp4-b200-dynamo-sglang-agentic-agg:
   image: lmsysorg/sglang:v0.5.22-cu130@sha256:e3a4f06001a29542fc4a8638536d9ffc5eb9c9942b08603c09b19a56eae4a1ae
@@ -5970,6 +4686,7 @@ glm5.2-fp4-b200-dynamo-sglang-agentic-agg:
     - dram-utilization: 1.0
       search-space:
       - spec-decoding: mtp
+        power: true
         conc-list: [1]
         kv-offloading: dram
         kv-offload-backend: { name: hicache }
@@ -5981,6 +4698,7 @@ glm5.2-fp4-b200-dynamo-sglang-agentic-agg:
           ep: 1
           dp-attn: false
       - spec-decoding: mtp
+        power: true
         conc-list: [1]
         kv-offloading: dram
         kv-offload-backend: { name: hicache }
@@ -5992,6 +4710,7 @@ glm5.2-fp4-b200-dynamo-sglang-agentic-agg:
           ep: 1
           dp-attn: false
       - spec-decoding: mtp
+        power: true
         conc-list: [4]
         kv-offloading: dram
         kv-offload-backend: { name: hicache }
@@ -6003,6 +4722,7 @@ glm5.2-fp4-b200-dynamo-sglang-agentic-agg:
           ep: 1
           dp-attn: false
       - spec-decoding: mtp
+        power: true
         conc-list: [8]
         kv-offloading: dram
         kv-offload-backend: { name: hicache }
@@ -6014,6 +4734,7 @@ glm5.2-fp4-b200-dynamo-sglang-agentic-agg:
           ep: 1
           dp-attn: false
       - spec-decoding: mtp
+        power: true
         conc-list: [12]
         kv-offloading: dram
         kv-offload-backend: { name: hicache }
@@ -6025,6 +4746,7 @@ glm5.2-fp4-b200-dynamo-sglang-agentic-agg:
           ep: 1
           dp-attn: false
       - spec-decoding: mtp
+        power: true
         conc-list: [32]
         kv-offloading: dram
         kv-offload-backend: { name: hicache }
@@ -6037,1223 +4759,473 @@ glm5.2-fp4-b200-dynamo-sglang-agentic-agg:
           dp-attn: true
 
 glm5.2-fp4-b200-dynamo-sglang-agentic-disagg:
-  image: lmsysorg/sglang:nightly-dev-20260910-00840301
-  model: nvidia/GLM-5.2-NVFP4
-  model-prefix: glm5.2
-  runner: cluster:b200-nscale
-  precision: fp4
-  framework: dynamo-sglang
-  router: { name: dynamo-router, version: "1.5.0.dev20260909" }
-  kv-p2p-transfer: nixl
-  multinode: true
-  disagg: true
-  srt-recipe-dir: glm5.2/sglang/b200-fp4/agentx
-  scenarios:
-    agentic-coding:
-    - dram-utilization: 0.80
-      search-space:
-      # 1P(DEP8)4D(TP4): three nodes total.
-      - spec-decoding: mtp
-        conc-list: [48]
-        kv-offloading: dram
-        kv-offload-backend: { name: hicache }
-        srt-recipe: disagg-variants.yaml:override_1p4d_tp4_c48
-        prefill:
-          num-worker: 1
-          tp: 8
-          ep: 8
-          dp-attn: true
-        decode:
-          num-worker: 4
-          tp: 4
-          ep: 1
-          dp-attn: false
-      # 1P(DEP8)1D(DEP8): two nodes total.
-      - spec-decoding: mtp
-        conc-list: [64]
-        kv-offloading: dram
-        kv-offload-backend: { name: hicache }
-        srt-recipe: disagg-variants.yaml:override_1p1d_c64
-        prefill:
-          num-worker: 1
-          tp: 8
-          ep: 8
-          dp-attn: true
-        decode:
-          num-worker: 1
-          tp: 8
-          ep: 8
-          dp-attn: true
-
-glm5.2-fp4-gb200-dynamo-sglang-agentic-agg:
-  image: lmsysorg/sglang:nightly-dev-20261020-ab580b2e@sha256:0af411bb320a95bb5e1c58b4c20c9852920a19aa9f12f148f69731b0dca3b576
+  image: lmsysorg/sglang:v0.5.22-cu130@sha256:e3a4f06001a29542fc4a8638536d9ffc5eb9c9942b08603c09b19a56eae4a1ae
   model: nvidia/GLM-5.2-NVFP4
   model-prefix: glm5.2
-  runner: cluster:gb200-nv
-  precision: fp4
-  framework: dynamo-sglang
-  router: { name: dynamo-router, version: "1.6.0.dev20261019" }
-  multinode: true
-  disagg: false
-  srt-recipe-dir: glm5.2/sglang/gb200-fp4/agentx
-  scenarios:
-    agentic-coding:
-    - dram-utilization: 0.80
-      search-space:
-      - spec-decoding: mtp
-        conc-list: [1]
-        kv-offloading: dram
-        kv-offload-backend: { name: hicache }
-        num-nodes: 1
-        srt-recipe: agg-variants.yaml:override_tp4_c1
-        # Shared deployment GPU power telemetry.
-        power: true
-        worker:
-          num-worker: 1
-          tp: 4
-          ep: 1
-          dp-attn: false
-      - spec-decoding: mtp
-        conc-list: [1]
-        kv-offloading: dram
-        kv-offload-backend: { name: hicache }
-        num-nodes: 2
-        srt-recipe: agg-variants.yaml:override_tp8_c1
-        # Shared deployment GPU power telemetry.
-        power: true
-        worker:
-          num-worker: 1
-          tp: 8
-          ep: 1
-          dp-attn: false
-glm5.2-fp4-gb200-dynamo-sglang-agentic-disagg:
-  image: lmsysorg/sglang:nightly-dev-20261020-ab580b2e@sha256:0af411bb320a95bb5e1c58b4c20c9852920a19aa9f12f148f69731b0dca3b576
-  model: nvidia/GLM-5.2-NVFP4
-  model-prefix: glm5.2
-  runner: cluster:gb200-nv
-  precision: fp4
-  framework: dynamo-sglang
-  router: { name: dynamo-router, version: "1.6.0.dev20261019" }
-  kv-p2p-transfer: nixl
-  multinode: true
-  disagg: true
-  srt-recipe-dir: glm5.2/sglang/gb200-fp4/agentx
-  scenarios:
-    agentic-coding:
-    - dram-utilization: 0.80
-      search-space:
-      - spec-decoding: mtp
-        conc-list: [36]
-        kv-offloading: dram
-        kv-offload-backend: { name: hicache }
-        srt-recipe: disagg-variants.yaml:override_1p6d_pp8_tp4_c36
-        prefill:
-          num-worker: 1
-          tp: 1
-          pp: 8
-          ep: 1
-          dp-attn: false
-        decode:
-          num-worker: 6
-          tp: 4
-          pp: 1
-          ep: 1
-          dp-attn: false
-      - spec-decoding: mtp
-        conc-list: [48]
-        kv-offloading: dram
-        kv-offload-backend: { name: hicache }
-        srt-recipe: disagg-variants.yaml:override_1p4d_pp8_tp4_c48
-        prefill:
-          num-worker: 1
-          tp: 1
-          pp: 8
-          ep: 1
-          dp-attn: false
-        decode:
-          num-worker: 4
-          tp: 4
-          pp: 1
-          ep: 1
-          dp-attn: false
-      - spec-decoding: mtp
-        conc-list: [64]
-        kv-offloading: dram
-        kv-offload-backend: { name: hicache }
-        srt-recipe: disagg-variants.yaml:override_1p2d_pp8_dep8_c64
-        prefill:
-          num-worker: 1
-          tp: 1
-          pp: 8
-          ep: 1
-          dp-attn: false
-        decode:
-          num-worker: 2
-          tp: 8
-          pp: 1
-          ep: 8
-          dp-attn: true
-      - spec-decoding: mtp
-        conc-list: [96]
-        kv-offloading: dram
-        kv-offload-backend: { name: hicache }
-        srt-recipe: disagg-variants.yaml:override_1p2d_pp8_dep8_c96
-        prefill:
-          num-worker: 1
-          tp: 1
-          pp: 8
-          ep: 1
-          dp-attn: false
-        decode:
-          num-worker: 2
-          tp: 8
-          pp: 1
-          ep: 8
-          dp-attn: true
-      - spec-decoding: mtp
-        conc-list: [96]
-        kv-offloading: dram
-        kv-offload-backend: { name: hicache }
-        srt-recipe: disagg-variants.yaml:override_1p1d_pp8_dep8_c96
-        prefill:
-          num-worker: 1
-          tp: 1
-          pp: 8
-          ep: 1
-          dp-attn: false
-        decode:
-          num-worker: 1
-          tp: 8
-          pp: 1
-          ep: 8
-          dp-attn: true
-      - spec-decoding: mtp
-        conc-list: [224]
-        kv-offloading: dram
-        kv-offload-backend: { name: hicache }
-        srt-recipe: disagg-variants.yaml:override_2p1d_pp8_dep16_c224
-        prefill:
-          num-worker: 2
-          tp: 1
-          pp: 8
-          ep: 1
-          dp-attn: false
-        decode:
-          num-worker: 1
-          tp: 16
-          pp: 1
-          ep: 16
-          dp-attn: true
-      - spec-decoding: mtp
-        conc-list: [336]
-        kv-offloading: dram
-        kv-offload-backend: { name: hicache }
-        srt-recipe: disagg-variants.yaml:override_3p1d_pp8_dep16_c336
-        prefill:
-          num-worker: 3
-          tp: 1
-          pp: 8
-          ep: 1
-          dp-attn: false
-        decode:
-          num-worker: 1
-          tp: 16
-          pp: 1
-          ep: 16
-          dp-attn: true
-glm5.2-fp4-gb300-dynamo-sglang-agentic-agg:
-  image: lmsysorg/sglang:nightly-dev-20261021-c1c287a4@sha256:b0473834763b2753e069cb96c1acaf235ba7fd632ccd9bbeb44da809c437fdeb
-  model: nvidia/GLM-5.2-NVFP4
-  model-prefix: glm5.2
-  runner: cluster:gb300-nv
-  precision: fp4
-  framework: dynamo-sglang
-  router: { name: dynamo-router, version: "1.6.0.dev20261015" }
-  multinode: true
-  disagg: false
-  srt-recipe-dir: glm5.2/sglang/gb300-fp4/agentx
-  scenarios:
-    agentic-coding:
-    - dram-utilization: 0.80
-      search-space:
-      - spec-decoding: mtp
-        conc-list: [1]
-        kv-offloading: dram
-        kv-offload-backend: { name: hicache }
-        num-nodes: 1
-        srt-recipe: agg-variants.yaml:override_tp4_c1
-        worker:
-          num-worker: 1
-          tp: 4
-          ep: 1
-          dp-attn: false
-      - spec-decoding: mtp
-        conc-list: [1]
-        kv-offloading: dram
-        kv-offload-backend: { name: hicache }
-        num-nodes: 2
-        srt-recipe: agg-variants.yaml:override_tp8_c1
-        worker:
-          num-worker: 1
-          tp: 8
-          ep: 1
-          dp-attn: false
-glm5.2-fp4-gb300-dynamo-sglang-agentic-disagg:
-  image: lmsysorg/sglang:nightly-dev-20261016-a93f16f0@sha256:0b3e39704480c423d8a00ca15ebee63154defc62944df2d4b11c594563bab457
-  model: nvidia/GLM-5.2-NVFP4
-  model-prefix: glm5.2
-  runner: cluster:gb300-nv
-  precision: fp4
-  framework: dynamo-sglang
-  router: { name: dynamo-router, version: "1.6.0.dev20261016" }
-  kv-p2p-transfer: nixl
-  multinode: true
-  disagg: true
-  srt-recipe-dir: glm5.2/sglang/gb300-fp4/agentx
-  scenarios:
-    agentic-coding:
-    - dram-utilization: 0.85
-      search-space:
-      - spec-decoding: mtp
-        conc-list: [30]
-        kv-offloading: dram
-        kv-offload-backend: { name: hicache }
-        srt-recipe: disagg-variants.yaml:override_1p5d_pp4_tp4_c30
-        prefill:
-          num-worker: 1
-          tp: 1
-          pp: 4
-          ep: 1
-          dp-attn: false
-        decode:
-          num-worker: 5
-          tp: 4
-          pp: 1
-          ep: 1
-          dp-attn: false
-      - spec-decoding: mtp
-        conc-list: [40]
-        kv-offloading: dram
-        kv-offload-backend: { name: hicache }
-        srt-recipe: disagg-variants.yaml:override_1p3d_pp4_tp4_c40
-        prefill:
-          num-worker: 1
-          tp: 1
-          pp: 4
-          ep: 1
-          dp-attn: false
-        decode:
-          num-worker: 3
-          tp: 4
-          pp: 1
-          ep: 1
-          dp-attn: false
-      - spec-decoding: mtp
-        conc-list: [56]
-        kv-offloading: dram
-        kv-offload-backend: { name: hicache }
-        srt-recipe: disagg-variants.yaml:override_1p1d_pp4_dep8_c56
-        prefill:
-          num-worker: 1
-          tp: 1
-          pp: 4
-          ep: 1
-          dp-attn: false
-        decode:
-          num-worker: 1
-          tp: 8
-          pp: 1
-          ep: 8
-          dp-attn: true
-      - spec-decoding: mtp
-        conc-list: [216]
-        kv-offloading: dram
-        kv-offload-backend: { name: hicache }
-        srt-recipe: disagg-variants.yaml:override_3p1d_pp4_dep8_c216
-        prefill:
-          num-worker: 3
-          tp: 1
-          pp: 4
-          ep: 1
-          dp-attn: false
-        decode:
-          num-worker: 1
-          tp: 8
-          pp: 1
-          ep: 8
-          dp-attn: true
-      - spec-decoding: mtp
-        conc-list: [264]
-        kv-offloading: dram
-        kv-offload-backend: { name: hicache }
-        srt-recipe: disagg-variants.yaml:override_3p1d_pp4_dep8_c264
-        prefill:
-          num-worker: 3
-          tp: 1
-          pp: 4
-          ep: 1
-          dp-attn: false
-        decode:
-          num-worker: 1
-          tp: 8
-          pp: 1
-          ep: 8
-          dp-attn: true
-      - spec-decoding: mtp
-        conc-list: [256]
-        kv-offloading: dram
-        kv-offload-backend: { name: hicache }
-        srt-recipe: disagg-variants.yaml:override_4p1d_pp4_dep16_c256
-        prefill:
-          num-worker: 4
-          tp: 1
-          pp: 4
-          ep: 1
-          dp-attn: false
-        decode:
-          num-worker: 1
-          tp: 16
-          pp: 1
-          ep: 16
-          dp-attn: true
-
-# GLM-5.2 NVFP4 TensorRT-LLM AgentX on GB300 with Dynamo disaggregated serving.
-# Six topology variants use NIXL KV transfer and MTP3/MTP5 decoding.
-glm5.2-fp4-gb300-dynamo-trt-agentic-disagg-mtp:
-  image: nvcr.io/nvidia/tensorrt-llm/release:1.3.0rc28.dev202609210001
-  model: nvidia/GLM-5.2-NVFP4
-  model-prefix: glm5.2
-  runner: cluster:gb300-nv
-  precision: fp4
-  framework: dynamo-trt
-  router: { name: dynamo-router, version: "1.6.0.dev20261010" }
-  kv-p2p-transfer: nixl
-  multinode: true
-  disagg: true
-  srt-recipe-dir: glm5.2/trtllm/gb300-fp4/agentx
-  scenarios:
-    agentic-coding:
-    - dram-utilization: 0.15239
-      search-space:
-      - spec-decoding: mtp
-        conc-list: [1]
-        kv-offloading: dram
-        kv-offload-backend: { name: native, version: "1.3.0rc28.dev202609210001" }
-        srt-recipe: disagg-variants.yaml:override_1p1d_tp8_c1_b1_mtp5
-        prefill:
-          num-worker: 1
-          tp: 4
-          ep: 4
-          dp-attn: true
-        decode:
-          num-worker: 1
-          tp: 8
-          ep: 1
-          dp-attn: false
-      - spec-decoding: mtp
-        conc-list: [30]
-        kv-offloading: dram
-        kv-offload-backend: { name: native, version: "1.3.0rc28.dev202609210001" }
-        srt-recipe: disagg-variants.yaml:override_1p4d_tep4_c30_b2_mtp5
-        prefill:
-          num-worker: 1
-          tp: 4
-          ep: 4
-          dp-attn: true
-        decode:
-          num-worker: 4
-          tp: 4
-          ep: 4
-          dp-attn: false
-      - spec-decoding: mtp
-        conc-list: [20]
-        kv-offloading: dram
-        kv-offload-backend: { name: native, version: "1.3.0rc28.dev202609210001" }
-        srt-recipe: disagg-variants.yaml:override_1p1d_tep8_c20_b5_mtp5
-        prefill:
-          num-worker: 1
-          tp: 4
-          ep: 4
-          dp-attn: true
-        decode:
-          num-worker: 1
-          tp: 8
-          ep: 8
-          dp-attn: false
-      - spec-decoding: mtp
-        conc-list: [60]
-        kv-offloading: dram
-        kv-offload-backend: { name: native, version: "1.3.0rc28.dev202609210001" }
-        srt-recipe: disagg-variants.yaml:override_3p4d_tep4_c60_b5_mtp5
-        prefill:
-          num-worker: 3
-          tp: 4
-          ep: 4
-          dp-attn: true
-        decode:
-          num-worker: 4
-          tp: 4
-          ep: 4
-          dp-attn: false
-      - spec-decoding: mtp
-        conc-list: [260]
-        kv-offloading: dram
-        kv-offload-backend: { name: native, version: "1.3.0rc28.dev202609210001" }
-        srt-recipe: disagg-variants.yaml:override_5p1d_dep16_c260_b16_mtp3
-        prefill:
-          num-worker: 5
-          tp: 4
-          ep: 4
-          dp-attn: true
-        decode:
-          num-worker: 1
-          tp: 16
-          ep: 16
-          dp-attn: true
-      - spec-decoding: mtp
-        conc-list: [227]
-        kv-offloading: dram
-        kv-offload-backend: { name: native, version: "1.3.0rc28.dev202609210001" }
-        srt-recipe: disagg-variants.yaml:override_4p1d_dep8_c227_b16_mtp3
-        prefill:
-          num-worker: 4
-          tp: 4
-          ep: 4
-          dp-attn: true
-        decode:
-          num-worker: 1
-          tp: 8
-          ep: 8
-          dp-attn: true
-
-qwen3.5-fp4-gb200-dynamo-sglang-mtp:
-  image: lmsysorg/sglang:nightly-dev-cu13-20260709-074bb928
-  model: nvidia/Qwen3.5-397B-A17B-NVFP4-V2
-  model-prefix: qwen3.5
-  runner: gb200
-  precision: fp4
-  framework: dynamo-sglang
-  kv-p2p-transfer: mooncake
-  multinode: true
-  disagg: true
-  srt-recipe-dir: qwen3.5/sglang/gb200-fp4-v2/8k1k/mtp
-  scenarios:
-    fixed-seq-len:
-    - isl: 8192
-      osl: 1024
-      search-space:
-      - spec-decoding: "mtp"
-        conc-list: [1]
-        srt-recipe: 1p1d-tp4-tp4-c1.yaml
-        prefill:
-          num-worker: 1
-          tp: 4
-          ep: 1
-          dp-attn: false
-        decode:
-          num-worker: 1
-          tp: 4
-          ep: 1
-          dp-attn: false
-      - spec-decoding: "mtp"
-        conc-list: [4]
-        srt-recipe: 1p1d-tp4-tp4-c4.yaml
-        prefill:
-          num-worker: 1
-          tp: 4
-          ep: 1
-          dp-attn: false
-        decode:
-          num-worker: 1
-          tp: 4
-          ep: 1
-          dp-attn: false
-      - spec-decoding: "mtp"
-        conc-list: [8]
-        srt-recipe: 1p1d-tp4-tp4-c8.yaml
-        prefill:
-          num-worker: 1
-          tp: 4
-          ep: 1
-          dp-attn: false
-        decode:
-          num-worker: 1
-          tp: 4
-          ep: 1
-          dp-attn: false
-      - spec-decoding: "mtp"
-        conc-list: [512]
-        srt-recipe: 2p2d-tp2-tp2-c512.yaml
-        prefill:
-          num-worker: 2
-          tp: 2
-          ep: 1
-          dp-attn: false
-        decode:
-          num-worker: 2
-          tp: 2
-          ep: 1
-          dp-attn: false
-      - spec-decoding: "mtp"
-        conc-list: [128]
-        srt-recipe: 3p5d-tp4-tp4-c128.yaml
-        prefill:
-          num-worker: 3
-          tp: 4
-          ep: 1
-          dp-attn: false
-        decode:
-          num-worker: 5
-          tp: 4
-          ep: 1
-          dp-attn: false
-      - spec-decoding: "mtp"
-        conc-list: [768]
-        srt-recipe: 2p3d-tp2-tp2-c768.yaml
-        prefill:
-          num-worker: 2
-          tp: 2
-          ep: 1
-          dp-attn: false
-        decode:
-          num-worker: 3
-          tp: 2
-          ep: 1
-          dp-attn: false
-      - spec-decoding: "mtp"
-        conc-list: [5120]
-        srt-recipe: 7p1d-dep4-dep16-c5120.yaml
-        prefill:
-          num-worker: 7
-          tp: 4
-          ep: 4
-          dp-attn: true
-        decode:
-          num-worker: 1
-          tp: 16
-          ep: 16
-          dp-attn: true
-      - spec-decoding: "mtp"
-        conc-list: [8192]
-        srt-recipe: 7p1d-dep4-dep16-c8192.yaml
-        prefill:
-          num-worker: 7
-          tp: 4
-          ep: 4
-          dp-attn: true
-        decode:
-          num-worker: 1
-          tp: 16
-          ep: 16
-          dp-attn: true
-      - spec-decoding: "mtp"
-        conc-list: [12288]
-        srt-recipe: 7p4d-dep4-dep4-c12288.yaml
-        prefill:
-          num-worker: 7
-          tp: 4
-          ep: 4
-          dp-attn: true
-        decode:
-          num-worker: 4
-          tp: 4
-          ep: 4
-          dp-attn: true
-
-qwen3.5-fp8-gb200-dynamo-sglang-mtp:
-  image: lmsysorg/sglang:v0.5.21-cu130@sha256:b1259f3ea3275f66237c498ea388919729018bc9f01c3d638391e06e2cf3f469
-  model: Qwen/Qwen3.5-397B-A17B-FP8
-  model-prefix: qwen3.5
-  runner: gb200
-  precision: fp8
+  runner: cluster:b200-nscale
+  precision: fp4
   framework: dynamo-sglang
-  router: { name: dynamo-router, version: "1.5.0.dev20260917" }
-  kv-p2p-transfer: mooncake
+  router: { name: dynamo-router, version: "1.5.0.dev20260909" }
+  kv-p2p-transfer: nixl
   multinode: true
   disagg: true
-  srt-recipe-dir: qwen3.5/sglang/gb200-fp8/8k1k
+  srt-recipe-dir: glm5.2/sglang/b200-fp4/agentx
   scenarios:
-    fixed-seq-len:
-    - isl: 8192
-      osl: 1024
+    agentic-coding:
+    - dram-utilization: 0.80
       search-space:
-      # 1P1D TP4/TP4. 8 worker GPUs.
-      - spec-decoding: "mtp"
-        conc-list: [1, 2, 8]
-        srt-recipe: disagg-1p1d-p-tp4-d-tp4-b128-c1x2x8-mtp.yaml
+      # 1P(DEP8)4D(TP4): three nodes total.
+      - spec-decoding: mtp
         power: true
+        conc-list: [48]
+        kv-offloading: dram
+        kv-offload-backend: { name: hicache }
+        srt-recipe: disagg-variants.yaml:override_1p4d_tp4_c48
         prefill:
           num-worker: 1
-          tp: 4
-          ep: 1
-          dp-attn: false
+          tp: 8
+          ep: 8
+          dp-attn: true
         decode:
-          num-worker: 1
+          num-worker: 4
           tp: 4
           ep: 1
           dp-attn: false
-      # 1P1D TEP8/TEP8. 16 worker GPUs.
-      - spec-decoding: "mtp"
-        conc-list: [32, 48, 80]
-        srt-recipe: disagg-1p1d-p-tp8-ep8-d-tp8-ep8-b1024-c32x48x80-mtp.yaml
+      # 1P(DEP8)1D(DEP8): two nodes total.
+      - spec-decoding: mtp
         power: true
+        conc-list: [64]
+        kv-offloading: dram
+        kv-offload-backend: { name: hicache }
+        srt-recipe: disagg-variants.yaml:override_1p1d_c64
         prefill:
           num-worker: 1
           tp: 8
           ep: 8
-          dp-attn: false
+          dp-attn: true
         decode:
           num-worker: 1
           tp: 8
           ep: 8
-          dp-attn: false
-      # 3P1D DEP4/DEP16. 28 worker GPUs.
-      - spec-decoding: "mtp"
-        conc-list: [480]
-        srt-recipe: disagg-3p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b1024-c480-mtp.yaml
-        power: true
-        prefill:
-          num-worker: 3
-          tp: 4
-          ep: 4
-          dp-attn: true
-        decode:
-          num-worker: 1
-          tp: 16
-          ep: 16
-          dp-attn: true
-      # 4P1D DEP4/DEP16. 32 worker GPUs.
-      - spec-decoding: "mtp"
-        conc-list: [768]
-        srt-recipe: disagg-4p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b1024-c768-mtp.yaml
-        power: true
-        prefill:
-          num-worker: 4
-          tp: 4
-          ep: 4
-          dp-attn: true
-        decode:
-          num-worker: 1
-          tp: 16
-          ep: 16
           dp-attn: true
-      # 6P1D DEP4/DEP16. 40 worker GPUs.
-      - spec-decoding: "mtp"
-        conc-list: [1280]
-        srt-recipe: disagg-6p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b1024-c1280-mtp.yaml
+
+glm5.2-fp4-gb200-dynamo-sglang-agentic-agg:
+  image: lmsysorg/sglang:nightly-dev-20261020-ab580b2e@sha256:0af411bb320a95bb5e1c58b4c20c9852920a19aa9f12f148f69731b0dca3b576
+  model: nvidia/GLM-5.2-NVFP4
+  model-prefix: glm5.2
+  runner: cluster:gb200-nv
+  precision: fp4
+  framework: dynamo-sglang
+  router: { name: dynamo-router, version: "1.6.0.dev20261019" }
+  multinode: true
+  disagg: false
+  srt-recipe-dir: glm5.2/sglang/gb200-fp4/agentx
+  scenarios:
+    agentic-coding:
+    - dram-utilization: 0.80
+      search-space:
+      - spec-decoding: mtp
+        conc-list: [1]
+        kv-offloading: dram
+        kv-offload-backend: { name: hicache }
+        num-nodes: 1
+        srt-recipe: agg-variants.yaml:override_tp4_c1
+        # Shared deployment GPU power telemetry.
         power: true
-        prefill:
-          num-worker: 6
-          tp: 4
-          ep: 4
-          dp-attn: true
-        decode:
+        worker:
           num-worker: 1
-          tp: 16
-          ep: 16
-          dp-attn: true
-      # 7P1D DEP4/DEP16. 44 worker GPUs.
-      - spec-decoding: "mtp"
-        conc-list: [1344]
-        srt-recipe: disagg-7p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b2048-c1344-mtp.yaml
-        power: true
-        prefill:
-          num-worker: 7
           tp: 4
-          ep: 4
-          dp-attn: true
-        decode:
-          num-worker: 1
-          tp: 16
-          ep: 16
-          dp-attn: true
-      # 8P1D DEP4/DEP16. 48 worker GPUs.
-      - spec-decoding: "mtp"
-        conc-list: [1920, 2304]
-        srt-recipe: disagg-8p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b2048-c1920x2304-mtp.yaml
+          ep: 1
+          dp-attn: false
+      - spec-decoding: mtp
+        conc-list: [1]
+        kv-offloading: dram
+        kv-offload-backend: { name: hicache }
+        num-nodes: 2
+        srt-recipe: agg-variants.yaml:override_tp8_c1
+        # Shared deployment GPU power telemetry.
         power: true
-        prefill:
-          num-worker: 8
-          tp: 4
-          ep: 4
-          dp-attn: true
-        decode:
+        worker:
           num-worker: 1
-          tp: 16
-          ep: 16
-          dp-attn: true
-
-# Kimi-K3 GB300 points chosen to sit near the TPS/GPU Pareto front on all four
-# AgentX p90 charts (interactivity, E2E latency, TTFT, E2E-normalized
-# interactivity), not on ITL alone. Each DCP8 worker spans two 4-GPU nodes.
-kimik3-fp4-gb300-dynamo-vllm-agentic-dspark-mooncake-dcp8-disagg:
-  image: vllm/vllm-openai:nightly-e4a5b5537344b103ed10de7764378ef09604ef3d@sha256:6b90105076216e861cd30fae8828efef9263a0399137b894289f3b6a685bf4ff
-  model: moonshotai/Kimi-K3
-  model-prefix: kimik3
-  runner: cluster:gb300-nv
+          tp: 8
+          ep: 1
+          dp-attn: false
+glm5.2-fp4-gb200-dynamo-sglang-agentic-disagg:
+  image: lmsysorg/sglang:nightly-dev-20261020-ab580b2e@sha256:0af411bb320a95bb5e1c58b4c20c9852920a19aa9f12f148f69731b0dca3b576
+  model: nvidia/GLM-5.2-NVFP4
+  model-prefix: glm5.2
+  runner: cluster:gb200-nv
   precision: fp4
-  framework: dynamo-vllm
-  router:
-    name: dynamo-router
-    version: a0de541ea8c861d5ac01d15953ca529bea68637b
+  framework: dynamo-sglang
+  router: { name: dynamo-router, version: "1.6.0.dev20261019" }
   kv-p2p-transfer: nixl
   multinode: true
   disagg: true
-  srt-recipe-dir: kimik3/vllm/gb300-fp4/agentx
+  srt-recipe-dir: glm5.2/sglang/gb200-fp4/agentx
   scenarios:
     agentic-coding:
-    - dram-utilization: 0.1775
+    - dram-utilization: 0.80
       search-space:
       - spec-decoding: mtp
+        conc-list: [36]
         kv-offloading: dram
-        kv-offload-backend:
-          name: mooncake
-          version: 0.3.13.post1
-        conc-list:
-        - 16
-        srt-recipe: disagg-variants.yaml:override_1p3d_specdecode
-        eval-srt-recipe: disagg-variants.yaml:override_1p3d_specdecode_eval
-        power: true
+        kv-offload-backend: { name: hicache }
+        srt-recipe: disagg-variants.yaml:override_1p6d_pp8_tp4_c36
         prefill:
           num-worker: 1
-          tp: 8
-          dcp-size: 8
-          ep: 8
+          tp: 1
+          pp: 8
+          ep: 1
           dp-attn: false
         decode:
-          num-worker: 3
-          tp: 8
-          dcp-size: 8
+          num-worker: 6
+          tp: 4
+          pp: 1
           ep: 1
           dp-attn: false
       - spec-decoding: mtp
+        conc-list: [48]
         kv-offloading: dram
-        kv-offload-backend:
-          name: mooncake
-          version: 0.3.13.post1
-        conc-list:
-        - 24
-        - 32
-        srt-recipe: disagg-variants.yaml:override_1p2d_specdecode
-        eval-srt-recipe: disagg-variants.yaml:override_1p2d_specdecode_eval
-        power: true
+        kv-offload-backend: { name: hicache }
+        srt-recipe: disagg-variants.yaml:override_1p4d_pp8_tp4_c48
         prefill:
           num-worker: 1
-          tp: 8
-          dcp-size: 8
-          ep: 8
+          tp: 1
+          pp: 8
+          ep: 1
           dp-attn: false
         decode:
-          num-worker: 2
-          tp: 8
-          dcp-size: 8
+          num-worker: 4
+          tp: 4
+          pp: 1
           ep: 1
           dp-attn: false
       - spec-decoding: mtp
+        conc-list: [64]
         kv-offloading: dram
-        kv-offload-backend:
-          name: mooncake
-          version: 0.3.13.post1
-        conc-list:
-        - 48
-        - 64
-        srt-recipe: disagg-variants.yaml:override_1p2d_cap128
-        eval-srt-recipe: disagg-variants.yaml:override_1p2d_cap128_eval
-        power: true
+        kv-offload-backend: { name: hicache }
+        srt-recipe: disagg-variants.yaml:override_1p2d_pp8_dep8_c64
         prefill:
           num-worker: 1
-          tp: 8
-          dcp-size: 8
-          ep: 8
+          tp: 1
+          pp: 8
+          ep: 1
           dp-attn: false
         decode:
           num-worker: 2
           tp: 8
-          dcp-size: 8
-          ep: 1
-          dp-attn: false
+          pp: 1
+          ep: 8
+          dp-attn: true
       - spec-decoding: mtp
+        conc-list: [96]
         kv-offloading: dram
-        kv-offload-backend:
-          name: mooncake
-          version: 0.3.13.post1
-        conc-list:
-        - 240
-        srt-recipe: disagg-variants.yaml:override_3p4d_cap128
-        eval-srt-recipe: disagg-variants.yaml:override_3p4d_cap128_eval
-        power: true
+        kv-offload-backend: { name: hicache }
+        srt-recipe: disagg-variants.yaml:override_1p2d_pp8_dep8_c96
         prefill:
-          num-worker: 3
-          tp: 8
-          dcp-size: 8
-          ep: 8
+          num-worker: 1
+          tp: 1
+          pp: 8
+          ep: 1
           dp-attn: false
         decode:
-          num-worker: 4
+          num-worker: 2
           tp: 8
-          dcp-size: 8
-          ep: 1
-          dp-attn: false
+          pp: 1
+          ep: 8
+          dp-attn: true
       - spec-decoding: mtp
+        conc-list: [96]
         kv-offloading: dram
-        kv-offload-backend:
-          name: mooncake
-          version: 0.3.13.post1
-        conc-list:
-        - 240
-        srt-recipe: disagg-variants.yaml:override_2p3d_cap128
-        eval-srt-recipe: disagg-variants.yaml:override_2p3d_cap128_eval
-        power: true
+        kv-offload-backend: { name: hicache }
+        srt-recipe: disagg-variants.yaml:override_1p1d_pp8_dep8_c96
         prefill:
-          num-worker: 2
-          tp: 8
-          dcp-size: 8
-          ep: 8
+          num-worker: 1
+          tp: 1
+          pp: 8
+          ep: 1
           dp-attn: false
         decode:
-          num-worker: 3
+          num-worker: 1
           tp: 8
-          dcp-size: 8
-          ep: 1
-          dp-attn: false
-
-
-kimik3-fp4-gb300-dynamo-vllm-agentic-dspark-mooncake-dep16-disagg:
-  image: vllm/vllm-openai:nightly-e4a5b5537344b103ed10de7764378ef09604ef3d@sha256:6b90105076216e861cd30fae8828efef9263a0399137b894289f3b6a685bf4ff
-  model: moonshotai/Kimi-K3
-  model-prefix: kimik3
-  runner: cluster:gb300-nv
-  precision: fp4
-  framework: dynamo-vllm
-  router:
-    name: dynamo-router
-    version: a0de541ea8c861d5ac01d15953ca529bea68637b
-  kv-p2p-transfer: nixl
-  multinode: true
-  disagg: true
-  srt-recipe-dir: kimik3/vllm/gb300-fp4/agentx
-  scenarios:
-    agentic-coding:
-    - dram-utilization: 0.1775
-      search-space:
+          pp: 1
+          ep: 8
+          dp-attn: true
+      - spec-decoding: mtp
+        conc-list: [224]
+        kv-offloading: dram
+        kv-offload-backend: { name: hicache }
+        srt-recipe: disagg-variants.yaml:override_2p1d_pp8_dep16_c224
+        prefill:
+          num-worker: 2
+          tp: 1
+          pp: 8
+          ep: 1
+          dp-attn: false
+        decode:
+          num-worker: 1
+          tp: 16
+          pp: 1
+          ep: 16
+          dp-attn: true
       - spec-decoding: mtp
+        conc-list: [336]
         kv-offloading: dram
-        kv-offload-backend:
-          name: mooncake
-          version: 0.3.13.post1
-        conc-list:
-        - 336
-        srt-recipe: disagg-tp8-dep16.yaml:override_3p1d_c336
-        eval-srt-recipe: disagg-tp8-dep16.yaml:override_3p1d_c336_eval
-        power: true
+        kv-offload-backend: { name: hicache }
+        srt-recipe: disagg-variants.yaml:override_3p1d_pp8_dep16_c336
         prefill:
           num-worker: 3
-          tp: 8
-          ep: 8
+          tp: 1
+          pp: 8
+          ep: 1
           dp-attn: false
         decode:
           num-worker: 1
           tp: 16
+          pp: 1
           ep: 16
           dp-attn: true
-
-kimik3-fp4-gb300-dynamo-vllm-agentic-dspark-mooncake-dcp8-agg:
-  image: vllm/vllm-openai:nightly-e4a5b5537344b103ed10de7764378ef09604ef3d@sha256:6b90105076216e861cd30fae8828efef9263a0399137b894289f3b6a685bf4ff
-  model: moonshotai/Kimi-K3
-  model-prefix: kimik3
+glm5.2-fp4-gb300-dynamo-sglang-agentic-agg:
+  image: lmsysorg/sglang:nightly-dev-20261021-c1c287a4@sha256:b0473834763b2753e069cb96c1acaf235ba7fd632ccd9bbeb44da809c437fdeb
+  model: nvidia/GLM-5.2-NVFP4
+  model-prefix: glm5.2
   runner: cluster:gb300-nv
   precision: fp4
-  framework: dynamo-vllm
+  framework: dynamo-sglang
+  router: { name: dynamo-router, version: "1.6.0.dev20261015" }
   multinode: true
   disagg: false
-  srt-recipe-dir: kimik3/vllm/gb300-fp4/agentx
+  srt-recipe-dir: glm5.2/sglang/gb300-fp4/agentx
   scenarios:
     agentic-coding:
-    - search-space:
+    - dram-utilization: 0.80
+      search-space:
       - spec-decoding: mtp
-        kv-offloading: none
-        conc-list:
-        - 1
-        num-nodes: 4
-        srt-recipe: agg-megakernel-variants.yaml:override_tp16_dspark5
-        power: true
+        conc-list: [1]
+        kv-offloading: dram
+        kv-offload-backend: { name: hicache }
+        num-nodes: 1
+        srt-recipe: agg-variants.yaml:override_tp4_c1
         worker:
           num-worker: 1
-          tp: 16
-          dcp-size: 16
+          tp: 4
           ep: 1
           dp-attn: false
-
-
-# Kimi-K3 MXFP4 B200 aggregated vLLM (TP8 x PP2, 2 nodes / 16 GPUs), agentic
-# coding. The native MXFP4 checkpoint (2.8T total params, ~1.4TB weights) does
-# not fit one 8xB200 node, so TP8 shards attention/dense and PP2 splits layers.
-# Plain TP (NOT TEP): ep 1, no expert parallelism -- the 896 routed experts are
-# TP-sharded within each pipeline stage. Node count = tp*pp/gpus_per_node =
-# 8*2/8 = 2. Aggregated (prefill num-worker 1 + decode num-worker 0, RECIPES.md
-# section 5): the single worker serves both phases, so no P/D KV transfer.
-# Serving is DIRECT vllm serve (srt-slurm frontend.type: vllm), not the dynamo
-# worker entrypoint -- framework stays dynamo-vllm for launcher routing only.
-# DCP8 over a2a with the direct symmetric-memory kernels, Mooncake DRAM KV
-# offload, and DSpark speculation sized per concurrency: 7 draft tokens (golden
-# AL 3.84) through conc 14, where the decode batch is small enough that deeper
-# speculation pays; 4 draft tokens (AL 3.36) at conc 24/32/48/56/72/80; and no speculation
-# at conc 96, where the batch already saturates the two nodes.
-kimik3-fp4-b200-dynamo-vllm-agentic-dspark:
-  image: vllm/vllm-openai:v0.32.0@sha256:befccf0e7e4089aa23926bb6f887a85c0d46c2a99e6de5c5ffdf5cb7957c5b34
-  model: moonshotai/Kimi-K3
-  model-prefix: kimik3
-  runner: cluster:b200-nscale
-  precision: fp4
-  framework: dynamo-vllm
-  multinode: true
-  disagg: false
-  srt-recipe-dir: kimik3/vllm/b200-fp4/agentx
-  scenarios:
-    agentic-coding:
-    - dram-utilization: 0.8
-      search-space:
       - spec-decoding: mtp
-        kv-offloading: none
         conc-list: [1]
+        kv-offloading: dram
+        kv-offload-backend: { name: hicache }
         num-nodes: 2
-        srt-recipe: agg-variants.yaml:override_tp8pp2_c1
-        power: true
+        srt-recipe: agg-variants.yaml:override_tp8_c1
         worker:
           num-worker: 1
           tp: 8
-          pp: 2
-          dcp-size: 8
           ep: 1
           dp-attn: false
+glm5.2-fp4-gb300-dynamo-sglang-agentic-disagg:
+  image: lmsysorg/sglang:nightly-dev-20261016-a93f16f0@sha256:0b3e39704480c423d8a00ca15ebee63154defc62944df2d4b11c594563bab457
+  model: nvidia/GLM-5.2-NVFP4
+  model-prefix: glm5.2
+  runner: cluster:gb300-nv
+  precision: fp4
+  framework: dynamo-sglang
+  router: { name: dynamo-router, version: "1.6.0.dev20261016" }
+  kv-p2p-transfer: nixl
+  multinode: true
+  disagg: true
+  srt-recipe-dir: glm5.2/sglang/gb300-fp4/agentx
+  scenarios:
+    agentic-coding:
+    - dram-utilization: 0.85
+      search-space:
       - spec-decoding: mtp
-        kv-offloading: none
-        conc-list: [4]
-        num-nodes: 2
-        srt-recipe: agg-variants.yaml:override_tp8pp2_c4
-        power: true
-        worker:
+        conc-list: [30]
+        kv-offloading: dram
+        kv-offload-backend: { name: hicache }
+        srt-recipe: disagg-variants.yaml:override_1p5d_pp4_tp4_c30
+        prefill:
           num-worker: 1
-          tp: 8
-          pp: 2
-          dcp-size: 8
+          tp: 1
+          pp: 4
           ep: 1
           dp-attn: false
-      - spec-decoding: mtp
-        kv-offloading: none
-        conc-list: [8]
-        num-nodes: 2
-        srt-recipe: agg-variants.yaml:override_tp8pp2_c8
-        power: true
-        worker:
-          num-worker: 1
-          tp: 8
-          pp: 2
-          dcp-size: 8
+        decode:
+          num-worker: 5
+          tp: 4
+          pp: 1
           ep: 1
           dp-attn: false
       - spec-decoding: mtp
-        kv-offloading: none
-        conc-list: [14]
-        num-nodes: 2
-        srt-recipe: agg-variants.yaml:override_tp8pp2_c14
-        power: true
-        worker:
+        conc-list: [40]
+        kv-offloading: dram
+        kv-offload-backend: { name: hicache }
+        srt-recipe: disagg-variants.yaml:override_1p3d_pp4_tp4_c40
+        prefill:
           num-worker: 1
-          tp: 8
-          pp: 2
-          dcp-size: 8
+          tp: 1
+          pp: 4
           ep: 1
           dp-attn: false
-      - spec-decoding: mtp
-        kv-offloading: none
-        conc-list: [24]
-        num-nodes: 2
-        srt-recipe: agg-variants.yaml:override_tp8pp2_c24
-        power: true
-        worker:
-          num-worker: 1
-          tp: 8
-          pp: 2
-          dcp-size: 8
+        decode:
+          num-worker: 3
+          tp: 4
+          pp: 1
           ep: 1
           dp-attn: false
       - spec-decoding: mtp
-        kv-offloading: none
-        conc-list: [48]
-        num-nodes: 2
-        srt-recipe: agg-variants.yaml:override_tp8pp2_c48
-        power: true
-        worker:
+        conc-list: [56]
+        kv-offloading: dram
+        kv-offload-backend: { name: hicache }
+        srt-recipe: disagg-variants.yaml:override_1p1d_pp4_dep8_c56
+        prefill:
           num-worker: 1
-          tp: 8
-          pp: 2
-          dcp-size: 8
+          tp: 1
+          pp: 4
           ep: 1
           dp-attn: false
-      - kv-offloading: none
-        conc-list: [96]
-        num-nodes: 2
-        srt-recipe: agg-variants.yaml:override_tp8pp2_c96
-        power: true
-        worker:
+        decode:
           num-worker: 1
           tp: 8
-          pp: 2
-          dcp-size: 8
-          ep: 1
-          dp-attn: false
+          pp: 1
+          ep: 8
+          dp-attn: true
       - spec-decoding: mtp
-        kv-offloading: none
-        conc-list: [32]
-        num-nodes: 2
-        srt-recipe: agg-variants.yaml:override_tp8pp2_c32
-        power: true
-        worker:
-          num-worker: 1
-          tp: 8
-          pp: 2
-          dcp-size: 8
+        conc-list: [216]
+        kv-offloading: dram
+        kv-offload-backend: { name: hicache }
+        srt-recipe: disagg-variants.yaml:override_3p1d_pp4_dep8_c216
+        prefill:
+          num-worker: 3
+          tp: 1
+          pp: 4
           ep: 1
           dp-attn: false
-      - spec-decoding: mtp
-        kv-offloading: none
-        conc-list: [56]
-        num-nodes: 2
-        srt-recipe: agg-variants.yaml:override_tp8pp2_c56
-        power: true
-        worker:
+        decode:
           num-worker: 1
           tp: 8
-          pp: 2
-          dcp-size: 8
-          ep: 1
-          dp-attn: false
+          pp: 1
+          ep: 8
+          dp-attn: true
       - spec-decoding: mtp
-        kv-offloading: none
-        conc-list: [72]
-        num-nodes: 2
-        srt-recipe: agg-variants.yaml:override_tp8pp2_c72
-        power: true
-        worker:
-          num-worker: 1
-          tp: 8
-          pp: 2
-          dcp-size: 8
+        conc-list: [264]
+        kv-offloading: dram
+        kv-offload-backend: { name: hicache }
+        srt-recipe: disagg-variants.yaml:override_3p1d_pp4_dep8_c264
+        prefill:
+          num-worker: 3
+          tp: 1
+          pp: 4
           ep: 1
           dp-attn: false
-      - spec-decoding: mtp
-        kv-offloading: none
-        conc-list: [80]
-        num-nodes: 2
-        srt-recipe: agg-variants.yaml:override_tp8pp2_c80
-        power: true
-        worker:
+        decode:
           num-worker: 1
           tp: 8
-          pp: 2
-          dcp-size: 8
+          pp: 1
+          ep: 8
+          dp-attn: true
+      - spec-decoding: mtp
+        conc-list: [256]
+        kv-offloading: dram
+        kv-offload-backend: { name: hicache }
+        srt-recipe: disagg-variants.yaml:override_4p1d_pp4_dep16_c256
+        prefill:
+          num-worker: 4
+          tp: 1
+          pp: 4
           ep: 1
           dp-attn: false
-qwen3.5-fp8-gb300-dynamo-sglang-mtp:
-  image: lmsysorg/sglang:v0.5.14-cu130@sha256:5027e95bf6ec536856b1b52a91d1f35ff5c564ab83e8a94758a169ff09bb8df3
-  model: Qwen/Qwen3.5-397B-A17B-FP8
-  model-prefix: qwen3.5
-  runner: gb300
-  precision: fp8
-  framework: dynamo-sglang
-  router: { name: dynamo-router, version: "46520ca59afe992fb5ef61b3197b2316f8df9b2b" }
-  kv-p2p-transfer: mooncake
+        decode:
+          num-worker: 1
+          tp: 16
+          pp: 1
+          ep: 16
+          dp-attn: true
+
+# GLM-5.2 NVFP4 TensorRT-LLM AgentX on GB300 with Dynamo disaggregated serving.
+# Six topology variants use NIXL KV transfer and MTP3/MTP5 decoding.
+glm5.2-fp4-gb300-dynamo-trt-agentic-disagg-mtp:
+  image: nvcr.io/nvidia/tensorrt-llm/release:1.3.0rc28.dev202609210001
+  model: nvidia/GLM-5.2-NVFP4
+  model-prefix: glm5.2
+  runner: cluster:gb300-nv
+  precision: fp4
+  framework: dynamo-trt
+  router: { name: dynamo-router, version: "1.6.0.dev20261010" }
+  kv-p2p-transfer: nixl
   multinode: true
   disagg: true
-  srt-recipe-dir: qwen3.5/sglang/gb300-fp8/8k1k
+  srt-recipe-dir: glm5.2/trtllm/gb300-fp4/agentx
   scenarios:
-    fixed-seq-len:
-    - isl: 8192
-      osl: 1024
+    agentic-coding:
+    - dram-utilization: 0.15239
       search-space:
-      # 1P1D TP4/TP4. 8 worker GPUs.
-      - spec-decoding: "mtp"
-        conc-list: [1, 2, 8]
-        srt-recipe: disagg-1p1d-p-tp4-d-tp4-b1024-c1x2x8-mtp.yaml
-        power: true
-        prefill:
-          num-worker: 1
-          tp: 4
-          ep: 1
-          dp-attn: false
-        decode:
-          num-worker: 1
-          tp: 4
-          ep: 1
-          dp-attn: false
-      # 1P1D TEP8/TEP8. 16 worker GPUs.
-      - spec-decoding: "mtp"
-        conc-list: [32, 48, 80]
-        srt-recipe: disagg-1p1d-p-tp8-ep8-d-tp8-ep8-b1024-c32x48x80-mtp.yaml
-        power: true
+      - spec-decoding: mtp
+        conc-list: [1]
+        kv-offloading: dram
+        kv-offload-backend: { name: native, version: "1.3.0rc28.dev202609210001" }
+        srt-recipe: disagg-variants.yaml:override_1p1d_tp8_c1_b1_mtp5
         prefill:
           num-worker: 1
-          tp: 8
-          ep: 8
-          dp-attn: false
+          tp: 4
+          ep: 4
+          dp-attn: true
         decode:
           num-worker: 1
           tp: 8
-          ep: 8
+          ep: 1
           dp-attn: false
-      # 3P1D DEP4/DEP16. 28 worker GPUs.
-      - spec-decoding: "mtp"
-        conc-list: [480]
-        srt-recipe: disagg-3p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b1024-c480-mtp.yaml
-        power: true
+      - spec-decoding: mtp
+        conc-list: [30]
+        kv-offloading: dram
+        kv-offload-backend: { name: native, version: "1.3.0rc28.dev202609210001" }
+        srt-recipe: disagg-variants.yaml:override_1p4d_tep4_c30_b2_mtp5
         prefill:
-          num-worker: 3
+          num-worker: 1
           tp: 4
           ep: 4
           dp-attn: true
         decode:
-          num-worker: 1
-          tp: 16
-          ep: 16
-          dp-attn: true
-      # 4P1D DEP4/DEP16. 32 worker GPUs.
-      - spec-decoding: "mtp"
-        conc-list: [768]
-        srt-recipe: disagg-4p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b1024-c768-mtp.yaml
-        power: true
-        prefill:
           num-worker: 4
           tp: 4
           ep: 4
+          dp-attn: false
+      - spec-decoding: mtp
+        conc-list: [20]
+        kv-offloading: dram
+        kv-offload-backend: { name: native, version: "1.3.0rc28.dev202609210001" }
+        srt-recipe: disagg-variants.yaml:override_1p1d_tep8_c20_b5_mtp5
+        prefill:
+          num-worker: 1
+          tp: 4
+          ep: 4
           dp-attn: true
         decode:
           num-worker: 1
-          tp: 16
-          ep: 16
-          dp-attn: true
-      # 6P1D DEP4/DEP16. 40 worker GPUs.
-      - spec-decoding: "mtp"
-        conc-list: [1280]
-        srt-recipe: disagg-6p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b1024-c1280-mtp.yaml
-        power: true
+          tp: 8
+          ep: 8
+          dp-attn: false
+      - spec-decoding: mtp
+        conc-list: [60]
+        kv-offloading: dram
+        kv-offload-backend: { name: native, version: "1.3.0rc28.dev202609210001" }
+        srt-recipe: disagg-variants.yaml:override_3p4d_tep4_c60_b5_mtp5
         prefill:
-          num-worker: 6
+          num-worker: 3
           tp: 4
           ep: 4
           dp-attn: true
         decode:
-          num-worker: 1
-          tp: 16
-          ep: 16
-          dp-attn: true
-      # 7P1D DEP4/DEP16. 44 worker GPUs.
-      - spec-decoding: "mtp"
-        conc-list: [1344]
-        srt-recipe: disagg-7p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b2048-c1344-mtp.yaml
-        power: true
+          num-worker: 4
+          tp: 4
+          ep: 4
+          dp-attn: false
+      - spec-decoding: mtp
+        conc-list: [260]
+        kv-offloading: dram
+        kv-offload-backend: { name: native, version: "1.3.0rc28.dev202609210001" }
+        srt-recipe: disagg-variants.yaml:override_5p1d_dep16_c260_b16_mtp3
         prefill:
-          num-worker: 7
+          num-worker: 5
           tp: 4
           ep: 4
           dp-attn: true
@@ -7262,22 +5234,56 @@ qwen3.5-fp8-gb300-dynamo-sglang-mtp:
           tp: 16
           ep: 16
           dp-attn: true
-      # 8P1D DEP4/DEP16. 48 worker GPUs.
-      - spec-decoding: "mtp"
-        conc-list: [1920, 2304]
-        srt-recipe: disagg-8p1d-p-tp4-ep4-dp4-d-tp16-ep16-dp16-b2048-c1920x2304-mtp.yaml
-        power: true
+      - spec-decoding: mtp
+        conc-list: [227]
+        kv-offloading: dram
+        kv-offload-backend: { name: native, version: "1.3.0rc28.dev202609210001" }
+        srt-recipe: disagg-variants.yaml:override_4p1d_dep8_c227_b16_mtp3
         prefill:
-          num-worker: 8
+          num-worker: 4
           tp: 4
           ep: 4
           dp-attn: true
         decode:
           num-worker: 1
-          tp: 16
-          ep: 16
+          tp: 8
+          ep: 8
           dp-attn: true
 
+glm5.3flash-fp8-gb300-sglang-agentic-mtp:
+  image: lmsysorg/sglang:v0.5.22-cu130@sha256:e3a4f06001a29542fc4a8638536d9ffc5eb9c9942b08603c09b19a56eae4a1ae
+  model: zai-org/GLM-5.3-Flash
+  model-prefix: glm5.3flash
+  runner: cluster:gb300-nv
+  precision: fp8
+  framework: sglang
+  multinode: false
+  srt-recipe-dir: glm5.3flash/sglang/gb300-fp8-mtp
+  scenarios:
+    agentic-coding:
+    # HiCache auto-sizes at fraction 0.90: 4 ranks x 178.13 GB = 712.5 GB of 964.7 GB (920,000 MiB).
+    - dram-utilization: 0.7386
+      search-space:
+      - { tp: 4, ep: 1, spec-decoding: mtp, kv-offloading: none, conc-list: [1, 4, 8, 16, 24, 32], srt-recipe: "agentic.yaml:override_gpu_kv" }
+      - { tp: 4, ep: 1, spec-decoding: mtp, kv-offloading: dram, kv-offload-backend: { name: hicache }, conc-list: [40, 44, 48], srt-recipe: "agentic.yaml:override_hicache" }
+
+glm5.3flash-fp4-gb300-sglang-agentic-mtp:
+  image: lmsysorg/sglang:v0.5.22-cu130@sha256:e3a4f06001a29542fc4a8638536d9ffc5eb9c9942b08603c09b19a56eae4a1ae
+  model: nvidia/GLM-5.3-Flash-NVFP4
+  model-prefix: glm5.3flash
+  runner: cluster:gb300-nv
+  precision: fp4
+  framework: sglang
+  multinode: false
+  srt-recipe-dir: glm5.3flash/sglang/gb300-fp4-mtp
+  scenarios:
+    agentic-coding:
+    # HiCache auto-sizes at fraction 0.90: 4 ranks x 178.13 GB = 712.5 GB of 964.7 GB (920,000 MiB).
+    - dram-utilization: 0.7386
+      search-space:
+      - { tp: 4, ep: 1, spec-decoding: mtp, kv-offloading: none, conc-list: [1, 4, 8, 16, 24, 32], srt-recipe: "agentic.yaml:override_gpu_kv" }
+      - { tp: 4, ep: 1, spec-decoding: mtp, kv-offloading: dram, kv-offload-backend: { name: hicache }, conc-list: [40, 44, 48], srt-recipe: "agentic.yaml:override_hicache" }
+
 # H100 AgentX arm for DeepSeek-V4.1-Flash. H100 is not in the upstream hardware
 # table (h200, gb200, gb300, mi350x are). It needs its own script, not the
 # shared symlink: the sparse attention indexer's
@@ -7461,6 +5467,23 @@ dsv41flash-fp4-b300-vllm-agentic-dspark:
       - { tp: 2, ep: 2, dp-attn: true, kv-offloading: none, spec-decoding: mtp, conc-list: [8, 16, 32, 64], router: { name: vllm-router, version: "0.1.14" }, srt-recipe: agentic.yaml }
       - { tp: 2, ep: 2, dp-attn: true, kv-offloading: dram, kv-offload-backend: { name: vllm-simple }, spec-decoding: mtp, conc-list: [128, 192], router: { name: vllm-router, version: "0.1.14" }, srt-recipe: agentic.yaml }
 
+kimik3.1-fp4-b300-vllm-agentic-dspark:
+  image: vllm/vllm-openai:kimi-k31@sha256:904520f3fefc32414abcedf6ba8dadc9c5978db1bcdaf40f58d6b9036ef30a99
+  model: moonshotai/Kimi-K3.1-Pro
+  model-prefix: kimik3.1
+  runner: cluster:b300-dsxe
+  precision: fp4
+  framework: vllm
+  multinode: false
+  srt-recipe-dir: kimik3.1/vllm/b300-fp4-mtp
+  scenarios:
+    agentic-coding:
+    # 0.75 resolves to 2249 GB of host DRAM, which the recipe's Simple CPU offload splits across the 8 TP ranks.
+    - dram-utilization: 0.75
+      search-space:
+      # The ~1.56 TB MXFP4 checkpoint needs all 8 GPUs. DSpark drafts 5 tokens up to conc 8, then 4, 3 and 2.
+      - { tp: 8, ep: 1, dcp-size: 8, spec-decoding: mtp, kv-offloading: dram, kv-offload-backend: { name: vllm-simple }, conc-list: [1, 2, 4, 8, 16, 24, 32, 40, 48, 56, 70], srt-recipe: agentic.yaml }
+
 dsv41flash-fp4-b200-vllm-agentic-dspark:
   image: vllm/vllm-openai:v0.32.0@sha256:befccf0e7e4089aa23926bb6f887a85c0d46c2a99e6de5c5ffdf5cb7957c5b34
   model: deepseek-ai/DeepSeek-V4.1-Flash
@@ -7539,8 +5562,17 @@ minimaxm31flash-fp4-gb300-vllm-agentic-dspark:
   scenarios:
     agentic-coding:
     - search-space:
-      - { tp: 4, spec-decoding: mtp, kv-offloading: none, conc-list: [1, 4, 8, 16, 32], srt-recipe: agentic.yaml }
-      - { tp: 4, ep: 4, dp-attn: true, spec-decoding: mtp, kv-offloading: none, conc-list: [64, 96, 128], router: { name: vllm-router, version: "0.1.14" }, srt-recipe: agentic.yaml }
+      - { tp: 4, spec-decoding: mtp, kv-offloading: none, conc-list: [1, 4, 32], srt-recipe: agentic.yaml }
+      - { tp: 4, spec-decoding: mtp, kv-offloading: none, conc-list: [8], srt-recipe: agentic.yaml:override_tp4_c8_cudagraph }
+      - { tp: 4, spec-decoding: mtp, kv-offloading: none, conc-list: [16], srt-recipe: agentic.yaml:override_tp4_c16_cudagraph }
+      - { tp: 4, spec-decoding: mtp, kv-offloading: none, conc-list: [24], srt-recipe: agentic.yaml:override_tp4_c24_batched32k }
+      - { tp: 4, spec-decoding: mtp, kv-offloading: none, conc-list: [40], srt-recipe: agentic.yaml:override_tp4_c40_batched8k }
+      - { tp: 4, ep: 4, dp-attn: true, spec-decoding: mtp, kv-offloading: none, conc-list: [64], router: { name: vllm-router, version: "0.1.14" }, srt-recipe: agentic.yaml }
+    - dram-utilization: 1.0
+      search-space:
+      - { tp: 2, spec-decoding: mtp, kv-offloading: dram, kv-offload-backend: { name: vllm-simple }, conc-list: [28], srt-recipe: agentic.yaml:override_tp2_c28_cpu_offload }
+      - { tp: 2, spec-decoding: mtp, kv-offloading: dram, kv-offload-backend: { name: vllm-simple }, conc-list: [32], srt-recipe: agentic.yaml:override_tp2_c32_cpu_offload }
+      - { tp: 2, spec-decoding: mtp, kv-offloading: dram, kv-offload-backend: { name: vllm-simple }, conc-list: [36], srt-recipe: agentic.yaml:override_tp2_c36_cpu_offload }
 
 # MiniMax-M3.1-Flash AgentX on GB300 with SGLang: day-zero image from the SGLang
 # cookbook (https://docs.sglang.io/cookbook/autoregressive/MiniMax/MiniMax-M3.1),
@@ -7548,7 +5580,7 @@ minimaxm31flash-fp4-gb300-vllm-agentic-dspark:
 # GB300 Balanced (TP4), High-Throughput (TP4, EP4; HiCache above conc 32) and
 # Low-Latency (MonoKernel, conc 1).
 # Seven-token DSpark (bundled draft); synthetic acceptance follows
-# infx/golden_al_distribution/minimaxm31flash_dspark.yaml.
+# infx/golden_al_distribution/minimax-m3.1-flash__dspark__native__probabilistic-block.yaml.
 minimaxm31flash-fp4-gb300-sglang-agentic-dspark:
   image: lmsysorg/sglang:dev-minimax-m31-flash@sha256:614b1509bcb729c653528d448bff9850f8977fcad9d12ba56bd6dbe3d7985e87
   model: MiniMaxAI/MiniMax-M3.1-Flash
@@ -7586,6 +5618,81 @@ minimaxm31flash-fp4-gb300-sglang-agentic-dspark:
       - { tp: 2, spec-decoding: mtp, kv-offloading: dram, kv-offload-backend: { name: hicache }, conc-list: [36], srt-recipe: 'agentic-spf.yaml:zip_override_tp2_hicache_spf_interval32[4]' }
       - { tp: 2, spec-decoding: mtp, kv-offloading: dram, kv-offload-backend: { name: hicache }, conc-list: [40], srt-recipe: 'agentic-spf.yaml:zip_override_tp2_hicache_spf_interval32[5]' }
 
+minimaxm31flash-fp4-gb300-dynamo-sglang-agentic-dspark-agg:
+  image: lmsysorg/sglang:nightly-cu134-20261030-e371881@sha256:a82fff791d7dc1e5cfdfde9022487c60c079286fd54684950d55b787eb2e673a
+  model: MiniMaxAI/MiniMax-M3.1-Flash
+  model-prefix: minimaxm31flash
+  runner: cluster:gb300-nv
+  precision: fp4
+  framework: dynamo-sglang
+  router: { name: dynamo-router, version: "1.7.0.dev20261030" }
+  multinode: true
+  disagg: false
+  srt-recipe-dir: minimaxm31flash/sglang/gb300-fp4/agentx
+  scenarios:
+    agentic-coding:
+    - search-space:
+      - spec-decoding: mtp
+        kv-offloading: none
+        conc-list: [1]
+        num-nodes: 1
+        srt-recipe: agg-variants.yaml:override_tp4_c1
+        worker: { num-worker: 1, tp: 4, ep: 1, dp-attn: false }
+      - spec-decoding: mtp
+        kv-offloading: none
+        conc-list: [1]
+        num-nodes: 1
+        srt-recipe: agg-variants.yaml:override_tp4_monokernel_c1
+        worker: { num-worker: 1, tp: 4, ep: 1, dp-attn: false }
+      - spec-decoding: mtp
+        kv-offloading: none
+        conc-list: [4]
+        num-nodes: 1
+        srt-recipe: agg-variants.yaml:override_tp4_c4
+        worker: { num-worker: 1, tp: 4, ep: 1, dp-attn: false }
+      - spec-decoding: mtp
+        kv-offloading: none
+        conc-list: [8]
+        num-nodes: 1
+        srt-recipe: agg-variants.yaml:override_tp4_c8
+        worker: { num-worker: 1, tp: 4, ep: 1, dp-attn: false }
+      - spec-decoding: mtp
+        kv-offloading: none
+        conc-list: [16]
+        num-nodes: 1
+        srt-recipe: agg-variants.yaml:override_tp4_c16
+        worker: { num-worker: 1, tp: 4, ep: 1, dp-attn: false }
+    - dram-utilization: 0.80
+      search-space:
+      - spec-decoding: mtp
+        kv-offloading: dram
+        kv-offload-backend: { name: hicache }
+        conc-list: [24]
+        num-nodes: 1
+        srt-recipe: agg-variants.yaml:override_tp4_hicache_spf_c24
+        worker: { num-worker: 1, tp: 4, ep: 1, dp-attn: false }
+      - spec-decoding: mtp
+        kv-offloading: dram
+        kv-offload-backend: { name: hicache }
+        conc-list: [40]
+        num-nodes: 1
+        srt-recipe: agg-variants.yaml:override_tp2_hicache_spf_c40
+        worker: { num-worker: 1, tp: 2, ep: 1, dp-attn: false }
+      - spec-decoding: mtp
+        kv-offloading: dram
+        kv-offload-backend: { name: hicache }
+        conc-list: [40]
+        num-nodes: 1
+        srt-recipe: agg-variants.yaml:override_tp2_hicache_c40
+        worker: { num-worker: 1, tp: 2, ep: 1, dp-attn: false }
+      - spec-decoding: mtp
+        kv-offloading: dram
+        kv-offload-backend: { name: hicache }
+        conc-list: [44]
+        num-nodes: 1
+        srt-recipe: agg-variants.yaml:override_tp2_hicache_c44
+        worker: { num-worker: 1, tp: 2, ep: 1, dp-attn: false }
+
 minimaxm31flash-fp4-gb300-dynamo-sglang-agentic-dspark-disagg:
   image: lmsysorg/sglang:nightly-cu134-20261030-e371881@sha256:a82fff791d7dc1e5cfdfde9022487c60c079286fd54684950d55b787eb2e673a
   model: MiniMaxAI/MiniMax-M3.1-Flash
@@ -7605,14 +5712,28 @@ minimaxm31flash-fp4-gb300-dynamo-sglang-agentic-dspark-disagg:
       - spec-decoding: mtp
         kv-offloading: dram
         kv-offload-backend: { name: hicache }
-        conc-list: [280, 320, 360, 400]
+        conc-list: [280, 320, 340, 360, 400]
         srt-recipe: disagg-variants.yaml:override_6p_dep2_dep8
         prefill: { num-worker: 6, tp: 2, ep: 2, dp-attn: true }
         decode: { num-worker: 1, tp: 8, ep: 8, dp-attn: true }
       - spec-decoding: mtp
         kv-offloading: dram
         kv-offload-backend: { name: hicache }
-        conc-list: [300]
+        conc-list: [224, 256]
+        srt-recipe: disagg-variants.yaml:override_4p_dep2_dep8
+        prefill: { num-worker: 4, tp: 2, ep: 2, dp-attn: true }
+        decode: { num-worker: 1, tp: 8, ep: 8, dp-attn: true }
+      - spec-decoding: mtp
+        kv-offloading: dram
+        kv-offload-backend: { name: hicache }
+        conc-list: [440, 480]
+        srt-recipe: disagg-variants.yaml:override_8p_dep2_dep8
+        prefill: { num-worker: 8, tp: 2, ep: 2, dp-attn: true }
+        decode: { num-worker: 1, tp: 8, ep: 8, dp-attn: true }
+      - spec-decoding: mtp
+        kv-offloading: dram
+        kv-offload-backend: { name: hicache }
+        conc-list: [220, 240, 260, 300, 360, 400]
         srt-recipe: disagg-variants.yaml:override_6p_dep2_dep16
         prefill: { num-worker: 6, tp: 2, ep: 2, dp-attn: true }
         decode: { num-worker: 1, tp: 16, ep: 16, dp-attn: true }
@@ -8012,7 +6133,7 @@ dsv41flash-fp4-b300-sglang-agentic-dspark-lowconc:
 # cookbook (https://docs.sglang.io/cookbook/autoregressive/MiniMax/MiniMax-M3.1),
 # manifest digest verified 2026-10-24.
 # Seven-token DSpark (bundled draft); synthetic acceptance follows
-# infx/golden_al_distribution/minimaxm31flash_dspark.yaml.
+# infx/golden_al_distribution/minimax-m3.1-flash__dspark__native__probabilistic-block.yaml.
 minimaxm31flash-fp4-b300-sglang-agentic-dspark:
   image: lmsysorg/sglang:dev-minimax-m31-flash@sha256:614b1509bcb729c653528d448bff9850f8977fcad9d12ba56bd6dbe3d7985e87
   model: MiniMaxAI/MiniMax-M3.1-Flash
@@ -8027,6 +6148,7 @@ minimaxm31flash-fp4-b300-sglang-agentic-dspark:
     - search-space:
       # Balanced: TP4.
       - { tp: 4, spec-decoding: mtp, kv-offloading: none, conc-list: [1, 4, 8, 16, 32], srt-recipe: agentic.yaml }
+      - { tp: 4, spec-decoding: mtp, kv-offloading: none, conc-list: [16], srt-recipe: 'agentic-tp4-spf-extra.yaml:override_tp4_c16_spf_interval32' }
       # Low-Latency: MSA-V1 MonoKernel at batch size 1.
       - { tp: 4, spec-decoding: mtp, kv-offloading: none, conc-list: [1], srt-recipe: agentic-low-latency.yaml }
     - dram-utilization: 0.80
@@ -8037,6 +6159,10 @@ minimaxm31flash-fp4-b300-sglang-agentic-dspark:
       - { tp: 4, spec-decoding: mtp, kv-offloading: dram, kv-offload-backend: { name: hicache }, conc-list: [40], srt-recipe: 'agentic-tp4-spf.yaml:zip_override_tp4_dram_spf_interval32[2]' }
       - { tp: 4, spec-decoding: mtp, kv-offloading: dram, kv-offload-backend: { name: hicache }, conc-list: [8], srt-recipe: 'agentic-tp4-spf.yaml:zip_override_tp4_dram_spf_interval32[3]' }
       - { tp: 4, spec-decoding: mtp, kv-offloading: dram, kv-offload-backend: { name: hicache }, conc-list: [16], srt-recipe: 'agentic-tp4-spf.yaml:zip_override_tp4_dram_spf_interval32[4]' }
+      - { tp: 4, spec-decoding: mtp, kv-offloading: dram, kv-offload-backend: { name: hicache }, conc-list: [20], srt-recipe: 'agentic-tp4-spf-extra.yaml:zip_override_tp4_dram_spf_interval32[0]' }
+      - { tp: 4, spec-decoding: mtp, kv-offloading: dram, kv-offload-backend: { name: hicache }, conc-list: [44], srt-recipe: 'agentic-tp4-spf-extra.yaml:zip_override_tp4_dram_spf_interval32[1]' }
+      - { tp: 4, spec-decoding: mtp, kv-offloading: dram, kv-offload-backend: { name: hicache }, conc-list: [52], srt-recipe: 'agentic-tp4-spf-extra.yaml:zip_override_tp4_dram_spf_interval32[2]' }
+      - { tp: 4, spec-decoding: mtp, kv-offloading: dram, kv-offload-backend: { name: hicache }, conc-list: [60], srt-recipe: 'agentic-tp4-spf-extra.yaml:zip_override_tp4_dram_spf_interval32[3]' }
     - dram-utilization: 1.0
       search-space:
       - { tp: 2, spec-decoding: mtp, kv-offloading: dram, kv-offload-backend: { name: hicache }, conc-list: [32, 36, 40, 44, 46, 48], srt-recipe: agentic-tp2.yaml }
@@ -8054,10 +6180,13 @@ minimaxm31flash-fp4-b300-sglang-agentic-dspark:
       - { tp: 2, spec-decoding: mtp, kv-offloading: dram, kv-offload-backend: { name: hicache }, conc-list: [40], srt-recipe: 'agentic-tp2-spf-interval.yaml:zip_override_tp2_spf_interval32[5]' }
       - { tp: 2, spec-decoding: mtp, kv-offloading: dram, kv-offload-backend: { name: hicache }, conc-list: [48], srt-recipe: 'agentic-tp2-spf-interval.yaml:override_tp2_c48_spf_interval24' }
       - { tp: 2, spec-decoding: mtp, kv-offloading: dram, kv-offload-backend: { name: hicache }, conc-list: [50], srt-recipe: 'agentic-tp2-spf-interval.yaml:override_tp2_c50_spf_interval20' }
+      - { tp: 2, spec-decoding: mtp, kv-offloading: dram, kv-offload-backend: { name: hicache }, conc-list: [44], srt-recipe: 'agentic-tp2-spf-extra.yaml:override_tp2_c44_spf_interval32' }
+      - { tp: 2, spec-decoding: mtp, kv-offloading: dram, kv-offload-backend: { name: hicache }, conc-list: [50], srt-recipe: 'agentic-tp2-spf-extra.yaml:override_tp2_c50_spf_interval20_mem093' }
+      - { tp: 2, spec-decoding: mtp, kv-offloading: dram, kv-offload-backend: { name: hicache }, conc-list: [52], srt-recipe: 'agentic-tp2-spf-extra.yaml:override_tp2_c52_spf_interval20_mem093' }
 
-# Official SGLang nightly; TP4 C1 uses GPU Engram, other points use host DRAM.
+# Official SGLang nightly; every point uses the host-DRAM Engram table.
 dsv41flash-fp4-gb300-sglang-agentic-dspark:
-  image: lmsysorg/sglang:nightly-dev-cu13-20261021-c1c287a4@sha256:b0473834763b2753e069cb96c1acaf235ba7fd632ccd9bbeb44da809c437fdeb
+  image: lmsysorg/sglang:nightly-dev-cu13-20261030-302b78cc@sha256:d4b7701dc94d287e4fc135dfb4c1a88df0778a936255021aeb26eb54d396e579
   model: deepseek-ai/DeepSeek-V4.1-Flash
   model-prefix: dsv41flash
   runner: cluster:gb300-nv
@@ -8317,6 +6446,7 @@ qwen3.8next-fp4-gb300-sglang-agentic-mtp:
     - dram-utilization: 1.0
       search-space:
       - tp: 1
+        require-power: true
         ep: 1
         dp-attn: false
         spec-decoding: mtp
@@ -8326,7 +6456,7 @@ qwen3.8next-fp4-gb300-sglang-agentic-mtp:
         srt-recipe: agentic.yaml
 
 musespark-fp4-gb300-sglang-agentic-dflash:
-  image: lmsysorg/sglang:nightly-dev-20261021-c1c287a4
+  image: lmsysorg/sglang:nightly-dev-cu13-20261030-302b78cc
   model: meta-models/Muse-Spark-Open-816B-A42B-NVFP4
   model-prefix: musespark
   runner: cluster:gb300-nv
@@ -8337,10 +6467,10 @@ musespark-fp4-gb300-sglang-agentic-dflash:
   scenarios:
     agentic-coding:
     - search-space:
-      - { tp: 4, ep: 4, kv-offloading: none, spec-decoding: draft_model, conc-list: [1, 5, 8, 10, 15], srt-recipe: agentic.yaml }
+      - { tp: 4, ep: 4, kv-offloading: none, spec-decoding: draft_model, conc-list: [1, 4, 8, 10, 15], srt-recipe: agentic.yaml }
     - dram-utilization: 0.80
       search-space:
-      - { tp: 4, ep: 4, kv-offloading: dram, kv-offload-backend: { name: hicache }, spec-decoding: draft_model, conc-list: [24, 28, 30, 34, 44, 48], srt-recipe: agentic.yaml }
+      - { tp: 4, ep: 4, kv-offloading: dram, kv-offload-backend: { name: hicache }, spec-decoding: draft_model, conc-list: [24, 30, 40, 44, 48], srt-recipe: agentic.yaml }
 
 musespark-fp4-gb300-dynamo-sglang-agentic-dflash:
   image: lmsysorg/sglang:dev-muse-spark-open@sha256:8cfc5a72cb296771f5f8a4a4688cb6d05685610a830cbb616fa4ab0eb7bb2b0a
@@ -8627,7 +6757,7 @@ qwen3.5-fp8-gb300-dynamo-sglang-agentic-pp-midcurve:
 # aggregated TP4 engine on 4 of the node's 8 GPUs per point, so tok/s/GPU is
 # per 4 GPUs. EAGLE runs off the built-in nextn head at K=5, with acceptance
 # pinned to the golden thinking-on AL 3.61 (infx/golden_al_distribution/
-# glm5.2_mtp.yaml). Same image as glm5.2-fp4-b300-sglang-agentic-mtp; the
+# glm-5.2-fp8__mtp__native__default-default.yaml). Same image as glm5.2-fp4-b300-sglang-agentic-mtp; the
 # Dynamo 1.5.0.dev20260903 wheels install at job start. c1-c20 run plain TP4;
 # c24-c48 add DP4 attention and the prefill delayer. HiCache keeps 270-295
 # GB/rank in host DRAM; with the DSA indexer pools that is about 1.3-1.42 TB
@@ -8726,7 +6856,7 @@ glm5.2-fp4-b300-dynamo-sglang-agentic-agg-tp4:
           dp-attn: true
 
 musespark-fp4-b300-sglang-agentic-dflash:
-  image: lmsysorg/sglang:nightly-dev-20261021-c1c287a4
+  image: lmsysorg/sglang:nightly-dev-cu13-20261030-302b78cc
   model: meta-models/Muse-Spark-Open-816B-A42B-NVFP4
   model-prefix: musespark
   runner: cluster:b300-dsxe
@@ -8738,8 +6868,24 @@ musespark-fp4-b300-sglang-agentic-dflash:
     agentic-coding:
     - dram-utilization: 0.80
       search-space:
-      - { tp: 8, ep: 8, kv-offloading: none, spec-decoding: draft_model, conc-list: [1, 4, 8, 10, 14, 16, 20, 24], srt-recipe: agentic.yaml }
-      - { tp: 4, ep: 4, kv-offloading: dram, kv-offload-backend: { name: hicache }, spec-decoding: draft_model, conc-list: [16, 28, 32, 40, 44, 48], srt-recipe: agentic.yaml }
+      - { tp: 8, ep: 8, kv-offloading: none, spec-decoding: draft_model, conc-list: [1, 4, 7, 16, 20, 24], srt-recipe: agentic.yaml }
+      - { tp: 4, ep: 4, kv-offloading: dram, kv-offload-backend: { name: hicache }, spec-decoding: draft_model, conc-list: [16, 28, 32, 38, 48], srt-recipe: agentic.yaml }
+
+kimik3.1-fp4-b300-sglang-agentic-dflash:
+  image: lmsysorg/sglang:dev-kimi-k31-pro@sha256:67fc77d1cbe67de27ca54d874c82757a4844743fea899ea7d0df547e30c2c391
+  model: moonshotai/Kimi-K3.1-Pro
+  model-prefix: kimik3.1
+  runner: cluster:b300-dsxe
+  precision: fp4
+  framework: sglang
+  multinode: false
+  srt-recipe-dir: kimik3.1/sglang/b300-fp4-mtp
+  scenarios:
+    agentic-coding:
+    - dram-utilization: 0.75
+      search-space:
+      - { tp: 8, ep: 1, kv-offloading: dram, kv-offload-backend: { name: hicache }, spec-decoding: draft_model, conc-list: [1, 2, 4, 8, 16], srt-recipe: agentic.yaml }
+      - { tp: 8, ep: 2, dcp-size: 8, kv-offloading: dram, kv-offload-backend: { name: hicache }, spec-decoding: draft_model, conc-list: [24, 32, 40, 48, 56, 70], srt-recipe: agentic.yaml }
 
 musespark-fp4-h100-sglang-agentic-dflash:
   image: lmsysorg/sglang:dev-muse-spark-open@sha256:8cfc5a72cb296771f5f8a4a4688cb6d05685610a830cbb616fa4ab0eb7bb2b0a
@@ -8756,84 +6902,6 @@ musespark-fp4-h100-sglang-agentic-dflash:
       search-space:
       - { tp: 8, ep: 8, kv-offloading: dram, kv-offload-backend: { name: hicache }, spec-decoding: draft_model, conc-list: [1, 2, 4, 8], srt-recipe: agentic.yaml }
 
-# Kimi-K3 GB200 disaggregated points: one
-# TP16/DCP16 prefill role and one TP16/DCP16 decode role, four 4-GPU nodes each
-# (32 GPUs). DSpark depth 4 with the golden acceptance selected by the launcher.
-kimik3-fp4-gb200-dynamo-vllm-agentic-dspark-mooncake-dcp16-disagg:
-  image: vllm/vllm-openai:nightly-e68efc685ab1e6f1eda004ced7157e3ca411da2f@sha256:1ff6716fe240a922d0d518b8884261e25b0c02eda8e2ce90888e364978249cad
-  model: moonshotai/Kimi-K3
-  model-prefix: kimik3
-  runner: cluster:gb200-nv
-  precision: fp4
-  framework: dynamo-vllm
-  router: { name: dynamo-router, version: "ffbbaaa6c44370e798687881317535ac17d66a76" }
-  kv-p2p-transfer: nixl
-  multinode: true
-  disagg: true
-  srt-recipe-dir: kimik3/vllm/gb200-fp4/agentx
-  scenarios:
-    agentic-coding:
-    # 0.142 resolves to 128 GB of host DRAM per 4-GPU server node on
-    # cluster:gb200-nv, matching the recipes' Mooncake segment size.
-    - dram-utilization: 0.142
-      search-space:
-      - spec-decoding: mtp
-        kv-offloading: dram
-        kv-offload-backend: { name: mooncake, version: "0.3.12.post1" }
-        conc-list: [16]
-        srt-recipe: disagg-variants.yaml:override_1p1d_dcp16_dcp16_dspark4_c16
-        eval-srt-recipe: disagg-variants.yaml:override_1p1d_dcp16_dcp16_dspark4_c16_eval
-        power: true
-        prefill:
-          num-worker: 1
-          tp: 16
-          dcp-size: 16
-          ep: 1
-          dp-attn: false
-        decode: { num-worker: 1, tp: 16, dcp-size: 16, ep: 1, dp-attn: false }
-      - spec-decoding: mtp
-        kv-offloading: dram
-        kv-offload-backend: { name: mooncake, version: "0.3.12.post1" }
-        conc-list: [32]
-        srt-recipe: disagg-variants.yaml:override_1p1d_dcp16_dcp16_dspark4_c32
-        eval-srt-recipe: disagg-variants.yaml:override_1p1d_dcp16_dcp16_dspark4_c32_eval
-        power: true
-        prefill:
-          num-worker: 1
-          tp: 16
-          dcp-size: 16
-          ep: 1
-          dp-attn: false
-        decode: { num-worker: 1, tp: 16, dcp-size: 16, ep: 1, dp-attn: false }
-      - spec-decoding: mtp
-        kv-offloading: dram
-        kv-offload-backend: { name: mooncake, version: "0.3.12.post1" }
-        conc-list: [48]
-        srt-recipe: disagg-variants.yaml:override_1p1d_dcp16_dcp16_dspark4_c48
-        eval-srt-recipe: disagg-variants.yaml:override_1p1d_dcp16_dcp16_dspark4_c48_eval
-        power: true
-        prefill:
-          num-worker: 1
-          tp: 16
-          dcp-size: 16
-          ep: 1
-          dp-attn: false
-        decode: { num-worker: 1, tp: 16, dcp-size: 16, ep: 1, dp-attn: false }
-
-glm5.3flash-fp8-gb300-sglang-agentic-mtp:
-  image: lmsysorg/sglang:v0.5.22-cu130@sha256:e3a4f06001a29542fc4a8638536d9ffc5eb9c9942b08603c09b19a56eae4a1ae
-  model: zai-org/GLM-5.3-Flash
-  model-prefix: glm5.3flash
-  runner: cluster:gb300-nv
-  precision: fp8
-  framework: sglang
-  multinode: false
-  srt-recipe-dir: glm5.3flash/sglang/gb300-fp8-mtp
-  scenarios:
-    agentic-coding:
-    - search-space:
-      - { tp: 4, ep: 1, spec-decoding: mtp, kv-offloading: none, conc-list: [1, 2, 4, 8, 12, 16, 24, 32, 48, 64], srt-recipe: agentic.yaml }
-
 glm5.3-fp4-b300-sglang-agentic-mtp:
   image: lmsysorg/sglang:v0.5.20-cu130@sha256:b27fce60bc5494c118c4910702812bcfa8cee67abcdd1ff8b0902f21647552f4
   model: nvidia/GLM-5.3-NVFP4
diff --git a/inferencex-e2e/configs/runners.yaml b/inferencex-e2e/configs/runners.yaml
index 564ae8d930..a781e6aa22 100644
--- a/inferencex-e2e/configs/runners.yaml
+++ b/inferencex-e2e/configs/runners.yaml
@@ -361,6 +361,7 @@ clusters:
     models:
       entries:
         DeepSeek-V4.1-Flash: {root: data-models, dir: DeepSeek-V4.1-Flash}
+        Kimi-K3.1-Pro: {root: scratch, dir: Kimi-K3.1-Pro}
         Muse-Spark-Open-816B-A42B-NVFP4: {root: data-models, dir: Muse-Spark-Open-816B-A42B-NVFP4}
         Qwen3.5-397B-A17B-FP8: {root: data-models, dir: Qwen3.5-397B-A17B-FP8}
     scheduler: slurm
@@ -373,6 +374,7 @@ clusters:
         hf-hub-cache: {path: /data/home/sa-gha-runner/gharunners/hf-hub-cache}
         aiperf-cache: {path: /data/home/sa-gha-runner/gharunners/ai-perf-cache}
         data-models: {path: /data/models}
+        scratch: {path: /scratch/models, visibility: node-local}
       squash:
         dir: /data/home/sa-gha-runner/gharunners/squash
         visibility: shared
@@ -394,7 +396,7 @@ clusters:
       entries:
         DeepSeek-R1-0528: {root: models, dir: DeepSeek-R1-0528}
         GLM-5.2-FP8: {root: models, dir: GLM-5.2-FP8}
-        Kimi-K3: {root: hf-hub-cache, dir: Kimi-K3}
+        Kimi-K3.1-Pro: {root: hf-hub-cache, dir: Kimi-K3.1-Pro}
         Muse-Spark-Open-816B-A42B-NVFP4: {root: hf-hub-cache, dir: Muse-Spark-Open-816B-A42B-NVFP4}
         Qwen3.5-397B-A17B-FP8: {root: hf-hub-cache, dir: Qwen3.5-397B-A17B-FP8}
     scheduler: slurm
@@ -455,12 +457,11 @@ clusters:
         deepseek-r1-fp4: {root: scratch, dir: DeepSeek-R1-0528-NVFP4-v2}
         GLM-5.2-FP8: {root: scratch, dir: GLM-5.2-FP8}
         GLM-5.2-NVFP4: {root: scratch, dir: GLM-5.2-NVFP4}
-        Kimi-K3: {root: scratch, dir: Kimi-K3}
+        Kimi-K3.1-Pro: {root: scratch, dir: Kimi-K3.1-Pro}
         MiniMax-M3.1-Flash: {root: data-models, dir: MiniMax-M3.1-Flash}
         Muse-Spark-Open-816B-A42B-NVFP4: {root: data-models, dir: Muse-Spark-Open-816B-A42B-NVFP4}
         Qwen3.5-397B-A17B-FP8: {root: scratch, dir: Qwen3.5-397B-A17B-FP8}
         Qwen3.5-397B-A17B-NVFP4: {root: scratch, dir: Qwen3.5-397B-A17B-NVFP4}
-        Qwen3.5-397B-A17B-NVFP4-V2: {root: scratch, dir: Qwen3.5-397B-A17B-NVFP4-V2}
         Qwen3.8-Flash-Next-NVFP4: {root: scratch, dir: Qwen3.8-Flash-Next-NVFP4}
     scheduler: slurm
     slurm:
@@ -521,8 +522,8 @@ clusters:
         GLM-5.2-FP8: {root: scratch, dir: GLM-5.2-FP8}
         GLM-5.2-NVFP4: {root: scratch, dir: GLM-5.2-NVFP4}
         GLM-5.3-NVFP4: {root: scratch, dir: GLM-5.3-NVFP4}
-        GLM-5.3-Flash: {root: data-models, dir: GLM-5.3-Flash}
         Kimi-K3: {root: scratch, dir: Kimi-K3}
+        Kimi-K3.1-Pro: {root: scratch, dir: Kimi-K3.1-Pro}
         MiniMax-M3: {root: scratch, dir: MiniMax-M3}
         MiniMax-M3-MXFP8: {root: scratch, dir: MiniMax-M3-MXFP8}
         MiniMax-M3-NVFP4: {root: scratch, dir: MiniMax-M3-NVFP4}
@@ -537,7 +538,6 @@ clusters:
       partition: batch_1
       account: benchmark
       exclusive: true
-      exclude: [dsxe-sa-b300-prd0-gpu-16]
       gres: "gpu:{gpus}"
       cpus-per-gpu: 24
       salloc-args: [--mem=0]
@@ -577,13 +577,12 @@ clusters:
         deepseek-r1-0528: {root: lustre-models, dir: deepseek-r1-0528}
         deepseek-r1-0528-fp4-v2: {root: lustre-models, dir: deepseek-r1-0528-fp4-v2}
         MiniMax-M3.1-Flash: {root: lustre-models, dir: MiniMax-M3.1-Flash}
-        Qwen3.5-397B-A17B-FP8: {root: lustre-models, dir: Qwen3.5-397B-A17B-FP8}
         Qwen3.5-397B-A17B-NVFP4-V2: {root: lustre-models, dir: Qwen3.5-397B-A17B-NVFP4-V2}
         Muse-Spark-Open-816B-A42B-NVFP4: {root: lustre-models, dir: Muse-Spark-Open-816B-A42B-NVFP4}
         GLM-5.2-NVFP4: {root: sa-shared-models, dir: GLM-5.2-NVFP4}
         DeepSeek-R1-0528: {root: numa1, dir: DeepSeek-R1-0528}
         DeepSeek-R1-0528-NVFP4-v2: {root: numa1, dir: DeepSeek-R1-0528-NVFP4-v2}
-        Kimi-K3: {root: numa1, dir: Kimi-K3}
+        Kimi-K3.1-Pro: {root: numa1, dir: Kimi-K3.1-Pro}
     scheduler: slurm
     slurm:
       partition: batch
@@ -625,6 +624,7 @@ clusters:
           aiperf-cache: /aiperf_mmap_cache
           hf-hub-cache: /hf_hub_cache
         power-exporter-port: 9401
+        cpu-power-exporter: {source: acpi}
   gb300-nv:
     gpus-per-node: 4
     available-cpu-dram-mib: 920_000
@@ -635,7 +635,8 @@ clusters:
         DeepSeek-R1-0528-NVFP4-v2: {root: scratch, dir: DeepSeek-R1-0528-NVFP4-v2}
         GLM-5.2-NVFP4: {root: scratch, dir: GLM-5.2-NVFP4}
         GLM-5.3-Flash: {root: data-models, dir: GLM-5.3-Flash}
-        Kimi-K3: {root: scratch, dir: Kimi-K3}
+        GLM-5.3-Flash-NVFP4: {root: data-models, dir: GLM-5.3-Flash-NVFP4}
+        Kimi-K3.1-Pro: {root: scratch, dir: Kimi-K3.1-Pro}
         MiniMax-M3.1-Flash: {root: data-models, dir: MiniMax-M3.1-Flash}
         Muse-Spark-Open-816B-A42B-NVFP4: {root: data-models, dir: Muse-Spark-Open-816B-A42B-NVFP4}
         Qwen3.5-397B-A17B-FP8: {root: scratch, dir: Qwen3.5-397B-A17B-FP8}
@@ -648,6 +649,9 @@ clusters:
       partitions: [batch_1, batch_3]
       account: benchmark
       exclusive: false
+      # 2026-11-05: c003's local NVMe extracted containers with zero-filled blocks (libcuda stub),
+      # and c008 twice read back empty Triton cache files. Remove after ops checks both disks.
+      exclude: [im-gb300-r01-c003, im-gb300-r01-c008]
       volumes:
         hf-hub-cache: {path: /data/home/sa-shared/gharunners/hf-hub-cache}
         aiperf-cache: {path: /data/home/sa-shared/gharunners/ai-perf-cache}
@@ -683,6 +687,7 @@ clusters:
           hf-hub-cache: /hf_hub_cache
           dynamo-wheels: /configs/dynamo-wheels
         power-exporter-port: 19401
+        cpu-power-exporter: {source: acpi}
   mi300x-amd:
     gpus-per-node: 8
     available-cpu-dram-mib: 1_531_436
@@ -709,6 +714,7 @@ clusters:
         single-node-time-limit: 180
         gpus-per-node-directive: true
         segment-directive: false
+        cpu-power-exporter: {source: rapl}
         host-setup:
           script: runners/srt-slurm/hooks/mi300x-amd/setup.sh
         mounts:
@@ -758,6 +764,7 @@ clusters:
         single-node-time-limit: 480
         gpus-per-node-directive: true
         segment-directive: false
+        cpu-power-exporter: {source: rapl}
         mounts:
           /dev/kfd: /dev/kfd
           /dev/dri: /dev/dri
@@ -775,7 +782,6 @@ clusters:
       MORI_RDMA_TC: '@fabric.rdma-tc'
     models:
       entries:
-        Kimi-K3: {root: it-share-data, dir: Kimi-K3}
         DeepSeek-R1-0528-MXFP4-v2: {root: it-share-data, dir: DeepSeek-R1-0528-MXFP4-v2}
         GLM-5.3: {root: it-share-data, dir: GLM-5.3}
         Qwen3.5-397B-A17B-FP8: {root: it-share-data, dir: Qwen3.5-397B-A17B-FP8}
@@ -808,11 +814,13 @@ clusters:
         gpus-per-node-directive: true
         segment-directive: false
         outputs: /it-share/gharunners2/srt-slurm/outputs
+        cpu-power-exporter: {source: rapl}
         host-setup:
           script: runners/srt-slurm/hooks/mi355x-amds/setup.sh
           env:
             IBDEVICES: '@fabric.rdma-devices'
-          timeout-s: 1200
+          # Covers the hook's 60-minute wait for prior-job VRAM to drain.
+          timeout-s: 4200
           nodes: all
         volume-mounts:
           shared-hf-hub-cache: /hf_hub_cache/hub
diff --git a/inferencex-e2e/configs/srt-recipes/telemetry-dcgm.yaml b/inferencex-e2e/configs/srt-recipes/telemetry-dcgm.yaml
index f6327f349f..4611320db8 100644
--- a/inferencex-e2e/configs/srt-recipes/telemetry-dcgm.yaml
+++ b/inferencex-e2e/configs/srt-recipes/telemetry-dcgm.yaml
@@ -1,10 +1,10 @@
-# Merged under the fragment of a point whose master row sets `power: true`. The launcher
-# adds the cluster's power-exporter-port and stages the dcgm-exporter image.
+# Merged under the fragment of every multi-node benchmark point on a cluster with a
+# power-exporter-port. The launcher adds the port and stages the dcgm-exporter image; the binder
+# sets `required` from the row's `power` field.
 telemetry:
   enabled: true
   collect_interval_ms: 1000
   storage_subdir: power
-  required: true
   startup_timeout_seconds: 120
   request_timeout_seconds: 2
   dcgm_exporter:
diff --git a/inferencex-e2e/configs/srt-recipes/telemetry-native.yaml b/inferencex-e2e/configs/srt-recipes/telemetry-native.yaml
index 308a006d29..cc19faa1a9 100644
--- a/inferencex-e2e/configs/srt-recipes/telemetry-native.yaml
+++ b/inferencex-e2e/configs/srt-recipes/telemetry-native.yaml
@@ -1,5 +1,3 @@
-# Native single-node benchmarks inherit the GPU exporter from the cluster record.
-# The binder sets `required` from REQUIRE_POWER.
 telemetry:
   enabled: true
   storage_subdir: power
diff --git a/inferencex-e2e/docs/MODELS.md b/inferencex-e2e/docs/MODELS.md
index afa4031486..6b88705976 100644
--- a/inferencex-e2e/docs/MODELS.md
+++ b/inferencex-e2e/docs/MODELS.md
@@ -18,8 +18,8 @@ InferenceX-e2e runs on a fixed GPU pool with a small team, so scenarios, precisi
 
 In general, we should be benchmarking free & ~open engines that is used in production by actual customers. Priority goes towards stuff that is used more in prod
 
-- **Pending A/B baseline retirement (not yet enacted):** standalone non-spec-decode baselines kept only for comparison with speculative decoding are slated for retirement. This covers `qwen3.5` non-MTP and `kimik3` non-DSpark, whose active configs still contain non-spec-decode points. `glm5.2` has no active non-spec-decode configs. Retire one only once replacement coverage exists for the affected model, hardware, and engine. A spec-decode counterpart existing is not by itself a reason to remove a config.
-- **No separate A/B tracks for new models:** [`infx/golden_al_distribution/`](../infx/golden_al_distribution) pins speculative AgentX runs to one measured acceptance-length curve, so spec-decode results are comparable on their own. New models, including Kimi-K3, do not need a non-spec-decode baseline from day 0.
+- **Pending A/B baseline retirement (not yet enacted):** standalone non-spec-decode baselines kept only for comparison with speculative decoding are slated for retirement. This covers `qwen3.5` non-MTP, whose active configs still contain non-spec-decode points. `glm5.2` has no active non-spec-decode configs. Retire one only once replacement coverage exists for the affected model, hardware, and engine. A spec-decode counterpart existing is not by itself a reason to remove a config.
+- **No separate A/B tracks for new models:** [`infx/golden_al_distribution/`](../infx/golden_al_distribution) pins speculative AgentX runs to one measured acceptance-length curve, so spec-decode results are comparable on their own. New models do not need a non-spec-decode baseline from day 0.
 - **Publish the best Pareto points, with or without speculative decoding.** Recipes may disable MTP, EAGLE/EAGLE3, DSpark, or another draft method when that gives a better operating point. Valid non-spec-decode results stay eligible under the [North-star Pareto policy](#north-star-pareto-policy), so a frontier may mix both.
 
 ## all-reduce policy
@@ -96,7 +96,6 @@ The table also records both the agreed plan-of-record (PoR) draft-model mapping
 
 | Model | Primary native/upstream engines | Agreed draft model(s) (PoR) | Proposed draft model(s) pending partner alignment | Additional engines |
 |---|---|---|---|---|
-| Kimi-K3 (`kimik3`) | native/upstream vLLM engine | `Inferact/Kimi-K3-DSpark` | None | Additional non-vLLM/SGLang engines under the ordering guideline and exceptions above |
 | GLM-5.2 (`glm5.2`) | native/upstream SGLang engine | native MTP | None | Additional non-vLLM/SGLang engines under the ordering guideline and exceptions above |
 | GLM-5.3-Flash (`glm5.3flash`) | native/upstream SGLang engine | native MTP | None | Additional non-vLLM/SGLang engines under the ordering guideline and exceptions above |
 | Qwen3.5-397B-A17B (`qwen3.5`) | native/upstream SGLang engine | native MTP | None | Additional non-vLLM/SGLang engines under the ordering guideline and exceptions above |
@@ -121,24 +120,49 @@ The 3 TB limit prevents an unrealistic memory-capacity race in which hardware ve
 
 Other offloading tiers, including NVMe KV cache offloading, are outside the initial scope and may be introduced after the InferenceX v3 release. NVMe KV cache offloading is tentatively targeted as a fast follow-up in InferenceX v3.5 or as part of InferenceX v4.
 
+### Kimi K3.1 Pro week-1 precision policy
+
+Agreed by the vLLM and SGLang communities for week-1 official AgentX results. "Native" means the precision of the original released checkpoint.
+
+| Component | Rule |
+|---|---|
+| Linear ops | Must match native (BF16) |
+| Shared expert | Must match native (BF16) |
+| MoE weights | MXFP4 or NVFP4 |
+| MoE activations | A4W4 allowed |
+| MoE dispatch | MX/NV-style quantization allowed |
+| MoE combine | Must match native (BF16) |
+| AllReduce / AG / RS | Must match native (BF16) |
+| KDA cache | FP32 |
+| Conv cache | Native (BF16) |
+| Indexer cache | FP4 allowed |
+| KV cache | FP8 allowed. FP4 only if the native checkpoint ships an FP4 KV cache |
+
+- EPLB: dynamic only, static EPLB not allowed.
+- A4W4 and NVFP4 MoE are allowed because AMD has no W4A8 (FP4 weight, FP8 activation) MoE kernel.
+- FP4 KV cache without native support is not allowed in official AgentX results for week 1; it may be reconsidered once it passes KVV (and/or TB 4.0). Vendor blogs may still show it on the AgentX harness: such results must be labeled unofficial per the InferenceX/AgentX trademark and should include the full KVV suite showing FP4 KV cache passes or is near every KVV eval.
+- Engines outside vLLM, SGLang, TileRT and TokenSpeed on widely available hardware (i.e. not MI455X, Rubin, etc.) must first pass KVV (and/or TB 4.0), with logs and reproduction scripts, before submitting.
+- Any rule may be revisited after week 1 with a passing KVV (and/or TB 4.0) result. Passing requires public reproduction scripts and full logs.
+
 ## Model support matrix
 
 | Model architecture class | Prefix | Date added | Active scenarios | Deprecated scenarios |
 |---|---|---|---|---|
-| GLM-5.3-Flash | `glm5.3flash` | 2026-11-01 | Agentic coding (native SGLang FP8 on GB300, embedded MTP; golden AL curve `glm5.3flash_mtp.yaml`) | |
-| MiniMax-M3.1-Flash | `minimaxm31flash` | 2026-10-23 | Agentic coding (vLLM DSpark; golden AL curve `minimaxm31flash_dspark.yaml`) | |
-| Muse Spark Open 816B-A42B | `musespark` | 2026-10-15 | Agentic coding (SGLang and GB300 TensorRT-LLM with DFlash2 draft `RadixArk/Muse-Spark-Open-DFlash2`; golden AL curve `musespark_dflash.yaml`) | |
+| GLM-5.3-Flash | `glm5.3flash` | 2026-11-05 ([#4708](https://github.com/SemiAnalysisAI/InferenceX/pull/4708)) | Agentic coding (SGLang MTP; golden AL curve `glm-5.3-flash__mtp__native__default-default.yaml`) | |
+| Kimi-K3.1-Pro | `kimik3.1` | 2026-11-04 ([#4795](https://github.com/SemiAnalysisAI/InferenceX/pull/4795)) | Agentic coding (vLLM and SGLang DSpark; golden AL curve `kimi-k3.1-pro__dspark__kimi-k3.1-pro-dspark-preview__probabilistic-block.yaml`; [week-1 precision policy](#kimi-k31-pro-week-1-precision-policy)) | |
+| MiniMax-M3.1-Flash | `minimaxm31flash` | 2026-10-23 | Agentic coding (vLLM DSpark; golden AL curve `minimax-m3.1-flash__dspark__native__probabilistic-block.yaml`) | |
+| Muse Spark Open 816B-A42B | `musespark` | 2026-10-15 | Agentic coding (SGLang and GB300 TensorRT-LLM with DFlash2 draft `RadixArk/Muse-Spark-Open-DFlash2`; golden AL curve `muse-spark-open-816b-a42b-nvfp4__dflash__muse-spark-open-dflash2__default-default.yaml`) | |
 | DeepSeek-V4.1-Flash | `dsv41flash` | 2026-09-10 | Agentic coding (vLLM: DSpark, Engram UVA offload; SGLang: DSpark arms added per SKU from 2026-09-17; ATOM: MI355X TP2/TP4 DSpark added 2026-09-23, removed in #3463, restored on srt-slurm 2026-09-30; GPU validation pending) | |
 | GLM-5.3 | `glm5.3` | 2026-09-22 ([#3366](https://github.com/SemiAnalysisAI/InferenceX/pull/3366)) | Agentic coding (MTP only, per the deprecation policy) | Single-turn 1k1k (deprecated for all models before this model was added; never run) |
 | Qwen3.8-Flash-Next | `qwen3.8next` | 2026-08-26 ([#2742](https://github.com/SemiAnalysisAI/InferenceX/pull/2742)) | Agentic coding | |
-| Kimi-K3 | `kimik3` | 2026-07-27 ([#2391](https://github.com/SemiAnalysisAI/InferenceX/pull/2391)) | Agentic coding (DSpark may be disabled for better Pareto points) | Standalone non-DSpark A/B baseline (not required from day 0) |
+| Kimi-K3 | `kimik3` | 2026-07-27 ([#2391](https://github.com/SemiAnalysisAI/InferenceX/pull/2391)) | None (retired 2026-11-03) | Agentic coding, including DSpark and non-DSpark points |
 | GLM-5.2 | `glm5.2` | 2026-07-18 ([#2268](https://github.com/SemiAnalysisAI/InferenceX/pull/2268)) | Agentic coding (non-MTP points remain eligible under the Pareto policy; see the deprecation policy) | |
 | MiniMax-M3 | `minimaxm3` | 2026-06-12 ([#1724](https://github.com/SemiAnalysisAI/InferenceX/pull/1724)) | None (fully retired 2026-10-29) | Agentic coding (removed 2026-10-29); Single-turn 1k1k, Single-turn 8k1k (removed 2026-08-04, [#2493](https://github.com/SemiAnalysisAI/InferenceX/pull/2493)) |
 | DeepSeek-V4-Pro | `dsv4` | 2026-04-24 ([#1130](https://github.com/SemiAnalysisAI/InferenceX/pull/1130)) | None (fully retired 2026-10-29) | Agentic coding (removed 2026-10-29); Single-turn 1k1k, Single-turn 8k1k (removed 2026-09-09, [#2921](https://github.com/SemiAnalysisAI/InferenceX/pull/2921)) |
 | GLM-5 / GLM-5.1 | `glm5`, `glm5.1` | 2026-03-06 ([#762](https://github.com/SemiAnalysisAI/InferenceX/pull/762)), with GLM-5.1 added 2026-04-21 ([#1098](https://github.com/SemiAnalysisAI/InferenceX/pull/1098)) | None (fully retired 2026-10-01, [#3638](https://github.com/SemiAnalysisAI/InferenceX/pull/3638)) | The earlier GLM-5 / GLM-5.1 recipes were retired 2026-07-18 ([#2276](https://github.com/SemiAnalysisAI/InferenceX/pull/2276)); the GLM-5.1 B200 TileRT 1k1k and 8k1k points (added 2026-08-09, [#2533](https://github.com/SemiAnalysisAI/InferenceX/pull/2533)) were retired 2026-10-01 ([#3638](https://github.com/SemiAnalysisAI/InferenceX/pull/3638)) |
 | MiniMax-M2.5/2.7 | `minimaxm2.5` | 2026-02-18 ([#755](https://github.com/SemiAnalysisAI/InferenceX/pull/755)) | None (retired 2026-06-20, [#1874](https://github.com/SemiAnalysisAI/InferenceX/pull/1874)) | Single-turn 1k1k, Single-turn 1k8k, Single-turn 8k1k |
 | Kimi-K2.5/2.6/2.7-Code | `kimik2.5` | 2026-02-17 ([#734](https://github.com/SemiAnalysisAI/InferenceX/pull/734)) | None (fully retired 2026-08-07, [#2527](https://github.com/SemiAnalysisAI/InferenceX/pull/2527)) | Single-turn 1k1k, Single-turn 1k8k, Agentic coding (removed 2026-08-04, [#2493](https://github.com/SemiAnalysisAI/InferenceX/pull/2493)), Single-turn 8k1k (removed 2026-08-07, [#2527](https://github.com/SemiAnalysisAI/InferenceX/pull/2527)) |
-| Qwen3.5-397B-A17B | `qwen3.5` | 2026-02-16 ([#704](https://github.com/SemiAnalysisAI/InferenceX/pull/704)) | Single-turn 8k1k and Agentic coding, both limited to fp8/fp4 | Single-turn 1k1k, Single-turn 1k8k, all bf16 recipes (removed 2026-08-04, [#2493](https://github.com/SemiAnalysisAI/InferenceX/pull/2493)) |
+| Qwen3.5-397B-A17B | `qwen3.5` | 2026-02-16 ([#704](https://github.com/SemiAnalysisAI/InferenceX/pull/704)) | Agentic coding, limited to fp8/fp4 | Single-turn 8k1k (removed 2026-11-02, [#4697](https://github.com/SemiAnalysisAI/InferenceX/pull/4697)); Single-turn 1k1k, Single-turn 1k8k, all bf16 recipes (removed 2026-08-04, [#2493](https://github.com/SemiAnalysisAI/InferenceX/pull/2493)) |
 | gpt-oss-120b | `gptoss` | 2025-09-09 | None (retired 2026-07-06, [#2101](https://github.com/SemiAnalysisAI/InferenceX/pull/2101)) | Single-turn 1k1k, Single-turn 1k8k, Single-turn 8k1k |
 | DeepSeek-R1-0528 | `dsr1` | 2025-08-13 | Single-turn 8k1k | Single-turn 1k1k, Single-turn 1k8k |
 | Llama-3.1-70B-Instruct | `llama70b` | 2025-08-12 | None (retired 2025-10-29, [#149](https://github.com/SemiAnalysisAI/InferenceX/pull/149)) | Single-turn 1k1k, Single-turn 1k8k, Single-turn 8k1k [^1] |
@@ -150,6 +174,7 @@ Other offloading tiers, including NVMe KV cache offloading, are outside the init
 - The `Prefix` column is the canonical `model-prefix` used in `configs/*-master.yaml` and by the `full-sweep` subcommand's `--model-prefix` filter, for example `python -m infx.matrix.generate full-sweep --config-files configs/nvidia-master.yaml --model-prefix dsr1`.
 - "Retired" means the model no longer has any active scenario. Retired models' configs are deleted from the master configs; the former `configs/deprecated/` archive was removed in #3463, so past settings live in git history and `perf-changelog.yaml`.
 - MiniMax-M3 and DeepSeek-V4-Pro retirement does not affect MiniMax-M3.1-Flash or DeepSeek-V4.1-Flash. Their SPEED-Bench collectors, golden AL curves, and B300 checkpoint mappings remain available for acceptance-length research and historical result interpretation; CollectiveX's DeepSeek-V4-Pro communication shape is also independent of serving benchmark coverage.
+- Kimi-K3 retirement removes all serving benchmark configs. Its SPEED-Bench collectors, golden AL curves, B300 checkpoint mapping, and vendor-eval tooling remain available for research and historical result interpretation. OperatorX retains Kimi-K3 operator shapes, but no longer inherits their retired serving recipes. Those cases use the current hardware/backend default image without recipe-specific env or engine args. Removing the entries also changes the vLLM default images for other unmatched cases on MI355X and B300; [`operatorx/perf-changelog.yaml`](../../operatorx/perf-changelog.yaml) records the runtime changes.
 - Deprecating a precision (e.g. Qwen3.5 bf16) or one arm of an A/B pair (e.g. non-MTP) narrows a model's recipe coverage without retiring the model. The model stays listed as active as long as one scenario still runs.
 - Klaud Cold reads the Scenarios table and this page's Model support matrix when it freezes an image-refresh baseline. A published single-turn point is exempt from re-measurement only if the family no longer runs any point with its ISL/OSL; the only Scenarios row for that ISL/OSL starts with `Deprecated since YYYY-MM-DD ([#N](PR link))` or `**Deprecated for all models** since YYYY-MM-DD ([#N](PR link))`, dated after the baseline and linking a PR of this repository; and the model's row lists that scenario under deprecated and not under active scenarios. Removing only some topologies or concurrencies exempts nothing. Keep that wording, one row per ISL/OSL and per model, and one cell per column when editing these tables; see [Klaud Cold reporting instructions](../../.github/klaud-candidate-prompt.md).
 - `dsr1` began as the DeepSeek-V3 workflow templates in the initial repo import and was switched to DeepSeek-R1 benchmarking on 2025-08-13 (renamed `dsv3` → `dsr1` on 2025-08-20).
diff --git a/inferencex-e2e/docs/PRINCIPLES.md b/inferencex-e2e/docs/PRINCIPLES.md
index 0c7f06e363..e5b8fee843 100644
--- a/inferencex-e2e/docs/PRINCIPLES.md
+++ b/inferencex-e2e/docs/PRINCIPLES.md
@@ -9,5 +9,6 @@
 ## Anti-Goal
 - Due to having limited GPU time and limited upstream maintainer bandwidth, we are unable to support comparing many inference engines.
   - The core focus of InferenceX is to compare between different AI accelerators.
-  - We should add another inference engine only when its benefits clearly outweigh the core maintainer time it would take away from supporting an AI accelerator that InferenceX does not yet cover
+  - We should add another inference engine only when its benefits clearly outweigh the core maintainer time it would take away from supporting an AI accelerator that InferenceX does not yet cover.
+  - **If you would like to submit your engine for Trainium, Ascend, Alibaba T-Head (PPU), Intel GPU, MI455X, Rubin Ultra, SambaNova, Etched Sohu, Groq LPX or Cerebras, etc, we would be happy to collaborate**
   - For those that want to compare inference engines, we recommend forking the repo, hooking up self hosted GPU resources to your fork repo and potentially writing your own blog on it similar to [ParaSail Engine](https://www.parasail.io/blog/minimax-m3-1-flash-day-0)
diff --git a/inferencex-e2e/docs/agentx-standalone.md b/inferencex-e2e/docs/agentx-standalone.md
index ae78978aab..eaff8e7a8e 100644
--- a/inferencex-e2e/docs/agentx-standalone.md
+++ b/inferencex-e2e/docs/agentx-standalone.md
@@ -9,10 +9,10 @@ Install the pinned PyPI release in a Python 3.11–3.13 virtual environment:
 ```bash
 python3 -m venv .venv-agentx
 source .venv-agentx/bin/activate
-python -m pip install 'agentx-harness==1.0.12'
+python -m pip install 'agentx-harness==1.0.13'
 ```
 
-The package version matches the `agentx-v1.0.12` GitHub release. The `agentx`
+The package version matches the `agentx-v1.0.13` GitHub release. The `agentx`
 command selects the `agentx` scenario by default.
 
 ## Run
@@ -20,8 +20,8 @@ command selects the `agentx` scenario by default.
 ```bash
 set -eo pipefail
 SERVER_URL="http://127.0.0.1:8000"
-SERVED_MODEL_NAME="moonshotai/Kimi-K3"
-TOKENIZER="moonshotai/Kimi-K3"
+SERVED_MODEL_NAME="deepseek-ai/DeepSeek-V4.1-Flash"
+TOKENIZER="deepseek-ai/DeepSeek-V4.1-Flash"
 DATASET="semianalysis_cc_traces_weka_062126"
 CONC=8
 OUTPUT_DIR="$PWD/results/agentx-c${CONC}-$(date -u +%Y%m%dT%H%M%SZ)"
diff --git a/inferencex-e2e/infx/bench/__main__.py b/inferencex-e2e/infx/bench/__main__.py
index 6ef5583aa1..7c66865f48 100644
--- a/inferencex-e2e/infx/bench/__main__.py
+++ b/inferencex-e2e/infx/bench/__main__.py
@@ -13,7 +13,7 @@
     "fixed-seq": "infx.bench.fixed_seq",
     "agentic": "infx.bench.agentic.run",
     "eval": "infx.bench.eval",
-    "speedbench-al": "infx.bench.speedbench_al",
+    "al-gate": "infx.bench.al_gate",
 }
 
 
diff --git a/inferencex-e2e/infx/bench/agentic/replay.py b/inferencex-e2e/infx/bench/agentic/replay.py
index 221677330d..528aac1554 100644
--- a/inferencex-e2e/infx/bench/agentic/replay.py
+++ b/inferencex-e2e/infx/bench/agentic/replay.py
@@ -72,7 +72,7 @@ def from_env(cls, env: Mapping[str, str], result_dir: Path) -> ReplayConfig:
         )
         extra_inputs = inputs.optional("AIPERF_EXTRA_INPUTS", env) or ""
         return cls(
-            url=_server_url(env),
+            url=server_url(env),
             model=inputs.optional("SERVED_MODEL_NAME", env) or values["MODEL"],
             tokenizer=inputs.optional("TOKENIZER", env) or values["MODEL"],
             concurrency=inputs.parse_positive_int("CONC", values["CONC"]),
@@ -91,7 +91,7 @@ def from_env(cls, env: Mapping[str, str], result_dir: Path) -> ReplayConfig:
                 if max_context
                 else None
             ),
-            server_metrics_urls=_server_metrics_urls(env),
+            server_metrics_urls=metrics_urls(env),
             artifact_dir=result_dir / "aiperf_artifacts",
             unsafe_override=duration < MIN_SCENARIO_DURATION_S,
             loader=loader,
@@ -101,7 +101,7 @@ def from_env(cls, env: Mapping[str, str], result_dir: Path) -> ReplayConfig:
         )
 
 
-def _server_url(env: Mapping[str, str]) -> str:
+def server_url(env: Mapping[str, str]) -> str:
     """srt-slurm's frontend, else ``AIPERF_SERVER_URL``, else ``http://localhost:$PORT``."""
     host = inputs.optional("SRT_FRONTEND_HOST", env)
     if host:
@@ -111,8 +111,11 @@ def _server_url(env: Mapping[str, str]) -> str:
     )
 
 
-def _server_metrics_urls(env: Mapping[str, str]) -> tuple[str, ...]:
-    """Every Prometheus endpoint AIPerf scrapes; it keeps ``endpoint_url`` per series."""
+def metrics_urls(env: Mapping[str, str], path: str = "/metrics") -> tuple[str, ...]:
+    """Every Prometheus endpoint AIPerf scrapes; it keeps ``endpoint_url`` per series.
+
+    ``path`` is the workers' Prometheus route when the endpoints come from ``SRT_*``.
+    """
     urls = inputs.optional("AIPERF_SERVER_METRICS_URLS", env)
     if not urls and env.get("SRTCTL_FRONTEND_TYPE") != "dynamo":
         prefill = env.get("SRT_PREFILL_ENDPOINTS")
@@ -121,7 +124,7 @@ def _server_metrics_urls(env: Mapping[str, str]) -> tuple[str, ...]:
         )
         endpoints = endpoints.removesuffix(",")
         if endpoints:
-            urls = ",".join(f"http://{e}/metrics" if e else "" for e in endpoints.split(","))
+            urls = ",".join(f"http://{e}{path}" if e else "" for e in endpoints.split(","))
     if not urls:
         return ()
     parts = urls.split(",")
diff --git a/inferencex-e2e/infx/bench/agentic/requirements.txt b/inferencex-e2e/infx/bench/agentic/requirements.txt
index 0425bee6db..c002681aec 100644
--- a/inferencex-e2e/infx/bench/agentic/requirements.txt
+++ b/inferencex-e2e/infx/bench/agentic/requirements.txt
@@ -1,2 +1,2 @@
-agentx-harness==1.0.12
+agentx-harness==1.0.13
 datasets>=4.7.0
diff --git a/inferencex-e2e/infx/bench/agentic/venv.py b/inferencex-e2e/infx/bench/agentic/venv.py
index 9f256a8a87..11ed40e23d 100644
--- a/inferencex-e2e/infx/bench/agentic/venv.py
+++ b/inferencex-e2e/infx/bench/agentic/venv.py
@@ -48,6 +48,11 @@ def agentx(self) -> Path:
         """The venv's ``agentx`` executable."""
         return self.venv / "bin" / "agentx"
 
+    @property
+    def aiperf(self) -> Path:
+        """The harness package's generic ``aiperf`` replay executable."""
+        return self.venv / "bin" / "aiperf"
+
     @property
     def hf(self) -> Path:
         """The venv's ``hf`` executable."""
diff --git a/inferencex-e2e/infx/bench/al_gate.py b/inferencex-e2e/infx/bench/al_gate.py
new file mode 100644
index 0000000000..3777cff21a
--- /dev/null
+++ b/inferencex-e2e/infx/bench/al_gate.py
@@ -0,0 +1,247 @@
+"""``al-gate``: replay a curve's golden SPEED-Bench collection, then judge the realized AL.
+
+An agentic eval job runs it as its srt-slurm benchmark stage, against the server its eval
+then uses. The generation engine's own Prometheus counters, scraped before and after the
+replay, give ``AL = 1 + accepted draft tokens / verification steps``; the verdict compares it
+with the curve's golden AL. Report-only: every measured verdict exits 0. A measurement that could not
+run exits non-zero, and its result document records the error.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import random
+import signal
+import time
+import urllib.request
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Any
+
+from infx.bench import env as inputs, proc, speedbench
+from infx.bench.agentic import replay
+from infx.bench.agentic.venv import Runtime, bootstrap
+from infx.bench.env import BenchError, InputError
+
+REQUIRED = (
+    "AL_GATE", "AL_GATE_CURVE", "AL_GATE_DRAFT_TOKENS", "AL_GATE_DATASET", "AL_GATE_OUTPUT_DIR",
+    "THINKING_MODE", "RESULT_FILENAME", "MODEL", "FRAMEWORK",
+)  # fmt: skip
+# Every golden collection (vllm bench serve) streamed each prompt once to /v1/completions with
+# max_tokens 4096 and ignore_eos false, the engines' default, so it is not sent.
+MAX_TOKENS = 4096
+MIN_RATIO, MAX_RATIO = 0.95, 1.05
+# AIPerf returns before the engines count the last verifications: scrape until unchanged.
+SETTLE_INTERVAL_S, SETTLE_CAP_S = 2.0, 60.0
+
+
+def main(argv: list[str]) -> int:
+    """Run the ``al-gate`` command."""
+    parser = argparse.ArgumentParser(prog="python3 -m infx.bench al-gate", description=__doc__)
+    parser.parse_args(argv)
+    # The shim's timeout stops the gate at its cap; record that instead of dying silently.
+    signal.signal(signal.SIGTERM, _stopped)
+    return run(os.environ, Runtime.for_job(os.environ))
+
+
+def _stopped(_signum: int, _frame: object) -> None:
+    """Raise when the shim's timeout stops the gate, so its result records why."""
+    cap = os.environ.get("AL_GATE_TIMEOUT_S", "?")
+    raise BenchError(f"stopped at the gate's {cap}s time cap")
+
+
+def run(env: Mapping[str, str], runtime: Runtime, golden_dir: Path | None = None) -> int:
+    """Measure the gate ``env`` describes in ``runtime``'s venv, which it prepares first."""
+    tokens = env.get("AL_GATE_DRAFT_TOKENS", "")
+    document: dict[str, Any] = {
+        "result_filename": env.get("RESULT_FILENAME"), "framework": env.get("FRAMEWORK"),
+        "eval_framework": env.get("EVAL_FRAMEWORK"), "eval_suite": env.get("EVAL_SUITE"),
+        "curve": env.get("AL_GATE_CURVE"), "thinking_mode": env.get("THINKING_MODE"),
+        "draft_tokens": int(tokens) if tokens.isdecimal() else None,
+        "golden_acceptance_length": None, "acceptance_length": None, "ratio": None,
+        "status": "error", "error": None, "accepted_tokens": None, "verifications": None,
+        "report_only": True,
+    }  # fmt: skip
+    try:
+        rc = _measure(env, runtime, document, golden_dir)
+    except Exception as error:
+        document["error"] = str(error) or type(error).__name__
+        _write(env, document)
+        raise
+    _write(env, document)
+    print(f"AL gate result (report-only): {json.dumps(document)}", flush=True)
+    return rc
+
+
+def _measure(
+    env: Mapping[str, str], runtime: Runtime, document: dict[str, Any], golden_dir: Path | None
+) -> int:
+    values = inputs.require(*REQUIRED, env=env)
+    if values["AL_GATE"] != "true":
+        raise InputError("AL_GATE must be true to run the acceptance-length gate")
+    tokens = inputs.parse_positive_int("AL_GATE_DRAFT_TOKENS", values["AL_GATE_DRAFT_TOKENS"])
+    server = replay.server_url(env)
+    # trtllm-serve serves Prometheus text at /prometheus/metrics; its /metrics is JSON.
+    trtllm = env.get("SRTCTL_FRONTEND_TYPE") == "trtllm_serve"
+    metrics_urls = replay.metrics_urls(env, "/prometheus/metrics" if trtllm else "/metrics")
+    if not metrics_urls:
+        raise InputError("no metrics endpoint: set AIPERF_SERVER_METRICS_URLS or SRT_*_ENDPOINTS")
+    # Relative to the workspace root, /infmax-workspace in containers.
+    dataset = proc.REPO_ROOT / values["AL_GATE_DATASET"]
+    prompts = speedbench.load(dataset)
+    if (actual := speedbench.digest(prompts)) != speedbench.PROMPTS_SHA256:
+        raise BenchError(f"{dataset} has sha256 {actual}, not {speedbench.PROMPTS_SHA256}")
+    if not runtime.active():
+        print(f"Preparing the AIPerf runtime in {runtime.venv}", flush=True)
+        rc = bootstrap(runtime)
+        if rc:
+            document["error"] = f"creating the AIPerf runtime exited with code {rc}"
+            return rc
+        # The venv interpreter needs the same safe sys.path as this one had.
+        environ = {**env, "PYTHONPATH": proc.pythonpath(), "PYTHONSAFEPATH": "1"}
+        runtime.exec_python(["-m", "infx.bench", "al-gate"], environ)
+
+    # Client venv only: PyYAML for the curves, Python 3.11 for infx.results and infx.srt_slurm.
+    from infx.golden_al_distribution import GOLDEN_DIR, load_curve
+    from infx.results.agentic.spec_decode import READERS, increase
+    from infx.srt_slurm.synthetic_acceptance import ENGINES
+
+    thinking = values["THINKING_MODE"]
+    curve = load_curve(values["AL_GATE_CURVE"], golden_dir or GOLDEN_DIR)
+    document["golden_acceptance_length"] = golden = curve.acceptance(thinking, tokens)
+    collection = curve.collection or {}
+    mode = collection.get("modes", {}).get(thinking)
+    if mode is None:
+        raise BenchError(f"golden curve {curve.name} records no {thinking} collection to replay")
+    # Only the generation engine's own counters measure its acceptance.
+    reader = READERS.get(ENGINES.get(values["FRAMEWORK"]))
+    if reader is None:
+        document["status"] = "no-counters"
+        return 0
+
+    renderer, kwargs = collection["renderer"], mode["chat_template_kwargs"] or {}
+    tokenizer = _tokenizer(values["MODEL"]) if renderer == "chat_template" else None
+    # vllm bench serve's SPEED-Bench loader order: random.seed(0); random.shuffle(prompts).
+    random.Random(0).shuffle(prompts)  # noqa: S311
+    raw = Path(values["AL_GATE_OUTPUT_DIR"]) / "al_gate"
+    raw.mkdir(parents=True, exist_ok=True)
+    with (raw / "prompts.jsonl").open("w", encoding="utf-8") as sink:
+        for prompt in prompts:
+            row = {"text": render(prompt, renderer, kwargs, tokenizer), "output_length": MAX_TOKENS}
+            sink.write(json.dumps(row, ensure_ascii=False) + "\n")
+    argv = [
+        str(runtime.aiperf), "profile", "--endpoint-type", "completions", "--streaming",
+        "--url", server, "--model", env.get("SERVED_MODEL_NAME") or values["MODEL"],
+        "--tokenizer", values["MODEL"], "--tokenizer-trust-remote-code",
+        "--custom-dataset-type", "single_turn", "--input-file", str(raw / "prompts.jsonl"),
+        "--dataset-sampling-strategy", "sequential", "--request-count", str(len(prompts)),
+        "--concurrency", str(speedbench.REPLAY_CONCURRENCY),
+        # JSON keeps each value's type; AIPerf guesses the types of key:value pairs.
+        "--extra-inputs", json.dumps(mode["sampling"]),
+        "--server-metrics", *metrics_urls, "--output-artifact-dir", str(raw / "aiperf_artifacts"),
+    ]  # fmt: skip
+    before = {url: _scrape(url) for url in metrics_urls}
+    (raw / "metrics_before.json").write_text(json.dumps(before, indent=2))
+    rc = proc.tee(argv, raw / "aiperf.log", dict(env))
+    if rc:
+        raise BenchError(f"aiperf exited with code {rc}")
+    export = json.loads((raw / "aiperf_artifacts" / "profile_export_aiperf.json").read_text())
+    if failed := export.get("error_request_count", {}).get("avg"):
+        raise BenchError(f"{failed:g} of {len(prompts)} requests failed")
+    deadline, previous = time.monotonic() + SETTLE_CAP_S, object()
+    while True:
+        after = {url: _scrape(url) for url in metrics_urls}
+        counted = reader(increase(before, after))
+        if counted == previous or time.monotonic() >= deadline:
+            break
+        previous = counted
+        time.sleep(SETTLE_INTERVAL_S)
+    (raw / "metrics_after.json").write_text(json.dumps(after, indent=2))
+    accepted, verifications = counted or (None, None)
+    document.update(accepted_tokens=accepted, verifications=verifications)
+    if not verifications:
+        document["status"] = "no-counters" if counted is None else "no-drafting"
+        return 0
+    length = 1 + accepted / verifications
+    ratio = round(length / golden, 4)
+    status = "below" if ratio < MIN_RATIO else "pass" if ratio <= MAX_RATIO else "above"
+    document.update(acceptance_length=round(length, 4), ratio=ratio, status=status)
+    return 0
+
+
+def render(prompt: str, renderer: str, kwargs: Mapping[str, Any], tokenizer: Any) -> str:
+    """One user turn rendered client-side, as the golden collector rendered it."""
+    turn = [{"role": "user", "content": prompt}]
+    if renderer == "deepseek_v4":
+        from infx.bench_serving.encoding_dsv4 import encode_messages
+
+        return encode_messages(turn, **dsv4_options(kwargs))
+    if renderer == "deepseek_v41":
+        from infx.bench_serving.encoding_dsv41 import encode_messages
+
+        return encode_messages(turn, **dsv41_options(kwargs))
+    if renderer != "chat_template":
+        raise BenchError(f"renderer {renderer!r} is not chat_template, deepseek_v4 or deepseek_v41")
+    return tokenizer.apply_chat_template(turn, add_generation_prompt=True, tokenize=False, **kwargs)
+
+
+def dsv4_options(kwargs: Mapping[str, Any]) -> dict[str, Any]:
+    """``encode_messages`` options for chat_template_kwargs, as vLLM v0.21-v0.25 map them.
+
+    Thinking is off unless ``thinking`` or ``enable_thinking`` is truthy; reasoning effort
+    ``none`` turns it off, ``max``/``xhigh`` mean ``max``, any other string ``high``.
+    """
+    mode = "thinking" if kwargs.get("thinking") or kwargs.get("enable_thinking") else "chat"
+    effort = kwargs.get("reasoning_effort")
+    if not isinstance(effort, str):
+        effort = None
+    elif effort == "none":
+        mode, effort = "chat", None
+    else:
+        effort = "max" if effort in ("max", "xhigh") else "high"
+    drop = kwargs.get("drop_thinking", True)
+    return {"thinking_mode": mode, "drop_thinking": drop, "reasoning_effort": effort}
+
+
+def dsv41_options(kwargs: Mapping[str, Any]) -> dict[str, Any]:
+    """``encode_messages`` options for chat_template_kwargs, as vLLM's deepseek_v41 maps them.
+
+    Thinking is on unless ``thinking`` or ``enable_thinking`` is given and falsy; reasoning effort
+    ``none`` turns it off, and no effort means ``high``.
+    """
+    thinking = bool(kwargs.get("thinking") or kwargs.get("enable_thinking"))
+    if "thinking" not in kwargs and "enable_thinking" not in kwargs:
+        thinking = True
+    effort = kwargs.get("reasoning_effort")
+    if effort == "none":
+        thinking, effort = False, None
+    return {
+        "thinking_mode": "thinking" if thinking else "chat",
+        "drop_thinking": kwargs.get("drop_thinking", True),
+        "reasoning_effort": "high" if effort is None else effort,
+    }
+
+
+def _tokenizer(model: str) -> Any:
+    """The served model's Hugging Face tokenizer; the client venv provides transformers."""
+    from transformers import AutoTokenizer
+
+    return AutoTokenizer.from_pretrained(model, trust_remote_code=True)
+
+
+def _scrape(url: str) -> str:
+    try:
+        with urllib.request.urlopen(url, timeout=30) as response:  # noqa: S310
+            return response.read().decode("utf-8", errors="replace")
+    except OSError as error:
+        raise BenchError(f"GET {url} failed: {error}") from error
+
+
+def _write(env: Mapping[str, str], document: Mapping[str, Any]) -> None:
+    """``<AL_GATE_OUTPUT_DIR>/al_gate_<RESULT_FILENAME>.json``, where the launcher looks."""
+    if env.get("AL_GATE_OUTPUT_DIR") and env.get("RESULT_FILENAME"):
+        path = Path(env["AL_GATE_OUTPUT_DIR"]) / f"al_gate_{env['RESULT_FILENAME']}.json"
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(json.dumps(document, indent=2) + "\n")
diff --git a/inferencex-e2e/infx/bench/fixed_seq.py b/inferencex-e2e/infx/bench/fixed_seq.py
index 43d1657780..2b7fa8976a 100644
--- a/inferencex-e2e/infx/bench/fixed_seq.py
+++ b/inferencex-e2e/infx/bench/fixed_seq.py
@@ -10,7 +10,7 @@
 from infx.bench import env, proc, server
 
 PYTHON = "python3"
-SINGLE_NODE_BACKENDS = {"sglang": "vllm", "atom": "vllm", "trt": "openai"}
+SINGLE_NODE_BACKENDS = {"sglang": "vllm", "atom": "vllm", "trt": "openai", "tokenspeed": "vllm"}
 
 
 @dataclass(frozen=True)
diff --git a/inferencex-e2e/infx/bench/speedbench.py b/inferencex-e2e/infx/bench/speedbench.py
new file mode 100644
index 0000000000..bbd0abbe88
--- /dev/null
+++ b/inferencex-e2e/infx/bench/speedbench.py
@@ -0,0 +1,89 @@
+"""The SPEED-Bench prompts every golden collection sent, prepared once per run.
+
+``python -m infx.bench.speedbench --output-dir DIR`` writes ``DIR/speedbench_coding.jsonl``, one
+``{"question_id", "prompt"}`` per line in dataset order: the first user message of each coding
+row of nvidia/SPEED-Bench's qualitative test split, as NeMo-Skills' pinned prepare.py resolves
+it. It writes nothing unless their digest is ``PROMPTS_SHA256``. It needs prepare.py's imports
+and about 35 GB under ``HF_HOME``; from ``inferencex-e2e/``::
+
+    uv run --no-project --exclude-newer PT12H --python 3.12 --with datasets --with numpy \
+        --with pandas --with tiktoken python -m infx.bench.speedbench --output-dir DIR
+
+Importing this module needs only the standard library: gate containers ``load`` the file.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import sys
+import types
+import urllib.request
+from pathlib import Path
+
+# The reviewed prepare.py, at the only NeMo-Skills commit that touched it.
+PREPARE_PY = (
+    "https://raw.githubusercontent.com/NVIDIA-NeMo/Skills/"
+    "5ac8609a56ac941540b10c92e68d556e6343cd4c/nemo_skills/dataset/speed-bench/prepare.py"
+)
+PREPARE_PY_SHA256 = "a551be4df541474e54e21b480022b0cbb66c2da068fda61b2a64bd3223bbbed2"
+# prepare.py loads SPEED-Bench's moving main branch; PROMPTS_SHA256 is of this revision.
+SPEED_BENCH_REVISION = "454f88454792dfa3ccfd7ef15fff248efde44cd1"
+# ``digest`` of the 80 coding prompts, in dataset order.
+PROMPTS_SHA256 = "6f1845452f1cfbc1930ea779ba6c3d5b437a9d5853eca199dd9b7619b20a0c18"
+PROMPTS_FILE = "speedbench_coding.jsonl"
+REPLAY_CONCURRENCY = 64
+# prepare.py runs as this importable module: datasets fingerprints its functions by reference.
+MODULE = "infx_speedbench_prepare"
+
+
+def digest(prompts: list[str]) -> str:
+    """sha256 of the prompts as one UTF-8 JSON array."""
+    return hashlib.sha256(json.dumps(prompts, ensure_ascii=False).encode()).hexdigest()
+
+
+def load(path: Path) -> list[str]:
+    """The prompts of a prepared ``speedbench_coding.jsonl``, in dataset order."""
+    with path.open(encoding="utf-8") as lines:
+        return [json.loads(line)["prompt"] for line in lines]
+
+
+def prepare(script: bytes) -> list[dict[str, str]]:
+    """Each coding row's id and first user message, as prepare.py's ``script`` resolves it."""
+    module = sys.modules[MODULE] = types.ModuleType(MODULE)
+    try:
+        exec(compile(script, PREPARE_PY, "exec"), module.__dict__)  # noqa: S102
+        rows = module.load_dataset(
+            "nvidia/SPEED-Bench", "qualitative", split="test", revision=SPEED_BENCH_REVISION
+        )
+        coding = rows.filter(lambda row: row["category"] == "coding")
+        # Only the coding rows reach its resolver; other categories need a gated dataset.
+        resolved = module._resolve_external_data(coding, "qualitative")  # noqa: SLF001
+        return [{"question_id": row["question_id"], "prompt": row["turns"][0]} for row in resolved]
+    finally:
+        sys.modules.pop(MODULE, None)
+
+
+def main(argv: list[str] | None = None) -> int:
+    """Prepare the gate's SPEED-Bench prompts into ``--output-dir``."""
+    parser = argparse.ArgumentParser(prog="python -m infx.bench.speedbench", description=__doc__)
+    parser.add_argument("--output-dir", type=Path, required=True)
+    args = parser.parse_args(argv)
+    with urllib.request.urlopen(PREPARE_PY, timeout=60) as response:
+        script = response.read()
+    if (actual := hashlib.sha256(script).hexdigest()) != PREPARE_PY_SHA256:
+        sys.exit(f"ERROR: {PREPARE_PY} has sha256 {actual}, not {PREPARE_PY_SHA256}")
+    rows = prepare(script)
+    if (actual := digest([row["prompt"] for row in rows])) != PROMPTS_SHA256:
+        sys.exit(f"ERROR: {len(rows)} prompts with sha256 {actual}, not {PROMPTS_SHA256}")
+    args.output_dir.mkdir(parents=True, exist_ok=True)
+    path = args.output_dir / PROMPTS_FILE
+    lines = (json.dumps(row, ensure_ascii=False) + "\n" for row in rows)
+    path.write_text("".join(lines), encoding="utf-8")
+    print(f"Wrote {len(rows)} SPEED-Bench prompts to {path} ({actual})")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/inferencex-e2e/infx/bench/speedbench_al.py b/inferencex-e2e/infx/bench/speedbench_al.py
deleted file mode 100644
index 291fe9eed6..0000000000
--- a/inferencex-e2e/infx/bench/speedbench_al.py
+++ /dev/null
@@ -1,346 +0,0 @@
-from __future__ import annotations
-
-import argparse
-import contextlib
-import hashlib
-import importlib.metadata
-import json
-import math
-import os
-import signal
-import socket
-import subprocess
-import sys
-import tempfile
-import time
-import urllib.request
-from collections.abc import Mapping, Sequence
-from pathlib import Path
-
-from infx.bench import env, proc, server
-
-PREPARE_URL = (
-    "https://raw.githubusercontent.com/NVIDIA-NeMo/Skills/"
-    "bcf059af55c20a89f797724598f9908d126153e6/"
-    "nemo_skills/dataset/speed-bench/prepare.py"
-)
-
-
-def levels(value: str) -> list[int]:
-    parsed = [env.parse_positive_int("MTP_LIST", item) for item in value.split()]
-    if not parsed or len(parsed) != len(set(parsed)):
-        raise env.InputError("MTP_LIST must contain distinct positive integers")
-    return parsed
-
-
-def select_category(source: Path, destination: Path, category: str) -> int:
-    count = 0
-    with source.open(encoding="utf-8") as rows, destination.open("w", encoding="utf-8") as out:
-        for line in rows:
-            row = json.loads(line)
-            if row.get("category") != category:
-                continue
-            messages = row["messages"]
-            # vLLM samples the first turn of each row, including multi-turn rows.
-            if (
-                not messages
-                or messages[0]["role"] != "user"
-                or not isinstance(messages[0]["content"], str)
-                or not messages[0]["content"]
-            ):
-                raise env.BenchError("SPEED-Bench row must start with a nonempty text user turn")
-            out.write(json.dumps(row) + "\n")
-            count += 1
-    if count == 0:
-        raise env.BenchError(f"No SPEED-Bench rows for category {category!r}")
-    return count
-
-
-def read_acceptance(path: Path, *, expected: int, mtp: int) -> float:
-    try:
-        result = json.loads(path.read_text(encoding="utf-8"))
-    except json.JSONDecodeError as error:
-        raise env.BenchError(f"Expected one benchmark result in {path}") from error
-    if (
-        result.get("completed") != expected
-        or result.get("failed", 0) != 0
-        or result.get("total_output_tokens", 0) <= 0
-    ):
-        raise env.BenchError(f"Incomplete SPEED-Bench result: {result.get('completed')}/{expected}")
-    value = result.get("spec_decode_acceptance_length")
-    if (
-        isinstance(value, bool)
-        or not isinstance(value, (int, float))
-        or not math.isfinite(value)
-        or not 1 <= value <= mtp + 1
-    ):
-        raise env.BenchError(f"Invalid acceptance length for MTP={mtp}: {value!r}")
-    drafts = result.get("spec_decode_num_drafts")
-    accepted = result.get("spec_decode_accepted_tokens")
-    if (
-        type(drafts) is not int
-        or drafts <= 0
-        or type(accepted) is not int
-        or not 0 <= accepted <= mtp * drafts
-        or not math.isclose(value, 1 + accepted / drafts, rel_tol=1e-9)
-    ):
-        raise env.BenchError("Missing or inconsistent speculative decoding counter deltas")
-    return float(value)
-
-
-def prepare_dataset(directory: Path, category: str) -> tuple[Path, int]:
-    constraints = directory / "constraints.txt"
-    constraints.write_text(
-        "".join(
-            f"{name}=={importlib.metadata.version(name)}\n"
-            for name in ("huggingface-hub", "transformers", "tokenizers")
-        ),
-        encoding="utf-8",
-    )
-    run(
-        [
-            sys.executable,
-            "-m",
-            "pip",
-            "install",
-            "-q",
-            "-c",
-            str(constraints),
-            "datasets",
-            "tiktoken",
-        ]
-    )
-    prepare = directory / "prepare.py"
-    with urllib.request.urlopen(PREPARE_URL, timeout=60) as response:
-        prepare.write_bytes(response.read())
-    run([sys.executable, str(prepare), "--config", "qualitative", "--output_dir", str(directory)])
-    selected = directory / "selected.jsonl"
-    dataset = directory / "qualitative.jsonl"
-    count = select_category(dataset, selected, category)
-    selected.replace(dataset)
-    return dataset, count
-
-
-def run(command: Sequence[str]) -> None:
-    code = proc.call(command)
-    if code:
-        raise env.BenchError(f"Command exited with status {code}: {command[0]}")
-
-
-def free_port(requested: int) -> int:
-    with socket.socket() as sock:
-        try:
-            sock.bind(("127.0.0.1", requested))
-        except OSError:
-            sock.bind(("127.0.0.1", 0))
-        return int(sock.getsockname()[1])
-
-
-def stop(child: subprocess.Popen[bytes]) -> None:
-    with contextlib.suppress(ProcessLookupError):
-        os.killpg(child.pid, signal.SIGTERM)
-    try:
-        child.wait(timeout=30)
-    except subprocess.TimeoutExpired:
-        pass
-    finally:
-        # The launcher can exit before its GPU workers.
-        with contextlib.suppress(ProcessLookupError):
-            os.killpg(child.pid, signal.SIGKILL)
-        child.wait()
-    wait_gpu_idle()
-
-
-def wait_gpu_idle() -> None:
-    # Reaping the launcher does not wait for TP workers to release their CUDA contexts.
-    deadline = time.monotonic() + 120
-    while True:
-        output = subprocess.check_output(
-            ["nvidia-smi", "--query-gpu=memory.used", "--format=csv,noheader,nounits"],
-            text=True,
-            timeout=10,
-        )
-        used = [int(line.strip()) for line in output.splitlines() if line.strip()]
-        if used and max(used) < 2000:
-            return
-        if time.monotonic() >= deadline:
-            raise env.BenchError(f"GPU memory did not drain after server shutdown: {used} MiB")
-        time.sleep(3)
-
-
-def collect_cell(
-    *,
-    model_path: str,
-    mtp: int,
-    port: int,
-    dataset: Path,
-    count: int,
-    output_len: int,
-    results: Path,
-    args: argparse.Namespace,
-) -> float:
-    command = [
-        "vllm",
-        "serve",
-        model_path,
-        "--host",
-        "127.0.0.1",
-        "--port",
-        str(port),
-        *args.server_args,
-        "--speculative-config",
-        json.dumps({"method": "mtp", "num_speculative_tokens": mtp}),
-    ]
-    log = results / f"server_on_mtp{mtp}.log"
-    result = results / f"speedbench_on_mtp{mtp}.json"
-    result.unlink(missing_ok=True)
-    proc.echo(command)
-    with log.open("wb") as sink:
-        child = subprocess.Popen(
-            command, stdout=sink, stderr=subprocess.STDOUT, start_new_session=True
-        )
-        try:
-            server.wait_ready(f"http://127.0.0.1:{port}/health", pid=child.pid, log=log)
-            run(
-                [
-                    "vllm",
-                    "bench",
-                    "serve",
-                    "--backend",
-                    "vllm",
-                    "--host",
-                    "127.0.0.1",
-                    "--port",
-                    str(port),
-                    "--model",
-                    model_path,
-                    "--dataset-name",
-                    "speed_bench",
-                    "--dataset-path",
-                    str(dataset.parent),
-                    "--speed-bench-output-len",
-                    str(output_len),
-                    "--num-prompts",
-                    "-1",
-                    "--max-concurrency",
-                    str(args.concurrency),
-                    "--temperature",
-                    str(args.temperature),
-                    "--top-p",
-                    str(args.top_p),
-                    "--chat-template-kwargs",
-                    os.environ["CHAT_TEMPLATE_KWARGS_ON"],
-                    "--trust-remote-code",
-                    # vLLM records counter deltas around the formal request window.
-                    "--num-warmups",
-                    "0",
-                    "--ready-check-timeout-sec",
-                    "0",
-                    "--seed",
-                    "42",
-                    "--save-result",
-                    "--save-detailed",
-                    "--result-dir",
-                    str(results),
-                    "--result-filename",
-                    result.name,
-                ]
-            )
-            return read_acceptance(result, expected=count, mtp=mtp)
-        finally:
-            stop(child)
-
-
-def write_matrix(path: Path, model: str, values: Mapping[int, float], metadata: Path) -> None:
-    text = f"# Collection provenance: {metadata.name}\n{json.dumps(model.rsplit('/', 1)[-1].lower())}:\n"
-    text += "  thinking_on:\n"
-    text += "".join(f"    {level}: {value:.6f}\n" for level, value in values.items())
-    path.write_text(text, encoding="utf-8")
-
-
-def main(argv: list[str]) -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--concurrency", type=int, required=True)
-    parser.add_argument("--temperature", type=float, required=True)
-    parser.add_argument("--top-p", type=float, required=True)
-    parser.add_argument("server_args", nargs=argparse.REMAINDER)
-    args = parser.parse_args(argv)
-    if args.server_args[:1] == ["--"]:
-        args.server_args = args.server_args[1:]
-    if args.concurrency < 1 or not args.temperature > 0 or not 0 < args.top_p <= 1:
-        raise env.InputError("Invalid concurrency or sampling parameters")
-    inputs = env.require(
-        "CATEGORY",
-        "CHAT_TEMPLATE_KWARGS_ON",
-        "IMAGE",
-        "MODEL",
-        "MODEL_PATH",
-        "MTP_LIST",
-        "OUT_YAML",
-        "PORT",
-        "SPEEDBENCH_OUTPUT_LEN",
-        "THINKING_MODES",
-    )
-    # GLM-5.3-Flash always thinks; enable_thinking=false does not disable it.
-    if inputs["THINKING_MODES"] != "on" or json.loads(inputs["CHAT_TEMPLATE_KWARGS_ON"]) not in (
-        {},
-        {"reasoning_effort": "max"},
-    ):
-        raise env.InputError(
-            "GLM-5.3-Flash collection requires THINKING_MODES=on and max reasoning effort"
-        )
-    mtp_levels = levels(inputs["MTP_LIST"])
-    output_len = env.positive_int("SPEEDBENCH_OUTPUT_LEN")
-    requested_port = env.positive_int("PORT")
-    model = Path(inputs["MODEL_PATH"])
-    if not (model / "config.json").is_file():
-        raise env.BenchError(
-            f"Staged checkpoint missing: {model / 'config.json'}; no download attempted"
-        )
-    out = Path(inputs["OUT_YAML"])
-    out.unlink(missing_ok=True)
-    results = out.parent / "speedbench_results"
-    results.mkdir(exist_ok=True)
-    metadata = results / "speedbench_provenance.json"
-    with tempfile.TemporaryDirectory(prefix="infx-speedbench-") as temp:
-        dataset, count = prepare_dataset(Path(temp), inputs["CATEGORY"])
-        provenance = {
-            "inputs": inputs,
-            "server_args": args.server_args,
-            "concurrency": args.concurrency,
-            "temperature": args.temperature,
-            "top_p": args.top_p,
-            "thinking": "reasoning_effort=max for GLM-5.3-Flash",
-            "draft": "embedded MTP, upstream checkpoint-default precision",
-            "verification": "standard (no block or synthetic acceptance flags)",
-            "prepare_url": PREPARE_URL,
-            "num_prompts": count,
-            "prompt_selection": "upstream vLLM SPEED-Bench: first user turn of each category row",
-            "rows_with_followup_turns": sum(
-                len(json.loads(line)["messages"]) > 1 for line in dataset.read_text().splitlines()
-            ),
-            "dataset_sha256": hashlib.sha256(dataset.read_bytes()).hexdigest(),
-            "config_sha256": hashlib.sha256((model / "config.json").read_bytes()).hexdigest(),
-            "vllm_version": importlib.metadata.version("vllm"),
-            "frontend": os.environ.get("VLLM_USE_RUST_FRONTEND"),
-            "complete": False,
-        }
-        metadata.write_text(json.dumps(provenance, indent=2) + "\n", encoding="utf-8")
-        values: dict[int, float] = {}
-        for mtp in mtp_levels:
-            print(f"Collecting thinking=on MTP={mtp}, {count} prompts", flush=True)
-            values[mtp] = collect_cell(
-                model_path=str(model),
-                mtp=mtp,
-                port=free_port(requested_port),
-                dataset=dataset,
-                count=count,
-                output_len=output_len,
-                results=results,
-                args=args,
-            )
-            write_matrix(out, inputs["MODEL"], values, metadata)
-            print(f"MTP={mtp}: AL={values[mtp]:.6f}", flush=True)
-        provenance["complete"] = True
-        metadata.write_text(json.dumps(provenance, indent=2) + "\n", encoding="utf-8")
-    return 0
diff --git a/inferencex-e2e/infx/bench_serving/encoding_dsv41.py b/inferencex-e2e/infx/bench_serving/encoding_dsv41.py
new file mode 100644
index 0000000000..40e21be44a
--- /dev/null
+++ b/inferencex-e2e/infx/bench_serving/encoding_dsv41.py
@@ -0,0 +1,548 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+# ruff: noqa: ANN001, ANN201, BLE001, E722, FURB110, N806, RUF001, S101, S105, SIM114, UP006, UP007, UP035, UP045
+
+"""DeepSeek-V4.1 encoding, as vLLM's ``deepseek_v41`` tokenizer mode rendered it.
+
+Copied from vLLM's ``vllm/tokenizers/deepseek_v41_encoding.py`` at b47b01cf33, the commit that
+added it, a day after the image the DeepSeek-V4.1-Flash golden AL was collected with. Later vLLM
+renders reasoning effort ``high`` as 75, not 50.
+"""
+
+import copy
+import json
+from typing import Any, Dict, List, Optional, Union
+
+bos_token: str = "<｜begin▁of▁sentence｜>"
+eos_token: str = "<｜end▁of▁sentence｜>"
+thinking_start_token: str = "<think>"
+thinking_end_token: str = "</think>"
+dsml_token: str = "｜DSML｜"
+
+USER_SP_TOKEN = "<｜User｜>"
+ASSISTANT_SP_TOKEN = "<｜Assistant｜>"
+LATEST_REMINDER_SP_TOKEN = "<｜latest_reminder｜>"
+IMAGE_PLACEHOLDER = "<｜deepseek_image｜>"
+
+DS_TASK_SP_TOKENS = {
+    "action": "<｜action｜>",
+    "query": "<｜query｜>",
+    "authority": "<｜authority｜>",
+    "domain": "<｜domain｜>",
+    "title": "<｜title｜>",
+    "read_url": "<｜read_url｜>",
+}
+VALID_TASKS = set(DS_TASK_SP_TOKENS.keys())
+
+system_msg_template: str = "{content}"
+user_msg_template: str = "{content}"
+latest_reminder_msg_template: str = "{content}"
+assistant_msg_template: str = "{reasoning}{content}{tool_calls}" + eos_token
+assistant_msg_wo_eos_template: str = "{reasoning}{content}{tool_calls}"
+thinking_template: str = "{reasoning_content}"
+
+response_format_template: str = (
+    "## Response Format:\n\nYou MUST strictly adhere to the following schema to reply:\n{schema}"
+)
+tool_output_template: str = "<tool_result>{content}</tool_result>"
+
+
+def to_json(value: Any) -> str:
+    """Serialize a value to JSON string."""
+    try:
+        return json.dumps(value, ensure_ascii=False)
+    except:
+        return json.dumps(value, ensure_ascii=True)
+
+
+def tools_from_openai_format(tools):
+    """Extract function definitions from OpenAI-format tool list."""
+    return [tool["function"] for tool in tools]
+
+
+def tool_calls_from_openai_format(tool_calls):
+    """Convert OpenAI-format tool calls to internal format."""
+    return [
+        {
+            "name": tool_call["function"]["name"],
+            "arguments": tool_call["function"]["arguments"],
+        }
+        for tool_call in tool_calls
+    ]
+
+
+def merge_tool_messages(messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """
+    Merge tool messages into the preceding user message using content_blocks format.
+
+    DeepSeek-V4.1 does not have a standalone "tool" role; instead, tool results
+    are encoded as <tool_result> blocks within user messages.
+    """
+    merged: List[Dict[str, Any]] = []
+
+    for msg in messages:
+        msg = copy.deepcopy(msg)
+        role = msg.get("role")
+
+        if role == "tool":
+            # Convert tool message to a user message with tool_result block
+            tool_block = {
+                "type": "tool_result",
+                "tool_use_id": msg.get("tool_call_id", ""),
+                "content": msg.get("content", ""),
+            }
+            # Merge into previous message if it's already a user (merged tool)
+            if merged and merged[-1].get("role") == "user" and "content_blocks" in merged[-1]:
+                merged[-1]["content_blocks"].append(tool_block)
+            else:
+                merged.append(
+                    {
+                        "role": "user",
+                        "content_blocks": [tool_block],
+                    }
+                )
+        elif role == "user":
+            content_blocks = msg.get("content_blocks")
+            if content_blocks is None:
+                content_blocks = [{"type": "text", "text": msg.get("content", "")}]
+            if (
+                merged
+                and merged[-1].get("role") == "user"
+                and "content_blocks" in merged[-1]
+                and merged[-1].get("task") is None
+            ):
+                merged[-1]["content_blocks"].extend(content_blocks)
+            else:
+                # Preserve structured content and all message-level metadata.
+                new_msg = msg
+                new_msg["content_blocks"] = content_blocks
+                merged.append(new_msg)
+        else:
+            merged.append(msg)
+
+    return merged
+
+
+def sort_tool_results_by_call_order(
+    messages: List[Dict[str, Any]],
+) -> List[Dict[str, Any]]:
+    """
+    Sort tool_result blocks within user messages by the order of tool_calls
+    in the preceding assistant message.
+    """
+    last_tool_call_order: Dict[str, int] = {}
+
+    for msg in messages:
+        role = msg.get("role")
+        if role == "assistant" and msg.get("tool_calls"):
+            last_tool_call_order = {}
+            for idx, tc in enumerate(msg["tool_calls"]):
+                tc_id = tc.get("id") or tc.get("function", {}).get("id", "")
+                if tc_id:
+                    last_tool_call_order[tc_id] = idx
+
+        elif role == "user" and msg.get("content_blocks"):
+            tool_blocks = [b for b in msg["content_blocks"] if b.get("type") == "tool_result"]
+            if len(tool_blocks) > 1 and last_tool_call_order:
+                sorted_blocks = sorted(
+                    tool_blocks,
+                    key=lambda b: last_tool_call_order.get(b.get("tool_use_id", ""), 0),
+                )
+                sorted_idx = 0
+                new_blocks = []
+                for block in msg["content_blocks"]:
+                    if block.get("type") == "tool_result":
+                        new_blocks.append(sorted_blocks[sorted_idx])
+                        sorted_idx += 1
+                    else:
+                        new_blocks.append(block)
+                msg["content_blocks"] = new_blocks
+
+    return messages
+
+
+SYSTEM_SP_TOKEN = "<｜System｜>"
+
+tool_calls_block_name: str = " calls"
+tool_call_tag_name: str = " invoke"
+tool_parameter_tag_name: str = " parameter"
+tool_call_template: str = '<{dsml_token}{tool_call_tag_name} name="{name}">\n{arguments}\n</{dsml_token}{tool_call_tag_name}>'
+tool_calls_template = "<{dsml_token}{tc_block_name}>\n{tool_calls}\n</{dsml_token}{tc_block_name}>"
+
+REASONING_EFFORT_TEMPLATE = (
+    "Reasoning Effort: {budget} "
+    "(range 1-100, the higher the value, the more thorough the reasoning)\n\n"
+)
+REASONING_EFFORT_MAPPINGS: Dict[str, int] = {
+    "low": 25,
+    "high": 50,
+    "xhigh": 75,
+    "max": 100,
+}
+
+DEFAULT_REASONING_EFFORT = "high"
+
+
+def render_reasoning_effort(
+    index: int,
+    thinking_mode: str,
+    effort: Union[str, int, None],
+) -> str:
+    """Render the V4.1 numeric reasoning effort prefix (thinking mode, index 0 only)."""
+    if effort is None:
+        effort = DEFAULT_REASONING_EFFORT
+    assert (type(effort) is int and 1 <= effort <= 100) or effort in REASONING_EFFORT_MAPPINGS, (
+        "Invalid reasoning effort for deepseek_v41: "
+        f"{effort}, should be int within [1,100] or {list(REASONING_EFFORT_MAPPINGS)}"
+    )
+    if type(effort) is str:
+        effort = REASONING_EFFORT_MAPPINGS[effort]
+    if index == 0 and thinking_mode == "thinking":
+        return REASONING_EFFORT_TEMPLATE.format(budget=effort)
+    return ""
+
+
+TOOLS_TEMPLATE = """## Tools
+
+You have access to a set of tools to help answer the user's question. You can invoke tools by writing a "<{dsml_token}{tc_block_name}>" block like the following:
+
+<{dsml_token}{tc_block_name}>
+<{dsml_token}{tool_call_tag_name} name="$TOOL_NAME">
+<{dsml_token}{tool_parameter_tag_name} name="$PARAMETER_NAME" string="true|false">$PARAMETER_VALUE</{dsml_token}{tool_parameter_tag_name}>
+...
+</{dsml_token}{tool_call_tag_name}>
+<{dsml_token}{tool_call_tag_name} name="$TOOL_NAME2">
+...
+</{dsml_token}{tool_call_tag_name}>
+</{dsml_token}{tc_block_name}>
+
+String parameters should be specified as is and set `string="true"`. For all other types (numbers, booleans, arrays, objects), pass the value in JSON format and set `string="false"`.
+
+If thinking_mode is enabled (triggered by {thinking_start_token}), you MUST output your complete reasoning inside {thinking_start_token}...{thinking_end_token} BEFORE any tool calls or final response.
+
+Otherwise, output directly after {thinking_end_token} with tool calls or final response.
+
+### Available Tool Schemas
+
+{tool_schemas}
+
+You MUST strictly follow the above defined tool name and parameter schemas to invoke tool calls.
+"""
+
+
+def render_tools(tools: List[Dict[str, Union[str, Dict[str, Any]]]]) -> str:
+    """Render tool schemas into the V4.1 system prompt format."""
+    tools_json = [to_json(t) for t in tools]
+
+    return TOOLS_TEMPLATE.format(
+        tool_schemas="\n".join(tools_json),
+        dsml_token=dsml_token,
+        tc_block_name=tool_calls_block_name,
+        tool_call_tag_name=tool_call_tag_name,
+        tool_parameter_tag_name=tool_parameter_tag_name,
+        thinking_start_token=thinking_start_token,
+        thinking_end_token=thinking_end_token,
+    )
+
+
+def encode_arguments_to_dsml(tool_call: Dict[str, Any]) -> str:
+    """Encode tool call arguments into V4.1 DSML parameter format."""
+    p_dsml_template = (
+        '<{dsml_token}{tool_parameter_tag_name} name="{key}" string="{is_str}">'
+        "{value}</{dsml_token}{tool_parameter_tag_name}>"
+    )
+    P_dsml_strs = []
+
+    arguments = tool_call["arguments"]
+    if not isinstance(arguments, dict):
+        # Tolerate JSON strings, including double-encoded ones.
+        for _ in range(2):
+            if isinstance(arguments, str):
+                try:
+                    arguments = json.loads(arguments)
+                except Exception:
+                    break
+            else:
+                break
+        if not isinstance(arguments, dict):
+            arguments = {"arguments": tool_call["arguments"]}
+
+    for k, v in arguments.items():
+        P_dsml_strs.append(
+            p_dsml_template.format(
+                dsml_token=dsml_token,
+                tool_parameter_tag_name=tool_parameter_tag_name,
+                key=k,
+                is_str="true" if isinstance(v, str) else "false",
+                value=v if isinstance(v, str) else to_json(v),
+            )
+        )
+
+    return "\n".join(P_dsml_strs)
+
+
+def find_last_user_index(messages: List[Dict[str, Any]]) -> int:
+    """
+    Find the index of the last user/developer message.
+
+    V4.1 supports mid-conversation system messages, which count as user
+    messages for the purposes of the assistant generation header.
+    """
+    last_user_index = -1
+    for idx in range(len(messages) - 1, -1, -1):
+        role = messages[idx].get("role")
+        if role in ["user", "developer"] or (role == "system" and idx > 0):
+            last_user_index = idx
+            break
+    return last_user_index
+
+
+def render_message(
+    index: int,
+    messages: List[Dict[str, Any]],
+    thinking_mode: str,
+    drop_thinking: bool = True,
+    reasoning_effort: Union[str, int, None] = None,
+) -> str:
+    """
+    Render a single message at the given index into its V4.1 encoded string form.
+    """
+    assert 0 <= index < len(messages)
+    assert thinking_mode in ["chat", "thinking"], f"Invalid thinking_mode `{thinking_mode}`"
+
+    msg = messages[index]
+    last_user_idx = find_last_user_index(messages)
+
+    role = msg.get("role")
+    content = msg.get("content")
+    tools = msg.get("tools")
+    response_format = msg.get("response_format")
+    tool_calls = msg.get("tool_calls")
+    reasoning_content = msg.get("reasoning_content")
+    wo_eos = msg.get("wo_eos", False)
+
+    if tools:
+        tools = tools_from_openai_format(tools)
+    if tool_calls:
+        tool_calls = tool_calls_from_openai_format(tool_calls)
+
+    # Reasoning effort prefix (thinking mode, index 0 only)
+    reasoning_effort_prompt = render_reasoning_effort(index, thinking_mode, reasoning_effort)
+    # System token leads the conversation when there is a reasoning effort prompt
+    # or the first message is a system message.
+    prompt = SYSTEM_SP_TOKEN if index == 0 and (reasoning_effort_prompt or role == "system") else ""
+    prompt += reasoning_effort_prompt
+
+    if role == "system":
+        if index > 0:
+            # Mid-conversation system message
+            prompt += SYSTEM_SP_TOKEN
+        prompt += system_msg_template.format(content=content or "")
+        if tools:
+            prompt += "\n\n" + render_tools(tools)
+        if response_format:
+            prompt += "\n\n" + response_format_template.format(schema=to_json(response_format))
+
+    elif role == "developer":
+        assert content, f"Invalid message for role `{role}`: {msg}"
+
+        content_developer = USER_SP_TOKEN
+        content_developer += content
+
+        if tools:
+            content_developer += "\n\n" + render_tools(tools)
+        if response_format:
+            content_developer += "\n\n" + response_format_template.format(
+                schema=to_json(response_format)
+            )
+
+        prompt += user_msg_template.format(content=content_developer)
+
+    elif role == "user":
+        prompt += USER_SP_TOKEN
+
+        # Handle content blocks (tool results mixed with text)
+        content_blocks = msg.get("content_blocks")
+        if content_blocks:
+            parts = []
+            for block in content_blocks:
+                block_type = block.get("type")
+                if block_type == "text":
+                    parts.append(block.get("text", ""))
+                elif block_type == "tool_result":
+                    tool_content = block.get("content", "")
+                    if isinstance(tool_content, list):
+                        text_parts = []
+                        for b in tool_content:
+                            if b.get("type") == "text":
+                                text_parts.append(b.get("text", ""))
+                            else:
+                                text_parts.append(f"[Unsupported {b.get('type')}]")
+                        tool_content = "\n\n".join(text_parts)
+                    parts.append(tool_output_template.format(content=tool_content))
+                else:
+                    parts.append(f"[Unsupported {block_type}]")
+            prompt += "\n\n".join(parts)
+        else:
+            prompt += content or ""
+
+    elif role == "latest_reminder":
+        prompt += LATEST_REMINDER_SP_TOKEN + latest_reminder_msg_template.format(content=content)
+
+    elif role == "tool":
+        raise NotImplementedError(
+            "deepseek_v41 merges tool messages into user; please preprocess with merge_tool_messages()"
+        )
+
+    elif role == "assistant":
+        thinking_part = ""
+        tc_content = ""
+
+        if tool_calls:
+            tc_list = [
+                tool_call_template.format(
+                    dsml_token=dsml_token,
+                    tool_call_tag_name=tool_call_tag_name,
+                    name=tc.get("name"),
+                    arguments=encode_arguments_to_dsml(tc),
+                )
+                for tc in tool_calls
+            ]
+            tc_content += "\n\n" + tool_calls_template.format(
+                dsml_token=dsml_token,
+                tool_calls="\n".join(tc_list),
+                tc_block_name=tool_calls_block_name,
+            )
+
+        summary_content = content or ""
+        rc = reasoning_content or ""
+
+        # Check if previous message has a task - if so, this is a task output (no thinking)
+        prev_has_task = index - 1 >= 0 and messages[index - 1].get("task") is not None
+
+        if thinking_mode == "thinking" and not prev_has_task:
+            if not drop_thinking or index > last_user_idx:
+                thinking_part = thinking_template.format(reasoning_content=rc) + thinking_end_token
+            else:
+                thinking_part = ""
+
+        if wo_eos:
+            prompt += assistant_msg_wo_eos_template.format(
+                reasoning=thinking_part,
+                content=summary_content,
+                tool_calls=tc_content,
+            )
+        else:
+            prompt += assistant_msg_template.format(
+                reasoning=thinking_part,
+                content=summary_content,
+                tool_calls=tc_content,
+            )
+    else:
+        raise NotImplementedError(f"Unknown role: {role}")
+
+    # Append transition tokens based on what follows
+    if index + 1 < len(messages) and messages[index + 1].get("role") not in [
+        "assistant",
+        "latest_reminder",
+    ]:
+        return prompt
+
+    task = messages[index].get("task")
+    if task is not None:
+        # Task special token for internal classification tasks
+        assert task in VALID_TASKS, f"Invalid task: '{task}'. Valid tasks are: {list(VALID_TASKS)}"
+        task_sp_token = DS_TASK_SP_TOKENS[task]
+
+        if task != "action":
+            # Non-action tasks: append task sp token directly after the message
+            prompt += task_sp_token
+        else:
+            # Action task: append Assistant + thinking token + action sp token
+            prompt += ASSISTANT_SP_TOKEN
+            prompt += thinking_end_token if thinking_mode != "thinking" else thinking_start_token
+            prompt += task_sp_token
+
+    elif messages[index].get("role") in ["user", "developer"] or (
+        messages[index].get("role") == "system" and index > 0
+    ):
+        # Normal generation: append Assistant + thinking token
+        # (mid-conversation system messages also trigger the assistant header)
+        prompt += ASSISTANT_SP_TOKEN
+        if not drop_thinking and thinking_mode == "thinking":
+            prompt += thinking_start_token
+        elif drop_thinking and thinking_mode == "thinking" and index >= last_user_idx:
+            prompt += thinking_start_token
+        else:
+            prompt += thinking_end_token
+
+    return prompt
+
+
+def _drop_thinking_messages(messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """
+    Drop reasoning_content and non-essential messages before the last user message.
+    Same as V4, but uses the V4.1 last-user definition (mid systems count).
+    """
+    last_user_idx = find_last_user_index(messages)
+    result = []
+    keep_roles = {"user", "system", "tool", "latest_reminder", "direct_search_results"}
+
+    for idx, msg in enumerate(messages):
+        role = msg.get("role")
+        if role in keep_roles or idx >= last_user_idx:
+            result.append(msg)
+        elif role == "assistant":
+            msg = copy.copy(msg)
+            msg.pop("reasoning_content", None)
+            result.append(msg)
+        # developer and other roles before last_user_idx are dropped
+
+    return result
+
+
+def encode_messages(
+    messages: List[Dict[str, Any]],
+    thinking_mode: str,
+    context: Optional[List[Dict[str, Any]]] = None,
+    drop_thinking: bool = True,
+    add_default_bos_token: bool = True,
+    reasoning_effort: Union[str, int, None] = None,
+) -> str:
+    """Encode preprocessed (text-only) messages into the V4.1 prompt format."""
+    context = context if context else []
+
+    # Preprocess: merge tool messages and sort tool results
+    messages = merge_tool_messages(messages)
+    messages = sort_tool_results_by_call_order(context + messages)[len(context) :]
+    if context:
+        context = merge_tool_messages(context)
+        context = sort_tool_results_by_call_order(context)
+
+    full_messages = context + messages
+
+    prompt = bos_token if add_default_bos_token and len(context) == 0 else ""
+
+    # Resolve drop_thinking: if any message has tools defined, don't drop thinking
+    effective_drop_thinking = drop_thinking
+    if any(m.get("tools") for m in full_messages):
+        effective_drop_thinking = False
+
+    if thinking_mode == "thinking" and effective_drop_thinking:
+        full_messages = _drop_thinking_messages(full_messages)
+        num_to_render = len(full_messages) - len(_drop_thinking_messages(context))
+        context_len = len(full_messages) - num_to_render
+    else:
+        num_to_render = len(messages)
+        context_len = len(context)
+
+    for idx in range(num_to_render):
+        prompt += render_message(
+            idx + context_len,
+            full_messages,
+            thinking_mode=thinking_mode,
+            drop_thinking=effective_drop_thinking,
+            reasoning_effort=reasoning_effort,
+        )
+
+    return prompt
diff --git a/inferencex-e2e/infx/clusters/slurm.py b/inferencex-e2e/infx/clusters/slurm.py
index c7c670f00c..6a31afb8d5 100644
--- a/inferencex-e2e/infx/clusters/slurm.py
+++ b/inferencex-e2e/infx/clusters/slurm.py
@@ -13,7 +13,7 @@
 from pydantic import AfterValidator, Field, PlainSerializer, field_validator, model_validator
 
 from infx.clusters.base import Record, SchedulerSettings, Visibility, Volume
-from infx.srt_slurm.workload import resolve_fabric
+from infx.srt_slurm.workload import CpuPowerSource, resolve_fabric
 
 if TYPE_CHECKING:
     from infx.clusters import Cluster
@@ -173,6 +173,17 @@ def rendered(self) -> dict[str, str | None]:
         return self.model_dump(by_alias=True)
 
 
+class CpuPowerExporter(Record):
+    """The CPU power exporter srt-slurm scrapes on this cluster's nodes.
+
+    A point that selects ``cpu-power`` binds ``telemetry.cpu_power_exporter`` with this source.
+    ACPI serves the Grace socket meter and RAPL the AMD EPYC package counter, the meters the
+    CPU leg integrates.
+    """
+
+    source: CpuPowerSource
+
+
 class SrtSlurmSettings(Record):
     """Cluster-owned srtslurm.yaml facts; job-specific values are added by the driver."""
 
@@ -203,6 +214,7 @@ class SrtSlurmSettings(Record):
     mounts: dict[str, str] = Field(default_factory=dict)
     workspace_mounts: dict[str, str] = Field(default_factory=dict, alias="workspace-mounts")
     power_exporter_port: int | None = Field(default=None, alias="power-exporter-port", gt=0)
+    cpu_power_exporter: CpuPowerExporter | None = Field(default=None, alias="cpu-power-exporter")
     extra: dict[str, Any] = Field(default_factory=dict)
 
     @field_validator("workspace_mounts")
@@ -217,6 +229,14 @@ def _workspace_mount_paths(cls, mounts: dict[str, str]) -> dict[str, str]:
                 raise ValueError(f"workspace-mounts target must be absolute: {target}")
         return mounts
 
+    @property
+    def gpu_exporter_image(self) -> str | None:
+        """The image of the cluster's GPU exporter, srtctl's ``default_gpu_exporter``; None
+        where the cluster declares none.
+        """
+        exporter = self.extra.get("default_gpu_exporter")
+        return (exporter.get("container_image") or None) if isinstance(exporter, dict) else None
+
     @model_validator(mode="before")
     @classmethod
     def _host_setup_fabric(cls, data: Any) -> Any:
@@ -277,6 +297,20 @@ def _mounted_volumes_exist(self) -> Self:
                 raise ValueError(f"srt-slurm.{field} names unknown volumes: {unknown}")
         return self
 
+    @model_validator(mode="after")
+    def _rapl_on_exclusive_nodes(self) -> Self:
+        """A RAPL CPU exporter needs exclusive nodes: the teardown takes the counters back
+        host-wide, which would cut off a concurrent job's CPU samples on a shared node.
+        """
+        srt = self.srt_slurm
+        exporter = None if srt is None else srt.cpu_power_exporter
+        shared = not (self.exclusive and srt is not None and srt.single_node_exclusive)
+        if exporter is not None and exporter.source == "rapl" and shared:
+            raise ValueError(
+                "a rapl cpu-power-exporter needs exclusive single- and multi-node jobs"
+            )
+        return self
+
     @model_validator(mode="after")
     def _one_cpu_request(self) -> Self:
         """Slurm rejects --cpus-per-task together with --cpus-per-gpu."""
diff --git a/inferencex-e2e/infx/evals/EVALS.md b/inferencex-e2e/infx/evals/EVALS.md
index 90e0579853..ff8b9471b8 100644
--- a/inferencex-e2e/infx/evals/EVALS.md
+++ b/inferencex-e2e/infx/evals/EVALS.md
@@ -73,10 +73,11 @@ agentic coverage, and `all-evals` wins over default eval coverage.
 ### Tool-use support contract
 
 The tool-use adapters are backend-independent clients of the local
-OpenAI-compatible endpoint. The deployment-smoke target set contains every
-generated Kimi K3 and MiniMax M3 agentic configuration in the NVIDIA and AMD
-master configs, including their single-node and multi-node vLLM and
-Dynamo-vLLM recipes. A configuration is verified only when the current PR head
+OpenAI-compatible endpoint. Kimi K3 and MiniMax M3 have no active master
+configs; their vendor suites and generator mappings remain available for
+explicit research configurations and historical results. The Kimi K3 and
+MiniMax M3 commands below require a caller-supplied config rather than the
+retired master entries. A configuration is verified only when the current PR head
 launches its tool-aware endpoint, the matching vendor smoke and `bfcl_smoke`
 complete their expected sample counts, and the native and
 `inferencex-eval-v1` artifacts are collected without `integration_error`.
@@ -572,6 +573,46 @@ Multi-node evals on AMD and NVIDIA Slurm clusters run through [srt-slurm](https:
 
 For multi-node `all-evals`, `EVAL_CONC` is a space-separated list. When it contains multiple values, `python3 -m infx.bench eval` runs those concurrency points sequentially against the same live engine, stages each result with a `_concN` filename suffix, and records expected/completed/failed points in `meta_env.json`.
 
+### Speculative acceptance gate
+
+AgentX throughput forces each speculative deployment's acceptance to its golden AL, so it
+cannot show a weak draft head, and an eval cannot either: speculative decoding is lossless.
+Each agentic eval whose generation role drafts therefore also measures its real acceptance
+length (AL) on the same server, in the same Slurm job, before its eval. It is report-only:
+it never fails or blocks the eval or any submission. Only deployments that run agentic evals
+are gated.
+
+- The `al-gate-prompts` job ([`al-gate-prompts.yml`](../../../.github/workflows/al-gate-prompts.yml))
+  restores the 80 SPEED-Bench Qualitative `coding` prompts every golden curve was measured on
+  from the Actions cache, keyed on `infx/bench/speedbench.py`, or prepares them on a miss
+  (digest-checked). It uploads them as the `al_gate_dataset` artifact. The agentic eval jobs
+  of `run-sweep.yml` and `e2e-tests.yml` wait for it and download it; if it fails, they run
+  without the gate; a sweep's call is capped at 30 minutes. Pushes to `main` and a weekly schedule keep the cache entry warm, because
+  a cache saved by a PR run is visible only to that PR.
+- When the prompts are present, the srt driver sets `EVAL_AL_GATE=true`. The golden
+  acceptance planner (`infx/srt_slurm/synthetic_acceptance.py`) reads the resolved recipe and
+  `infx/srt_slurm/al_gate.py` picks the curve, by the generation role's method, draft and
+  verifier as synthetic acceptance does, and its draft length. The submission then runs
+  `benchmarks/srt_al_gate.sh` as srt-slurm's benchmark stage, the only stage that receives the
+  workers' metrics endpoints, followed by the usual post-benchmark eval. srt-slurm runs a
+  benchmark stage only without `EVAL_ONLY`, so the job is submitted with
+  `EVAL_ONLY=false RUN_EVAL=true` and power telemetry off; `srt_eval.sh` restores
+  `EVAL_ONLY=true` for the eval.
+- `python3 -m infx.bench al-gate` replays the prompts at concurrency 64 with the curve's
+  recorded [collection settings](../golden_al_distribution/README.md#collection-settings),
+  reads `AL = 1 + accepted draft tokens / verification steps` from the engine's own
+  Prometheus counters, and writes `al_gate_<RESULT_FILENAME>.json` with `pass` (within 5% of
+  golden), `below`, `above`, `no-counters`, `no-drafting` or `error`. The shim always exits 0,
+  so the eval runs after any outcome. The eval shares the job's time limit, so the shim stops
+  the gate after `AL_GATE_TIMEOUT_S` (default 1800 s) and the gate records an `error`.
+- A gate that cannot run is `skipped` with its reason: no prompts, a curve without collection
+  settings, TileRT (no streaming `/v1/completions`, no metrics), or a multi-node Dynamo
+  vLLM data-parallel worker whose metrics srtctl exposes only on its leader. Dynamo TRT-LLM is
+  gated: srtctl publishes TensorRT-LLM metrics by default, and a recipe that turns them off
+  (`backend.publish_metrics: false`) reports `no-counters`.
+- The result travels in the eval artifact; the raw replay files (`al_gate/`) are in the eval
+  server logs. `collect-evals` adds a "Speculative acceptance gate" table to its step summary.
+
 ### Workflow structure
 - `e2e-tests.yml`: `test-sweep-evals` (single-node fixed-seq-len), `test-sweep-multi-node-evals`
   (multi-node fixed-seq-len), `test-sweep-agentic-evals` (single-node agentic), and
@@ -580,6 +621,7 @@ For multi-node `all-evals`, `EVAL_CONC` is a space-separated list. When it conta
   `sweep-multi-node-agentic-evals` (same four-way split)
 - All four use their respective benchmark templates (`benchmark-tmpl.yml` for single-node,
   `benchmark-multinode-tmpl.yml` for multi-node) with `eval-only: true`, `run-eval: true`
+- `al-gate-prompts` runs before the two agentic eval jobs (see [Speculative acceptance gate](#speculative-acceptance-gate))
 - `collect-evals` depends on all four eval jobs; `collect-results` only runs when benchmark jobs ran
 - `infx.matrix.plan` splits eval results by node count and scenario type into `evals`
   (single-node fixed-seq-len), `agentic_evals` (single-node agentic), `multinode_evals`
diff --git a/inferencex-e2e/infx/golden_al_distribution/README.md b/inferencex-e2e/infx/golden_al_distribution/README.md
index dfdc080cf5..d7d6bdf53a 100644
--- a/inferencex-e2e/infx/golden_al_distribution/README.md
+++ b/inferencex-e2e/infx/golden_al_distribution/README.md
@@ -2,7 +2,7 @@
 
 English | [中文](README_zh.md)
 
-This directory contains the golden acceptance-length (AL) curves used to standardize speculative decoding moving forward in InferenceX. Each YAML maps a model, thinking mode, and draft length (`num_speculative_tokens`) to a mean AL measured on the **coding** category of the SPEED-Bench Qualitative split.
+This directory contains the golden acceptance-length (AL) curves used to standardize speculative decoding moving forward in InferenceX. Each YAML maps a model, thinking mode, and draft length (`num_speculative_tokens`) to a mean AL measured on the **coding** category of the SPEED-Bench Qualitative split, and records the [collection settings](#collection-settings) that produced those values.
 
 ## Why SPEED-Bench
 
@@ -33,6 +33,15 @@ SGLang MTP synthetic throughput, the connector rejects a generation role whose
 `speculative-num-steps + 1`. Manual acceptance-length settings are not needed.
 Eval-only runs remove synthetic settings and use real verification.
 
+TokenSpeed MTP recipes use the same automatic selection from
+`speculative-num-steps`, with `speculative-num-draft-tokens` equal to the step
+count plus one and `speculative-eagle-topk: 1`. The connector sets
+`synthetic-acceptance-length` and the required `sampling-backend: greedy` for
+AgentX throughput. Eval-only and fixed-sequence runs remove that length and
+select `sampling-backend: flashinfer` for real verification. TokenSpeed's
+connector accepts explicit MTP flags; other speculative algorithms and the
+JSON `speculative-config` shorthand are rejected.
+
 vLLM supports this through synthetic rejection sampling. For example, an EAGLE3 run can inject the selected YAML value through `synthetic_acceptance_length`:
 
 ```bash
@@ -98,10 +107,28 @@ The push-button [`speedbench-al.yml`](../../../.github/workflows/speedbench-al.y
    The `1` is the target model's guaranteed verification token. Values are rounded to two decimal places.
 6. The collector emits a YAML matrix. The workflow publishes it in the GitHub Actions step summary and uploads it as a `speedbench-reference-al-<model-prefix>` artifact.
 7. Server logs and detailed per-request results are retained so reviewers can confirm sensible output, correct thinking mode, and the absence of silent server or chat-template failures.
-8. After review, the matrix is committed here with its exact sampling metadata and source Actions run URL. With `open-pr=true` and `golden-curve=<curve stem>` (for example `dsv4_mtp`), the workflow writes `<curve stem>.yaml` here with the source run URL on its first line. It loads the file through `python -m infx.golden_al_distribution show` and then opens the PR. The whole file is replaced, so cells the run did not collect are dropped.
+8. After review, the matrix is committed here with its exact sampling metadata, its [collection settings](#collection-settings), and source Actions run URL. With `open-pr=true` and `golden-curve=<curve stem>` (for example `deepseek-v4-pro__mtp__native__default-default`), the workflow writes `<curve stem>.yaml` here with the source run URL in its `source_run` key. It loads the file through `python -m infx.golden_al_distribution show` and then opens the PR. The whole file is replaced, so cells the run did not collect are dropped.
 
 The collection measures real head quality only to establish the golden curve. AgentX then uses that committed curve as the synthetic acceptance target for every comparable submission.
 
+## Collection settings
+
+Each curve YAML records the SPEED-Bench client settings of its collection in a reserved top-level `collection` key beside the model key, and `load_curve(name).collection` returns them (`None` for a curve without the block). Every agentic speculative eval runs the report-only acceptance-length gate first: it replays these settings with real verification on the eval's own server and compares the measured AL with the golden AL; see [the speculative acceptance gate](../evals/EVALS.md#speculative-acceptance-gate).
+
+```yaml
+collection:
+  renderer: chat_template  # or deepseek_v4, deepseek_v41
+  modes:                   # one entry per thinking mode with AL values
+    thinking_on:
+      chat_template_kwargs: {enable_thinking: true}  # null when the collector passed none
+      sampling: {temperature: 0.6, top_p: 0.95, top_k: 20, presence_penalty: 0.0, repetition_penalty: 1.0}
+```
+
+- `renderer` is how the client turned each prompt into text. `chat_template` applies the served model's Hugging Face chat template to one user message, with the generation prompt and `chat_template_kwargs`. `deepseek_v4` and `deepseek_v41` are vLLM's tokenizer modes of those names; the gate uses the equivalent encoders in this repository ([V4](../bench_serving/encoding_dsv4.py), [V4.1](../bench_serving/encoding_dsv41.py)), with `chat_template_kwargs` as their thinking options. The V4.1 encoder is vLLM's from the week of the collection: later vLLM renders reasoning effort `high` as 75, not 50.
+- `sampling` lists every sampling parameter the requests carried, including the `repetition_penalty: 1.0` that `vllm bench serve` adds. A parameter that is not listed was not sent, so the server used its own default.
+- Everything else is the same for every collection: the 80 prompts of the SPEED-Bench Qualitative `coding` category, in the order vLLM's loader sends them, as streaming `/v1/completions` requests with `max_tokens` 4096 and no `ignore_eos`. Collections ran at different concurrencies; the gate always replays at 64, treating AL as independent of concurrency.
+- New curves must include the block; the gate skips a curve without one. [`muse-spark-open-816b-a42b-nvfp4__dflash__muse-spark-open-dflash2__default-default.yaml`](muse-spark-open-816b-a42b-nvfp4__dflash__muse-spark-open-dflash2__default-default.yaml) was collected with SGLang's `bench_serving` client on its native `/generate` endpoint, which sends no `repetition_penalty`; the gate replays the same rendered prompts and sampling on `/v1/completions`. [`glm-5.3-nvfp4__mtp__native__default-default.yaml`](glm-5.3-nvfp4__mtp__native__default-default.yaml) was collected the same way and has no block yet.
+
 ## Reproducing a collection
 
 Test the model-specific collector and image first, then dispatch the workflow from the branch containing that collector:
@@ -127,25 +154,31 @@ Before accepting an updated curve, reviewers should verify:
 - Detailed outputs are coherent and use the intended thinking mode.
 - Server logs contain no fallback, draft-disable, or chat-template errors.
 - The YAML metadata matches the dispatched image, sampling settings, model, and speculative method.
-- The source Actions run is linked at the first line of the YAML.
+- The `collection` block matches the collector's concurrency, prompt rendering, and per-mode settings.
+- `source_run` is the Actions run that produced the artifact.
 - The committed values exactly match the workflow artifact.
 
 ## Current golden curves
 
-| Model | Method | Golden YAML | Source run |
-| --- | --- | --- | --- |
-| DeepSeek V4 Pro | MTP | [`dsv4_mtp.yaml`](dsv4_mtp.yaml) | [27180633016](https://github.com/SemiAnalysisAI/InferenceX/actions/runs/27180633016) |
-| DeepSeek V4 Pro 0813 | DSpark (probabilistic draft) | [`dsv4-pro-0813-dspark.yaml`](dsv4-pro-0813-dspark.yaml) | [31742838308](https://github.com/SemiAnalysisAI/InferenceX/actions/runs/31742838308) |
-| DeepSeek V4.1 Flash | DSpark (probabilistic draft, block verify) | [`dsv41flash_dspark.yaml`](dsv41flash_dspark.yaml) | [34493175056](https://github.com/SemiAnalysisAI/InferenceX/actions/runs/34493175056) |
-| Qwen3.5 397B-A17B | MTP | [`qwen3.5_mtp.yaml`](qwen3.5_mtp.yaml) | [27317114007](https://github.com/SemiAnalysisAI/InferenceX/actions/runs/27317114007) |
-| Kimi K3 | DSpark | [`kimik3_dspark.yaml`](kimik3_dspark.yaml) | [30304797750](https://github.com/SemiAnalysisAI/InferenceX/actions/runs/30304797750) |
-| Kimi K3 | DSpark (probabilistic draft, block verify) | [`kimik3_dspark_probabilistic_sample_method_block_rejection_sample_method.yaml`](kimik3_dspark_probabilistic_sample_method_block_rejection_sample_method.yaml) | [30316471205](https://github.com/SemiAnalysisAI/InferenceX/actions/runs/30316471205) |
-| MiniMax-M3 | EAGLE3 | [`minimaxm3_eagle3.yaml`](minimaxm3_eagle3.yaml) | [28061204145](https://github.com/SemiAnalysisAI/InferenceX/actions/runs/28061204145) |
-| MiniMax-M3 | EAGLE3 (GQA) | [`minimaxm3_eagle3_gqa.yaml`](minimaxm3_eagle3_gqa.yaml) | [29784780049](https://github.com/SemiAnalysisAI/InferenceX/actions/runs/29784780049) |
-| GLM-5.2 | MTP | [`glm5.2_mtp.yaml`](glm5.2_mtp.yaml) | [28058352479](https://github.com/SemiAnalysisAI/InferenceX/actions/runs/28058352479) |
-| GLM-5.3 | MTP (provisional, K=3 copied from GLM-5.2) | [`glm5.3_mtp.yaml`](glm5.3_mtp.yaml) | [28058352479](https://github.com/SemiAnalysisAI/InferenceX/actions/runs/28058352479) (GLM-5.2) |
-| Qwen3.8-Flash-Next | MTP (native) | [`qwen3.8next_mtp.yaml`](qwen3.8next_mtp.yaml) | [33034290269](https://github.com/SemiAnalysisAI/InferenceX/actions/runs/33034290269) |
-| Muse Spark Open | DFlash2 | [`musespark_dflash.yaml`](musespark_dflash.yaml) | [38808046215](https://github.com/SemiAnalysisAI/InferenceX/actions/runs/38808046215) |
+| Model | Method | Golden YAML |
+| --- | --- | --- |
+| DeepSeek V4 Pro | MTP | [`deepseek-v4-pro__mtp__native__default-default.yaml`](deepseek-v4-pro__mtp__native__default-default.yaml) |
+| DeepSeek V4 Pro 0813 | DSpark (probabilistic draft) | [`deepseek-v4-pro-0813__dspark__native__probabilistic-default.yaml`](deepseek-v4-pro-0813__dspark__native__probabilistic-default.yaml) |
+| DeepSeek V4.1 Flash | DSpark (probabilistic draft, block verify) | [`deepseek-v4.1-flash__dspark__native__probabilistic-block.yaml`](deepseek-v4.1-flash__dspark__native__probabilistic-block.yaml) |
+| Qwen3.5 397B-A17B | MTP | [`qwen3.5-397b-a17b-nvfp4__mtp__native__default-default.yaml`](qwen3.5-397b-a17b-nvfp4__mtp__native__default-default.yaml) |
+| Kimi K3 | DSpark | [`kimi-k3__dspark__kimi-k3-dspark__default-default.yaml`](kimi-k3__dspark__kimi-k3-dspark__default-default.yaml) |
+| Kimi K3 | DSpark (probabilistic draft, block verify) | [`kimi-k3__dspark__kimi-k3-dspark__probabilistic-block.yaml`](kimi-k3__dspark__kimi-k3-dspark__probabilistic-block.yaml) |
+| Kimi K3 | DSpark (probabilistic draft) | [`kimi-k3__dspark__kimi-k3-dspark__probabilistic-default.yaml`](kimi-k3__dspark__kimi-k3-dspark__probabilistic-default.yaml) |
+| Kimi K3.1 Pro | DSpark (probabilistic draft, block verify) | [`kimi-k3.1-pro__dspark__kimi-k3.1-pro-dspark-preview__probabilistic-block.yaml`](kimi-k3.1-pro__dspark__kimi-k3.1-pro-dspark-preview__probabilistic-block.yaml) |
+| Kimi K3.1 Pro | DFLASH (RadixArk draft, block verify) | [`kimi-k3.1-pro__dflash__kimi-k3.1-dflash2-preview__default-block.yaml`](kimi-k3.1-pro__dflash__kimi-k3.1-dflash2-preview__default-block.yaml) |
+| MiniMax-M3 | EAGLE3 | [`minimax-m3__eagle3__minimax-m3-eagle3__default-default.yaml`](minimax-m3__eagle3__minimax-m3-eagle3__default-default.yaml) |
+| MiniMax-M3 | EAGLE3 (GQA) | [`minimax-m3__eagle3__minimax-m3-eagle3-gqa__default-default.yaml`](minimax-m3__eagle3__minimax-m3-eagle3-gqa__default-default.yaml) |
+| MiniMax-M3 | EAGLE3 (GQA, block verify) | [`minimax-m3__eagle3__minimax-m3-eagle3-gqa__default-block.yaml`](minimax-m3__eagle3__minimax-m3-eagle3-gqa__default-block.yaml) |
+| GLM-5.2 | MTP | [`glm-5.2-fp8__mtp__native__default-default.yaml`](glm-5.2-fp8__mtp__native__default-default.yaml) |
+| GLM-5.3 | MTP (SGLang) | [`glm-5.3-nvfp4__mtp__native__default-default.yaml`](glm-5.3-nvfp4__mtp__native__default-default.yaml) |
+| GLM-5.3-Flash | MTP | [`glm-5.3-flash__mtp__native__default-default.yaml`](glm-5.3-flash__mtp__native__default-default.yaml) |
+| Qwen3.8-Flash-Next | MTP (native) | [`qwen3.8-flash-next-fp8__mtp__native__default-default.yaml`](qwen3.8-flash-next-fp8__mtp__native__default-default.yaml) |
+| Muse Spark Open | DFlash2 | [`muse-spark-open-816b-a42b-nvfp4__dflash__muse-spark-open-dflash2__default-default.yaml`](muse-spark-open-816b-a42b-nvfp4__dflash__muse-spark-open-dflash2__default-default.yaml) |
 
 ## Using golden curves in srt-slurm runs
 
@@ -155,13 +188,46 @@ Before accepting an updated curve, reviewers should verify:
 - Eval-only and non-AgentX runs use real verification, and the connector removes stale synthetic settings. Non-speculative roles receive no simulation settings. `RUN_EVAL` does not disable simulation for the throughput portion.
 - Missing golden curves or unmeasured draft lengths fail before submission. Add measured golden data for a new combination instead of a guessed or hard-coded length.
 
+## Curve identities and names
+
+Every curve file is named `<model>__<method>__<draft>__<draft_sample>-<verify>.yaml`: the curve's model key, its method (`mtp` for a model-native head, `eagle3`, `dspark`, `dflash`), its draft (`native` or the draft model), and the draft sampler and verifier the collector set (`default` when it left the engine default).
+
+[`identities.yaml`](identities.yaml) gives each curve two blocks. A new curve needs both before it merges; a test checks each file name against them.
+
+`select` decides which runs use the curve. `curve_name` returns the most specific matching curve (the one declaring the most of `draft_family`, `draft_sample` and `verify`) and fails when none match or the most specific ones tie.
+
+| Key | Meaning |
+| --- | --- |
+| `model_prefixes` | InferenceX model prefixes that use the curve |
+| `method` | `mtp`, `eagle3`, `dspark` or `dflash`. SGLang `EAGLE` and `NEXTN` mean the model's native `mtp` head, except MiniMax-M3's EAGLE, which is `eagle3` |
+| `draft_family` | Only where one model's curves differ by draft: `gqa` when the draft model id contains `gqa`, else `default` |
+| `draft_sample` | Only where one model's curves differ by draft sampler: the run's `draft_sample_method` must equal it |
+| `verify` | Only where one model's curves differ by verifier: `standard`, `block` or `relaxed`. The run's verifier is read as the audit reads it; an unknown verifier (ATOM, TileRT) never matches a curve that sets `verify` |
+
+`collection` records how the curve was measured: `engine`, `draft`, `draft_sample` (`greedy`, `probabilistic`), `verify` (`standard`, `block`, `relaxed`), `adaptive`, `topology` (`chain`, `tree-topk<N>`), `draft_precision` (the draft weights' quantization), `draft_kv_cache_dtype` and `kv_cache_dtype` (the target's). `provisional: true` marks a curve not measured for its model. Each fact is `{value, source}`:
+
+| Source | Meaning |
+| --- | --- |
+| `explicit` | Set by the collector or recipe |
+| `documented` | Fixed by the connector or engine: a recipe's synthetic sampler becomes `block`, and block, relaxed and adaptive verification are opt-in, so unset means `standard` and not adaptive |
+| `assumed` | The connector's own reading, such as ATOM DSpark drafting probabilistically |
+| `default` | Unset, so the engine default; `value` is null |
+| `unknown` | Not readable, such as ATOM's verifier; `value` is null |
+
+[`infx/srt_slurm/spec_identity.py`](../srt_slurm/spec_identity.py) describes a run's generation role in the same vocabulary and audits it against its selected curve without changing the selection. KV cache dtypes are normalized: `fp8_e4m3` is `fp8`, `bfloat16` is `bf16` and `auto` is the engine default. Findings are `mismatch` (both values known and different), `unverified` (an engine default or unknown on either side, other than the same engine's default on both), `adaptive` (no fixed-k curve applies), `provisional` and `engine`. To audit every speculative role of the sweep matrix:
+
+```bash
+python -m infx.matrix.generate full-sweep --config-files configs/nvidia-master.yaml configs/amd-master.yaml --scenario-type agentic-coding > matrix.json
+python -m infx.srt_slurm.spec_identity snapshot matrix.json --root .
+```
+
 ## Querying the curves
 
 This directory is the `infx.golden_al_distribution` Python package. `golden_length(model_prefix, spec, thinking)` returns the value AgentX synthetic acceptance applies, and `curve_name` shows which YAML a speculative config resolves to. The same lookup runs from a shell:
 
 ```bash
 python -m infx.golden_al_distribution list                          # every curve and its measured draft lengths
-python -m infx.golden_al_distribution show qwen3.5_mtp              # every AL in one curve
+python -m infx.golden_al_distribution show qwen3.5-397b-a17b-nvfp4__mtp__native__default-default              # every AL in one curve
 python -m infx.golden_al_distribution lookup qwen3.5 mtp 3          # 3.39 (thinking_on by default)
 python -m infx.golden_al_distribution lookup kimik3 dspark 7 --draft-sample-method probabilistic --json
 ```
diff --git a/inferencex-e2e/infx/golden_al_distribution/README_zh.md b/inferencex-e2e/infx/golden_al_distribution/README_zh.md
index e25bdd372c..58699b442e 100644
--- a/inferencex-e2e/infx/golden_al_distribution/README_zh.md
+++ b/inferencex-e2e/infx/golden_al_distribution/README_zh.md
@@ -2,7 +2,7 @@
 
 [English](README.md) | 中文
 
-本目录包含今后用于在 InferenceX 中标准化推测解码的黄金接受长度（Acceptance Length，AL）曲线。每个 YAML 按模型、思考模式和草稿长度（`num_speculative_tokens`），记录在 SPEED-Bench Qualitative split 的 **coding** 类别上测得的平均 AL。
+本目录包含今后用于在 InferenceX 中标准化投机解码的黄金接受长度（Acceptance Length，AL）曲线。每个 YAML 按模型、思考模式和草稿长度（`num_speculative_tokens`），记录在 SPEED-Bench Qualitative split 的 **coding** 类别上测得的平均 AL，并记录产生这些数值的[收集设置](#收集设置)。
 
 ## 为什么选择 SPEED-Bench
 
@@ -26,6 +26,13 @@ AL 取决于工作负载：草稿模型的预测在某些领域比其他领域
 
 对于 Qwen3.5 的 srt-slurm 启动，srt 驱动会运行 `infx/srt_slurm/synthetic_acceptance.py` 连接器，在应用调用方覆盖设置后，根据生成角色的 `speculative-num-steps` 和 `THINKING_MODE` 选择已提交的曲线。验证 token 不计为额外的 MTP 步数。对于采用合成接受的 SGLang MTP 吞吐测试，如果生成角色缺少 `speculative-num-draft-tokens`，或者其值不是等于 `speculative-num-steps + 1` 的整数，连接器会拒绝启动。无需手动设置接受长度。仅评测运行会移除合成设置并使用真实验证。
 
+TokenSpeed MTP 配置同样根据 `speculative-num-steps` 自动选择黄金 AL，要求
+`speculative-num-draft-tokens` 等于步数加一，且 `speculative-eagle-topk: 1`。
+连接器为 AgentX 吞吐测试设置 `synthetic-acceptance-length` 和所需的
+`sampling-backend: greedy`；仅评测和固定序列长度运行会移除该接受长度，并选择
+`sampling-backend: flashinfer` 进行真实验证。TokenSpeed 连接器接受显式 MTP 参数，
+拒绝其他投机算法和 JSON `speculative-config` 简写。
+
 vLLM 通过合成拒绝采样支持这一策略。例如，EAGLE3 运行可以通过 `synthetic_acceptance_length` 注入所选 YAML 值：
 
 ```bash
@@ -91,10 +98,28 @@ python -m atom.entrypoints.openai_server \
    其中 `1` 是目标模型保证生成的验证 token。结果四舍五入到小数点后两位。
 6. 收集脚本生成 YAML 矩阵。工作流将其发布到 GitHub Actions step summary，并上传为 `speedbench-reference-al-<model-prefix>` artifact。
 7. 工作流保留服务日志和逐请求详细结果，以便审阅者确认输出合理、思考模式正确，并且没有静默的服务或聊天模板故障。
-8. 审阅完成后，将矩阵连同准确的采样元数据和源 Actions run URL 一并提交到本目录。设置 `open-pr=true` 和 `golden-curve=<曲线文件名>`（例如 `dsv4_mtp`）时，工作流会写入本目录下的 `<曲线文件名>.yaml`，首行为源 run URL，再通过 `python -m infx.golden_al_distribution show` 加载校验，然后开启 PR。它会替换整个文件，因此本次未收集的格子会被删除。
+8. 审阅完成后，将矩阵连同准确的采样元数据、[收集设置](#收集设置)和源 Actions run URL 一并提交到本目录。设置 `open-pr=true` 和 `golden-curve=<曲线文件名>`（例如 `deepseek-v4-pro__mtp__native__default-default`）时，工作流会写入本目录下的 `<曲线文件名>.yaml`，`source_run` 键为源 run URL，再通过 `python -m infx.golden_al_distribution show` 加载校验，然后开启 PR。它会替换整个文件，因此本次未收集的格子会被删除。
 
 收集过程仅通过测量真实草稿头质量来建立黄金曲线。之后，AgentX 对所有可比较提交使用该已提交曲线作为合成接受目标。
 
+## 收集设置
+
+每个曲线 YAML 在模型键旁的保留顶层键 `collection` 中记录该次收集使用的 SPEED-Bench 客户端设置，`load_curve(name).collection` 会返回这些设置（没有该块的曲线返回 `None`）。每个 agentic 投机解码评测都会先运行仅作报告的接受长度门禁：它在评测自身的服务上以真实验证重放这些设置，并将测得的 AL 与黄金 AL 比较，详见[投机解码接受门禁](../evals/EVALS.md#speculative-acceptance-gate)。
+
+```yaml
+collection:
+  renderer: chat_template  # 或 deepseek_v4、deepseek_v41
+  modes:                   # 曲线中有 AL 数值的每个思考模式各一项
+    thinking_on:
+      chat_template_kwargs: {enable_thinking: true}  # 收集脚本未传入任何参数时为 null
+      sampling: {temperature: 0.6, top_p: 0.95, top_k: 20, presence_penalty: 0.0, repetition_penalty: 1.0}
+```
+
+- `renderer` 表示客户端如何把每个提示词渲染成文本。`chat_template` 对一条用户消息应用所服务模型的 Hugging Face 聊天模板，并带上生成提示和 `chat_template_kwargs`。`deepseek_v4` 和 `deepseek_v41` 是 vLLM 中同名的 tokenizer 模式；门禁使用本仓库中等效的编码器（[V4](../bench_serving/encoding_dsv4.py)、[V4.1](../bench_serving/encoding_dsv41.py)），并把 `chat_template_kwargs` 作为其思考选项。V4.1 编码器取自采集当周的 vLLM：之后的 vLLM 把推理强度 `high` 渲染为 75，而不是 50。
+- `sampling` 列出请求携带的全部采样参数，其中包括 `vllm bench serve` 附加的 `repetition_penalty: 1.0`。未列出的参数即未发送，服务端使用了自身的默认值。
+- 其余设置对所有收集都相同：SPEED-Bench Qualitative `coding` 类别的 80 条提示词，按 vLLM 加载器的发送顺序，以流式 `/v1/completions` 请求发送，`max_tokens` 为 4096，且不设置 `ignore_eos`。各次收集的并发数不同；门禁始终以并发 64 重放，即视 AL 与并发无关。
+- 新曲线必须包含该块；没有该块的曲线会被门禁跳过。[`muse-spark-open-816b-a42b-nvfp4__dflash__muse-spark-open-dflash2__default-default.yaml`](muse-spark-open-816b-a42b-nvfp4__dflash__muse-spark-open-dflash2__default-default.yaml) 使用 SGLang 的 `bench_serving` 客户端在其原生 `/generate` 端点上收集，不发送 `repetition_penalty`；门禁在 `/v1/completions` 上重放相同的渲染后提示词和采样设置。[`glm-5.3-nvfp4__mtp__native__default-default.yaml`](glm-5.3-nvfp4__mtp__native__default-default.yaml) 的收集方式相同，目前还没有该块。
+
 ## 复现一次收集
 
 首先测试模型专用收集脚本和镜像，然后从包含该收集脚本的分支触发工作流：
@@ -120,25 +145,30 @@ gh workflow run speedbench-al.yml \
 - 详细输出内容连贯，并使用预期的思考模式。
 - 服务日志中没有回退、禁用草稿或聊天模板错误。
 - YAML 元数据与触发时使用的镜像、采样设置、模型和推测方法一致。
-- YAML 第一行链接了源 Actions run。
+- `collection` 块与收集脚本的并发数、提示词渲染方式和各模式设置一致。
+- `source_run` 是生成该 artifact 的 Actions run。
 - 提交的数值与工作流 artifact 完全一致。
 
 ## 当前黄金曲线
 
-| 模型 | 方法 | 黄金 YAML | 源 run |
-| --- | --- | --- | --- |
-| DeepSeek V4 Pro | MTP | [`dsv4_mtp.yaml`](dsv4_mtp.yaml) | [27180633016](https://github.com/SemiAnalysisAI/InferenceX/actions/runs/27180633016) |
-| DeepSeek V4 Pro 0813 | DSpark（概率采样草稿） | [`dsv4-pro-0813-dspark.yaml`](dsv4-pro-0813-dspark.yaml) | [31742838308](https://github.com/SemiAnalysisAI/InferenceX/actions/runs/31742838308) |
-| DeepSeek V4.1 Flash | DSpark（概率采样草稿 + 块验证） | [`dsv41flash_dspark.yaml`](dsv41flash_dspark.yaml) | [34493175056](https://github.com/SemiAnalysisAI/InferenceX/actions/runs/34493175056) |
-| Qwen3.5 397B-A17B | MTP | [`qwen3.5_mtp.yaml`](qwen3.5_mtp.yaml) | [27317114007](https://github.com/SemiAnalysisAI/InferenceX/actions/runs/27317114007) |
-| Kimi K3 | DSpark | [`kimik3_dspark.yaml`](kimik3_dspark.yaml) | [30304797750](https://github.com/SemiAnalysisAI/InferenceX/actions/runs/30304797750) |
-| Kimi K3 | DSpark（概率采样草稿 + 块验证） | [`kimik3_dspark_probabilistic_sample_method_block_rejection_sample_method.yaml`](kimik3_dspark_probabilistic_sample_method_block_rejection_sample_method.yaml) | [30316471205](https://github.com/SemiAnalysisAI/InferenceX/actions/runs/30316471205) |
-| MiniMax-M3 | EAGLE3 | [`minimaxm3_eagle3.yaml`](minimaxm3_eagle3.yaml) | [28061204145](https://github.com/SemiAnalysisAI/InferenceX/actions/runs/28061204145) |
-| MiniMax-M3 | EAGLE3（GQA） | [`minimaxm3_eagle3_gqa.yaml`](minimaxm3_eagle3_gqa.yaml) | [29784780049](https://github.com/SemiAnalysisAI/InferenceX/actions/runs/29784780049) |
-| GLM-5.2 | MTP | [`glm5.2_mtp.yaml`](glm5.2_mtp.yaml) | [28058352479](https://github.com/SemiAnalysisAI/InferenceX/actions/runs/28058352479) |
-| GLM-5.3 | MTP（临时，K=3 取自 GLM-5.2） | [`glm5.3_mtp.yaml`](glm5.3_mtp.yaml) | [28058352479](https://github.com/SemiAnalysisAI/InferenceX/actions/runs/28058352479)（GLM-5.2） |
-| Qwen3.8-Flash-Next | MTP (native) | [`qwen3.8next_mtp.yaml`](qwen3.8next_mtp.yaml) | [33034290269](https://github.com/SemiAnalysisAI/InferenceX/actions/runs/33034290269) |
-| Muse Spark Open | DFlash2 | [`musespark_dflash.yaml`](musespark_dflash.yaml) | [38808046215](https://github.com/SemiAnalysisAI/InferenceX/actions/runs/38808046215) |
+| 模型 | 方法 | 黄金 YAML |
+| --- | --- | --- |
+| DeepSeek V4 Pro | MTP | [`deepseek-v4-pro__mtp__native__default-default.yaml`](deepseek-v4-pro__mtp__native__default-default.yaml) |
+| DeepSeek V4 Pro 0813 | DSpark（概率采样草稿） | [`deepseek-v4-pro-0813__dspark__native__probabilistic-default.yaml`](deepseek-v4-pro-0813__dspark__native__probabilistic-default.yaml) |
+| DeepSeek V4.1 Flash | DSpark（概率采样草稿 + 块验证） | [`deepseek-v4.1-flash__dspark__native__probabilistic-block.yaml`](deepseek-v4.1-flash__dspark__native__probabilistic-block.yaml) |
+| Qwen3.5 397B-A17B | MTP | [`qwen3.5-397b-a17b-nvfp4__mtp__native__default-default.yaml`](qwen3.5-397b-a17b-nvfp4__mtp__native__default-default.yaml) |
+| Kimi K3 | DSpark | [`kimi-k3__dspark__kimi-k3-dspark__default-default.yaml`](kimi-k3__dspark__kimi-k3-dspark__default-default.yaml) |
+| Kimi K3 | DSpark（概率采样草稿 + 块验证） | [`kimi-k3__dspark__kimi-k3-dspark__probabilistic-block.yaml`](kimi-k3__dspark__kimi-k3-dspark__probabilistic-block.yaml) |
+| Kimi K3 | DSpark（概率采样草稿） | [`kimi-k3__dspark__kimi-k3-dspark__probabilistic-default.yaml`](kimi-k3__dspark__kimi-k3-dspark__probabilistic-default.yaml) |
+| Kimi K3.1 Pro | DSpark（概率采样草稿 + 块验证） | [`kimi-k3.1-pro__dspark__kimi-k3.1-pro-dspark-preview__probabilistic-block.yaml`](kimi-k3.1-pro__dspark__kimi-k3.1-pro-dspark-preview__probabilistic-block.yaml) |
+| Kimi K3.1 Pro | DFLASH（RadixArk 草稿 + 块验证） | [`kimi-k3.1-pro__dflash__kimi-k3.1-dflash2-preview__default-block.yaml`](kimi-k3.1-pro__dflash__kimi-k3.1-dflash2-preview__default-block.yaml) |
+| MiniMax-M3 | EAGLE3 | [`minimax-m3__eagle3__minimax-m3-eagle3__default-default.yaml`](minimax-m3__eagle3__minimax-m3-eagle3__default-default.yaml) |
+| MiniMax-M3 | EAGLE3（GQA） | [`minimax-m3__eagle3__minimax-m3-eagle3-gqa__default-default.yaml`](minimax-m3__eagle3__minimax-m3-eagle3-gqa__default-default.yaml) |
+| MiniMax-M3 | EAGLE3（GQA + 块验证） | [`minimax-m3__eagle3__minimax-m3-eagle3-gqa__default-block.yaml`](minimax-m3__eagle3__minimax-m3-eagle3-gqa__default-block.yaml) |
+| GLM-5.2 | MTP | [`glm-5.2-fp8__mtp__native__default-default.yaml`](glm-5.2-fp8__mtp__native__default-default.yaml) |
+| GLM-5.3 | MTP（SGLang） | [`glm-5.3-nvfp4__mtp__native__default-default.yaml`](glm-5.3-nvfp4__mtp__native__default-default.yaml) |
+| Qwen3.8-Flash-Next | MTP (native) | [`qwen3.8-flash-next-fp8__mtp__native__default-default.yaml`](qwen3.8-flash-next-fp8__mtp__native__default-default.yaml) |
+| Muse Spark Open | DFlash2 | [`muse-spark-open-816b-a42b-nvfp4__dflash__muse-spark-open-dflash2__default-default.yaml`](muse-spark-open-816b-a42b-nvfp4__dflash__muse-spark-open-dflash2__default-default.yaml) |
 
 ## 在 srt-slurm 运行中使用黄金曲线
 
@@ -148,13 +178,46 @@ gh workflow run speedbench-al.yml \
 - 仅评测和非 AgentX 运行使用真实验证，连接器会移除陈旧的合成设置。非投机角色不会收到模拟设置。`RUN_EVAL` 不会关闭吞吐部分的模拟。
 - 缺少黄金曲线或 draft 长度未测量时，会在提交前失败。新组合应补充实测黄金数据，而不是使用猜测或硬编码的长度。
 
+## 曲线身份与命名
+
+每个曲线文件命名为 `<model>__<method>__<draft>__<draft_sample>-<verify>.yaml`：曲线的模型键、方法（模型原生头为 `mtp`，以及 `eagle3`、`dspark`、`dflash`）、草稿模型（`native` 或草稿模型名），以及收集脚本设置的草稿采样器和验证器（沿用引擎默认值时为 `default`）。
+
+[`identities.yaml`](identities.yaml) 为每条曲线提供两个块。新曲线合并前必须同时具备二者；测试会据此检查每个文件名。
+
+`select` 决定哪些运行使用该曲线。`curve_name` 返回最具体的匹配曲线（声明 `draft_family`、`draft_sample`、`verify` 最多的那条），没有匹配或最具体的多条并列时报错。
+
+| 键 | 含义 |
+| --- | --- |
+| `model_prefixes` | 使用该曲线的 InferenceX 模型前缀 |
+| `method` | `mtp`、`eagle3`、`dspark` 或 `dflash`。SGLang 的 `EAGLE` 和 `NEXTN` 表示模型原生 `mtp` 头，MiniMax-M3 的 EAGLE 除外，其为 `eagle3` |
+| `draft_family` | 仅在同一模型的曲线因草稿模型而不同时设置：草稿模型名含 `gqa` 时为 `gqa`，否则为 `default` |
+| `draft_sample` | 仅在同一模型的曲线因草稿采样器而不同时设置：运行的 `draft_sample_method` 必须与之相等 |
+| `verify` | 仅在同一模型的曲线因验证器而不同时设置：`standard`、`block` 或 `relaxed`。运行的验证器按审计相同的方式读取；未知验证器（ATOM、TileRT）不会匹配设置了 `verify` 的曲线 |
+
+`collection` 记录曲线的测量方式：`engine`、`draft`、`draft_sample`（`greedy`、`probabilistic`）、`verify`（`standard`、`block`、`relaxed`）、`adaptive`、`topology`（`chain`、`tree-topk<N>`）、`draft_precision`（草稿权重的量化方式）、`draft_kv_cache_dtype` 和 `kv_cache_dtype`（目标模型的）。`provisional: true` 表示该曲线并非针对该模型测量。每项为 `{value, source}`：
+
+| Source | 含义 |
+| --- | --- |
+| `explicit` | 由收集脚本或配方显式设置 |
+| `documented` | 由 connector 或引擎确定：配方中的 synthetic 采样器会变为 `block`；block、relaxed 和 adaptive 验证均需显式开启，未设置即为 `standard` 且非自适应 |
+| `assumed` | connector 自身的判断，例如 ATOM DSpark 采用 probabilistic 草稿 |
+| `default` | 未设置，沿用引擎默认值；`value` 为 null |
+| `unknown` | 无法读取，例如 ATOM 的验证器；`value` 为 null |
+
+[`infx/srt_slurm/spec_identity.py`](../srt_slurm/spec_identity.py) 用同一词汇描述运行的生成角色，并对照所选曲线进行审计，但不改变选择结果。KV cache dtype 会做归一化：`fp8_e4m3` 即 `fp8`，`bfloat16` 即 `bf16`，`auto` 为引擎默认值。结果类型包括 `mismatch`（双方值均已知且不同）、`unverified`（任一方为引擎默认值或未知，双方同为同一引擎默认值时除外）、`adaptive`（不适用固定 k 曲线）、`provisional` 和 `engine`。审计扫描矩阵中的每个推测解码角色：
+
+```bash
+python -m infx.matrix.generate full-sweep --config-files configs/nvidia-master.yaml configs/amd-master.yaml --scenario-type agentic-coding > matrix.json
+python -m infx.srt_slurm.spec_identity snapshot matrix.json --root .
+```
+
 ## 查询曲线
 
 本目录即 `infx.golden_al_distribution` Python 包。`golden_length(model_prefix, spec, thinking)` 返回 AgentX 合成接受所使用的数值，`curve_name` 给出某个投机解码配置对应的 YAML。也可以在 shell 中执行相同的查询：
 
 ```bash
 python -m infx.golden_al_distribution list                          # 所有曲线及其已测量的草稿长度
-python -m infx.golden_al_distribution show qwen3.5_mtp              # 单条曲线的全部 AL
+python -m infx.golden_al_distribution show qwen3.5-397b-a17b-nvfp4__mtp__native__default-default              # 单条曲线的全部 AL
 python -m infx.golden_al_distribution lookup qwen3.5 mtp 3          # 3.39（默认 thinking_on）
 python -m infx.golden_al_distribution lookup kimik3 dspark 7 --draft-sample-method probabilistic --json
 ```
diff --git a/inferencex-e2e/infx/golden_al_distribution/__init__.py b/inferencex-e2e/infx/golden_al_distribution/__init__.py
index 32576f1224..7f349b896c 100644
--- a/inferencex-e2e/infx/golden_al_distribution/__init__.py
+++ b/inferencex-e2e/infx/golden_al_distribution/__init__.py
@@ -1,9 +1,9 @@
 """Committed golden acceptance-length (AL) curves for AgentX synthetic acceptance.
 
-Each ``<curve>.yaml`` beside this module maps one measured model to
-``{thinking_mode: {num_speculative_tokens: AL}}``. ``curve_name`` turns an
-InferenceX model prefix and speculative config into a curve, and
-``golden_length`` returns the committed value. From a shell, use
+Each ``<model>__<method>__<draft>__<draft_sample>-<verify>.yaml`` beside this module maps one
+measured model to ``{thinking_mode: {num_speculative_tokens: AL}}``. ``identities.yaml`` says
+which runs select each curve and how it was collected. ``curve_name`` turns an InferenceX model
+prefix and speculative config into a curve, and ``golden_length`` returns the committed value. From a shell, use
 ``python -m infx.golden_al_distribution {list,show,lookup}``.
 """
 
diff --git a/inferencex-e2e/infx/golden_al_distribution/__main__.py b/inferencex-e2e/infx/golden_al_distribution/__main__.py
index 15a20a7dfa..e2865e4868 100644
--- a/inferencex-e2e/infx/golden_al_distribution/__main__.py
+++ b/inferencex-e2e/infx/golden_al_distribution/__main__.py
@@ -1,7 +1,7 @@
 """Query the committed golden AL curves.
 
 python -m infx.golden_al_distribution list
-python -m infx.golden_al_distribution show qwen3.5_mtp
+python -m infx.golden_al_distribution show qwen3.5-397b-a17b-nvfp4__mtp__native__default-default
 python -m infx.golden_al_distribution lookup qwen3.5 mtp 3 --thinking thinking_on
 """
 
@@ -95,12 +95,12 @@ def lookup_command(args: argparse.Namespace) -> None:
         spec["model"] = args.draft_model
     if args.draft_sample_method:
         spec["draft_sample_method"] = args.draft_sample_method
-    value = golden_length(args.model, spec, args.thinking, args.golden_dir)
+    value = golden_length(args.model, spec, args.thinking, args.golden_dir, args.verify)
     if args.json:
         print(
             json.dumps(
                 {
-                    "curve": curve_name(args.model, spec),
+                    "curve": curve_name(args.model, spec, args.golden_dir, args.verify),
                     "thinking": args.thinking,
                     "tokens": args.tokens,
                     "acceptance_length": value,
@@ -126,7 +126,9 @@ def main(argv: list[str] | None = None) -> int:
     list_parser.set_defaults(handler=list_command)
 
     show_parser = commands.add_parser("show", help="every AL in one curve")
-    show_parser.add_argument("curve", help="curve file stem, e.g. qwen3.5_mtp")
+    show_parser.add_argument(
+        "curve", help="curve file stem, e.g. qwen3.5-397b-a17b-nvfp4__mtp__native__default-default"
+    )
     show_parser.add_argument("--json", action="store_true")
     show_parser.set_defaults(handler=show_command)
 
@@ -145,6 +147,11 @@ def main(argv: list[str] | None = None) -> int:
         choices=("greedy", "probabilistic"),
         help="Kimi DSpark draft sampler",
     )
+    lookup_parser.add_argument(
+        "--verify",
+        choices=("standard", "block", "relaxed"),
+        help="the run's verifier; omit when unknown (selects block-verified curves only by it)",
+    )
     lookup_parser.add_argument("--json", action="store_true")
     lookup_parser.set_defaults(handler=lookup_command)
 
diff --git a/inferencex-e2e/infx/golden_al_distribution/curves.py b/inferencex-e2e/infx/golden_al_distribution/curves.py
index 4618bb1533..6dd66d9f77 100644
--- a/inferencex-e2e/infx/golden_al_distribution/curves.py
+++ b/inferencex-e2e/infx/golden_al_distribution/curves.py
@@ -11,18 +11,28 @@
 
 from infx import yamlio
 
-GOLDEN_DIR = Path(__file__).resolve().parent
+from .identity import IDENTITIES_STEM, IDENTITY_DIR, select_curve
+
+GOLDEN_DIR = IDENTITY_DIR
 THINKING_MODES = ("thinking_on", "thinking_off")
 CURVE_NAME = re.compile(r"[a-z0-9_.-]+")
 
 
 @dataclass(frozen=True)
 class Curve:
-    """One committed curve: ``{thinking_mode: {num_speculative_tokens: AL}}``."""
+    """One committed curve: ``{thinking_mode: {num_speculative_tokens: AL}}``.
+
+    ``collection`` holds the SPEED-Bench client settings that measured the curve (the YAML's
+    reserved ``collection`` key), which the acceptance-length gate replays; None if unrecorded.
+    ``source_run`` is the URL of the Actions run that measured the values (reserved
+    ``source_run`` key).
+    """
 
     name: str
     model: str
     modes: Mapping[str, Mapping[int, Any]]
+    collection: Mapping[str, Any] | None = None
+    source_run: str | None = None
 
     def tokens(self, thinking: str) -> list[int]:
         """Return the sorted draft lengths measured for one thinking mode."""
@@ -41,40 +51,30 @@ def acceptance(self, thinking: str, tokens: int) -> float:
         return value
 
 
-def curve_name(model: str, spec: Mapping[str, Any]) -> str:
-    """Map an InferenceX model prefix and speculative config to a curve file stem.
-
-    SGLang names native model MTP EAGLE or NEXTN, so those map to the model's own head curve.
-    Kimi DSpark has one curve per draft sampler and raises ValueError for any other sampler.
-    """
-    method = str(spec.get("method", "")).lower()
-    if method in ("eagle", "nextn"):
-        method = "eagle3" if model == "minimaxm3" else "mtp"
-    curve = f"{model}_{method}"
-    if model in ("dsv4", "dsv4dspark", "dsv4dsparkprob") and method == "dspark":
-        curve = "dsv4-pro-0813-dspark"
-    elif model == "minimaxm3" and method == "eagle3":
-        if "gqa" in str(spec.get("model", "")).lower():
-            curve += "_gqa"
-    elif model == "kimik3" and method == "dspark":
-        sampling = spec.get("draft_sample_method")
-        if sampling == "probabilistic":
-            curve += "_probabilistic_sample_method_block_rejection_sample_method"
-        elif sampling != "greedy":
-            raise ValueError(f"No Kimi DSpark golden curve for draft sampling {sampling!r}")
-    if not CURVE_NAME.fullmatch(curve):
-        raise ValueError(f"Invalid golden curve identity: {curve!r}")
-    return curve
+def curve_name(
+    model: str,
+    spec: Mapping[str, Any],
+    golden_dir: Path = GOLDEN_DIR,
+    verify: str | None = None,
+) -> str:
+    """The curve file stem whose ``identities.yaml`` select block best matches a model prefix,
+    speculative config and verifier (None when unknown), or ValueError."""
+    name = select_curve(model, spec, golden_dir, verify)
+    if not CURVE_NAME.fullmatch(name):
+        raise ValueError(f"Invalid golden curve identity: {name!r}")
+    return name
 
 
 def load_curve(name: str, golden_dir: Path = GOLDEN_DIR) -> Curve:
     """Load ``<name>.yaml`` from ``golden_dir``, or raise ValueError if missing or malformed."""
-    if not CURVE_NAME.fullmatch(name):
+    if not CURVE_NAME.fullmatch(name) or name == IDENTITIES_STEM:
         raise ValueError(f"Invalid golden curve identity: {name!r}")
     path = golden_dir / f"{name}.yaml"
     if not path.is_file():
         raise ValueError(f"No committed golden curve {path.name} in {golden_dir}")
     data = yamlio.safe_load(path.read_text())
+    collection = data.pop("collection", None) if isinstance(data, dict) else None
+    source_run = data.pop("source_run", None) if isinstance(data, dict) else None
     if not isinstance(data, dict) or len(data) != 1:
         raise ValueError(f"Expected one model in golden curve {path.name}")
     [(model, modes)] = data.items()
@@ -83,19 +83,27 @@ def load_curve(name: str, golden_dir: Path = GOLDEN_DIR) -> Curve:
     for mode, cells in modes.items():
         if cells is not None and not isinstance(cells, dict):
             raise ValueError(f"Expected draft lengths in {mode} of golden curve {path.name}")
-    return Curve(name=name, model=str(model), modes=modes)
+    return Curve(
+        name=name, model=str(model), modes=modes, collection=collection, source_run=source_run
+    )
 
 
 def list_curves(golden_dir: Path = GOLDEN_DIR) -> list[Curve]:
     """Return every committed curve in ``golden_dir``, sorted by name."""
-    return [load_curve(path.stem, golden_dir) for path in sorted(golden_dir.glob("*.yaml"))]
+    paths = sorted(golden_dir.glob("*.yaml"))
+    return [load_curve(path.stem, golden_dir) for path in paths if path.stem != IDENTITIES_STEM]
 
 
 def golden_length(
-    model: str, spec: Mapping[str, Any], thinking: str, golden_dir: Path = GOLDEN_DIR
+    model: str,
+    spec: Mapping[str, Any],
+    thinking: str,
+    golden_dir: Path = GOLDEN_DIR,
+    verify: str | None = None,
 ) -> float:
-    """Return the committed AL for a model prefix, speculative config and thinking mode."""
-    name = curve_name(model, spec)
+    """Return the committed AL for a model prefix, speculative config, thinking mode and
+    verifier (None when unknown)."""
+    name = curve_name(model, spec, golden_dir, verify)
     tokens = spec.get("num_speculative_tokens")
     if not isinstance(tokens, int) or isinstance(tokens, bool) or tokens <= 0:
         raise ValueError("Speculative decoding requires a positive integer draft length")
diff --git a/inferencex-e2e/infx/golden_al_distribution/dsv4-pro-0813-dspark.yaml b/inferencex-e2e/infx/golden_al_distribution/deepseek-v4-pro-0813__dspark__native__probabilistic-default.yaml
similarity index 62%
rename from inferencex-e2e/infx/golden_al_distribution/dsv4-pro-0813-dspark.yaml
rename to inferencex-e2e/infx/golden_al_distribution/deepseek-v4-pro-0813__dspark__native__probabilistic-default.yaml
index cab002f9d0..7a7dd61a51 100644
--- a/inferencex-e2e/infx/golden_al_distribution/dsv4-pro-0813-dspark.yaml
+++ b/inferencex-e2e/infx/golden_al_distribution/deepseek-v4-pro-0813__dspark__native__probabilistic-default.yaml
@@ -1,4 +1,4 @@
-# Source GitHub Actions run: https://github.com/SemiAnalysisAI/InferenceX/actions/runs/31742838308
+source_run: https://github.com/SemiAnalysisAI/InferenceX/actions/runs/31742838308
 # Acceptance Length (AL) reference values measured with SPEED-Bench.
 # dataset: coding | temperature: 1.0 | output_len: 4096
 # thinking_on chat_template_kwargs: {"thinking": true, "reasoning_effort": "high"}
@@ -17,3 +17,12 @@ deepseek-v4-pro-0813:
     6: 3.77
     7: 3.73
     8: 3.47
+
+# SPEED-Bench client settings of this collection; the acceptance-length gate replays them
+# (README.md#collection-settings).
+collection:
+  renderer: deepseek_v4
+  modes:
+    thinking_on:
+      chat_template_kwargs: {thinking: true, reasoning_effort: high}
+      sampling: {temperature: 1.0, repetition_penalty: 1.0}
diff --git a/inferencex-e2e/infx/golden_al_distribution/dsv4_mtp.yaml b/inferencex-e2e/infx/golden_al_distribution/deepseek-v4-pro__mtp__native__default-default.yaml
similarity index 57%
rename from inferencex-e2e/infx/golden_al_distribution/dsv4_mtp.yaml
rename to inferencex-e2e/infx/golden_al_distribution/deepseek-v4-pro__mtp__native__default-default.yaml
index d8f35396a5..4668600434 100644
--- a/inferencex-e2e/infx/golden_al_distribution/dsv4_mtp.yaml
+++ b/inferencex-e2e/infx/golden_al_distribution/deepseek-v4-pro__mtp__native__default-default.yaml
@@ -1,4 +1,4 @@
-# Source GitHub Actions run: https://github.com/SemiAnalysisAI/InferenceX/actions/runs/27180633016
+source_run: https://github.com/SemiAnalysisAI/InferenceX/actions/runs/27180633016
 # Acceptance Length (AL) reference values measured with SPEED-Bench.
 # dataset: coding | temperature: 1.0 | output_len: 4096
 # thinking_on chat_template_kwargs: {"thinking": true, "reasoning_effort": "high"}
@@ -25,3 +25,15 @@ deepseek-v4-pro:
     6: 3.16
     7: 3.00
     8: 3.11
+
+# SPEED-Bench client settings of this collection; the acceptance-length gate replays them
+# (README.md#collection-settings).
+collection:
+  renderer: deepseek_v4
+  modes:
+    thinking_on:
+      chat_template_kwargs: {thinking: true, reasoning_effort: high}
+      sampling: {temperature: 1.0, repetition_penalty: 1.0}
+    thinking_off:
+      chat_template_kwargs: null
+      sampling: {temperature: 1.0, repetition_penalty: 1.0}
diff --git a/inferencex-e2e/infx/golden_al_distribution/dsv41flash_dspark.yaml b/inferencex-e2e/infx/golden_al_distribution/deepseek-v4.1-flash__dspark__native__probabilistic-block.yaml
similarity index 68%
rename from inferencex-e2e/infx/golden_al_distribution/dsv41flash_dspark.yaml
rename to inferencex-e2e/infx/golden_al_distribution/deepseek-v4.1-flash__dspark__native__probabilistic-block.yaml
index 4a2af28fa3..d29f44d9ef 100644
--- a/inferencex-e2e/infx/golden_al_distribution/dsv41flash_dspark.yaml
+++ b/inferencex-e2e/infx/golden_al_distribution/deepseek-v4.1-flash__dspark__native__probabilistic-block.yaml
@@ -1,4 +1,4 @@
-# Source GitHub Actions run: https://github.com/SemiAnalysisAI/InferenceX/actions/runs/34493175056
+source_run: https://github.com/SemiAnalysisAI/InferenceX/actions/runs/34493175056
 # Draft lengths 6-8 rejected by the image (no measured AL): https://github.com/SemiAnalysisAI/InferenceX/actions/runs/34494319147
 # Acceptance Length (AL) measured with SPEED-Bench Qualitative coding.
 # model: deepseek-ai/DeepSeek-V4.1-Flash | image: vllm/vllm-openai:deepseekv41-flash-0909 | TP: 4
@@ -21,3 +21,13 @@ deepseek-v4.1-flash:
     3: 2.90
     4: 3.26
     5: 3.51
+
+collection:
+  renderer: deepseek_v41
+  modes:
+    thinking_on:
+      chat_template_kwargs: {thinking: true, reasoning_effort: high}
+      sampling: {temperature: 1.0, repetition_penalty: 1.0}
+    thinking_off:
+      chat_template_kwargs: {thinking: false}
+      sampling: {temperature: 1.0, repetition_penalty: 1.0}
diff --git a/inferencex-e2e/infx/golden_al_distribution/glm5.2_mtp.yaml b/inferencex-e2e/infx/golden_al_distribution/glm-5.2-fp8__mtp__native__default-default.yaml
similarity index 61%
rename from inferencex-e2e/infx/golden_al_distribution/glm5.2_mtp.yaml
rename to inferencex-e2e/infx/golden_al_distribution/glm-5.2-fp8__mtp__native__default-default.yaml
index afebacac98..05576fc237 100644
--- a/inferencex-e2e/infx/golden_al_distribution/glm5.2_mtp.yaml
+++ b/inferencex-e2e/infx/golden_al_distribution/glm-5.2-fp8__mtp__native__default-default.yaml
@@ -1,4 +1,4 @@
-# Source GitHub Actions run: https://github.com/SemiAnalysisAI/InferenceX/actions/runs/28058352479
+source_run: https://github.com/SemiAnalysisAI/InferenceX/actions/runs/28058352479
 # Acceptance Length (AL) reference values measured with SPEED-Bench.
 # dataset: coding | temperature: 1.0 | top_p: 0.95 | output_len: 4096
 # thinking_on chat_template_kwargs: {"enable_thinking": true}
@@ -17,3 +17,12 @@ glm-5.2-fp8:
     6: 3.78
     7: 3.91
     8: 4.06
+
+# SPEED-Bench client settings of this collection; the acceptance-length gate replays them
+# (README.md#collection-settings).
+collection:
+  renderer: chat_template
+  modes:
+    thinking_on:
+      chat_template_kwargs: {enable_thinking: true}
+      sampling: {temperature: 1.0, top_p: 0.95, repetition_penalty: 1.0}
diff --git a/inferencex-e2e/infx/golden_al_distribution/glm-5.3-flash__mtp__native__default-default.yaml b/inferencex-e2e/infx/golden_al_distribution/glm-5.3-flash__mtp__native__default-default.yaml
new file mode 100644
index 0000000000..8ddefbab5f
--- /dev/null
+++ b/inferencex-e2e/infx/golden_al_distribution/glm-5.3-flash__mtp__native__default-default.yaml
@@ -0,0 +1,26 @@
+source_run: https://github.com/SemiAnalysisAI/InferenceX/actions/runs/41288481245
+# Acceptance Length (AL) reference values measured with SPEED-Bench.
+# dataset: coding | temperature: 1.0 | top_p: 0.95 | output_len: 4096
+# thinking_on chat_template_kwargs: {"reasoning_effort": "max"} (the chat template's default effort)
+# Measured on glm-5.3-flash (FP8, B300, vLLM MTP, TP8, concurrency 1), per num_speculative_tokens.
+#
+# key = num_speculative_tokens (MTP level); value = golden AL
+glm-5.3-flash:
+  thinking_on:
+    1: 1.86
+    2: 2.52
+    3: 3.00
+    4: 3.35
+    5: 3.60
+    6: 3.79
+    7: 3.93
+    8: 3.99
+
+# SPEED-Bench client settings of this collection; the acceptance-length gate replays them
+# (README.md#collection-settings).
+collection:
+  renderer: chat_template
+  modes:
+    thinking_on:
+      chat_template_kwargs: {reasoning_effort: max}
+      sampling: {temperature: 1.0, top_p: 0.95, repetition_penalty: 1.0}
diff --git a/inferencex-e2e/infx/golden_al_distribution/glm-5.3-nvfp4__mtp__native__default-default.yaml b/inferencex-e2e/infx/golden_al_distribution/glm-5.3-nvfp4__mtp__native__default-default.yaml
new file mode 100644
index 0000000000..5af9513e63
--- /dev/null
+++ b/inferencex-e2e/infx/golden_al_distribution/glm-5.3-nvfp4__mtp__native__default-default.yaml
@@ -0,0 +1,19 @@
+source_run: https://github.com/SemiAnalysisAI/InferenceX/actions/runs/41127067850
+# Acceptance Length (AL) reference values measured with SPEED-Bench.
+# dataset: coding | temperature: 1.0 | top_p: 0.95 | output_len: 4096
+# thinking_on: chat template default
+# speculative: NEXTN, eagle-topk 1, num-draft-tokens = level + 1; kv_cache_dtype: engine default
+# Measured on glm-5.3-nvfp4 (NVIDIA B300 SXM6 AC, SGLang MTP), per num_speculative_tokens.
+# Auto-generated by benchmarks/single_node/speedbench/glm5.3_fp4_b300_sglang.sh (speedbench-al.yml).
+#
+# key = num_speculative_tokens (MTP level); value = golden AL
+glm-5.3-nvfp4:
+  thinking_on:
+    1: 1.84
+    2: 2.49
+    3: 2.94
+    4: 3.28
+    5: 3.48
+    6: 3.70
+    7: 3.74
+    8: 3.87
diff --git a/inferencex-e2e/infx/golden_al_distribution/glm5.3_mtp.yaml b/inferencex-e2e/infx/golden_al_distribution/glm5.3_mtp.yaml
deleted file mode 100644
index 4933511703..0000000000
--- a/inferencex-e2e/infx/golden_al_distribution/glm5.3_mtp.yaml
+++ /dev/null
@@ -1,19 +0,0 @@
-# PROVISIONAL — copied from glm5.2_mtp.yaml; NOT measured on GLM-5.3.
-#
-# GLM-5.3 shares GLM-5.2's base and layer topology (its config.json differs only
-# by the fp8 quantization block), so the GLM-5.2 curve is the closest committed
-# reference. Only the K=3 cell is carried over, because the ROCm TileRT GLM
-# profile builds MTP at draft depth 3 and no other cell can be exercised.
-# Replace this file with a SPEED-Bench run on glm-5.3-fp8 when one exists.
-#
-# Inherited value provenance (GLM-5.2, unchanged):
-#   Source GitHub Actions run: https://github.com/SemiAnalysisAI/InferenceX/actions/runs/28058352479
-#   Acceptance Length (AL) reference values measured with SPEED-Bench.
-#   dataset: coding | temperature: 1.0 | top_p: 0.95 | output_len: 4096
-#   thinking_on chat_template_kwargs: {"enable_thinking": true}
-#   Measured on glm-5.2-fp8 (B300, vLLM MTP), per num_speculative_tokens.
-#
-# key = num_speculative_tokens (MTP level); value = golden AL
-glm-5.3-fp8:
-  thinking_on:
-    3: 2.99
diff --git a/inferencex-e2e/infx/golden_al_distribution/glm5.3flash_mtp.yaml b/inferencex-e2e/infx/golden_al_distribution/glm5.3flash_mtp.yaml
deleted file mode 100644
index 8216550753..0000000000
--- a/inferencex-e2e/infx/golden_al_distribution/glm5.3flash_mtp.yaml
+++ /dev/null
@@ -1,13 +0,0 @@
-# Source GitHub Actions run: https://github.com/SemiAnalysisAI/InferenceX/actions/runs/41288481245
-# SPEED-Bench coding, 80 first-user-turn prompts, concurrency 1, max reasoning effort.
-# vLLM B300 TP8, temperature 1.0, top_p 0.95, natural EOS, output cap 4096.
-glm-5.3-flash:
-  thinking_on:
-    1: 1.858382
-    2: 2.518506
-    3: 3.004589
-    4: 3.349344
-    5: 3.603536
-    6: 3.790803
-    7: 3.925358
-    8: 3.992497
diff --git a/inferencex-e2e/infx/golden_al_distribution/identities.yaml b/inferencex-e2e/infx/golden_al_distribution/identities.yaml
new file mode 100644
index 0000000000..b5ed6017fe
--- /dev/null
+++ b/inferencex-e2e/infx/golden_al_distribution/identities.yaml
@@ -0,0 +1,233 @@
+deepseek-v4-pro__mtp__native__default-default:
+  select: {model_prefixes: [dsv4], method: mtp}
+  collection:
+    engine: vllm
+    draft: native
+    draft_sample: {value: null, source: default}
+    verify: {value: standard, source: documented}
+    adaptive: {value: false, source: documented}
+    topology: {value: chain, source: documented}
+    draft_precision: {value: null, source: default}
+    draft_kv_cache_dtype: {value: null, source: default}
+    kv_cache_dtype: {value: fp8, source: explicit}
+
+deepseek-v4-pro-0813__dspark__native__probabilistic-default:
+  select: {model_prefixes: [dsv4, dsv4dspark, dsv4dsparkprob], method: dspark}
+  collection:
+    engine: vllm
+    draft: native
+    draft_sample: {value: probabilistic, source: explicit}
+    verify: {value: standard, source: documented}
+    adaptive: {value: false, source: documented}
+    topology: {value: chain, source: documented}
+    draft_precision: {value: null, source: default}
+    draft_kv_cache_dtype: {value: null, source: default}
+    kv_cache_dtype: {value: fp8, source: explicit}
+
+deepseek-v4.1-flash__dspark__native__probabilistic-block:
+  select: {model_prefixes: [dsv41flash], method: dspark}
+  collection:
+    engine: vllm
+    draft: native
+    draft_sample: {value: probabilistic, source: explicit}
+    verify: {value: block, source: explicit}
+    adaptive: {value: false, source: explicit}
+    topology: {value: chain, source: documented}
+    draft_precision: {value: null, source: unknown}
+    draft_kv_cache_dtype: {value: null, source: unknown}
+    kv_cache_dtype: {value: null, source: unknown}
+
+glm-5.2-fp8__mtp__native__default-default:
+  select: {model_prefixes: [glm5.2], method: mtp}
+  collection:
+    engine: vllm
+    draft: native
+    draft_sample: {value: null, source: default}
+    verify: {value: standard, source: documented}
+    adaptive: {value: false, source: documented}
+    topology: {value: chain, source: documented}
+    draft_precision: {value: null, source: default}
+    draft_kv_cache_dtype: {value: null, source: default}
+    kv_cache_dtype: {value: fp8, source: explicit}
+
+glm-5.3-flash__mtp__native__default-default:
+  select: {model_prefixes: [glm5.3flash], method: mtp}
+  collection:
+    engine: vllm
+    draft: native
+    draft_sample: {value: null, source: default}
+    verify: {value: standard, source: documented}
+    adaptive: {value: false, source: documented}
+    topology: {value: chain, source: documented}
+    draft_precision: {value: null, source: default}
+    draft_kv_cache_dtype: {value: null, source: default}
+    kv_cache_dtype: {value: fp8, source: explicit}
+
+glm-5.3-nvfp4__mtp__native__default-default:
+  select: {model_prefixes: [glm5.3], method: mtp}
+  collection:
+    engine: sglang
+    draft: native
+    draft_sample: {value: null, source: default}
+    verify: {value: standard, source: documented}
+    adaptive: {value: false, source: documented}
+    topology: {value: chain, source: documented}
+    draft_precision: {value: null, source: default}
+    draft_kv_cache_dtype: {value: null, source: default}
+    kv_cache_dtype: {value: null, source: default}
+
+kimi-k3__dspark__kimi-k3-dspark__default-default:
+  select: {model_prefixes: [kimik3], method: dspark, draft_sample: greedy}
+  collection:
+    engine: vllm
+    draft: Inferact/Kimi-K3-DSpark
+    draft_sample: {value: null, source: default}
+    verify: {value: standard, source: documented}
+    adaptive: {value: false, source: documented}
+    topology: {value: chain, source: documented}
+    draft_precision: {value: null, source: default}
+    draft_kv_cache_dtype: {value: null, source: default}
+    kv_cache_dtype: {value: fp8, source: explicit}
+
+kimi-k3__dspark__kimi-k3-dspark__probabilistic-block:
+  select: {model_prefixes: [kimik3], method: dspark, draft_sample: probabilistic}
+  collection:
+    engine: vllm
+    draft: Inferact/Kimi-K3-DSpark
+    draft_sample: {value: probabilistic, source: explicit}
+    verify: {value: block, source: explicit}
+    adaptive: {value: false, source: documented}
+    topology: {value: chain, source: documented}
+    draft_precision: {value: null, source: default}
+    draft_kv_cache_dtype: {value: null, source: default}
+    kv_cache_dtype: {value: fp8, source: explicit}
+
+kimi-k3__dspark__kimi-k3-dspark__probabilistic-default:
+  select: {model_prefixes: [kimik3], method: dspark, draft_sample: probabilistic, verify: standard}
+  collection:
+    engine: vllm
+    draft: Inferact/Kimi-K3-DSpark
+    draft_sample: {value: probabilistic, source: explicit}
+    verify: {value: standard, source: documented}
+    adaptive: {value: false, source: documented}
+    topology: {value: chain, source: documented}
+    draft_precision: {value: null, source: default}
+    draft_kv_cache_dtype: {value: null, source: default}
+    kv_cache_dtype: {value: fp8, source: explicit}
+
+kimi-k3.1-pro__dflash__kimi-k3.1-dflash2-preview__default-block:
+  select: {model_prefixes: [kimik3.1], method: dflash}
+  collection:
+    engine: sglang
+    draft: RadixArk/Kimi-K3.1-Dflash2-Preview
+    draft_sample: {value: null, source: default}
+    verify: {value: block, source: explicit}
+    adaptive: {value: false, source: documented}
+    topology: {value: chain, source: documented}
+    draft_precision: {value: null, source: default}
+    draft_kv_cache_dtype: {value: fp8, source: explicit}
+    kv_cache_dtype: {value: fp8, source: explicit}
+
+kimi-k3.1-pro__dspark__kimi-k3.1-pro-dspark-preview__probabilistic-block:
+  select: {model_prefixes: [kimik3.1], method: dspark, draft_sample: probabilistic}
+  collection:
+    engine: vllm
+    draft: Inferact/Kimi-K3.1-Pro-DSpark-preview
+    draft_sample: {value: probabilistic, source: explicit}
+    verify: {value: block, source: explicit}
+    adaptive: {value: false, source: documented}
+    topology: {value: chain, source: documented}
+    draft_precision: {value: null, source: default}
+    draft_kv_cache_dtype: {value: null, source: default}
+    kv_cache_dtype: {value: fp8, source: explicit}
+
+minimax-m3__eagle3__minimax-m3-eagle3__default-default:
+  select: {model_prefixes: [minimaxm3], method: eagle3, draft_family: default}
+  collection:
+    engine: vllm
+    draft: Inferact/MiniMax-M3-EAGLE3
+    draft_sample: {value: null, source: default}
+    verify: {value: standard, source: documented}
+    adaptive: {value: false, source: documented}
+    topology: {value: chain, source: documented}
+    draft_precision: {value: null, source: default}
+    draft_kv_cache_dtype: {value: null, source: default}
+    kv_cache_dtype: {value: null, source: default}
+
+minimax-m3__eagle3__minimax-m3-eagle3-gqa__default-default:
+  select: {model_prefixes: [minimaxm3], method: eagle3, draft_family: gqa}
+  collection:
+    engine: vllm
+    draft: Inferact/MiniMax-M3-EAGLE3-GQA
+    draft_sample: {value: null, source: default}
+    verify: {value: standard, source: documented}
+    adaptive: {value: false, source: documented}
+    topology: {value: chain, source: documented}
+    draft_precision: {value: null, source: default}
+    draft_kv_cache_dtype: {value: null, source: default}
+    kv_cache_dtype: {value: null, source: default}
+
+minimax-m3__eagle3__minimax-m3-eagle3-gqa__default-block:
+  select: {model_prefixes: [minimaxm3], method: eagle3, draft_family: gqa, verify: block}
+  collection:
+    engine: vllm
+    draft: Inferact/MiniMax-M3-EAGLE3-GQA
+    draft_sample: {value: null, source: default}
+    verify: {value: block, source: explicit}
+    adaptive: {value: false, source: documented}
+    topology: {value: chain, source: documented}
+    draft_precision: {value: null, source: default}
+    draft_kv_cache_dtype: {value: null, source: default}
+    kv_cache_dtype: {value: null, source: default}
+
+minimax-m3.1-flash__dspark__native__probabilistic-block:
+  select: {model_prefixes: [minimaxm31flash], method: dspark}
+  collection:
+    engine: vllm
+    draft: native
+    draft_sample: {value: probabilistic, source: explicit}
+    verify: {value: block, source: explicit}
+    adaptive: {value: false, source: documented}
+    topology: {value: chain, source: documented}
+    draft_precision: {value: null, source: default}
+    draft_kv_cache_dtype: {value: fp8, source: explicit}
+    kv_cache_dtype: {value: nvfp4, source: explicit}
+
+muse-spark-open-816b-a42b-nvfp4__dflash__muse-spark-open-dflash2__default-default:
+  select: {model_prefixes: [musespark], method: dflash}
+  collection:
+    engine: sglang
+    draft: RadixArk/Muse-Spark-Open-DFlash2
+    draft_sample: {value: null, source: default}
+    verify: {value: standard, source: documented}
+    adaptive: {value: false, source: documented}
+    topology: {value: chain, source: documented}
+    draft_precision: {value: null, source: default}
+    draft_kv_cache_dtype: {value: null, source: default}
+    kv_cache_dtype: {value: fp8, source: explicit}
+
+qwen3.5-397b-a17b-nvfp4__mtp__native__default-default:
+  select: {model_prefixes: [qwen3.5], method: mtp}
+  collection:
+    engine: vllm
+    draft: native
+    draft_sample: {value: null, source: default}
+    verify: {value: standard, source: documented}
+    adaptive: {value: false, source: documented}
+    topology: {value: chain, source: documented}
+    draft_precision: {value: null, source: default}
+    draft_kv_cache_dtype: {value: null, source: default}
+    kv_cache_dtype: {value: fp8, source: explicit}
+
+qwen3.8-flash-next-fp8__mtp__native__default-default:
+  select: {model_prefixes: [qwen3.8next], method: mtp}
+  collection:
+    engine: vllm
+    draft: native
+    draft_sample: {value: null, source: default}
+    verify: {value: standard, source: documented}
+    adaptive: {value: false, source: documented}
+    topology: {value: chain, source: documented}
+    draft_precision: {value: null, source: default}
+    draft_kv_cache_dtype: {value: null, source: default}
+    kv_cache_dtype: {value: null, source: default}
diff --git a/inferencex-e2e/infx/golden_al_distribution/identity.py b/inferencex-e2e/infx/golden_al_distribution/identity.py
new file mode 100644
index 0000000000..ca012e316f
--- /dev/null
+++ b/inferencex-e2e/infx/golden_al_distribution/identity.py
@@ -0,0 +1,285 @@
+"""Golden curve identities: which runs select a curve, how it was collected, and the audit.
+
+``identities.yaml`` gives every curve a ``select`` block, which ``select_curve`` matches against
+a run's speculative config, and a ``collection`` block, which ``compare`` checks a run against.
+The curve file name is derived from the identity (``canonical_name``).
+"""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Mapping
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from infx import yamlio
+
+IDENTITY_DIR = Path(__file__).resolve().parent
+IDENTITIES_STEM = "identities"
+SOURCES = ("explicit", "documented", "assumed", "default", "unknown")
+FACTS = (
+    "draft_sample", "verify", "adaptive", "topology",
+    "draft_precision", "draft_kv_cache_dtype", "kv_cache_dtype",
+)  # fmt: skip
+ENGINES = ("vllm", "sglang", "trtllm", "atom", "tilert")
+METHODS = ("mtp", "eagle3", "dspark", "dflash")
+DRAFT_FAMILIES = ("default", "gqa")
+SAMPLERS = ("greedy", "probabilistic")
+VERIFIERS = ("standard", "block", "relaxed")
+
+
+@dataclass(frozen=True)
+class Fact:
+    """A drafting or verification setting and how it is known; null when default or unknown."""
+
+    value: Any
+    source: str
+
+    def __post_init__(self) -> None:
+        if self.source not in SOURCES:
+            raise ValueError(f"Fact source {self.source!r} is not one of {', '.join(SOURCES)}")
+        if (self.value is None) != (self.source in ("default", "unknown")):
+            raise ValueError(
+                "A fact has a null value exactly when its source is default or unknown"
+            )
+
+    @property
+    def known(self) -> bool:
+        return self.value is not None
+
+    def render(self) -> str:
+        return self.source if not self.known else f"{self.value} ({self.source})"
+
+
+@dataclass(frozen=True)
+class Collection:
+    """How drafting and verification ran, for a curve's collection or for a launch."""
+
+    engine: str
+    draft: str
+    draft_sample: Fact
+    verify: Fact
+    adaptive: Fact
+    topology: Fact
+    draft_precision: Fact
+    draft_kv_cache_dtype: Fact
+    kv_cache_dtype: Fact
+
+
+@dataclass(frozen=True)
+class Selector:
+    """The runs that select a curve."""
+
+    model_prefixes: tuple[str, ...]
+    method: str
+    draft_family: str | None = None
+    draft_sample: str | None = None
+    verify: str | None = None
+
+    @property
+    def specificity(self) -> int:
+        return sum(key is not None for key in (self.draft_family, self.draft_sample, self.verify))
+
+
+@dataclass(frozen=True)
+class CurveIdentity:
+    name: str
+    select: Selector
+    collection: Collection
+    provisional: bool = False
+
+
+@dataclass(frozen=True)
+class Finding:
+    """One way a run differs from its curve's collection.
+
+    ``kind`` is ``mismatch`` (both values known and different), ``unverified`` (either side
+    is an engine default or unknown, and they are not the same engine's default),
+    ``adaptive`` (the run adapts verification, so no fixed-k curve applies), ``provisional``
+    (the curve was not measured for this model) or ``engine``.
+    """
+
+    kind: str
+    field: str
+    run: str
+    curve: str
+
+    def as_list(self) -> list[str]:
+        return [self.kind, self.field, self.run, self.curve]
+
+
+def normalize_method(model_prefix: str, method: str) -> str:
+    """The identity vocabulary's method for an engine's method name.
+
+    SGLang names a model-native MTP head EAGLE or NEXTN; MiniMax-M3's EAGLE head is EAGLE3.
+    """
+    method = method.lower()
+    if method in ("eagle", "nextn"):
+        return "eagle3" if model_prefix == "minimaxm3" else "mtp"
+    return method
+
+
+def draft_family(draft_model: str) -> str:
+    return "gqa" if "gqa" in draft_model.lower() else "default"
+
+
+def _slug(text: str) -> str:
+    return re.sub(r"[^a-z0-9.]+", "-", text.rsplit("/", 1)[-1].lower()).strip("-")
+
+
+def canonical_name(model: str, identity: CurveIdentity) -> str:
+    """``<model>__<method>__<draft>__<draft_sample>-<verify>``, "default" for unset settings."""
+    collection = identity.collection
+    parts = [
+        _slug(model),
+        identity.select.method,
+        _slug(collection.draft),
+        "-".join(
+            str(fact.value) if fact.source == "explicit" else "default"
+            for fact in (collection.draft_sample, collection.verify)
+        ),
+    ]
+    return "__".join(parts)
+
+
+def _fact(field: str, data: Any) -> Fact:
+    if not isinstance(data, Mapping) or set(data) != {"value", "source"}:
+        raise ValueError(f"{field} must be {{value, source}}")
+    return Fact(data["value"], data["source"])
+
+
+def parse_identity(name: str, data: Any) -> CurveIdentity:
+    """One curve's identity from ``identities.yaml``, or ValueError naming the curve."""
+    try:
+        if not isinstance(data, Mapping):
+            raise ValueError("an identity must be a mapping")
+        select, collection = data["select"], data["collection"]
+        prefixes = tuple(select["model_prefixes"])
+        selector = Selector(
+            model_prefixes=prefixes,
+            method=select["method"],
+            draft_family=select.get("draft_family"),
+            draft_sample=select.get("draft_sample"),
+            verify=select.get("verify"),
+        )
+        if not prefixes or selector.method not in METHODS:
+            raise ValueError("select needs model_prefixes and a known method")
+        if selector.draft_family not in (None, *DRAFT_FAMILIES):
+            raise ValueError(f"draft_family must be one of {', '.join(DRAFT_FAMILIES)}")
+        if selector.draft_sample not in (None, *SAMPLERS):
+            raise ValueError(f"select draft_sample must be one of {', '.join(SAMPLERS)}")
+        if selector.verify not in (None, *VERIFIERS):
+            raise ValueError(f"select verify must be one of {', '.join(VERIFIERS)}")
+        identity = CurveIdentity(
+            name=name,
+            select=selector,
+            collection=Collection(
+                engine=collection["engine"],
+                draft=collection["draft"],
+                **{field: _fact(field, collection[field]) for field in FACTS},
+            ),
+            provisional=data.get("provisional", False) is True,
+        )
+    except (KeyError, TypeError, ValueError) as error:
+        raise ValueError(f"Invalid identity of golden curve {name}: {error}") from error
+    if identity.collection.engine not in ENGINES:
+        raise ValueError(f"Identity of {name} names unknown engine {identity.collection.engine!r}")
+    return identity
+
+
+def load_identities(golden_dir: Path = IDENTITY_DIR) -> dict[str, CurveIdentity]:
+    """Every curve identity in ``golden_dir``'s ``identities.yaml``, by curve name."""
+    path = golden_dir / f"{IDENTITIES_STEM}.yaml"
+    if not path.is_file():
+        raise ValueError(f"No committed golden curve identities {path.name} in {golden_dir}")
+    data = yamlio.safe_load(path.read_text())
+    if not isinstance(data, Mapping):
+        raise ValueError(f"{IDENTITIES_STEM}.yaml must map curve names to identities")
+    return {str(name): parse_identity(str(name), value) for name, value in data.items()}
+
+
+def _selects(
+    selector: Selector, model_prefix: str, spec: Mapping[str, Any], verify: str | None
+) -> bool:
+    if model_prefix not in selector.model_prefixes:
+        return False
+    if normalize_method(model_prefix, str(spec.get("method", ""))) != selector.method:
+        return False
+    if selector.draft_family and draft_family(str(spec.get("model", ""))) != selector.draft_family:
+        return False
+    if selector.verify and verify != selector.verify:
+        return False
+    return not selector.draft_sample or spec.get("draft_sample_method") == selector.draft_sample
+
+
+def select_curve(
+    model_prefix: str,
+    spec: Mapping[str, Any],
+    golden_dir: Path = IDENTITY_DIR,
+    verify: str | None = None,
+) -> str:
+    """The most specific curve whose ``select`` block matches, or ValueError.
+
+    ``verify`` is the run's verifier, None when unknown; an unknown verifier matches only
+    curves that do not select on it. Ties for the most specific match are an error.
+    """
+    identities = load_identities(golden_dir).values()
+    matches = [i for i in identities if _selects(i.select, model_prefix, spec, verify)]
+    if matches:
+        best = max(i.select.specificity for i in matches)
+        names = [i.name for i in matches if i.select.specificity == best]
+        if len(names) == 1:
+            return names[0]
+        method = normalize_method(model_prefix, str(spec.get("method", "")))
+        raise ValueError(f"{model_prefix} {method} matches several golden curves: {names}")
+    method = normalize_method(model_prefix, str(spec.get("method", "")))
+    near = [
+        i.select
+        for i in identities
+        if model_prefix in i.select.model_prefixes and i.select.method == method
+    ]
+    if near:
+        options = "; ".join(
+            ", ".join(
+                f"{key}={value}"
+                for key, value in (
+                    ("draft_family", s.draft_family),
+                    ("draft_sample", s.draft_sample),
+                    ("verify", s.verify),
+                )
+                if value
+            )
+            for s in near
+        )
+        raise ValueError(
+            f"No {model_prefix} {method} golden curve for draft model "
+            f"{spec.get('model')!r}, draft sampling {spec.get('draft_sample_method')!r} and "
+            f"verify {verify!r}; curves need {options}"
+        )
+    raise ValueError(f"No golden curve for model prefix {model_prefix!r} and method {method!r}")
+
+
+def compare(run: Collection, curve: CurveIdentity) -> list[Finding]:
+    """Where ``run`` differs from ``curve``'s collection, in field order."""
+    theirs_all = curve.collection
+    same_engine = run.engine == theirs_all.engine
+    findings = []
+    if run.adaptive.value is True:
+        findings.append(
+            Finding("adaptive", "adaptive", run.adaptive.render(), theirs_all.adaptive.render())
+        )
+    for field in FACTS:
+        mine, theirs = getattr(run, field), getattr(theirs_all, field)
+        if field == "adaptive" and mine.value is True:
+            continue
+        if mine.known and theirs.known:
+            if mine.value != theirs.value:
+                findings.append(Finding("mismatch", field, mine.render(), theirs.render()))
+        elif not (same_engine and mine.source == theirs.source == "default"):
+            findings.append(Finding("unverified", field, mine.render(), theirs.render()))
+    if curve.provisional:
+        findings.append(Finding("provisional", "values", "-", "not measured for this model"))
+    if not same_engine:
+        findings.append(Finding("engine", "engine", run.engine, theirs_all.engine))
+    return findings
diff --git a/inferencex-e2e/infx/golden_al_distribution/kimi-k3.1-pro__dflash__kimi-k3.1-dflash2-preview__default-block.yaml b/inferencex-e2e/infx/golden_al_distribution/kimi-k3.1-pro__dflash__kimi-k3.1-dflash2-preview__default-block.yaml
new file mode 100644
index 0000000000..d5e1107a32
--- /dev/null
+++ b/inferencex-e2e/infx/golden_al_distribution/kimi-k3.1-pro__dflash__kimi-k3.1-dflash2-preview__default-block.yaml
@@ -0,0 +1,28 @@
+source_run: https://github.com/SemiAnalysisAI/InferenceX/actions/runs/41913266143
+# Acceptance Length (AL) reference values measured with SPEED-Bench.
+# dataset: coding | top_p: 0.95 | output_len: 4096
+# thinking_on: temperature=1.0, chat_template_kwargs: {"thinking": true}
+# speculative: DFLASH, draft RadixArk/Kimi-K3.1-Dflash2-Preview, block verification
+# Measured on kimi-k3.1-pro (NVIDIA B300 SXM6 AC, SGLang DFLASH), per num_speculative_tokens.
+# Auto-generated by benchmarks/single_node/speedbench/kimik3.1_fp4_b300_sglang.sh (speedbench-al.yml).
+#
+# key = num_speculative_tokens (DFLASH draft tokens); value = golden AL
+kimi-k3.1-pro:
+  thinking_on:
+    1: 1.83
+    2: 2.45
+    3: 2.90
+    4: 3.25
+    5: 3.43
+    6: 3.57
+    7: 3.68
+    8: 3.81
+
+# SPEED-Bench client settings of this collection; the acceptance-length gate replays them
+# (README.md#collection-settings).
+collection:
+  renderer: chat_template
+  modes:
+    thinking_on:
+      chat_template_kwargs: {thinking: true}
+      sampling: {temperature: 1.0, top_p: 0.95, repetition_penalty: 1.0}
diff --git a/inferencex-e2e/infx/golden_al_distribution/kimi-k3.1-pro__dspark__kimi-k3.1-pro-dspark-preview__probabilistic-block.yaml b/inferencex-e2e/infx/golden_al_distribution/kimi-k3.1-pro__dspark__kimi-k3.1-pro-dspark-preview__probabilistic-block.yaml
new file mode 100644
index 0000000000..9abe170c1a
--- /dev/null
+++ b/inferencex-e2e/infx/golden_al_distribution/kimi-k3.1-pro__dspark__kimi-k3.1-pro-dspark-preview__probabilistic-block.yaml
@@ -0,0 +1,28 @@
+source_run: https://github.com/SemiAnalysisAI/InferenceX/actions/runs/41871192206
+# Acceptance Length (AL) reference values measured with SPEED-Bench.
+# dataset: coding | top_p: 0.95 | output_len: 4096
+# thinking_on: temperature=1.0, chat_template_kwargs: {"thinking": true}
+# speculative-config: draft_sample_method=probabilistic | rejection_sample_method=block
+# Measured on kimi-k3.1-pro (B300, vLLM DSpark, draft: Inferact/Kimi-K3.1-Pro-DSpark-preview), per num_speculative_tokens.
+# Auto-generated by benchmarks/single_node/speedbench/kimik3.1_fp4_b300_vllm_probabilistic_sample_method_block_rejection_sample_method.sh (speedbench-al.yml).
+#
+# key = num_speculative_tokens (DSpark level); value = golden AL
+kimi-k3.1-pro:
+  thinking_on:
+    1: 1.79
+    2: 2.33
+    3: 2.70
+    4: 2.92
+    5: 3.08
+    6: 3.14
+    7: 3.21
+    8: 3.33
+
+# SPEED-Bench client settings of this collection; the acceptance-length gate replays them
+# (README.md#collection-settings).
+collection:
+  renderer: chat_template
+  modes:
+    thinking_on:
+      chat_template_kwargs: {thinking: true}
+      sampling: {temperature: 1.0, top_p: 0.95, repetition_penalty: 1.0}
diff --git a/inferencex-e2e/infx/golden_al_distribution/kimik3_dspark.yaml b/inferencex-e2e/infx/golden_al_distribution/kimi-k3__dspark__kimi-k3-dspark__default-default.yaml
similarity index 59%
rename from inferencex-e2e/infx/golden_al_distribution/kimik3_dspark.yaml
rename to inferencex-e2e/infx/golden_al_distribution/kimi-k3__dspark__kimi-k3-dspark__default-default.yaml
index 1ad725b921..a76afa6d4f 100644
--- a/inferencex-e2e/infx/golden_al_distribution/kimik3_dspark.yaml
+++ b/inferencex-e2e/infx/golden_al_distribution/kimi-k3__dspark__kimi-k3-dspark__default-default.yaml
@@ -1,4 +1,4 @@
-# Source GitHub Actions run: https://github.com/SemiAnalysisAI/InferenceX/actions/runs/30304797750
+source_run: https://github.com/SemiAnalysisAI/InferenceX/actions/runs/30304797750
 # Acceptance Length (AL) reference values measured with SPEED-Bench.
 # dataset: coding | top_p: 0.95 | output_len: 4096
 # thinking_on: temperature=1.0, chat_template_kwargs: {"thinking": true}
@@ -16,3 +16,12 @@ kimi-k3:
     6: 3.54
     7: 3.78
     8: 3.88
+
+# SPEED-Bench client settings of this collection; the acceptance-length gate replays them
+# (README.md#collection-settings).
+collection:
+  renderer: chat_template
+  modes:
+    thinking_on:
+      chat_template_kwargs: {thinking: true}
+      sampling: {temperature: 1.0, top_p: 0.95, repetition_penalty: 1.0}
diff --git a/inferencex-e2e/infx/golden_al_distribution/kimik3_dspark_probabilistic_sample_method_block_rejection_sample_method.yaml b/inferencex-e2e/infx/golden_al_distribution/kimi-k3__dspark__kimi-k3-dspark__probabilistic-block.yaml
similarity index 65%
rename from inferencex-e2e/infx/golden_al_distribution/kimik3_dspark_probabilistic_sample_method_block_rejection_sample_method.yaml
rename to inferencex-e2e/infx/golden_al_distribution/kimi-k3__dspark__kimi-k3-dspark__probabilistic-block.yaml
index b27aeed0ea..ea3eaaef84 100644
--- a/inferencex-e2e/infx/golden_al_distribution/kimik3_dspark_probabilistic_sample_method_block_rejection_sample_method.yaml
+++ b/inferencex-e2e/infx/golden_al_distribution/kimi-k3__dspark__kimi-k3-dspark__probabilistic-block.yaml
@@ -1,4 +1,4 @@
-# Source GitHub Actions run: https://github.com/SemiAnalysisAI/InferenceX/actions/runs/30316471205
+source_run: https://github.com/SemiAnalysisAI/InferenceX/actions/runs/30316471205
 # Acceptance Length (AL) reference values measured with SPEED-Bench.
 # dataset: coding | top_p: 0.95 | output_len: 4096
 # thinking_on: temperature=1.0, chat_template_kwargs: {"thinking": true}
@@ -17,3 +17,12 @@ kimi-k3:
     6: 3.75
     7: 3.84
     8: 4.00
+
+# SPEED-Bench client settings of this collection; the acceptance-length gate replays them
+# (README.md#collection-settings).
+collection:
+  renderer: chat_template
+  modes:
+    thinking_on:
+      chat_template_kwargs: {thinking: true}
+      sampling: {temperature: 1.0, top_p: 0.95, repetition_penalty: 1.0}
diff --git a/inferencex-e2e/infx/golden_al_distribution/kimi-k3__dspark__kimi-k3-dspark__probabilistic-default.yaml b/inferencex-e2e/infx/golden_al_distribution/kimi-k3__dspark__kimi-k3-dspark__probabilistic-default.yaml
new file mode 100644
index 0000000000..cbbb975cdf
--- /dev/null
+++ b/inferencex-e2e/infx/golden_al_distribution/kimi-k3__dspark__kimi-k3-dspark__probabilistic-default.yaml
@@ -0,0 +1,41 @@
+source_run: https://github.com/SemiAnalysisAI/InferenceX/actions/runs/41121033716
+# Acceptance Length (AL) reference values measured with SPEED-Bench.
+# dataset: coding | top_p: 0.95 | output_len: 4096
+# thinking_on: temperature=1.0, chat_template_kwargs: {"thinking": true}
+# thinking_off: temperature=0.6, chat_template_kwargs: {"thinking": false}
+# Measured on kimi-k3 (B300, vLLM DSpark, draft: Inferact/Kimi-K3-DSpark), per num_speculative_tokens.
+# speculative-config extras: {"draft_sample_method": "probabilistic"}
+# Auto-generated by benchmarks/single_node/speedbench/kimik3_fp4_b300_vllm_probabilistic_sample_method.sh (speedbench-al.yml).
+#
+# key = num_speculative_tokens (DSpark level); value = golden AL
+kimi-k3:
+  thinking_on:
+    1: 1.86
+    2: 2.48
+    3: 2.96
+    4: 3.24
+    5: 3.53
+    6: 3.69
+    7: 3.84
+    8: 3.98
+  thinking_off:
+    1: 1.89
+    2: 2.62
+    3: 3.10
+    4: 3.41
+    5: 3.92
+    6: 4.07
+    7: 4.22
+    8: 4.62
+
+# SPEED-Bench client settings of this collection; the acceptance-length gate replays them
+# (README.md#collection-settings).
+collection:
+  renderer: chat_template
+  modes:
+    thinking_on:
+      chat_template_kwargs: {thinking: true}
+      sampling: {temperature: 1.0, top_p: 0.95, repetition_penalty: 1.0}
+    thinking_off:
+      chat_template_kwargs: {thinking: false}
+      sampling: {temperature: 0.6, top_p: 0.95, repetition_penalty: 1.0}
diff --git a/inferencex-e2e/infx/golden_al_distribution/minimaxm31flash_dspark.yaml b/inferencex-e2e/infx/golden_al_distribution/minimax-m3.1-flash__dspark__native__probabilistic-block.yaml
similarity index 71%
rename from inferencex-e2e/infx/golden_al_distribution/minimaxm31flash_dspark.yaml
rename to inferencex-e2e/infx/golden_al_distribution/minimax-m3.1-flash__dspark__native__probabilistic-block.yaml
index 3b88fc4041..cd981757ff 100644
--- a/inferencex-e2e/infx/golden_al_distribution/minimaxm31flash_dspark.yaml
+++ b/inferencex-e2e/infx/golden_al_distribution/minimax-m3.1-flash__dspark__native__probabilistic-block.yaml
@@ -1,4 +1,4 @@
-# Source GitHub Actions run: https://github.com/SemiAnalysisAI/InferenceX/actions/runs/39895397914
+source_run: https://github.com/SemiAnalysisAI/InferenceX/actions/runs/39895397914
 # Acceptance Length (AL) reference values measured with SPEED-Bench.
 # dataset: coding | top_p: 0.95 | output_len: 4096
 # thinking_on (adaptive): temperature=1.0, chat_template_kwargs: {}
@@ -15,3 +15,10 @@ minimax-m3.1-flash:
     5: 3.46
     6: 3.81
     7: 4.04
+
+collection:
+  renderer: chat_template
+  modes:
+    thinking_on:
+      chat_template_kwargs: null
+      sampling: {temperature: 1.0, top_p: 0.95, repetition_penalty: 1.0}
diff --git a/inferencex-e2e/infx/golden_al_distribution/minimax-m3__eagle3__minimax-m3-eagle3-gqa__default-block.yaml b/inferencex-e2e/infx/golden_al_distribution/minimax-m3__eagle3__minimax-m3-eagle3-gqa__default-block.yaml
new file mode 100644
index 0000000000..bdf1301824
--- /dev/null
+++ b/inferencex-e2e/infx/golden_al_distribution/minimax-m3__eagle3__minimax-m3-eagle3-gqa__default-block.yaml
@@ -0,0 +1,42 @@
+source_run: https://github.com/SemiAnalysisAI/InferenceX/actions/runs/41121037354
+# Acceptance Length (AL) reference values measured with SPEED-Bench.
+# dataset: coding | temperature: 1.0 | top_p: 0.95 | top_k: 40 | output_len: 4096
+# thinking_on chat_template_kwargs: {"thinking_mode": "enabled"}
+# thinking_off chat_template_kwargs: {"thinking_mode": "disabled"}
+# Measured on minimax-m3 (B300, vLLM EAGLE3), per num_speculative_tokens.
+# draft: Inferact/MiniMax-M3-EAGLE3-GQA
+# speculative-config extras: {"rejection_sample_method": "block"}
+# Auto-generated by benchmarks/single_node/speedbench/minimaxm3_fp4_b300_vllm_gqa_block_rejection_sample_method.sh (speedbench-al.yml).
+#
+# key = num_speculative_tokens (EAGLE3 level); value = golden AL
+minimax-m3:
+  thinking_on:
+    1: 1.79
+    2: 2.37
+    3: 2.76
+    4: 3.01
+    5: 3.20
+    6: 3.36
+    7: 3.52
+    8: 3.51
+  thinking_off:
+    1: 1.83
+    2: 2.44
+    3: 2.93
+    4: 3.25
+    5: 3.55
+    6: 3.66
+    7: 3.78
+    8: 3.89
+
+# SPEED-Bench client settings of this collection; the acceptance-length gate replays them
+# (README.md#collection-settings).
+collection:
+  renderer: chat_template
+  modes:
+    thinking_on:
+      chat_template_kwargs: {thinking_mode: enabled}
+      sampling: {temperature: 1.0, top_p: 0.95, top_k: 40, repetition_penalty: 1.0}
+    thinking_off:
+      chat_template_kwargs: {thinking_mode: disabled}
+      sampling: {temperature: 1.0, top_p: 0.95, top_k: 40, repetition_penalty: 1.0}
diff --git a/inferencex-e2e/infx/golden_al_distribution/minimaxm3_eagle3_gqa.yaml b/inferencex-e2e/infx/golden_al_distribution/minimax-m3__eagle3__minimax-m3-eagle3-gqa__default-default.yaml
similarity index 57%
rename from inferencex-e2e/infx/golden_al_distribution/minimaxm3_eagle3_gqa.yaml
rename to inferencex-e2e/infx/golden_al_distribution/minimax-m3__eagle3__minimax-m3-eagle3-gqa__default-default.yaml
index a8337088bf..68f4886095 100644
--- a/inferencex-e2e/infx/golden_al_distribution/minimaxm3_eagle3_gqa.yaml
+++ b/inferencex-e2e/infx/golden_al_distribution/minimax-m3__eagle3__minimax-m3-eagle3-gqa__default-default.yaml
@@ -1,4 +1,4 @@
-# Source GitHub Actions run: https://github.com/SemiAnalysisAI/InferenceX/actions/runs/29784780049
+source_run: https://github.com/SemiAnalysisAI/InferenceX/actions/runs/29784780049
 # Acceptance Length (AL) reference values measured with SPEED-Bench.
 # dataset: coding | temperature: 1.0 | top_p: 0.95 | top_k: 40 | output_len: 4096
 # thinking_on chat_template_kwargs: {"thinking_mode": "enabled"}
@@ -26,3 +26,15 @@ minimax-m3:
     6: 3.76
     7: 3.75
     8: 3.93
+
+# SPEED-Bench client settings of this collection; the acceptance-length gate replays them
+# (README.md#collection-settings).
+collection:
+  renderer: chat_template
+  modes:
+    thinking_on:
+      chat_template_kwargs: {thinking_mode: enabled}
+      sampling: {temperature: 1.0, top_p: 0.95, top_k: 40, repetition_penalty: 1.0}
+    thinking_off:
+      chat_template_kwargs: {thinking_mode: disabled}
+      sampling: {temperature: 1.0, top_p: 0.95, top_k: 40, repetition_penalty: 1.0}
diff --git a/inferencex-e2e/infx/golden_al_distribution/minimaxm3_eagle3.yaml b/inferencex-e2e/infx/golden_al_distribution/minimax-m3__eagle3__minimax-m3-eagle3__default-default.yaml
similarity index 57%
rename from inferencex-e2e/infx/golden_al_distribution/minimaxm3_eagle3.yaml
rename to inferencex-e2e/infx/golden_al_distribution/minimax-m3__eagle3__minimax-m3-eagle3__default-default.yaml
index 51de516678..4573c3cea0 100644
--- a/inferencex-e2e/infx/golden_al_distribution/minimaxm3_eagle3.yaml
+++ b/inferencex-e2e/infx/golden_al_distribution/minimax-m3__eagle3__minimax-m3-eagle3__default-default.yaml
@@ -1,4 +1,4 @@
-# Source GitHub Actions run: https://github.com/SemiAnalysisAI/InferenceX/actions/runs/28061204145
+source_run: https://github.com/SemiAnalysisAI/InferenceX/actions/runs/28061204145
 # Acceptance Length (AL) reference values measured with SPEED-Bench.
 # dataset: coding | temperature: 1.0 | top_p: 0.95 | top_k: 40 | output_len: 4096
 # thinking_on chat_template_kwargs: {"thinking_mode": "enabled"}
@@ -26,3 +26,15 @@ minimax-m3:
     6: 3.57
     7: 3.85
     8: 4.06
+
+# SPEED-Bench client settings of this collection; the acceptance-length gate replays them
+# (README.md#collection-settings).
+collection:
+  renderer: chat_template
+  modes:
+    thinking_on:
+      chat_template_kwargs: {thinking_mode: enabled}
+      sampling: {temperature: 1.0, top_p: 0.95, top_k: 40, repetition_penalty: 1.0}
+    thinking_off:
+      chat_template_kwargs: {thinking_mode: disabled}
+      sampling: {temperature: 1.0, top_p: 0.95, top_k: 40, repetition_penalty: 1.0}
diff --git a/inferencex-e2e/infx/golden_al_distribution/musespark_dflash.yaml b/inferencex-e2e/infx/golden_al_distribution/muse-spark-open-816b-a42b-nvfp4__dflash__muse-spark-open-dflash2__default-default.yaml
similarity index 74%
rename from inferencex-e2e/infx/golden_al_distribution/musespark_dflash.yaml
rename to inferencex-e2e/infx/golden_al_distribution/muse-spark-open-816b-a42b-nvfp4__dflash__muse-spark-open-dflash2__default-default.yaml
index 0668f4de8e..10b7a3ad1e 100644
--- a/inferencex-e2e/infx/golden_al_distribution/musespark_dflash.yaml
+++ b/inferencex-e2e/infx/golden_al_distribution/muse-spark-open-816b-a42b-nvfp4__dflash__muse-spark-open-dflash2__default-default.yaml
@@ -1,4 +1,4 @@
-# Source GitHub Actions run: https://github.com/SemiAnalysisAI/InferenceX/actions/runs/38808046215
+source_run: https://github.com/SemiAnalysisAI/InferenceX/actions/runs/38808046215
 # Acceptance Length (AL) reference values measured with SPEED-Bench.
 # dataset: coding | temperature: 1.0 | top_p: 0.95 | output_len: 4096
 # thinking_on: chat template default (reasoning_effort xhigh)
@@ -16,3 +16,10 @@ muse-spark-open-816b-a42b-nvfp4:
     5: 3.70
     6: 3.93
     7: 4.05
+
+collection:
+  renderer: chat_template
+  modes:
+    thinking_on:
+      chat_template_kwargs: null
+      sampling: {temperature: 1.0, top_p: 0.95}
diff --git a/inferencex-e2e/infx/golden_al_distribution/qwen3.5_mtp.yaml b/inferencex-e2e/infx/golden_al_distribution/qwen3.5-397b-a17b-nvfp4__mtp__native__default-default.yaml
similarity index 57%
rename from inferencex-e2e/infx/golden_al_distribution/qwen3.5_mtp.yaml
rename to inferencex-e2e/infx/golden_al_distribution/qwen3.5-397b-a17b-nvfp4__mtp__native__default-default.yaml
index f179693046..ceb6bed190 100644
--- a/inferencex-e2e/infx/golden_al_distribution/qwen3.5_mtp.yaml
+++ b/inferencex-e2e/infx/golden_al_distribution/qwen3.5-397b-a17b-nvfp4__mtp__native__default-default.yaml
@@ -1,4 +1,4 @@
-# Source GitHub Actions run: https://github.com/SemiAnalysisAI/InferenceX/actions/runs/27317114007
+source_run: https://github.com/SemiAnalysisAI/InferenceX/actions/runs/27317114007
 # Acceptance Length (AL) reference values measured with SPEED-Bench.
 # dataset: coding | output_len: 4096
 # thinking_on : temp 0.6 top_p 0.95 top_k 20 presence_penalty 0.0 | chat_template_kwargs: {"enable_thinking": true}
@@ -26,3 +26,15 @@ qwen3.5-397b-a17b-nvfp4:
     6: 4.48
     7: 4.73
     8: 4.71
+
+# SPEED-Bench client settings of this collection; the acceptance-length gate replays them
+# (README.md#collection-settings).
+collection:
+  renderer: chat_template
+  modes:
+    thinking_on:
+      chat_template_kwargs: {enable_thinking: true}
+      sampling: {temperature: 0.6, top_p: 0.95, top_k: 20, presence_penalty: 0.0, repetition_penalty: 1.0}
+    thinking_off:
+      chat_template_kwargs: {enable_thinking: false}
+      sampling: {temperature: 0.7, top_p: 0.8, top_k: 20, presence_penalty: 1.5, repetition_penalty: 1.0}
diff --git a/inferencex-e2e/infx/golden_al_distribution/qwen3.8next_mtp.yaml b/inferencex-e2e/infx/golden_al_distribution/qwen3.8-flash-next-fp8__mtp__native__default-default.yaml
similarity index 62%
rename from inferencex-e2e/infx/golden_al_distribution/qwen3.8next_mtp.yaml
rename to inferencex-e2e/infx/golden_al_distribution/qwen3.8-flash-next-fp8__mtp__native__default-default.yaml
index 46800f97e0..b1d887be56 100644
--- a/inferencex-e2e/infx/golden_al_distribution/qwen3.8next_mtp.yaml
+++ b/inferencex-e2e/infx/golden_al_distribution/qwen3.8-flash-next-fp8__mtp__native__default-default.yaml
@@ -1,4 +1,4 @@
-# Source GitHub Actions run: https://github.com/SemiAnalysisAI/InferenceX/actions/runs/33034290269
+source_run: https://github.com/SemiAnalysisAI/InferenceX/actions/runs/33034290269
 # Acceptance Length (AL) reference values measured with SPEED-Bench.
 # dataset: coding | output_len: 4096
 # thinking_on : temp 1.0 top_p 0.95 top_k 20 presence_penalty 0.0 | chat_template_kwargs: {"enable_thinking": true}
@@ -15,3 +15,12 @@ qwen3.8-flash-next-fp8:
     4: 2.47
     5: 2.59
     6: 2.66
+
+# SPEED-Bench client settings of this collection; the acceptance-length gate replays them
+# (README.md#collection-settings).
+collection:
+  renderer: chat_template
+  modes:
+    thinking_on:
+      chat_template_kwargs: {enable_thinking: true}
+      sampling: {temperature: 1.0, top_p: 0.95, top_k: 20, presence_penalty: 0.0, repetition_penalty: 1.0}
diff --git a/inferencex-e2e/infx/launch/artifacts.py b/inferencex-e2e/infx/launch/artifacts.py
index 9579d005e9..acde0136fe 100644
--- a/inferencex-e2e/infx/launch/artifacts.py
+++ b/inferencex-e2e/infx/launch/artifacts.py
@@ -129,6 +129,20 @@ def copy_agentic_results(source_dir: Path, workspace: Path, result_filename: str
     _say(f"Copied {len(files)} agentic result file(s)")
 
 
+def copy_al_gate_result(logs_dir: Path, workspace: Path, result_filename: str) -> None:
+    """Copy an eval's acceptance gate verdict when the job ran one; a failed copy only warns.
+
+    Its raw replay files stay in the server logs.
+    """
+    verdict = logs_dir / f"al_gate_{result_filename}.json"
+    if not verdict.is_file():
+        return
+    try:
+        copy_to_workspace(verdict, workspace / verdict.name)
+    except ArtifactError as error:
+        _warn(f"WARNING: {error}")
+
+
 def copy_eval_artifacts(eval_dir: Path, workspace: Path) -> None:
     """Copy every top-level file of ``eval_dir``; a missing directory only warns."""
     if not eval_dir.is_dir():
@@ -160,6 +174,8 @@ def collect_agentic_power_results(
     concurrencies: Sequence[int],
     *,
     results_python: str | None,
+    require_power: bool = True,
+    expected_cpu: bool = False,
 ) -> int:
     """Stage the AgentX power audit inputs and validate each concurrency's power window.
 
@@ -182,7 +198,7 @@ def collect_agentic_power_results(
 
     if step := validate_agentic_power(
         logs_dir, workspace, result_filename, producer_sha, concurrencies,
-        results_python=results_python, require_power=True,
+        results_python=results_python, require_power=require_power, expected_cpu=expected_cpu,
     ):  # fmt: skip
         rc = step
     return rc
@@ -197,10 +213,12 @@ def validate_agentic_power(
     *,
     results_python: str | None,
     require_power: bool,
+    expected_cpu: bool = False,
 ) -> int:
     """Run the AgentX power adapter for every concurrency; return the last failing code.
 
-    With ``require_power`` a concurrency without a valid power window fails.
+    With ``require_power`` a concurrency without a valid power window fails, and with
+    ``expected_cpu`` one without a valid Grace CPU leg fails too.
     """
     logs_dir = logs_dir.resolve()
     workspace = workspace.resolve()
@@ -214,7 +232,10 @@ def validate_agentic_power(
             results_python, workspace, logs_dir,
             logs_dir / "agentic" / f"conc_{concurrency}",
             workspace / f"{result_filename}_conc{concurrency}.json",
-            producer_sha, require_power=require_power,
+            producer_sha,
+            "--audit-source", f"LOGS/agentic/conc_{concurrency}/power_validation.json",
+            *(["--expected-cpu-power"] if expected_cpu else []),
+            require_power=require_power,
         ):  # fmt: skip
             rc = step
     return rc
diff --git a/inferencex-e2e/infx/launch/drivers/srt/__init__.py b/inferencex-e2e/infx/launch/drivers/srt/__init__.py
index 1b0a3b0a96..4ddf4036af 100644
--- a/inferencex-e2e/infx/launch/drivers/srt/__init__.py
+++ b/inferencex-e2e/infx/launch/drivers/srt/__init__.py
@@ -17,6 +17,7 @@
 from typing import TYPE_CHECKING
 
 from infx.clusters.slurm import SlurmSettings
+from infx.config import repository_root
 from infx.launch import policy
 from infx.launch.backends.base import BackendError
 from infx.launch.backends.slurm import srtctl_job_name
@@ -42,7 +43,7 @@
     RequestError,
     SingleNodeRequest,
 )
-from infx.srt_slurm.workload import BOUND_RECIPE
+from infx.srt_slurm.workload import BOUND_RECIPE, selects_dedicated_discovery
 
 if TYPE_CHECKING:
     from infx.clusters import Cluster
@@ -69,12 +70,16 @@ def run_single_node(launch: Launch) -> int:
             step_mib, job_mib = None, 0
         if (options := config.srun_options(run.backend.settings, step_mib)) is not None:
             run.env["SRT_SRUN_OPTIONS"] = options
-        if rc := submit.bind_point(run, checkout, root / "arguments"):
+        native_power = not request.eval_only
+        cpu_source = config.cpu_power_source(
+            run.cluster, run.srt, native_power and request.cpu_power, default=native_power
+        )
+        if rc := submit.bind_point(run, checkout, root / "arguments", cpu_source):
             return rc
         selected, bound, runtime_args = submit.bound_arguments(root / "arguments")
         event.set(recipe=selected.removeprefix(f"{run.workspace}/"))
         containers = {}
-        if not request.eval_only:
+        if native_power:
             image, reference = config.stage_gpu_exporter(run, single_node=True)
             containers[image] = reference
         job_config = config.SrtJob(
@@ -90,15 +95,17 @@ def run_single_node(launch: Launch) -> int:
             single_node=True,
             account=run.account,
             mem_mib=job_mib,
+            cpu_power_source=cpu_source,
         )
         config.create_volume_mounts(run)
         config.write(checkout.root / "srtslurm.yaml", config.render(run.cluster, job_config))
-        if rc := run_setup(run, checkout):
+        if rc := run_setup(run, checkout, cpu_power_exporter=cpu_source is not None):
             return rc
 
     fetched = root / "fetched-outputs"
     submitted = submit.Submitted(manifest=run.workspace / submit.SINGLE_NODE_SUBMISSION)
     run.life.callback(collect.finish_single_node, run, submitted, fetched)
+    submit.request_al_gate(run)
     eval_args = submit.eval_args(run.env, submit.SINGLE_NODE_EVAL_COMMAND)
     arguments = ["--json", "--yes", "--output", str(root / "outputs"), *runtime_args, *eval_args]
     applied = submit.apply(run, checkout, bound, arguments, stdout=submitted.manifest)
@@ -113,7 +120,7 @@ def run_single_node(launch: Launch) -> int:
     status = run.backend.state(job)
     with event.stage("collect"):
         logs = run.backend.fetch_outputs(job, fetched) / "logs"
-        if not request.eval_only:
+        if native_power:
             (logs / "power").mkdir(parents=True, exist_ok=True)
             (logs / "power/native-job-status.txt").write_text(f"{job.id}|{status.raw}\n")
         rc = collect.finalize_single_node_results(run, logs, checkout.commit)
@@ -168,14 +175,23 @@ def run_multinode(launch: Launch) -> int:
         staged = staged_recipe(srt_recipe)
         if not recipe_mirror_path(request.workspace, srt_recipe).is_file():
             raise LaunchError(f"{srt_recipe} is not in the recipe mirror")
-        decision = power.decide_power(launch.cluster.id, launch.path, request)
-        event.set(power=asdict(decision))
-        if not request.eval_only and (decision.agentx or decision.adapter):
-            require(request, "INFERENCEX_RESULTS_PYTHON")
+        mirrored = str(request.workspace / srt_recipe)
         model = models.checkpoint(launch.cluster, request)
         served = models.served_path(launch.cluster, request, model)
         model_paths = models.model_paths(launch.cluster, request, served)
         run = SrtRun.create(launch, request, models.job_env(launch.cluster, request, served))
+        decision = power.decide_power(
+            launch.cluster.id,
+            launch.path,
+            run.srt,
+            request,
+            lambda: selects_dedicated_discovery(
+                mirrored, agentic=request.is_agentic, root=repository_root()
+            ),
+        )
+        event.set(power=asdict(decision))
+        if not request.eval_only and (decision.agentx or decision.adapter):
+            require(request, "INFERENCEX_RESULTS_PYTHON")
         preflight = run.srt.preflight and not (model_paths and model and model.node_local)
         if request.framework == "tilert":
             require(request, "PREFILL_IMAGE")
@@ -188,16 +204,21 @@ def run_multinode(launch: Launch) -> int:
         )
         install_srtctl(run, checkout, python=system_python)
         config.write_lane_config(run, lane, checkout, decision, model_paths)
-        if rc := run_setup(run, checkout):
+        if rc := run_setup(run, checkout, cpu_power_exporter=decision.cpu):
             return rc
         infmax = compute_workspace(run, checkout, shared=shared)
         run.env["INFMAX_WORKSPACE"] = str(infmax)
 
         recipe = str(checkout.root / BOUND_RECIPE)
-        power_port, client_env = config.binder_inputs(run.cluster, run.srt, lane, request, decision)
-        if rc := submit.bind_recipe(run, checkout, staged, recipe, power_port, client_env):
+        gpu_power, cpu_source, client_env = config.binder_inputs(
+            run.cluster, run.srt, lane, request, decision
+        )
+        if rc := submit.bind_recipe(
+            run, checkout, staged, recipe, gpu_power, cpu_source, client_env
+        ):
             return rc
         prepare_recipe(Path(recipe), srtctl_job_name(request.runner_name), run.srt.dist_timeout_s)
+        submit.request_al_gate(run)
         arguments = submit.multinode_arguments(run, lane, recipe, overrides, preflight=preflight)
         manifest = run.workspace / submit.MULTINODE_SUBMISSION
         submitted = submit.Submitted(manifest=manifest)
@@ -249,8 +270,8 @@ def volume(where: str, cluster_id: str, name: str) -> None:
             continue
         if (cluster_id, path) not in lanes.SRT_LANES:
             problems.append(f"{where}: no SRT_LANES row")
-        elif (srt := _srt_settings(clusters.get(cluster_id))) and srt.power_exporter_port is None:
-            problems.append(f"{where}: no srt-slurm.power-exporter-port")
+        elif (srt := _srt_settings(clusters.get(cluster_id))) and srt.gpu_exporter_image is None:
+            problems.append(f"{where}: no srt-slurm.extra.default_gpu_exporter")
     for cluster_id, overrides in models.OVERRIDES.items():
         if scoped(cluster_id) and profile("OVERRIDES", cluster_id) is not None:
             entries = clusters[cluster_id].models.entries
diff --git a/inferencex-e2e/infx/launch/drivers/srt/checkout.py b/inferencex-e2e/infx/launch/drivers/srt/checkout.py
index 49e0a5e537..7d58f3d350 100644
--- a/inferencex-e2e/infx/launch/drivers/srt/checkout.py
+++ b/inferencex-e2e/infx/launch/drivers/srt/checkout.py
@@ -21,6 +21,9 @@
 from infx.launch.drivers.srt.run import SrtRun, require
 
 SUBMODULE = Path("utils/srt-slurm")
+# The cpu-power-exporter release asset ``make setup`` installs for a job that scrapes Grace CPU
+# power; it ships with the srt-slurm release the submodule pins, so bump both together.
+CPU_POWER_EXPORTER_RELEASE = "v2.66.1"
 PATCHES = Path("runners/srt-slurm/patches")
 SETUP_LOG = "srt-setup.log"
 SETUP_ATTEMPTS = 5
@@ -195,14 +198,19 @@ def _discard_corrupt_archives(configs: Path) -> bool:
     return discarded
 
 
-def run_setup(run: SrtRun, checkout: Checkout) -> int:
-    """Run ``make setup`` in the checkout, logging to SETUP_LOG; return its exit code."""
+def run_setup(run: SrtRun, checkout: Checkout, *, cpu_power_exporter: bool = False) -> int:
+    """Run ``make setup`` in the checkout, logging to SETUP_LOG; return its exit code.
+
+    ``cpu_power_exporter`` pins the cpu-power-exporter release, which makes its download fatal.
+    """
     log = run.workspace / SETUP_LOG
     event = run.life.event
     event.evidence(log)
     for attempt in range(1, SETUP_ATTEMPTS + 1):
         print(f"Setting up srt-slurm, attempt {attempt} (details: {SETUP_LOG})", flush=True)
         argv = ["make", "setup", f"ARCH={run.cluster.arch}"]
+        if cpu_power_exporter:
+            argv.append(f"CPU_POWER_EXPORTER_RELEASE={CPU_POWER_EXPORTER_RELEASE}")
         rc = _run_logged(argv, log, env=run.env, cwd=checkout.root)
         if rc == 0:
             print("srt-slurm setup complete", flush=True)
diff --git a/inferencex-e2e/infx/launch/drivers/srt/collect.py b/inferencex-e2e/infx/launch/drivers/srt/collect.py
index 228021b558..97a6402d3a 100644
--- a/inferencex-e2e/infx/launch/drivers/srt/collect.py
+++ b/inferencex-e2e/infx/launch/drivers/srt/collect.py
@@ -21,6 +21,7 @@
     bundle_server_logs,
     collect_agentic_power_results,
     copy_agentic_results,
+    copy_al_gate_result,
     copy_eval_artifacts,
     copy_fixed_sequence_results,
     copy_to_workspace,
@@ -68,6 +69,7 @@ def finish_single_node(run: SrtRun, submitted: Submitted, fetched: Path) -> int:
         logs = output / "logs"
         power_rc = 0 if run.request.eval_only else _stage_power_package(run, logs)
         bundle_server_logs(output, run.workspace / SINGLE_NODE_LOGS)
+        copy_al_gate_result(logs, run.workspace, run.request.result_filename)
         result = logs / f"{run.request.result_filename}.json"
         if result.is_file():
             try:
@@ -107,7 +109,8 @@ def finalize_single_node_results(run: SrtRun, logs: Path, producer_sha: str) ->
     A single-node point publishes the fixed-sequence bundle shape: the validation
     sidecar sits beside the result, named after it, and the audit names that file.
 
-    srt-slurm treats a failed post-benchmark eval as non-fatal; InferenceX does not.
+    srt-slurm treats a failed post-benchmark eval as non-fatal; InferenceX does not. An eval's
+    report-only acceptance gate never fails it.
     """
     request, event = run.request, run.life.event
     power_rc = 0
@@ -189,11 +192,22 @@ def stage_logs_on_exit() -> None:
             python = request.inferencex_results_python
             if power.agentx:
                 power_rc = collect_agentic_power_results(
-                    status, job.id, logs, infmax, *audit, results_python=python
+                    status,
+                    job.id,
+                    logs,
+                    infmax,
+                    *audit,
+                    results_python=python,
+                    require_power=not power.best_effort,
+                    expected_cpu=power.expect_cpu,
                 )
             else:
                 power_rc = validate_agentic_power(
-                    logs, *audit, results_python=python, require_power=request.require_power
+                    logs,
+                    *audit,
+                    results_python=python,
+                    require_power=request.require_power,
+                    expected_cpu=power.expect_cpu,
                 )
             if power_rc:
                 event.fail(
@@ -215,6 +229,7 @@ def stage_logs_on_exit() -> None:
                 event.error(error)
                 rc = rc or 1
         if request.run_eval or request.eval_only:
+            copy_al_gate_result(logs, run.workspace, request.result_filename)
             try:
                 copy_eval_artifacts(logs / "eval_results", run.workspace)
             except ArtifactError as error:
diff --git a/inferencex-e2e/infx/launch/drivers/srt/config.py b/inferencex-e2e/infx/launch/drivers/srt/config.py
index f52b89a553..530b9e4ad7 100644
--- a/inferencex-e2e/infx/launch/drivers/srt/config.py
+++ b/inferencex-e2e/infx/launch/drivers/srt/config.py
@@ -19,6 +19,7 @@
 from infx.launch.context import LaunchError
 from infx.launch.drivers.srt.lanes import srt_time_limit
 from infx.launch.drivers.srt.recipe import HEALTH_ATTEMPTS
+from infx.srt_slurm.workload import NATIVE
 
 if TYPE_CHECKING:
     from infx.clusters import Cluster
@@ -28,10 +29,22 @@
     from infx.launch.drivers.srt.power import PowerDecision
     from infx.launch.drivers.srt.run import SrtRun
     from infx.launch.request import SrtRequest
+    from infx.srt_slurm.workload import CpuPowerSource, GpuPower
 
 NGINX_IMAGE = "nginx:1.27.4"
 EXPORTER_PROVENANCE = "exporter-image.sha256"
 HEALTH_CHECK = {"max_attempts": HEALTH_ATTEMPTS, "interval_seconds": 10}
+# energy_uj is root-only (CVE-2020-8694); the glob matches only the top-level package zones.
+# A failed grant warns and continues: it costs the CPU leg, whose verdict enforces required
+# power, not the benchmark. A cancelled job skips teardown, so the CI account keeps read
+# access until the next RAPL job's teardown; that account already has sudo on these hosts.
+RAPL_COUNTERS = "/sys/class/powercap/intel-rapl/intel-rapl:*/energy_uj"
+RAPL_GRANT = (
+    f"for zone in {RAPL_COUNTERS}; do"
+    ' test -r "$zone" || sudo -n chown "$(id -un)" "$zone"'
+    ' || echo "cannot read $zone; CPU power will be missing" >&2; done'
+)
+RAPL_RESTORE = f"sudo -n chown root {RAPL_COUNTERS}"
 
 
 @dataclass(frozen=True)
@@ -50,6 +63,7 @@ class SrtJob:
     single_node: bool = False
     account: str | None = None
     mem_mib: int | None = None
+    cpu_power_source: CpuPowerSource | None = None
 
 
 def pyxis_spelling(image: str) -> str:
@@ -91,7 +105,11 @@ def volume_path(cluster: Cluster, volume: str) -> Path:
 
 
 def render(cluster: Cluster, job: SrtJob) -> dict[str, Any]:
-    """The srtslurm.yaml mapping of ``job`` on ``cluster``; ``srt-slurm.extra`` only adds keys."""
+    """The srtslurm.yaml mapping of ``job`` on ``cluster``; ``srt-slurm.extra`` only adds keys.
+
+    A job whose CPU power exporter reads RAPL gives the job user the RAPL counters until
+    teardown.
+    """
     settings = slurm_settings(cluster)
     srt = settings.srt_slurm
     if srt is None:
@@ -131,9 +149,8 @@ def render(cluster: Cluster, job: SrtJob) -> dict[str, Any]:
         config["use_segment_sbatch_directive"] = False
     elif srt.segment_directive is not None:
         config["use_segment_sbatch_directive"] = srt.segment_directive
-    config["use_exclusive_sbatch_directive"] = (
-        srt.single_node_exclusive if job.single_node else settings.exclusive
-    )
+    exclusive = srt.single_node_exclusive if job.single_node else settings.exclusive
+    config["use_exclusive_sbatch_directive"] = exclusive
     directives: dict[str, str] = {}
     if settings.exclude:
         directives["exclude"] = ",".join(settings.exclude)
@@ -154,6 +171,10 @@ def render(cluster: Cluster, job: SrtJob) -> dict[str, Any]:
         if setup.nodes is not None:
             host_setup["nodes"] = setup.nodes
         config["default_host_setup"] = host_setup
+    if job.cpu_power_source == "rapl":
+        host_setup = config.setdefault("default_host_setup", {"commands": []})
+        host_setup["commands"].append(RAPL_GRANT)
+        host_setup.setdefault("teardown", []).append(RAPL_RESTORE)
     if shadowed := sorted(config.keys() & srt.extra.keys()):
         raise LaunchError(f"cluster {cluster.id!r} srt-slurm.extra sets rendered keys {shadowed}")
     config.update(srt.extra)
@@ -167,10 +188,9 @@ def write(path: Path, config: Mapping[str, Any]) -> None:
 
 def stage_gpu_exporter(run: SrtRun, *, single_node: bool = False) -> tuple[str, str]:
     """Stage the cluster's GPU exporter image: its recipe name and the reference jobs start from."""
-    exporter = run.srt.extra.get("default_gpu_exporter")
-    if not isinstance(exporter, dict) or not exporter.get("container_image"):
-        raise LaunchError("native power requires a cluster GPU exporter")
-    image = exporter["container_image"]
+    image = run.srt.gpu_exporter_image
+    if image is None:
+        raise LaunchError("power requires a cluster GPU exporter")
     staged = run.backend.stage_image(image, helper="dcgm-exporter", single_node=single_node)
     (run.workspace / EXPORTER_PROVENANCE).write_text(f"{run.backend.image_provenance(staged)}\n")
     return image, staged.reference
@@ -252,27 +272,52 @@ def agentic_client_env(
     return env
 
 
+def cpu_power_source(
+    cluster: Cluster, srt: SrtSlurmSettings, cpu_power: bool, *, default: bool = False
+) -> CpuPowerSource | None:
+    """The cluster's CPU power exporter source when the point selected cpu-power, or measures
+    it by ``default`` on a cluster that declares an exporter; else None.
+    """
+    if srt.cpu_power_exporter is not None and (cpu_power or default):
+        return srt.cpu_power_exporter.source
+    if cpu_power:
+        raise LaunchError(
+            f"cluster {cluster.id!r} declares no srt-slurm.cpu-power-exporter for cpu-power"
+        )
+    return None
+
+
 def binder_inputs(
     cluster: Cluster,
     srt: SrtSlurmSettings,
     lane: SrtLane,
     request: SrtRequest,
     decision: PowerDecision,
-) -> tuple[int | None, dict[str, str]]:
-    """The DCGM exporter port and AgentX client env a multi-node recipe is bound with.
-
-    The client marks power windows exactly when the launcher collects the point's AgentX power,
-    and fails invalid power when the workflow or the lane's power rule requires it.
+) -> tuple[GpuPower | None, str | None, dict[str, str]]:
+    """The GPU power telemetry, CPU exporter source and AgentX client env a recipe is bound with.
+
+    GPU power is the DCGM block on the cluster's ``power-exporter-port`` where it declares one,
+    else the cluster's own GPU exporter. The CPU source is the cluster's CPU exporter when the
+    point selected cpu-power. The client marks power windows exactly when the launcher collects
+    the point's AgentX power, and fails invalid power when the workflow or the lane's power rule
+    requires it.
     """
-    port = srt.power_exporter_port if decision.dcgm else None
+    gpu_power: GpuPower | None = None
+    if decision.dcgm:
+        gpu_power = NATIVE if srt.power_exporter_port is None else srt.power_exporter_port
+    cpu_source = cpu_power_source(cluster, srt, decision.cpu)
     if not request.is_agentic:
-        return port, {}
-    return port, {
-        **agentic_client_env(cluster, srt, lane, request),
-        "IS_MULTINODE": str(request.is_multinode).lower(),
-        "ENABLE_AGENTX_POWER": "1" if decision.agentx or decision.adapter else "0",
-        "REQUIRE_POWER": "1" if decision.require or request.require_power else "0",
-    }
+        return gpu_power, cpu_source, {}
+    return (
+        gpu_power,
+        cpu_source,
+        {
+            **agentic_client_env(cluster, srt, lane, request),
+            "IS_MULTINODE": str(request.is_multinode).lower(),
+            "ENABLE_AGENTX_POWER": "1" if decision.agentx or decision.adapter else "0",
+            "REQUIRE_POWER": "1" if decision.require or request.require_power else "0",
+        },
+    )
 
 
 def write_lane_config(
@@ -312,6 +357,7 @@ def write_lane_config(
         model_paths=model_paths,
         mounts=lane_mounts(run, lane),
         account=run.account,
+        cpu_power_source=cpu_power_source(run.cluster, run.srt, power.cpu),
     )
     config_yaml = checkout.root / "srtslurm.yaml"
     write(config_yaml, render(run.cluster, job))
diff --git a/inferencex-e2e/infx/launch/drivers/srt/lanes.py b/inferencex-e2e/infx/launch/drivers/srt/lanes.py
index 882eb98c0b..53cc8efb62 100644
--- a/inferencex-e2e/infx/launch/drivers/srt/lanes.py
+++ b/inferencex-e2e/infx/launch/drivers/srt/lanes.py
@@ -51,7 +51,9 @@ class SrtLane:
     ("b200-nscale", LaunchPath.SRT_MULTI): SrtLane(frameworks=_DYNAMO),
     ("b300-dsxe", LaunchPath.SRT_MULTI): SrtLane(frameworks=_DYNAMO),
     ("gb200-nv", LaunchPath.SRT_MULTI): SrtLane(
-        frameworks=any_of("dynamo-sglang", "dynamo-trt", "dynamo-vllm", "llmd-vllm"),
+        frameworks=any_of(
+            "dynamo-sglang", "dynamo-trt", "dynamo-vllm", "llmd-vllm", "sglang", "vllm"
+        ),
         setup_scripts={"dynamo-sglang": "install-torchao.sh"},
         mounts=(
             LaneMount(
@@ -61,7 +63,7 @@ class SrtLane:
                 world_writable=True,
             ),
         ),
-        shared_run_root=(Match(any_of("kimik3", "qwen3.5", "glm5.2")),),
+        shared_run_root=(Match(any_of("qwen3.5", "glm5.2")),),
     ),
     ("gb300-nv", LaunchPath.SRT_MULTI): SrtLane(
         real_verification=Match(frameworks=any_of("dynamo-trt"), agentic=True),
diff --git a/inferencex-e2e/infx/launch/drivers/srt/models.py b/inferencex-e2e/infx/launch/drivers/srt/models.py
index fdb2bbfdc8..2f50b91009 100644
--- a/inferencex-e2e/infx/launch/drivers/srt/models.py
+++ b/inferencex-e2e/infx/launch/drivers/srt/models.py
@@ -81,7 +81,6 @@ class Override:
     ),
     "mi355x-amds": (
         Override(Match(any_of("dsr1"), any_of("fp8"), any_of("sglang-disagg")), hub=True),
-        Override(Match(any_of("qwen3.5"), any_of("fp4"), any_of("sglang-disagg")), hub=True),
     ),
 }
 
diff --git a/inferencex-e2e/infx/launch/drivers/srt/power.py b/inferencex-e2e/infx/launch/drivers/srt/power.py
index b0de2a47f4..64c68c322a 100644
--- a/inferencex-e2e/infx/launch/drivers/srt/power.py
+++ b/inferencex-e2e/infx/launch/drivers/srt/power.py
@@ -1,11 +1,14 @@
-"""DCGM power eligibility of the srt-slurm multi-node lanes.
+"""Power eligibility of the srt-slurm multi-node lanes.
 
-A matrix point asks for DCGM power with its master ``power`` field; each lane lists the
-requests that may have it.
+Every multi-node benchmark point on a cluster with a GPU exporter measures GPU power, and CPU
+power where the cluster declares a CPU exporter, unless its recipe runs etcd and NATS on a
+dedicated node. A point without ``power`` keeps its result when telemetry fails. A lane rule
+the point matches changes how its AgentX power is measured.
 """
 
 from __future__ import annotations
 
+from collections.abc import Callable
 from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
@@ -13,16 +16,19 @@
 from infx.launch.policy import LaunchPath, Match, any_of
 
 if TYPE_CHECKING:
+    from infx.clusters.slurm import SrtSlurmSettings
     from infx.launch.request import MultiNodeRequest
 
 
 class PowerPolicyError(LaunchError):
-    """The point asks for DCGM power on a lane that does not support it."""
+    """The point asks for power its cluster cannot measure."""
 
 
 @dataclass(frozen=True)
 class PowerRule:
-    """One allowed power combination; ``require`` makes the client fail invalid AgentX power."""
+    """How matching points measure AgentX power; ``require`` makes the client fail invalid
+    AgentX power.
+    """
 
     when: Match
     agentx: bool
@@ -35,68 +41,17 @@ class PowerLane:
     """Ordered power rules for one lane; first match wins."""
 
     rules: tuple[PowerRule, ...]
-    error: str
-    agentic_error: str | None = None
 
 
 POWER_LANES: dict[tuple[str, LaunchPath], PowerLane] = {
-    ("gb200-nv", LaunchPath.SRT_MULTI): PowerLane(
-        rules=(
-            PowerRule(
-                Match(any_of("glm5.2"), any_of("fp4"), any_of("dynamo-sglang"), agentic=True),
-                agentx=True,
-            ),
-            PowerRule(
-                Match(any_of("kimik3"), any_of("fp4"), any_of("dynamo-vllm"), agentic=True),
-                agentx=True,
-                require=True,
-            ),
-            PowerRule(Match(frameworks=any_of("dynamo-sglang"), agentic=False), agentx=False),
-        ),
-        error="dcgm-power requires dynamo-sglang or the supported Kimi-K3 AgentX route",
-        agentic_error="AgentX dcgm-power requires GLM-5.2 FP4 dynamo-sglang or Kimi-K3 FP4 dynamo-vllm",
-    ),
-    ("gb300-nv", LaunchPath.SRT_MULTI): PowerLane(
-        rules=(
-            PowerRule(
-                Match(any_of("kimik3"), any_of("fp4"), any_of("dynamo-vllm"), agentic=True),
-                agentx=True,
-                require=True,
-            ),
-            PowerRule(Match(frameworks=any_of("dynamo-sglang")), agentx=False),
-        ),
-        error="dcgm-power requires dynamo-sglang or the supported Kimi-K3 AgentX route",
-    ),
-    ("b200-nscale", LaunchPath.SRT_NATIVE): PowerLane(
-        rules=(
-            PowerRule(
-                Match(any_of("kimik3"), any_of("fp4"), any_of("dynamo-vllm"), agentic=True),
-                agentx=True,
-            ),
-        ),
-        error="B200 nscale dcgm-power requires Kimi-K3 FP4 AgentX dynamo-vllm",
-    ),
-    ("b200-nscale", LaunchPath.SRT_MULTI): PowerLane(
-        rules=(
-            PowerRule(
-                Match(any_of("qwen3.5"), any_of("fp8"), any_of("dynamo-sglang"), agentic=True),
-                agentx=True,
-            ),
-        ),
-        error="B200 Nscale dcgm-power requires Qwen3.5 FP8 AgentX dynamo-sglang",
-    ),
     ("h200-dgxc", LaunchPath.SRT_MULTI): PowerLane(
         rules=(
-            PowerRule(
-                Match(any_of("kimik3"), any_of("fp4"), any_of("vllm"), agentic=True), agentx=True
-            ),
             PowerRule(
                 Match(any_of("glm5.2"), any_of("fp8"), any_of("dynamo-sglang"), agentic=True),
                 agentx=False,
                 adapter=True,
             ),
         ),
-        error="H200 dcgm-power requires AgentX dynamo-sglang glm5.2 FP8 or Kimi-K3 vLLM FP4",
     ),
 }
 
@@ -105,29 +60,55 @@ class PowerLane:
 class PowerDecision:
     """Outcome of power eligibility for one launch."""
 
+    # GPU power is measured: DCGM, or the cluster's own exporter where it sets no DCGM port.
+    # The name is the job-event schema's (``event.Power.dcgm``).
     dcgm: bool
     agentx: bool
     adapter: bool = False
     require: bool = False
+    # The cluster's CPU exporter is bound.
+    cpu: bool = False
+    # The point selected cpu-power, so a required point fails without a valid CPU leg.
+    expect_cpu: bool = False
+    # Invalid AgentX power leaves the benchmark result standing.
+    best_effort: bool = False
 
 
 NO_POWER = PowerDecision(dcgm=False, agentx=False)
 
 
-def decide_power(cluster_id: str, path: LaunchPath, request: MultiNodeRequest) -> PowerDecision:
-    """Apply the lane's rules when the point's ``power`` field is on.
+def decide_power(
+    cluster_id: str,
+    path: LaunchPath,
+    srt: SrtSlurmSettings,
+    request: MultiNodeRequest,
+    dedicated_discovery: Callable[[], bool] = lambda: False,
+) -> PowerDecision:
+    """Measure power on every benchmark point of a cluster with a GPU exporter, except one
+    without ``power`` whose recipe runs ``dedicated_discovery``.
 
-    Raises ``PowerPolicyError`` for a combination the lane does not allow.
+    Raises ``PowerPolicyError`` when the point asks for power the cluster cannot measure.
     """
-    if not request.power:
+    if request.eval_only:
+        return NO_POWER
+    if srt.gpu_exporter_image is None:
+        if request.power:
+            raise PowerPolicyError(f"cluster {cluster_id!r} measures no GPU power on {path}")
+        return NO_POWER
+    if request.cpu_power and srt.cpu_power_exporter is None:
+        raise PowerPolicyError(
+            f"cluster {cluster_id!r} declares no srt-slurm.cpu-power-exporter for cpu-power"
+        )
+    if not request.power and dedicated_discovery():
         return NO_POWER
-    lane = POWER_LANES.get((cluster_id, path))
-    if lane is None:
-        raise PowerPolicyError(f"cluster {cluster_id!r} measures no DCGM power on {path}")
-    for rule in lane.rules:
-        if rule.when(request):
-            return PowerDecision(
-                dcgm=True, agentx=rule.agentx, adapter=rule.adapter, require=rule.require
-            )
-    message = lane.agentic_error if request.is_agentic and lane.agentic_error else lane.error
-    raise PowerPolicyError(message)
+    lane = POWER_LANES.get((cluster_id, path), PowerLane(rules=()))
+    rule = next((rule for rule in lane.rules if rule.when(request)), None)
+    return PowerDecision(
+        dcgm=True,
+        agentx=rule.agentx if rule else request.is_agentic,
+        adapter=rule is not None and rule.adapter,
+        require=request.power and rule is not None and rule.require,
+        cpu=srt.cpu_power_exporter is not None,
+        expect_cpu=request.cpu_power,
+        best_effort=not (request.power or request.require_power),
+    )
diff --git a/inferencex-e2e/infx/launch/drivers/srt/submit.py b/inferencex-e2e/infx/launch/drivers/srt/submit.py
index 19787679aa..82eca19be7 100644
--- a/inferencex-e2e/infx/launch/drivers/srt/submit.py
+++ b/inferencex-e2e/infx/launch/drivers/srt/submit.py
@@ -17,6 +17,7 @@
 from infx.bench.proc import echo
 from infx.launch.backends.slurm import srtctl_job_name
 from infx.launch.context import LaunchError
+from infx.srt_slurm import al_gate
 from infx.srt_slurm.single_node import submission_fields
 
 if TYPE_CHECKING:
@@ -24,6 +25,7 @@
     from infx.launch.drivers.srt.checkout import Checkout
     from infx.launch.drivers.srt.lanes import SrtLane
     from infx.launch.drivers.srt.run import SrtRun
+    from infx.srt_slurm.workload import CpuPowerSource, GpuPower
 
 SINGLE_NODE_SUBMISSION = "srt-single-node-submission.json"
 MULTINODE_SUBMISSION = "srt-submission.json"
@@ -49,6 +51,39 @@
 _SHELL_NAME = re.compile(r"[A-Za-z_][A-Za-z0-9_]*")
 
 
+def request_al_gate(run: SrtRun) -> None:
+    """Ask the planner for an agentic speculative eval's acceptance gate when its prompts are
+    staged.
+
+    ``EVAL_AL_GATE`` reaches the eval through ``post_eval.passthrough_env``. Without the
+    prompts, the eval runs alone and the gate's skipped result says why.
+    """
+    request = run.request
+    if not (
+        request.eval_only and request.is_agentic and request.spec_decoding not in (None, "none")
+    ):
+        return
+    dataset = run.env.get("AL_GATE_DATASET", "")
+    workspace = run.workspace.resolve()
+    staged = (workspace / dataset).resolve()
+    if (
+        dataset
+        and not Path(dataset).is_absolute()
+        and staged.is_relative_to(workspace)
+        and staged.is_file()
+    ):
+        run.env["EVAL_AL_GATE"] = "true"
+        return
+    write_al_gate(run, al_gate.skipped(f"no SPEED-Bench prompts at {dataset!r}", run.env))
+
+
+def write_al_gate(run: SrtRun, document: Mapping[str, object]) -> None:
+    """Write an acceptance gate result beside the eval's, where the workflow uploads it."""
+    path = run.workspace / f"al_gate_{run.request.result_filename}.json"
+    path.write_text(json.dumps(document, indent=2) + "\n")
+    print(f"AL gate (report-only): {document.get('status')}: {document.get('error')}", flush=True)
+
+
 def eval_args(env: Mapping[str, str], command: str) -> list[str]:
     """Post-eval ``--set`` arguments: ``command``, and the WORKLOAD_ENV names set in ``env``."""
     names = sorted(
@@ -66,12 +101,19 @@ def eval_args(env: Mapping[str, str], command: str) -> list[str]:
     ]
 
 
-def bind_point(run: SrtRun, checkout: Checkout, arguments: Path) -> int:
-    """Bind the single-node recipe variant for this point; the binder writes ``arguments``."""
+def bind_point(
+    run: SrtRun, checkout: Checkout, arguments: Path, cpu_power_source: CpuPowerSource | None
+) -> int:
+    """Bind the single-node recipe variant for this point; the binder writes ``arguments``.
+
+    ``cpu_power_source`` adds the cluster's CPU power exporter to the native telemetry.
+    """
     prepare = [
         str(checkout.venv / "bin/python"), "-m", "infx.srt_slurm.single_node", "prepare",
         f"{run.workspace}/{run.request.srt_recipe}", str(arguments), *_fabric(run),
     ]  # fmt: skip
+    if cpu_power_source is not None:
+        prepare += ["--cpu-power-source", cpu_power_source]
     return _bind(run, prepare, checkout.root)
 
 
@@ -89,13 +131,17 @@ def bind_recipe(
     checkout: Checkout,
     staged: str,
     output: str,
-    power_port: int | None,
+    gpu_power: GpuPower | None,
+    cpu_power_source: CpuPowerSource | None,
     client_env: Mapping[str, str],
 ) -> int:
-    """Compose and bind the staged fragment into ``output``, with telemetry if ``power_port``."""
+    """Compose and bind the staged fragment into ``output``, with GPU telemetry if
+    ``gpu_power`` and the cluster's CPU exporter if ``cpu_power_source``."""
     bind = [str(checkout.venv / "bin/python"), "-m", "infx.srt_slurm.workload", staged, output]
-    if power_port is not None:
-        bind += ["--power-port", str(power_port)]
+    if gpu_power is not None:
+        bind += ["--gpu-power", str(gpu_power)]
+    if cpu_power_source is not None:
+        bind += ["--cpu-power-source", cpu_power_source]
     for name, value in client_env.items():
         bind += ["--client-env", f"{name}={value}"]
     bind += _fabric(run)
@@ -144,7 +190,8 @@ def apply(
 
     Containers start in the workspace mount: PyTorch's generated module imports fail from /
     with PYTHONPYCACHEPREFIX set. ``arguments`` still win. ``stdout`` receives srtctl's JSON
-    manifest; the planner's golden acceptance length goes into the launch's record.
+    manifest; the planner's golden acceptance length goes into the launch's record, and an
+    acceptance gate it skipped is written beside the eval.
     """
     record = checkout.root / ACCEPTANCE_RECORD
     argv = [
@@ -162,8 +209,11 @@ def apply(
                 argv, env=env, cwd=checkout.root, stdout=handle, check=False
             ).returncode
     with contextlib.suppress(OSError, ValueError, KeyError, TypeError):
-        length = json.loads(record.read_text())["golden_acceptance_length"]
-        event.set(golden_acceptance_length=length)
+        planned = json.loads(record.read_text())
+        event.set(golden_acceptance_length=planned["golden_acceptance_length"])
+        gate = planned.get("al_gate")
+        if isinstance(gate, dict) and gate.get("status") == "skipped":
+            write_al_gate(run, gate)
     if rc:
         event.fail("SubmitFailed", f"srtctl apply exited {rc}")
     return subprocess.CompletedProcess(argv, rc, stdout.read_text(errors="replace"), "")
diff --git a/inferencex-e2e/infx/launch/event.py b/inferencex-e2e/infx/launch/event.py
index cf8237b255..eca07c007a 100644
--- a/inferencex-e2e/infx/launch/event.py
+++ b/inferencex-e2e/infx/launch/event.py
@@ -46,6 +46,9 @@ class Power(_Record):
     agentx: bool
     adapter: bool
     require: bool = False
+    cpu: bool = False
+    expect_cpu: bool = False
+    best_effort: bool = False
 
 
 class JobError(_Record):
diff --git a/inferencex-e2e/infx/launch/policy.py b/inferencex-e2e/infx/launch/policy.py
index 5115da1e3c..75b29b36e0 100644
--- a/inferencex-e2e/infx/launch/policy.py
+++ b/inferencex-e2e/infx/launch/policy.py
@@ -64,7 +64,7 @@ class LaunchPath(StrEnum):
 
 NATIVE_SRT_LANES: dict[str, tuple[Match, ...]] = {
     "b200-nscale": (
-        Match(any_of("kimik3", "glm5.2"), any_of("fp4"), any_of("dynamo-vllm")),
+        Match(any_of("glm5.2"), any_of("fp4"), any_of("dynamo-vllm")),
         Match(any_of("glm5.2"), any_of("fp4"), any_of("dynamo-sglang"), specs=any_of("mtp")),
     ),
 }
diff --git a/inferencex-e2e/infx/launch/request.py b/inferencex-e2e/infx/launch/request.py
index 2c37dd67ad..07423ab445 100644
--- a/inferencex-e2e/infx/launch/request.py
+++ b/inferencex-e2e/infx/launch/request.py
@@ -138,6 +138,7 @@ class SrtRequest(LaunchRequest):
     eval_only: TrueFlag = Field(alias="EVAL_ONLY")
     thinking_mode: str | None = Field(None, alias="THINKING_MODE")
     require_power: PowerFlag = Field(False, alias="REQUIRE_POWER")
+    cpu_power: OneFlag = Field(False, alias="CPU_POWER")
     inferencex_results_python: str | None = Field(None, alias="INFERENCEX_RESULTS_PYTHON")
 
     @model_validator(mode="after")
diff --git a/inferencex-e2e/infx/matrix/fingerprint.py b/inferencex-e2e/infx/matrix/fingerprint.py
index ab4eb43e9b..5df797fb17 100644
--- a/inferencex-e2e/infx/matrix/fingerprint.py
+++ b/inferencex-e2e/infx/matrix/fingerprint.py
@@ -18,6 +18,8 @@
     ("name",),
     ("benchmark", "concurrencies"),
     ("benchmark", "env", "CONC"),
+    ("benchmark", "env", "SPEC_ALGORITHM"),
+    ("benchmark", "env", "SPEC_DRAFT_MODEL"),
     ("telemetry", "dcgm_exporter", "port"),
 )
 BIND_ERRORS = (OSError, KeyError, TypeError, ValueError, yaml.YAMLError)
@@ -54,9 +56,9 @@ def _without(block: dict[str, Any], path: tuple[str, ...]) -> dict[str, Any]:
 
 def _concrete_recipes(entry: Mapping[str, Any], root: Path) -> list[dict[str, Any]]:
     """Render the row's bound srt recipe, minus the fields that vary per point or run."""
-    power_port = EXPORTER_PORT if entry.get("power") else None
+    gpu_power = EXPORTER_PORT if entry.get("power") else None
     _, recipe = bound_variant(
-        entry, point_environment(entry), root, expand=expand_variants, power_port=power_port
+        entry, point_environment(entry), root, expand=expand_variants, gpu_power=gpu_power
     )
     for path in RECIPE_EXCLUDED:
         recipe = _without(recipe, path)
diff --git a/inferencex-e2e/infx/matrix/generate.py b/inferencex-e2e/infx/matrix/generate.py
index be6cbc6e40..f0162748cc 100644
--- a/inferencex-e2e/infx/matrix/generate.py
+++ b/inferencex-e2e/infx/matrix/generate.py
@@ -14,7 +14,7 @@
 from infx.clusters import CLUSTER_LABEL_PREFIX
 from infx.clusters.slurm import Fabric
 from infx.srt_slurm.variants import deep_merge, expand_variants
-from infx.srt_slurm.workload import resolve_fabric
+from infx.srt_slurm.workload import discovery_on_dedicated_node, resolve_fabric
 
 from .validation import (
     DEFAULT_AGENTIC_DURATION_SECONDS,
@@ -241,16 +241,7 @@ def recipe_auxiliary_node_count(recipe: dict) -> int:
     """Return the nodes a recipe needs beyond its workers, for service pools and dedicated roles."""
     services = [service for service in recipe.get("services") or [] if service.get("enabled", True)]
     pool_nodes = sum(service.get("nodes") or 0 for service in services)
-    infra_dedicated = (recipe.get("infra") or {}).get("etcd_nats_dedicated_node", False)
-    discovery = [service for service in services if service.get("type") in ("etcd", "nats")]
-    if discovery:
-        placements = {
-            (service.get("placement") or {}).get("node") == "dedicated" for service in discovery
-        }
-        if len(placements) != 1:
-            raise ValueError("Recipe etcd and nats must agree on dedicated placement")
-        infra_dedicated = placements.pop()
-    dedicated_roles = int(infra_dedicated)
+    dedicated_roles = int(discovery_on_dedicated_node(recipe))
     for section, legacy_key in (
         ("frontend", "dedicated_node"),
         ("benchmark", "client_dedicated_node"),
@@ -1049,6 +1040,8 @@ def _fixed_sequence_entries(
             entry.update(srt_recipe_fields(config, benchmark))
             if benchmark.get(Fields.POWER.value):
                 entry[Fields.POWER.value] = True
+            if benchmark.get(Fields.CPU_POWER.value):
+                entry[Fields.CPU_POWER.value] = True
             entry.update(
                 {
                     Fields.EXP_NAME.value: f"{model_code}_{seq_len_to_str(isl, osl)}",
@@ -1167,6 +1160,10 @@ def _agentic_entries(
         entry.update(srt_recipe_fields(config, benchmark))
         if benchmark.get(Fields.POWER.value):
             entry[Fields.POWER.value] = True
+        if benchmark.get(Fields.CPU_POWER.value):
+            entry[Fields.CPU_POWER.value] = True
+        if benchmark.get(Fields.REQUIRE_POWER.value, benchmark.get("require_power", False)):
+            entry[Fields.REQUIRE_POWER.value] = True
         entry.update(
             {
                 Fields.KV_OFFLOADING.value: kv_offloading,
diff --git a/inferencex-e2e/infx/matrix/validation.py b/inferencex-e2e/infx/matrix/validation.py
index bd5f2ecdba..010d937b59 100644
--- a/inferencex-e2e/infx/matrix/validation.py
+++ b/inferencex-e2e/infx/matrix/validation.py
@@ -79,6 +79,7 @@ class Fields(Enum):
     DURATION = "duration"
     REQUIRE_POWER = "require-power"
     POWER = "power"
+    CPU_POWER = "cpu-power"
 
     CONC = "conc"
     MAX_MODEL_LEN = "max-model-len"
@@ -169,6 +170,7 @@ class SingleNodeMatrixEntry(BaseModel):
     eval_framework: str | None = Field(default=None, alias=Fields.EVAL_FRAMEWORK.value)
     eval_suite: str | None = Field(default=None, alias=Fields.EVAL_SUITE.value)
     router: ComponentMetadata | None = None
+    cpu_power: bool = Field(default=False, alias=Fields.CPU_POWER.value, strict=True)
     recipe_fingerprint: str | None = Field(
         default=None,
         alias=Fields.RECIPE_FINGERPRINT.value,
@@ -263,6 +265,7 @@ class MultiNodeMatrixEntry(BaseModel):
     osl: int
     require_power: bool = Field(default=False, alias=Fields.REQUIRE_POWER.value, strict=True)
     power: bool = Field(default=False, strict=True)
+    cpu_power: bool = Field(default=False, alias=Fields.CPU_POWER.value, strict=True)
     prefill: WorkerConfig
     decode: WorkerConfig
     conc: list[int]
@@ -302,6 +305,7 @@ class SingleNodeAgenticMatrixEntry(BaseModel):
     model_config = ConfigDict(extra="forbid", populate_by_name=True)
 
     image: str
+    require_power: bool = Field(default=False, alias=Fields.REQUIRE_POWER.value, strict=True)
     srt_recipe: str | None = Field(default=None, alias=Fields.SRT_RECIPE.value, min_length=1)
     model: str
     model_prefix: str = Field(alias=Fields.MODEL_PREFIX.value)
@@ -352,6 +356,7 @@ class MultiNodeAgenticMatrixEntry(BaseModel):
     model_config = ConfigDict(extra="forbid", populate_by_name=True)
 
     image: str
+    require_power: bool = Field(default=False, alias=Fields.REQUIRE_POWER.value, strict=True)
     model: str
     model_prefix: str = Field(alias=Fields.MODEL_PREFIX.value)
     precision: str
@@ -364,6 +369,7 @@ class MultiNodeAgenticMatrixEntry(BaseModel):
     )
     node_count: int = Field(alias=Fields.NODE_COUNT.value, gt=0, strict=True)
     power: bool = Field(default=False, strict=True)
+    cpu_power: bool = Field(default=False, alias=Fields.CPU_POWER.value, strict=True)
     prefill: WorkerConfig
     decode: WorkerConfig
     conc: list[int]
@@ -563,6 +569,8 @@ class SingleNodeSearchSpaceEntry(BaseModel):
     )
     dp_attn: bool | None = Field(default=None, alias=Fields.DP_ATTN.value)
     router: ComponentMetadata | None = None
+    # Native single-node points always measure GPU power; this adds the cluster's CPU exporter.
+    cpu_power: bool = Field(default=False, alias=Fields.CPU_POWER.value, strict=True)
     conc_start: int | None = Field(default=None, alias=Fields.CONC_START.value)
     conc_end: int | None = Field(default=None, alias=Fields.CONC_END.value)
     conc_list: list[int] | None = Field(default=None, alias=Fields.CONC_LIST.value)
@@ -578,6 +586,13 @@ def validate_single_node_topology(self) -> Self:
         return _validate_tp_context_topology(self)
 
 
+def _cpu_power_rides_on_power(self: Any) -> Any:
+    """``cpu-power`` adds the cluster's Grace CPU exporter to a point that measures power."""
+    if self.cpu_power and not self.power:
+        raise ValueError(f"{Fields.CPU_POWER.value} requires {Fields.POWER.value} on the entry")
+    return self
+
+
 class MultiNodeSearchSpaceEntry(BaseModel):
     model_config = ConfigDict(extra="forbid", populate_by_name=True)
 
@@ -592,6 +607,7 @@ class MultiNodeSearchSpaceEntry(BaseModel):
         default=None, alias=Fields.EVAL_SRT_RECIPE.value
     )
     power: bool = Field(default=False, strict=True)
+    cpu_power: bool = Field(default=False, alias=Fields.CPU_POWER.value, strict=True)
     num_nodes: int | None = Field(default=None, alias=Fields.NUM_NODES.value, gt=0, strict=True)
     router: ComponentMetadata | None = None
     kv_p2p_transfer: str | None = Field(
@@ -601,6 +617,10 @@ class MultiNodeSearchSpaceEntry(BaseModel):
     conc_end: int | None = Field(default=None, alias=Fields.CONC_END.value)
     conc_list: list[int] | None = Field(default=None, alias=Fields.CONC_LIST.value)
 
+    @model_validator(mode="after")
+    def validate_cpu_power(self) -> Self:
+        return _cpu_power_rides_on_power(self)
+
     @model_validator(mode="after")
     def validate_conc_fields(self) -> Self:
         """Return the entry, raising ValueError for an invalid conc range or list."""
@@ -644,12 +664,14 @@ class MultiNodeSeqLenConfig(BaseModel):
 class AgenticCodingSearchSpaceEntry(BaseModel):
     model_config = ConfigDict(extra="forbid", populate_by_name=True)
 
+    require_power: bool = Field(default=False, alias=Fields.REQUIRE_POWER.value, strict=True)
     tp: int | None = Field(default=None, gt=0)
     srt_recipe: RecipeReference | None = Field(default=None, alias=Fields.SRT_RECIPE.value)
     eval_srt_recipe: RecipeReference | None = Field(
         default=None, alias=Fields.EVAL_SRT_RECIPE.value
     )
     power: bool = Field(default=False, strict=True)
+    cpu_power: bool = Field(default=False, alias=Fields.CPU_POWER.value, strict=True)
     pp: int = Field(default=1, gt=0, strict=True)
     dcp_size: int = Field(default=1, alias=Fields.DCP_SIZE.value, gt=0, strict=True)
     pcp_size: int = Field(default=1, alias=Fields.PCP_SIZE.value, gt=0, strict=True)
@@ -716,6 +738,7 @@ def validate_topology_fields(self) -> Self:
                     f"Only multinode entries measure DCGM power; remove {Fields.POWER.value}"
                 )
             _validate_tp_context_topology(self)
+        _cpu_power_rides_on_power(self)
         if has_aggregate_worker or has_complete_multinode:
             explicitly_single_node_fields = {
                 "pp",
diff --git a/inferencex-e2e/infx/results/agentic/__init__.py b/inferencex-e2e/infx/results/agentic/__init__.py
index 67ada94c91..5bfc2e3825 100644
--- a/inferencex-e2e/infx/results/agentic/__init__.py
+++ b/inferencex-e2e/infx/results/agentic/__init__.py
@@ -5,7 +5,7 @@
 from collections.abc import Iterable, Mapping
 from typing import Any
 
-from infx.results.metadata import parse_component_metadata
+from infx.results.metadata import parse_component_metadata, speculation_fields
 from infx.results.topology import Parallelism, validate_parallelism
 
 from .request_metrics import compute_request_metrics
@@ -208,6 +208,7 @@ def build_result(
         "request_accounting": request_accounting,
     }
     agg.update(multinode_fields)
+    agg.update(speculation_fields(env))
     if decode_cpu_dram_gb := _env_int(env, "DECODE_CPU_DRAM_GB", 0):
         agg["decode_allocated_cpu_dram_gb"] = decode_cpu_dram_gb
 
diff --git a/inferencex-e2e/infx/results/agentic/backends/__init__.py b/inferencex-e2e/infx/results/agentic/backends/__init__.py
index d873d9c4b3..371bce0426 100644
--- a/inferencex-e2e/infx/results/agentic/backends/__init__.py
+++ b/inferencex-e2e/infx/results/agentic/backends/__init__.py
@@ -8,6 +8,7 @@
 from .base import ServerMetricsBackend
 from .dynamo_vllm import DynamoVllmBackend
 from .sglang import SglangBackend
+from .tokenspeed import TokenSpeedBackend
 from .trtllm import TrtllmBackend
 from .vllm import VllmBackend
 
@@ -16,6 +17,7 @@
     DynamoVllmBackend(),
     AtomBackend(),
     SglangBackend(),
+    TokenSpeedBackend(),
     VllmBackend(),
 )
 
diff --git a/inferencex-e2e/infx/results/agentic/backends/tokenspeed.py b/inferencex-e2e/infx/results/agentic/backends/tokenspeed.py
new file mode 100644
index 0000000000..4a6c0b49dc
--- /dev/null
+++ b/inferencex-e2e/infx/results/agentic/backends/tokenspeed.py
@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from typing import Any
+
+from infx.results.agentic.common import gauge_stat
+
+from .base import ServerMetricsBackend
+
+
+class TokenSpeedBackend(ServerMetricsBackend):
+    name = "tokenspeed"
+
+    def matches(self, metrics: dict[str, dict[str, Any]], framework: str) -> bool:
+        return any(name.startswith("tokenspeed:") for name in metrics) or (
+            not metrics and framework.lower() == "tokenspeed"
+        )
+
+    def populate(
+        self,
+        metrics: dict[str, dict[str, Any]],
+        flat: dict[str, Any],
+        nested: dict[str, Any],
+    ) -> None:
+        # TokenSpeed exports device-page occupancy as a 0..1 fraction, despite the suffix.
+        usage = gauge_stat(metrics, "tokenspeed:kv_cache_usage_perc", combine="max")
+        flat["gpu_kv_cache_usage_pct"] = usage
+        nested["kv_cache"]["gpu_usage_pct"] = usage
diff --git a/inferencex-e2e/infx/results/agentic/power_adapter.py b/inferencex-e2e/infx/results/agentic/power_adapter.py
index 59860c74e7..361eea57b5 100644
--- a/inferencex-e2e/infx/results/agentic/power_adapter.py
+++ b/inferencex-e2e/infx/results/agentic/power_adapter.py
@@ -363,6 +363,7 @@ def run_native_agentic_power(
     logs_root: Path,
     expected_producer_sha: str,
     require_power: bool = False,
+    expected_cpu: bool = False,
     audit_source: str | None = None,
     validation_result: Path | None = None,
 ) -> int:
@@ -423,6 +424,7 @@ def run_native_agentic_power(
             logs_root=logs_root,
             validation_result=validation_result,
             require_power=require_power,
+            expected_cpu=expected_cpu,
         )
     if audit_source is not None:
         try:
@@ -456,6 +458,7 @@ def main() -> int:
         action="store_true",
         default=os.environ.get("REQUIRE_POWER", "").lower() in {"1", "true", "yes"},
     )
+    parser.add_argument("--expected-cpu-power", action="store_true")
     args = parser.parse_args()
     if args.multinode_contract_missing:
         if args.agg_result is None:
@@ -508,6 +511,7 @@ def main() -> int:
         logs_root=args.logs_root,
         expected_producer_sha=args.expected_producer_sha,
         require_power=args.require_power,
+        expected_cpu=args.expected_cpu_power,
         audit_source=args.audit_source,
         validation_result=args.validation_result,
     )
diff --git a/inferencex-e2e/infx/results/agentic/spec_decode.py b/inferencex-e2e/infx/results/agentic/spec_decode.py
new file mode 100644
index 0000000000..921c65782f
--- /dev/null
+++ b/inferencex-e2e/infx/results/agentic/spec_decode.py
@@ -0,0 +1,101 @@
+"""Realized speculative acceptance from the engines' own Prometheus counters.
+
+``AL = 1 + accepted draft tokens / verification steps``, from the generation engine's counters'
+increase between a scrape before and one after the measured traffic.
+"""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Callable, Mapping
+
+# family -> [(labels, increase)] of every scraped endpoint's series
+Increase = dict[str, list[tuple[dict[str, str], float]]]
+Keep = Callable[[dict[str, str]], bool]
+Reading = tuple[float, float] | None
+
+_SAMPLE = re.compile(r'([A-Za-z_:][A-Za-z0-9_:]*)(?:\{((?:[^"}]|"(?:[^"\\]|\\.)*")*)\})?\s+(\S+)')
+_LABEL = re.compile(r'([A-Za-z_][A-Za-z0-9_]*)\s*=\s*"((?:[^"\\]|\\.)*)"')
+
+
+def parse(text: str) -> dict[str, dict[frozenset[tuple[str, str]], float]]:
+    """``{family: {labels: value}}`` of a Prometheus text exposition, label values escaped.
+
+    Families drop a ``_total`` suffix; ``_created`` timestamps are skipped. Other text (TRT-LLM's
+    JSON ``/metrics``, say) raises ``ValueError``.
+    """
+    samples: dict[str, dict[frozenset[tuple[str, str]], float]] = {}
+    for number, line in enumerate(text.splitlines(), 1):
+        line = line.strip()
+        if not line or line.startswith("#"):
+            continue
+        sample = _SAMPLE.match(line)
+        if sample is None:
+            raise ValueError(f"line {number} is not Prometheus text exposition: {line[:80]!r}")
+        name, labels, value = sample.groups()
+        if not name.endswith("_created"):
+            series = samples.setdefault(name.removesuffix("_total"), {})
+            series[frozenset(_LABEL.findall(labels or ""))] = float(value)
+    return samples
+
+
+def increase(before: Mapping[str, str], after: Mapping[str, str]) -> Increase:
+    """Each series' increase between two scrapes (``{url: text}``), as Prometheus counts it.
+
+    A series that went backwards was reset, so its new value counts; a new series starts at 0.
+    """
+    families: Increase = {}
+    for url, text in after.items():
+        start = parse(before[url])
+        for family, series in parse(text).items():
+            for labels, value in series.items():
+                old = start.get(family, {}).get(labels, 0.0)
+                rise = value - old if value >= old else value
+                families.setdefault(family, []).append((dict(labels), rise))
+    return families
+
+
+def _sum(counters: Increase, family: str, keep: Keep | None = None) -> float | None:
+    """The kept series' summed increase of the families matching ``family``; None without any."""
+    kept = []
+    for name, series in counters.items():
+        if re.fullmatch(family, name):
+            kept += [value for labels, value in series if keep is None or keep(labels)]
+    return sum(kept) if kept else None
+
+
+def _read(counters: Increase, accepted: str, steps: str, keep: Keep | None = None) -> Reading:
+    verifications = _sum(counters, steps, keep)
+    return None if verifications is None else (_sum(counters, accepted) or 0.0, verifications)
+
+
+def _sglang(counters: Increase) -> Reading:
+    # Disaggregated prefill workers export the same families without verifying any draft.
+    verifications, tokens, requests = (
+        _sum(counters, f"sglang[:_]{name}", lambda s: s.get("engine_type") != "prefill")
+        for name in ("spec_verify_calls", "generation_tokens", "num_requests")
+    )
+    if verifications is None or tokens is None or requests is None:
+        return None
+    # Each verification emits its accepted drafts and one token; prefill emits each first token.
+    return tokens - requests - verifications, verifications
+
+
+# ``(accepted draft tokens, verifications)`` or None, by synthetic_acceptance.ENGINES names.
+READERS: dict[str, Callable[[Increase], Reading]] = {
+    "vllm": lambda c: _read(
+        c, "vllm:spec_decode_num_accepted_tokens", "vllm:spec_decode_num_drafts"
+    ),
+    "tokenspeed": lambda c: _read(
+        c, "tokenspeed:spec_decode_num_accepted_tokens", "tokenspeed:spec_decode_num_drafts"
+    ),
+    "sglang": _sglang,
+    # Every verification drafts a first token; deeper positions are drafted only sometimes.
+    "trtllm": lambda c: _read(
+        c,
+        "trtllm_spec_decode_accepted_tokens",
+        "trtllm_spec_decode_drafted_tokens",
+        lambda s: s.get("token_position") == "0",
+    ),
+    "atom": lambda c: _read(c, "atom[:_]mtp_accepted_tokens", "atom[:_]mtp_decode_steps"),
+}
diff --git a/inferencex-e2e/infx/results/fixed_sequence.py b/inferencex-e2e/infx/results/fixed_sequence.py
index e9a19c4adb..28723b3f59 100644
--- a/inferencex-e2e/infx/results/fixed_sequence.py
+++ b/inferencex-e2e/infx/results/fixed_sequence.py
@@ -279,6 +279,7 @@ def aggregate_power_result(
             aggregate_gpus=aggregate_gpus,
             expected_producer_sha=env.get("POWER_PRODUCER_SHA") or None,
             logs_root=Path(env.get("POWER_RESULT_ROOT", "LOGS")),
+            expected_cpu=env.get("CPU_POWER") == "1",
             validation_result=validation_path,
             require_power=require_power,
         )
diff --git a/inferencex-e2e/infx/results/metadata.py b/inferencex-e2e/infx/results/metadata.py
index 0f2b45e907..f49a135c71 100644
--- a/inferencex-e2e/infx/results/metadata.py
+++ b/inferencex-e2e/infx/results/metadata.py
@@ -40,3 +40,9 @@ def run_attempt(env: Mapping[str, str]) -> int | None:
     """GitHub run attempt that produced a result, or None outside Actions."""
     value = env.get("GITHUB_RUN_ATTEMPT", "")
     return int(value) if value.isascii() and value.isdecimal() and int(value) > 0 else None
+
+
+def speculation_fields(env: Mapping[str, str]) -> dict[str, str]:
+    """The algorithm and draft model the launcher bound for a drafting point, else nothing."""
+    fields = {"spec_algorithm": "SPEC_ALGORITHM", "spec_draft_model": "SPEC_DRAFT_MODEL"}
+    return {field: env[name] for field, name in fields.items() if env.get(name)}
diff --git a/inferencex-e2e/infx/results/power/__init__.py b/inferencex-e2e/infx/results/power/__init__.py
index 6a74fc8dd4..c63de75acf 100644
--- a/inferencex-e2e/infx/results/power/__init__.py
+++ b/inferencex-e2e/infx/results/power/__init__.py
@@ -30,6 +30,26 @@
     "decode_joules_per_output_token",
 )
 ALL_POWER_METRIC_KEYS = WHOLE_METRIC_KEYS + ROLE_METRIC_KEYS
+# Additive metrics from the cpu/ sub-package: the socket meter (Grace socket or AMD
+# package), the ACPI rails and the NVML module rail. They share power metric schema version 2
+# and are governed by cpu_power_valid, not power_valid.
+CPU_METRIC_KEYS = (
+    "avg_cpu_socket_power_w",
+    "avg_total_cpu_power_w",
+    "total_cpu_energy_j",
+    "avg_total_cpu_rail_power_w",
+    "total_cpu_rail_energy_j",
+    "avg_total_cpu_sysio_power_w",
+    "total_cpu_sysio_energy_j",
+    "avg_total_module_power_w",
+    "total_module_energy_j",
+)
+
+
+def _rounded_metric(key: str, value: float | None) -> float:
+    if value is None or not math.isfinite(value):
+        raise ValueError(f"non-finite power metric: {key}")
+    return round(value, 3 if key.endswith(("_w", "_j")) else 6)
 
 
 def with_power_metrics(
@@ -39,15 +59,21 @@ def with_power_metrics(
     schema_version: int,
     power_valid: bool,
     metrics: Mapping[str, float],
+    cpu_power_valid: bool | None = None,
+    cpu_metrics: Mapping[str, float] | None = None,
 ) -> dict[str, Any]:
     """Return a result with stale metrics replaced by one validated metric set.
 
     The caller supplies the metric family and schema version. Detailed invalid
     reasons belong in its validation sidecar, not the numeric metric payload.
     Neither the input result nor the supplied metrics is mutated.
+
+    The CPU-side leg is tri-state: ``cpu_power_valid=None`` means the package
+    carried no ``cpu/`` sub-package, so only stale CPU keys are stripped and the
+    output stays byte-identical to a run without the leg.
     """
     data = dict(result) if isinstance(result, Mapping) else result
-    for key in metric_keys:
+    for key in (*metric_keys, *CPU_METRIC_KEYS, "cpu_power_valid"):
         data.pop(key, None)
     data["power_metric_schema_version"] = schema_version
     data["power_valid"] = int(power_valid)
@@ -55,8 +81,10 @@ def with_power_metrics(
     data.pop("power_audit", None)
     if power_valid:
         for key, value in metrics.items():
-            if value is None or not math.isfinite(value):
-                raise ValueError(f"non-finite power metric: {key}")
-            precision = 3 if key.endswith(("_w", "_j")) else 6
-            data[key] = round(value, precision)
+            data[key] = _rounded_metric(key, value)
+    if cpu_power_valid is not None:
+        data["cpu_power_valid"] = int(cpu_power_valid)
+        if cpu_power_valid:
+            for key, value in (cpu_metrics or {}).items():
+                data[key] = _rounded_metric(key, value)
     return data
diff --git a/inferencex-e2e/infx/results/power/audit.py b/inferencex-e2e/infx/results/power/audit.py
index 443b18f3e5..96c037f8d1 100644
--- a/inferencex-e2e/infx/results/power/audit.py
+++ b/inferencex-e2e/infx/results/power/audit.py
@@ -7,6 +7,36 @@
 from collections.abc import Mapping
 from typing import Any
 
+from .cpu_side import SENSOR_KINDS
+
+_REASON_CODE = re.compile(r"[a-z][a-z0-9_]{0,63}")
+_CPU_COUNT_FIELDS = ("expected_sockets", "observed_sockets", "sample_row_count")
+
+
+def _bounded_reasons(values: Any) -> list[str]:
+    if not isinstance(values, list):
+        return []
+    return [
+        reason for reason in values if isinstance(reason, str) and _REASON_CODE.fullmatch(reason)
+    ][:32]
+
+
+def _cpu_audit(cpu: Mapping[str, Any]) -> dict[str, Any]:
+    """Project the CPU-side provenance: sensor kind, source, counts, reasons."""
+    summary: dict[str, Any] = {}
+    kind = cpu.get("sensor_kind")
+    if isinstance(kind, str) and kind in SENSOR_KINDS:
+        summary["sensor_kind"] = kind
+    source = cpu.get("source")
+    if isinstance(source, str) and 0 < len(source) <= 32:
+        summary["source"] = source
+    for key in _CPU_COUNT_FIELDS:
+        value = cpu.get(key)
+        if type(value) is int and value >= 0:
+            summary[key] = value
+    summary["reason_codes"] = _bounded_reasons(cpu.get("reason_codes"))
+    return summary
+
 
 def audit_summary(validation: Mapping[str, Any], source: str) -> dict[str, Any]:
     """Project the shared app audit contract without publishing raw telemetry."""
@@ -49,11 +79,10 @@ def audit_summary(validation: Mapping[str, Any], source: str) -> dict[str, Any]:
         audit["observed_gpu_ids"] = list(
             dict.fromkeys(str(value) for value in ids if 0 < len(str(value)) <= 128)
         )[:1024]
+    cpu = validation.get("cpu")
+    if isinstance(cpu, Mapping):
+        audit["cpu"] = _cpu_audit(cpu)
     return {
-        "power_invalid_reasons": [
-            reason
-            for reason in validation.get("reasons", [])
-            if isinstance(reason, str) and re.fullmatch(r"[a-z][a-z0-9_]{0,63}", reason)
-        ][:32],
+        "power_invalid_reasons": _bounded_reasons(validation.get("reasons", [])),
         "power_audit": audit,
     }
diff --git a/inferencex-e2e/infx/results/power/common.py b/inferencex-e2e/infx/results/power/common.py
index 3a8fb651ee..8f4a99f981 100644
--- a/inferencex-e2e/infx/results/power/common.py
+++ b/inferencex-e2e/infx/results/power/common.py
@@ -7,12 +7,10 @@
 import json
 import math
 import sys
-from collections.abc import Iterable, Mapping
+from collections.abc import Mapping
 from dataclasses import dataclass
 from pathlib import Path
 
-from . import POWER_METRIC_SCHEMA_VERSION, with_power_metrics
-
 
 @dataclass(frozen=True)
 class BenchmarkData:
@@ -31,6 +29,11 @@ def integration_duration_s(self) -> float:
         return self.end_unix - self.start_unix
 
 
+# Widest gap between consecutive samples inside the integration window that
+# still counts as continuous coverage (srt-slurm contract.MAX_SAMPLE_GAP_SECONDS).
+MAX_SAMPLE_GAP_SECONDS = 3.0
+
+
 def _append_reason(reasons: list[str], reason: str) -> None:
     """Append a validation reason once while preserving discovery order."""
     if reason not in reasons:
@@ -54,6 +57,16 @@ def _interpolate_power(samples: list[tuple[float, float]], timestamp: float) ->
     return left_power + fraction * (right_power - left_power)
 
 
+def _bracketing_sequence(times: tuple[float, ...], start: float, end: float) -> list[float] | None:
+    """Samples covering ``[start, end]``: the last at/before, the inside, the first at/after."""
+    before = [value for value in times if value <= start]
+    after = [value for value in times if value >= end]
+    if not before or not after:
+        return None
+    inside = [value for value in times if start < value < end]
+    return [before[-1], *inside, after[0]]
+
+
 def _integrate_device(
     samples: list[tuple[float, float]],
     *,
@@ -254,24 +267,3 @@ def audit_metrics(metrics: Mapping[str, float | None]) -> dict[str, float]:
         for key, value in metrics.items()
         if value is not None and math.isfinite(value)
     }
-
-
-def patch_power_metrics(
-    path: Path,
-    *,
-    metric_keys: Iterable[str],
-    power_valid: bool,
-    metrics: Mapping[str, float],
-) -> None:
-    """Validate replacement metrics before atomically updating an aggregate."""
-    data = json.loads(path.read_text(encoding="utf-8"))
-    if not isinstance(data, dict):
-        raise ValueError(f"aggregate is not a JSON object: {path}")
-    data = with_power_metrics(
-        data,
-        metric_keys=metric_keys,
-        schema_version=POWER_METRIC_SCHEMA_VERSION,
-        power_valid=power_valid,
-        metrics=metrics,
-    )
-    _write_json_atomic(path, data)
diff --git a/inferencex-e2e/infx/results/power/cpu_side.py b/inferencex-e2e/infx/results/power/cpu_side.py
new file mode 100644
index 0000000000..c82484b342
--- /dev/null
+++ b/inferencex-e2e/infx/results/power/cpu_side.py
@@ -0,0 +1,334 @@
+"""CPU-side power leg of the srt-slurm power package.
+
+srt-slurm's ``cpu_power_exporter`` leg writes ``power/cpu/samples.csv`` beside
+the GPU package (srt-slurm ``src/srtctl/core/power/cpu_session.py``); its
+``cpu_manifest.json`` is debugging metadata and is not read. Both accepted
+schemas are the wide format: one row per (scrape, host, socket) whose ``sensor`` names the
+socket meter of its source, the Grace socket meter for ACPI or the AMD EPYC package
+counter for RAPL. ACPI rows also carry the component rails of that socket in
+``cpu_rail_w`` / ``soc_w``; RAPL rows carry none. Schema v3 (srt-slurm v2.59.0+) adds
+``module_w``, NVML superchip module power; the module contains both GPUs, so it is
+published as its own rail and never added to the CPU or GPU totals.
+
+Each socket's meter series is integrated over the GPU leg's bound formal
+window with the shared trapezoid and boundary interpolation and published as
+additive metrics next to the GPU-board numbers. The CPU-only, SysIO and module
+rails are integrated the same way when every socket reports them; a rail with
+gaps drops only its own metrics. Any failure records ``cpu_power_valid=0`` with
+reason codes and leaves every GPU field untouched. This module only judges the
+leg; the caller decides whether an invalid leg fails the job.
+"""
+
+from __future__ import annotations
+
+import csv
+import itertools
+import math
+from collections.abc import Iterable
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, NamedTuple
+
+from .common import (
+    MAX_SAMPLE_GAP_SECONDS,
+    _append_reason,
+    _bracketing_sequence,
+    _integrate_device,
+    audit_metrics,
+)
+
+CPU_DIRNAME = "cpu"
+CPU_SAMPLES_FILENAME = "samples.csv"
+
+_CPU_SAMPLES_HEADER_V2 = (
+    "schema_version",
+    "timestamp_unix",
+    "hostname",
+    "source",
+    "sensor",
+    "socket_id",
+    "power_w",
+    "cpu_rail_w",
+    "soc_w",
+    "dram_w",
+    "total_power_w",
+)
+# srt-slurm cpu_samples._SCHEMA_VERSION_BY_HEADER: every row carries its header's
+# version. v2.51.1 writes v2; v2.59.0+ writes v3, module_w before total_power_w.
+_SCHEMA_VERSION_BY_HEADER = {
+    _CPU_SAMPLES_HEADER_V2: 2,
+    (*_CPU_SAMPLES_HEADER_V2[:-1], "module_w", "total_power_w"): 3,
+}
+
+# Two sockets per worker host: a GB200/GB300 compute tray or a dual AMD EPYC host.
+SOCKETS_PER_HOST = 2
+
+
+class SocketMeter(NamedTuple):
+    """The headline per-socket meter of one exporter source.
+
+    srt-slurm names its rows ``CPU<socket>:<sensor_suffix>`` (cpu_rails.SENSOR_SUFFIXES).
+    """
+
+    sensor_suffix: str
+    sensor_kind: str
+
+
+SENSOR_GRACE = "grace_socket"
+SENSOR_RAPL = "rapl_package"
+# srt-slurm cpu_sample.PRIMARY_KIND_BY_SOURCE. ACPI reads "Grace Power Socket N", the whole
+# socket (CPU rail, SysIO, LPDDR5X and regulator loss); RAPL reads the AMD package energy
+# counter, which the kernel gives no DRAM domain.
+SOCKET_METERS = {
+    "acpi": SocketMeter("cpuSidePowerUsageW", SENSOR_GRACE),
+    "rapl": SocketMeter("packagePowerUsageW", SENSOR_RAPL),
+}
+SENSOR_KINDS = frozenset(meter.sensor_kind for meter in SOCKET_METERS.values())
+# Wide-format rail column -> published rail family: "CPU Power Socket N" (cores,
+# no SysIO), "SysIO Power Socket N" and the v3 NVML superchip module. dram_w
+# stays blank on NVL72 firmware; module_w is blank when NVML is unavailable.
+RAIL_COLUMNS = {"cpu_rail_w": "cpu_rail", "soc_w": "cpu_sysio", "module_w": "module"}
+
+_INTEGRATION_METHOD = "per_socket_trapezoidal_with_linear_boundary_interpolation"
+
+
+@dataclass(frozen=True)
+class CpuSampleRow:
+    timestamp_unix: float
+    hostname: str
+    source: str
+    sensor: str
+    socket_id: int
+    power_w: float
+    rails: tuple[tuple[str, float], ...] = ()
+
+
+@dataclass
+class CpuPowerAudit:
+    """Everything the sidecar needs to explain the CPU-side verdict."""
+
+    valid: bool = False
+    sensor_kind: str | None = None
+    source: str | None = None
+    expected_sockets: int = 0
+    observed_sockets: int = 0
+    sample_row_count: int = 0
+    reason_codes: list[str] = field(default_factory=list)
+    per_series_energy_j: dict[str, float] = field(default_factory=dict)
+    per_series_max_sample_gap_s: dict[str, float] = field(default_factory=dict)
+    metrics: dict[str, float] = field(default_factory=dict)
+
+    def invalidate(self, *reasons: str) -> None:
+        for reason in reasons:
+            _append_reason(self.reason_codes, reason)
+        self.valid = False
+        self.metrics = {}
+
+    def to_payload(self) -> dict[str, Any]:
+        return {
+            "cpu_power_valid": self.valid,
+            "reason_codes": list(self.reason_codes),
+            "sensor_kind": self.sensor_kind,
+            "source": self.source,
+            "sockets_per_host": SOCKETS_PER_HOST,
+            "expected_sockets": self.expected_sockets,
+            "observed_sockets": self.observed_sockets,
+            "sample_row_count": self.sample_row_count,
+            "integration_method": _INTEGRATION_METHOD,
+            "max_sample_gap_seconds": MAX_SAMPLE_GAP_SECONDS,
+            "per_series_max_sample_gap_s": dict(self.per_series_max_sample_gap_s),
+            # Overflowed integrations reach here as inf; keep the sidecar strict JSON.
+            "per_series_energy_j": {
+                key: value if math.isfinite(value) else None
+                for key, value in self.per_series_energy_j.items()
+            },
+            "metrics": audit_metrics(self.metrics),
+        }
+
+
+def _parse_row(raw: list[str], header: tuple[str, ...], version: int) -> CpuSampleRow | None:
+    if len(raw) != len(header):
+        return None
+    cell = dict(zip(header, raw, strict=True))
+    try:
+        schema_version = int(cell["schema_version"])
+        timestamp_unix = float(cell["timestamp_unix"])
+        socket_id = int(cell["socket_id"])
+        power_w = float(cell["power_w"])
+    except ValueError:
+        return None
+    hostname, source, sensor = cell["hostname"], cell["source"], cell["sensor"]
+    if schema_version != version or not hostname or not source or not sensor:
+        return None
+    if not math.isfinite(timestamp_unix) or not math.isfinite(power_w) or power_w < 0:
+        return None
+    if socket_id < 0:
+        return None
+    rails = []
+    for column, family in RAIL_COLUMNS.items():
+        value = cell.get(column, "")
+        if not value:
+            continue
+        try:
+            watts = float(value)
+        except ValueError:
+            return None
+        if not math.isfinite(watts) or watts < 0:
+            return None
+        rails.append((family, watts))
+    return CpuSampleRow(
+        timestamp_unix=timestamp_unix,
+        hostname=hostname,
+        source=source,
+        sensor=sensor,
+        socket_id=socket_id,
+        power_w=power_w,
+        rails=tuple(rails),
+    )
+
+
+def read_cpu_samples(path: Path) -> tuple[tuple[CpuSampleRow, ...], tuple[str, ...]]:
+    """Strictly parse a v2 or v3 wide sample file; malformed rows invalidate the leg."""
+    if not path.is_file():
+        return (), ("cpu_samples_missing",)
+    rows: list[CpuSampleRow] = []
+    reasons: list[str] = []
+    try:
+        with open(path, newline="", encoding="utf-8") as handle:
+            reader = csv.reader(handle)
+            header = tuple(next(reader, ()))
+            version = _SCHEMA_VERSION_BY_HEADER.get(header)
+            if version is None:
+                return (), ("cpu_samples_header_mismatch",)
+            for raw in reader:
+                row = _parse_row(raw, header, version)
+                if row is None:
+                    _append_reason(reasons, "cpu_samples_malformed")
+                    continue
+                rows.append(row)
+    except (OSError, UnicodeDecodeError, csv.Error):
+        _append_reason(reasons, "cpu_samples_malformed")
+    return tuple(rows), tuple(reasons)
+
+
+SocketKey = tuple[str, int]
+# (host, socket) -> family -> {timestamp: watts}; the socket meter and its rails.
+SocketSeries = dict[SocketKey, dict[str, dict[float, float]]]
+
+
+def _socket_series(rows: Iterable[CpuSampleRow]) -> tuple[SocketSeries, set[str], bool]:
+    """Group the socket meter rows per socket, with the sources seen and a duplicate flag."""
+    series: SocketSeries = {}
+    sources: set[str] = set()
+    duplicate = False
+    for row in rows:
+        meter = SOCKET_METERS.get(row.source)
+        if meter is None or row.sensor.partition(":")[2] != meter.sensor_suffix:
+            continue
+        by_family = series.setdefault((row.hostname, row.socket_id), {})
+        points = by_family.setdefault(meter.sensor_kind, {})
+        if row.timestamp_unix in points:
+            duplicate = True
+        points[row.timestamp_unix] = row.power_w
+        sources.add(row.source)
+        for family, watts in row.rails:
+            by_family.setdefault(family, {})[row.timestamp_unix] = watts
+    return series, sources, duplicate
+
+
+def _max_sample_gap(samples: list[tuple[float, float]], start: float, end: float) -> float | None:
+    """The widest gap between the samples bracketing ``[start, end]``; None when not bracketed."""
+    sequence = _bracketing_sequence(tuple(t for t, _ in samples), start, end)
+    if sequence is None:
+        return None
+    return max((later - earlier for earlier, later in itertools.pairwise(sequence)), default=0.0)
+
+
+def validate_cpu_leg(
+    cpu_dir: Path,
+    *,
+    window: tuple[float, float] | None,
+    expected_hosts: Iterable[str],
+    expected: bool = False,
+) -> CpuPowerAudit | None:
+    """Validate and integrate the CPU sub-package; None when the run carried none.
+
+    ``expected`` is the point's ``cpu-power`` switch: a missing sub-package is
+    then a verdict rather than silence.
+    """
+    if not cpu_dir.is_dir():
+        if not expected:
+            return None
+        audit = CpuPowerAudit()
+        audit.invalidate("cpu_artifacts_missing")
+        return audit
+    audit = CpuPowerAudit()
+    rows, sample_reasons = read_cpu_samples(cpu_dir / CPU_SAMPLES_FILENAME)
+    audit.sample_row_count = len(rows)
+    audit.invalidate(*sample_reasons)
+    series, sources, duplicate = _socket_series(rows)
+    if duplicate or len(sources) > 1:
+        audit.invalidate("cpu_samples_malformed")
+    expected_keys = {
+        (host, socket) for host in expected_hosts for socket in range(SOCKETS_PER_HOST)
+    }
+    audit.expected_sockets = len(expected_keys)
+    audit.observed_sockets = len(series)
+    if window is None:
+        audit.invalidate("cpu_window_unavailable")
+    if audit.reason_codes:
+        return audit
+    if not expected_keys or set(series) != expected_keys:
+        audit.invalidate("cpu_socket_count_mismatch")
+        return audit
+    audit.source = next(iter(sources))
+    kind = audit.sensor_kind = SOCKET_METERS[audit.source].sensor_kind
+
+    # A rail is published only when every socket reports it, gap-free; the socket
+    # meter must be gap-free on every socket or the whole leg is invalid.
+    families = [kind] + [
+        rail
+        for rail in RAIL_COLUMNS.values()
+        if all(rail in by_family for by_family in series.values())
+    ]
+    start, end = window
+    energy: dict[str, float] = {}
+    dropped_rails: set[str] = set()
+    for (host, socket), by_family in sorted(series.items()):
+        for family in families:
+            samples = sorted(by_family[family].items())
+            label = f"{host}/socket{socket}/{family}"
+            gap = _max_sample_gap(samples, start, end)
+            if gap is not None:
+                audit.per_series_max_sample_gap_s[label] = gap
+            if gap is None or gap > MAX_SAMPLE_GAP_SECONDS:
+                if family != kind:
+                    dropped_rails.add(family)
+                elif gap is None:
+                    audit.invalidate("cpu_window_not_bracketed")
+                else:
+                    audit.invalidate("cpu_sample_gap_exceeded")
+                continue
+            joules = _integrate_device(samples, start_unix=start, end_unix=end)
+            audit.per_series_energy_j[label] = joules
+            energy[family] = energy.get(family, 0.0) + joules
+    if audit.reason_codes:
+        audit.per_series_energy_j = {}
+        return audit
+
+    duration = end - start
+    metrics = {
+        "avg_cpu_socket_power_w": energy[kind] / duration / len(expected_keys),
+        "avg_total_cpu_power_w": energy[kind] / duration,
+        "total_cpu_energy_j": energy[kind],
+    }
+    for rail in RAIL_COLUMNS.values():
+        if rail in energy and rail not in dropped_rails:
+            metrics[f"avg_total_{rail}_power_w"] = energy[rail] / duration
+            metrics[f"total_{rail}_energy_j"] = energy[rail]
+    if any(not math.isfinite(value) for value in metrics.values()):
+        audit.invalidate("non_finite_power_metric")
+        return audit
+    audit.metrics = metrics
+    audit.valid = True
+    return audit
diff --git a/inferencex-e2e/infx/results/power/multinode.py b/inferencex-e2e/infx/results/power/multinode.py
index c857ed4e64..c451752431 100644
--- a/inferencex-e2e/infx/results/power/multinode.py
+++ b/inferencex-e2e/infx/results/power/multinode.py
@@ -27,6 +27,13 @@
 failed sibling window, the sidecar retains the healthy measurement in
 ``selected_window`` and its per-GPU diagnostics at the top level. Publication
 and aggregate power metrics remain blocked.
+
+CPU-side leg: when the package also carries ``power/cpu/`` (see
+:mod:`.cpu_side`), each socket's meter (Grace socket or AMD package) and its rails are
+integrated over the same bound formal window and published under
+``cpu_power_valid``. That verdict is independent of ``power_valid``. A missing
+or invalid CPU leg fails the run only with ``require_power`` and
+``expected_cpu``; otherwise it never changes the exit code.
 """
 
 from __future__ import annotations
@@ -45,20 +52,25 @@
 
 from . import (
     ALL_POWER_METRIC_KEYS as _ALL_POWER_METRIC_KEYS,
+    CPU_METRIC_KEYS as CPU_METRIC_KEYS,
+    POWER_METRIC_SCHEMA_VERSION,
     ROLE_METRIC_KEYS as ROLE_METRIC_KEYS,
     WHOLE_METRIC_KEYS as WHOLE_METRIC_KEYS,
+    with_power_metrics,
 )
 from .common import (
+    MAX_SAMPLE_GAP_SECONDS,
     BenchmarkData,
     _append_reason,
+    _bracketing_sequence,
     _integrate_device,
     _load_benchmark_data,
     _percentile_total_power,
     _write_json_atomic,
     audit_metrics,
     benchmark_window_payload,
-    patch_power_metrics,
 )
+from .cpu_side import CPU_DIRNAME, CpuPowerAudit, validate_cpu_leg
 
 SCHEMA_VERSION = 1
 PRODUCER = "srt-slurm.dcgm-power"
@@ -83,7 +95,6 @@
 SAMPLES_HEADER_V3 = (*SAMPLES_HEADER_V2, "temperature_c")
 SAMPLES_HEADERS = {1: SAMPLES_HEADER, 2: SAMPLES_HEADER_V2, 3: SAMPLES_HEADER_V3}
 
-MAX_SAMPLE_GAP_SECONDS = 3.0
 MAX_TEMPERATURE_C = 200.0
 
 WORKER_ROLES = ("prefill", "decode", "agg")
@@ -732,16 +743,6 @@ def _check_window_result(window: ParsedWindow, result_root: Path) -> list[str]:
     return []
 
 
-def _bracketing_sequence(times: tuple[float, ...], start: float, end: float) -> list[float] | None:
-    """Return the sample ``times`` from the last at or before ``start`` to the first at or after ``end``, or None."""
-    before = [value for value in times if value <= start]
-    after = [value for value in times if value >= end]
-    if not before or not after:
-        return None
-    inside = [value for value in times if start < value < end]
-    return [before[-1], *inside, after[0]]
-
-
 def _check_coverage(
     start: float,
     end: float,
@@ -926,10 +927,16 @@ class MultinodePowerAudit:
     window_metrics: dict[str, float] = field(default_factory=dict)
     per_gpu_energy_j: dict[str, float] = field(default_factory=dict)
     per_gpu_role: dict[str, str] = field(default_factory=dict)
+    # Not serialized; absent for a GPU assigned to more than one worker.
+    per_gpu_worker_index: dict[str, int] = field(default_factory=dict)
     per_gpu_max_sample_gap_s: dict[str, float] = field(default_factory=dict)
     observed_gpu_count: int = 0
     expected_gpu_count: int = 0
     metrics: dict[str, float] = field(default_factory=dict)
+    # Input the CPU-side leg borrows from the GPU package; not serialized.
+    expected_worker_hosts: tuple[str, ...] = ()
+    # None when the package carried no cpu/ sub-package.
+    cpu: CpuPowerAudit | None = None
 
 
 def _canonical_sha256(payload: dict) -> str:
@@ -956,8 +963,48 @@ def validate_and_integrate(
     decode_gpus: int,
     aggregate_gpus: int,
     expected_producer_sha: str | None,
+    expected_cpu: bool = False,
+) -> MultinodePowerAudit:
+    """Recompute package validity, cross-check verdicts, and integrate energy.
+
+    The GPU leg runs first and binds the formal window; the CPU-side leg then
+    reuses that window and the manifest topology as inputs. No GPU verdict
+    reaches it: an unpinned producer or failed GPU coverage withholds GPU
+    energy only, and ``cpu_power_valid`` judges the CPU samples on their own.
+    """
+    audit = _validate_gpu_leg(
+        power_dir=power_dir,
+        logs_root=logs_root,
+        bench_result_path=bench_result_path,
+        benchmark=benchmark,
+        prefill_gpus=prefill_gpus,
+        decode_gpus=decode_gpus,
+        aggregate_gpus=aggregate_gpus,
+        expected_producer_sha=expected_producer_sha,
+    )
+    window = None
+    if audit.window is not None and _window_contract_holds(audit.window, audit.window_validations):
+        window = (audit.window["start_time_unix"], audit.window["end_time_unix"])
+    audit.cpu = validate_cpu_leg(
+        power_dir / CPU_DIRNAME,
+        window=window,
+        expected_hosts=audit.expected_worker_hosts,
+        expected=expected_cpu,
+    )
+    return audit
+
+
+def _validate_gpu_leg(
+    *,
+    power_dir: Path,
+    logs_root: Path,
+    bench_result_path: Path,
+    benchmark: BenchmarkData | None,
+    prefill_gpus: int,
+    decode_gpus: int,
+    aggregate_gpus: int,
+    expected_producer_sha: str | None,
 ) -> MultinodePowerAudit:
-    """Recompute package validity, cross-check verdicts, and integrate energy."""
     audit = MultinodePowerAudit(
         expected_producer_git_commit=expected_producer_sha,
     )
@@ -1006,6 +1053,7 @@ def validate_and_integrate(
         _add_reason(audit, "manifest_malformed", f"manifest malformed: {exc!r}")
         audit.recomputed_publication_valid = False
         return audit
+    audit.expected_worker_hosts = tuple(sorted({device.hostname for device in expected_devices}))
 
     rows, sample_reasons = read_samples(power_dir / SAMPLES_FILENAME)
     recompute_failures += [f"{reason} in {SAMPLES_FILENAME}" for reason in sample_reasons]
@@ -1107,11 +1155,15 @@ def validate_and_integrate(
     audit.per_gpu_role = {
         uuid_label.get(key, f"{key[0]}/{key[1]}"): role for key, role in sorted(roles.items())
     }
+    for device in expected_devices:
+        indices = {assignment.worker_index for assignment in device.assignments}
+        if device.key in roles and len(indices) == 1:
+            label = uuid_label.get(device.key, f"{device.key[0]}/{device.key[1]}")
+            audit.per_gpu_worker_index[label] = indices.pop()
 
     window = _select_window_for_result(
         audit, parsed_windows, logs_root, bench_result_path, benchmark
     )
-
     if (
         not audit.package_integrity_valid
         or not topology_valid
@@ -1279,14 +1331,88 @@ def _select_window_for_result(
     return window
 
 
+# Per-window audit codes that describe GPU sample coverage rather than the
+# window's own contract (srt-slurm power/windows.py _check_coverage); the
+# CPU-side leg re-checks its own coverage.
+_GPU_COVERAGE_REASONS = frozenset(
+    {
+        "measurement_window_not_bracketed",
+        "sample_gap_exceeded",
+        "gpu_uuid_changed",
+        "sample_loss_exceeded",
+    }
+)
+
+
+def _window_contract_holds(window: dict, validations: list[dict]) -> bool:
+    """True when the bound window passed every check that is not GPU coverage."""
+    for validation in validations:
+        if (validation["benchmark_type"], validation["concurrency"]) == (
+            window["benchmark_type"],
+            window["concurrency"],
+        ):
+            return all(reason in _GPU_COVERAGE_REASONS for reason in validation["reason_codes"])
+    return False
+
+
+def _host_workers(audit: MultinodePowerAudit) -> list[dict]:
+    """Project validated device energy onto one entry per worker per physical host.
+
+    A worker spanning hosts yields one entry per host, each with the manifest's worker
+    index, so consumers can model trays by host and still group entries by worker.
+    """
+    if not audit.power_valid or audit.window is None:
+        return []
+    if audit.per_gpu_energy_j.keys() - audit.per_gpu_worker_index.keys():
+        return []
+    duration_s = audit.window["end_time_unix"] - audit.window["start_time_unix"]
+    energies: dict[tuple[str, int, str], list[float]] = {}
+    for device, joules in audit.per_gpu_energy_j.items():
+        key = (
+            audit.per_gpu_role[device],
+            audit.per_gpu_worker_index[device],
+            device.rsplit("/", 1)[0],
+        )
+        energies.setdefault(key, []).append(joules)
+    return [
+        {
+            "role": role,
+            "worker_idx": worker_idx,
+            "hosts": [host],
+            "num_gpus": len(values),
+            "avg_power_w": round(sum(values) / duration_s / len(values), 3),
+        }
+        for (role, worker_idx, host), values in sorted(energies.items())
+    ]
+
+
 def _patch_agg(agg_path: Path, audit: MultinodePowerAudit) -> None:
     """Write the ``audit`` verdict and power metrics into the aggregate JSON at ``agg_path``."""
-    patch_power_metrics(
-        agg_path,
+    cpu = audit.cpu
+    data = json.loads(agg_path.read_text(encoding="utf-8"))
+    if not isinstance(data, dict):
+        raise ValueError(f"aggregate is not a JSON object: {agg_path}")
+    data = with_power_metrics(
+        data,
+        schema_version=POWER_METRIC_SCHEMA_VERSION,
         metric_keys=_ALL_POWER_METRIC_KEYS,
         power_valid=audit.power_valid,
         metrics=audit.metrics,
+        cpu_power_valid=None if cpu is None else cpu.valid,
+        cpu_metrics={} if cpu is None else cpu.metrics,
     )
+    data.pop("workers", None)
+    if workers := _host_workers(audit):
+        data["workers"] = workers
+    _write_json_atomic(agg_path, data)
+
+
+def _withhold_metrics(audit: MultinodePowerAudit, cpu_reason: str | None = None) -> None:
+    """Drop every publishable number; the CPU leg only when the failure is shared."""
+    audit.power_valid = False
+    audit.metrics = {}
+    if audit.cpu is not None and cpu_reason is not None:
+        audit.cpu.invalidate(cpu_reason)
 
 
 def _sidecar_payload(
@@ -1297,7 +1423,7 @@ def _sidecar_payload(
     benchmark: BenchmarkData | None,
 ) -> dict:
     """Build the power validation sidecar JSON from ``audit`` and the benchmark inputs."""
-    return {
+    payload = {
         "schema_version": 1,
         "power_valid": audit.power_valid,
         "reasons": list(audit.reasons),
@@ -1335,6 +1461,10 @@ def _sidecar_payload(
         },
         "metrics": audit_metrics(audit.metrics),
     }
+    # Only when the package carried cpu/: sidecars without it stay byte-identical.
+    if audit.cpu is not None:
+        payload["cpu"] = audit.cpu.to_payload()
+    return payload
 
 
 def run(
@@ -1349,6 +1479,7 @@ def run(
     aggregate_gpus: int = 0,
     validation_result: Path | None = None,
     require_power: bool = False,
+    expected_cpu: bool = False,
 ) -> int:
     """Validate multinode power artifacts, patch metrics, and audit the verdict."""
     validation_result = validation_result or bench_result.with_name(
@@ -1366,24 +1497,22 @@ def run(
         decode_gpus=decode_gpus,
         aggregate_gpus=aggregate_gpus,
         expected_producer_sha=expected_producer_sha,
+        expected_cpu=expected_cpu,
     )
     for reason in benchmark_reasons:
         _add_reason(audit, reason)
     if benchmark is None or audit.reasons:
-        audit.power_valid = False
-        audit.metrics = {}
+        _withhold_metrics(audit)
 
     if not agg_result.is_file():
         _add_reason(audit, "aggregate_result_missing", f"aggregate missing: {agg_result}")
-        audit.power_valid = False
-        audit.metrics = {}
+        _withhold_metrics(audit, "aggregate_result_missing")
     else:
         try:
             _patch_agg(agg_result, audit)
         except (OSError, json.JSONDecodeError, ValueError) as exc:
             _add_reason(audit, "aggregate_result_unwritable", str(exc))
-            audit.power_valid = False
-            audit.metrics = {}
+            _withhold_metrics(audit, "aggregate_result_unwritable")
             print(
                 f"[aggregate_power_multinode] Failed to patch {agg_result}: {exc}",
                 file=sys.stderr,
@@ -1407,6 +1536,20 @@ def run(
         )
         return 1 if require_power else 0
 
+    if audit.cpu is not None:
+        cpu = audit.cpu
+        print(
+            f"[aggregate_power_multinode] cpu_power_valid={int(cpu.valid)} "
+            f"sensor_kind={cpu.sensor_kind} "
+            f"avg_total_cpu_power_w={cpu.metrics.get('avg_total_cpu_power_w', 0.0):.2f} "
+            f"total_cpu_energy_j={cpu.metrics.get('total_cpu_energy_j', 0.0):.2f} "
+            f"reasons={','.join(cpu.reason_codes) or '-'}"
+        )
+
+    if require_power and expected_cpu and (audit.cpu is None or not audit.cpu.valid):
+        print("[aggregate_power_multinode] Required CPU power is invalid", file=sys.stderr)
+        return 1
+
     if not audit.power_valid:
         print(
             f"[aggregate_power_multinode] Power validation failed: "
diff --git a/inferencex-e2e/infx/srt_slurm/al_gate.py b/inferencex-e2e/infx/srt_slurm/al_gate.py
new file mode 100644
index 0000000000..d79eefb8eb
--- /dev/null
+++ b/inferencex-e2e/infx/srt_slurm/al_gate.py
@@ -0,0 +1,193 @@
+"""Plan and summarize the report-only SPEED-Bench acceptance gate of AgentX speculative evals.
+
+An agentic eval job whose generation role drafts replays the golden curve's SPEED-Bench
+collection before its eval, against the same server: srt-slurm runs the gate as the job's
+benchmark stage, which alone receives the workers' metrics endpoints, and the eval as its
+post-benchmark eval. The gate never fails the job.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Any
+
+from infx.golden_al_distribution import GOLDEN_DIR, curve_name, load_curve
+from infx.srt_slurm.synthetic_acceptance import (
+    ENGINES,
+    generation_role,
+    spec_parameters,
+    verifier,
+)
+
+COMMAND = "bash /infmax-workspace/benchmarks/srt_al_gate.sh"
+OUTPUT_DIR = "/logs"
+# srt-slurm runs the benchmark stage, then the eval, only without EVAL_ONLY.
+SRT_ENVIRONMENT = {"EVAL_ONLY": "false", "RUN_EVAL": "true"}
+EXEMPT_FRAMEWORKS = {
+    "tilert": "TileRT rejects streaming /v1/completions and serves no metrics",
+}
+LEADER_ONLY_METRICS = (
+    "srtctl gives the gate only the leader's metrics of this multi-node Dynamo vLLM "
+    "data-parallel worker, so AL would cover part of the prompts"
+)
+
+
+def requested(environment: Mapping[str, str]) -> bool:
+    """Whether the launcher found the prompts for this agentic speculative eval."""
+    return environment.get("EVAL_AL_GATE") == "true"
+
+
+def leader_only_metrics(
+    role: Mapping[str, Any], recipe: Mapping[str, Any], environment: Mapping[str, str]
+) -> bool:
+    """Whether srtctl runs a Dynamo vLLM worker's data-parallel ranks as one process per node,
+    as it does when they span nodes but a tensor x pipeline replica fits on one."""
+    args = role.get("args") or {}
+    dp, tp, pp = (int(args.get(f"{k}-parallel-size", 1)) for k in ("data", "tensor", "pipeline"))
+    if dp == 1:
+        return False
+    gpus_per_node = (recipe.get("resources") or {}).get("gpus_per_node")
+    if gpus_per_node is None:  # srtctl then uses the cluster's, from runners.yaml
+        from infx.clusters import CLUSTER_LABEL_PREFIX, load_clusters
+
+        cluster = environment["RUNNER_TYPE"].removeprefix(CLUSTER_LABEL_PREFIX)
+        gpus_per_node = load_clusters()[cluster].gpus_per_node
+    return tp * pp <= gpus_per_node < tp * pp * dp
+
+
+def plan(
+    recipe: Mapping[str, Any],
+    framework: str,
+    environment: Mapping[str, str],
+    *,
+    golden_dir: Path = GOLDEN_DIR,
+) -> dict[str, Any] | None:
+    """The gate a resolved eval recipe runs, a ``skipped`` record, or None when it does not draft.
+
+    A runnable gate has ``curve``, ``draft_tokens`` and ``golden_acceptance_length``. The curve
+    is the one synthetic acceptance selects for the generation role and its verifier.
+    """
+    if framework in EXEMPT_FRAMEWORKS:
+        return skipped(EXEMPT_FRAMEWORKS[framework], environment)
+    engine = ENGINES.get(framework)
+    if engine is None:
+        return skipped(f"{framework} has no speculative settings to read", environment)
+    role = generation_role(recipe)
+    spec = spec_parameters(role, engine)
+    if not spec:
+        return None
+    if framework == "dynamo-vllm" and leader_only_metrics(role, recipe, environment):
+        return skipped(LEADER_ONLY_METRICS, environment)
+    try:
+        verify = verifier(role, engine).value
+        name = curve_name(environment["MODEL_PREFIX"], spec, golden_dir, verify)
+        curve = load_curve(name, golden_dir)
+        tokens = spec.get("num_speculative_tokens")
+        golden = curve.acceptance(environment["THINKING_MODE"], tokens)
+    except (KeyError, TypeError, ValueError) as error:
+        return skipped(f"no golden AL: {error}", environment)
+    if curve.collection is None:
+        return skipped(f"golden curve {curve.name} records no collection to replay", environment)
+    return {"curve": curve.name, "draft_tokens": tokens, "golden_acceptance_length": golden}
+
+
+def skipped(reason: str, environment: Mapping[str, str]) -> dict[str, Any]:
+    """The result document of a gate that did not run."""
+    return {
+        "result_filename": environment.get("RESULT_FILENAME"),
+        "framework": environment.get("FRAMEWORK"),
+        "eval_framework": environment.get("EVAL_FRAMEWORK"),
+        "eval_suite": environment.get("EVAL_SUITE"),
+        "status": "skipped",
+        "error": reason,
+        "report_only": True,
+    }
+
+
+def overrides(gate: Mapping[str, Any], environment: Mapping[str, str]) -> list[str]:
+    """``srtctl apply`` arguments that run ``gate`` as the benchmark stage, without power.
+
+    ``benchmark.env`` outranks the job environment. The container resolves the relative
+    ``AL_GATE_DATASET`` in ``/infmax-workspace``.
+    """
+    env = {
+        "AL_GATE": "true",
+        "AL_GATE_CURVE": gate["curve"],
+        "AL_GATE_DRAFT_TOKENS": str(gate["draft_tokens"]),
+        "AL_GATE_DATASET": environment["AL_GATE_DATASET"],
+        "AL_GATE_OUTPUT_DIR": OUTPUT_DIR,
+        "THINKING_MODE": environment["THINKING_MODE"],
+        **{
+            name: environment[name]
+            for name in ("EVAL_FRAMEWORK", "EVAL_SUITE")
+            if environment.get(name)
+        },
+    }
+    arguments = [
+        "--set", 'benchmark.type="custom"',
+        "--set", f"benchmark.command={json.dumps(COMMAND)}",
+    ]  # fmt: skip
+    for name, value in env.items():
+        arguments += ["--set", f"benchmark.env.{name}={json.dumps(value)}"]
+    return [*arguments, "--unset", "telemetry"]
+
+
+def _number(value: float | None, digits: int = 2) -> str:
+    return "-" if value is None else f"{value:.{digits}f}"
+
+
+def summarize(results: list[Mapping[str, Any]]) -> str:
+    """Markdown of the gate verdicts, or an empty string without any."""
+    if not results:
+        return ""
+    lines = [
+        "## Speculative acceptance gate (report-only)",
+        "",
+        (
+            "Measured with real verification on the eval's server; "
+            "`pass` is within 5% of the golden AL."
+        ),
+        "",
+        "| Point | Eval | Curve | Draft tokens | Golden AL | Measured AL | Ratio | Status |",
+        "| --- | --- | --- | --- | --- | --- | --- | --- |",
+    ]
+    for r in sorted(
+        results, key=lambda r: (str(r.get("result_filename")), str(r.get("eval_framework")))
+    ):
+        evaluation = " ".join(filter(None, (r.get("eval_framework"), r.get("eval_suite")))) or "-"
+        status = r.get("status")
+        if r.get("error"):
+            status = f"{status}: {r['error']}"
+        lines.append(
+            f"| `{r.get('result_filename')}` | {evaluation} | {r.get('curve') or '-'} | "
+            f"{r.get('draft_tokens') or '-'} | {_number(r.get('golden_acceptance_length'))} | "
+            f"{_number(r.get('acceptance_length'))} | {_number(r.get('ratio'), 3)} | {status} |"
+        )
+    return "\n".join(lines) + "\n"
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    commands = parser.add_subparsers(dest="command", required=True)
+    summary = commands.add_parser("summarize", help="tabulate downloaded al_gate_*.json results")
+    summary.add_argument("results", type=Path)
+    args = parser.parse_args(argv)
+    results = []
+    for path in sorted(args.results.rglob("al_gate_*.json")):
+        try:
+            document = json.loads(path.read_text())
+        except (OSError, ValueError) as error:
+            print(f"WARNING: unreadable {path}: {error}", file=sys.stderr)
+            continue
+        if isinstance(document, dict) and "status" in document:
+            results.append(document)
+    sys.stdout.write(summarize(results))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/inferencex-e2e/infx/srt_slurm/generate.py b/inferencex-e2e/infx/srt_slurm/generate.py
index 4b74685237..f1e9033fa3 100644
--- a/inferencex-e2e/infx/srt_slurm/generate.py
+++ b/inferencex-e2e/infx/srt_slurm/generate.py
@@ -23,7 +23,14 @@
 from infx.matrix.validation import config_root, load_config_files, load_runner_file
 from infx.srt_slurm.single_node import select_recipe
 from infx.srt_slurm.synthetic_acceptance import build_overrides, selected_recipes
-from infx.srt_slurm.workload import bind_multinode, check_setup_script, resolve_fabric
+from infx.srt_slurm.workload import (
+    CpuPowerSource,
+    GpuPower,
+    bind_multinode,
+    check_setup_script,
+    resolve_fabric,
+    selects_dedicated_discovery,
+)
 
 if TYPE_CHECKING:
     from infx.clusters import Cluster, RunnerInventory
@@ -65,6 +72,7 @@ def point_environment(point: Mapping[str, Any]) -> dict[str, str]:
             IS_MULTINODE="true",
             SRT_RECIPE=point["srt-recipe"],
             POWER="1" if point.get("power") else "0",
+            CPU_POWER="1" if point.get("cpu-power") else "0",
             CONC_LIST=" ".join(map(str, point["conc"])),
             DECODE_CPU_DRAM_GB=str(point.get("decode-cpu-dram-gb", 0)),
         )
@@ -97,16 +105,19 @@ def _binder_inputs(
     environment: Mapping[str, str],
     placement: tuple[str, Cluster] | None,
     root: Path,
-) -> tuple[int | None, dict[str, str]]:
-    """The DCGM exporter port and AgentX client env the launcher binds a multi-node point with.
+) -> tuple[GpuPower | None, str | None, dict[str, str]]:
+    """The GPU power telemetry, CPU exporter source and AgentX client env the launcher binds a
+    point with; a single-node point gets only the CPU exporter source.
 
     Raises ``ValueError`` when they depend on a cluster the runner label does not single out,
     or the cluster's lanes refuse the point.
     """
-    agentic = environment["IS_AGENTIC"] == "1"
-    if "prefill" not in point or not (agentic or point.get("power")):
-        return None, {}
+    single_node = "prefill" not in point
+    cpu_power = bool(point.get("cpu-power"))
     if placement is None:
+        multinode_binds = environment["IS_AGENTIC"] == "1" or point.get("power")
+        if not (cpu_power if single_node else multinode_binds):
+            return None, None, {}
         raise ValueError(
             f"runner {point['runner']!r} must schedule on one cluster to bind the cluster's "
             "power telemetry and AgentX client paths"
@@ -116,6 +127,11 @@ def _binder_inputs(
     srt = slurm_settings(cluster).srt_slurm
     if srt is None:
         raise ValueError(f"cluster {cluster.id!r} has no slurm.srt-slurm settings")
+    if single_node:
+        try:
+            return None, config.cpu_power_source(cluster, srt, cpu_power, default=True), {}
+        except LaunchError as error:
+            raise ValueError(str(error)) from error
     runtime = {
         "RUNNER_NAME": runner,
         "GITHUB_WORKSPACE": str(root),
@@ -125,7 +141,15 @@ def _binder_inputs(
     try:
         path = launch_path(cluster.id, request)
         lane = lanes.srt_lane(cluster.id, path)
-        decision = power.decide_power(cluster.id, path, request)
+        decision = power.decide_power(
+            cluster.id,
+            path,
+            srt,
+            request,
+            lambda: selects_dedicated_discovery(
+                str(root / point["srt-recipe"]), agentic=request.is_agentic, root=root
+            ),
+        )
         return config.binder_inputs(cluster, srt, lane, request, decision)
     except LaunchError as error:
         raise ValueError(f"cluster {cluster.id!r}: {error}") from error
@@ -137,18 +161,24 @@ def bound_variant(
     root: Path,
     *,
     expand: Callable[..., list[tuple[str | None, dict[str, Any]]]] = selected_recipes,
-    power_port: int | None = None,
+    gpu_power: GpuPower | None = None,
+    cpu_power_source: CpuPowerSource | None = None,
     client_env: Mapping[str, str] | None = None,
 ) -> tuple[str | None, dict[str, Any]]:
     """The variant the launcher submits for ``point``, composed and bound.
 
-    Multi-node variants get the DCGM telemetry block on ``power_port`` and the client paths
-    ``client_env``, the binder inputs the launcher computes. ``'@fabric.<name>'`` values stay
-    unresolved: recipe fingerprints hash them as written.
+    Variants get the CPU exporter on ``cpu_power_source``; multi-node variants also get the
+    GPU telemetry ``gpu_power`` and the client paths ``client_env``: the binder
+    inputs the launcher computes. ``'@fabric.<name>'`` values stay unresolved: recipe
+    fingerprints hash them as written.
     """
     if "prefill" not in point:
         selected, recipe = select_recipe(
-            str(root / point["srt-recipe"]), environment, root=root, expand=expand
+            str(root / point["srt-recipe"]),
+            environment,
+            root=root,
+            expand=expand,
+            cpu_power_source=cpu_power_source,
         )
         return selected.partition(":")[2] or None, recipe
     return bind_multinode(
@@ -156,7 +186,8 @@ def bound_variant(
         environment,
         root=root,
         expand=expand,
-        power_port=power_port,
+        gpu_power=gpu_power,
+        cpu_power_source=cpu_power_source,
         client_env=client_env,
     )
 
@@ -205,7 +236,7 @@ def generate_recipes(
 ) -> dict[str, Any]:
     """Bind every srt-slurm point of ``config_keys``; write recipes and a manifest.
 
-    A multi-node point is bound with its cluster's DCGM exporter port and AgentX client
+    A multi-node point is bound with its cluster's GPU power telemetry and AgentX client
     paths; the manifest names that cluster, the one its runner label schedules on. A runner
     label on several clusters leaves ``'@fabric.<name>'`` values as written and the
     manifest's ``cluster`` null.
@@ -232,26 +263,24 @@ def generate_recipes(
         for point in points:
             environment = point_environment(point)
             placement = _placement(inventory, point["runner"])
-            power_port, client_env = _binder_inputs(point, environment, placement, root)
+            gpu_power, cpu_source, client_env = _binder_inputs(point, environment, placement, root)
             fabric = _cluster_fabric(placement[1]) if placement else None
             variant, recipe = bound_variant(
-                point, environment, root, power_port=power_port, client_env=client_env
-            )
+                point, environment, root,
+                gpu_power=gpu_power, cpu_power_source=cpu_source, client_env=client_env,
+            )  # fmt: skip
             if fabric is not None:
                 recipe = resolve_fabric(recipe, fabric)
             check_setup_script(recipe, root / point["srt-recipe"].partition(":")[0], root)
-            if "prefill" not in point:
-                clusters = {
-                    inventory.cluster_for(runner).id: inventory.cluster_for(runner)
-                    for runner in inventory.labels[point["runner"]]
-                }
-                for cluster in clusters.values():
-                    srt = slurm_settings(cluster).srt_slurm
-                    _apply_acceptance_and_validate(
-                        recipe, environment, point["srt-recipe"], srt.extra if srt else None
-                    )
-            else:
-                _apply_acceptance_and_validate(recipe, environment, point["srt-recipe"])
+            clusters = {
+                inventory.cluster_for(runner).id: inventory.cluster_for(runner)
+                for runner in inventory.labels[point["runner"]]
+            }
+            for cluster in clusters.values():
+                srt = slurm_settings(cluster).srt_slurm
+                _apply_acceptance_and_validate(
+                    recipe, environment, point["srt-recipe"], srt.extra if srt else None
+                )
             identity = json.dumps({"point": point, "variant": variant}, sort_keys=True)
             digest = hashlib.sha256(identity.encode()).hexdigest()[:12]
             name = f"{re.sub(r'[^A-Za-z0-9_.-]', '_', key)}-{digest}.yaml"
diff --git a/inferencex-e2e/infx/srt_slurm/single_node.py b/inferencex-e2e/infx/srt_slurm/single_node.py
index f84bd6e8e4..6e589acdfb 100644
--- a/inferencex-e2e/infx/srt_slurm/single_node.py
+++ b/inferencex-e2e/infx/srt_slurm/single_node.py
@@ -16,7 +16,11 @@
 from infx.srt_slurm.synthetic_acceptance import ENGINES, selected_recipes, spec_parameters
 from infx.srt_slurm.workload import (
     BOUND_RECIPE,
+    NATIVE,
+    CpuPowerSource,
+    add_cpu_power_source_argument,
     add_fabric_argument,
+    bind_speculation,
     bind_workload,
     check_setup_script,
     compose_recipe,
@@ -37,6 +41,14 @@ def parallelism_constraints(
     """Read each engine's native topology fields without translating the recipe."""
     tp, ep = int(environment["TP"]), int(environment["EP_SIZE"])
     dp_attention = environment["DP_ATTENTION"] == "true"
+    if engine == "tokenspeed":
+        data_parallel = args["data-parallel-size"]
+        return {
+            "attention TP x DP": (args["attn-tp-size"] * data_parallel, tp),
+            "DP_ATTENTION": (data_parallel > 1, dp_attention),
+            "ep-size": (args["ep-size"], ep),
+            "pipeline-parallel-size": (args["pipeline-parallel-size"], 1),
+        }
     if engine == "sglang":
         return {
             "tensor-parallel-size": (args["tensor-parallel-size"], tp),
@@ -74,12 +86,14 @@ def select_recipe(
     *,
     root: Path | None = None,
     expand: Callable[..., list[tuple[str | None, dict[str, Any]]]] = selected_recipes,
+    cpu_power_source: CpuPowerSource | None = None,
 ) -> tuple[str, dict[str, Any]]:
     """Resolve a matrix point to one native variant, never submit an entire sweep.
 
     Variants are composed with the shared block under ``root`` (default: this
     repository) and bound before they are validated. ``expand`` lists the selected
     variants: srtctl at launch, ``variants.expand_variants`` in the planner.
+    ``cpu_power_source`` adds the cluster's CPU power exporter to the native telemetry.
     """
     path, _, selector = config.partition(":")
     agentic = environment["IS_AGENTIC"] == "1"
@@ -88,7 +102,8 @@ def select_recipe(
         agentic=agentic,
         multinode=False,
         root=root or repository_root(),
-        native_power=environment.get("EVAL_ONLY") != "true",
+        gpu_power=NATIVE if environment.get("EVAL_ONLY") != "true" else None,
+        cpu_power_source=cpu_power_source,
     )
     recipes = expand(raw, selector or None)
     matches = []
@@ -97,6 +112,7 @@ def select_recipe(
         try:
             recipe = bind_workload(recipe, environment, agentic=agentic, multinode=False)
             validate_recipe(recipe, environment)
+            bind_speculation(recipe, environment)
         except ValueError as exc:
             errors.append(f"{name}: {exc}")
         except (KeyError, TypeError) as exc:
@@ -117,14 +133,14 @@ def validate_recipe(recipe: dict[str, Any], environment: Mapping[str, str]) -> N
     workload = benchmark["env"]
     engine_config = recipe["engine"]
     engine = engine_config["type"] if isinstance(engine_config, dict) else engine_config
-    if environment["FRAMEWORK"] not in {"sglang", "trt", "atom", "vllm"}:
+    if environment["FRAMEWORK"] not in {"sglang", "trt", "atom", "vllm", "tokenspeed"}:
         raise ValueError(f"Unsupported single-node framework: {environment['FRAMEWORK']!r}")
     spec = spec_parameters(role, engine)
     if spec and spec["method"] not in {"eagle", "eagle3", "nextn", "mtp", "dspark", "dflash"}:
         raise ValueError(
             "Single-node SRT supports only native MTP, EAGLE3, DSpark, DFlash or no speculation"
         )
-    speculation = "mtp" if spec else workload.get("SPEC_DECODING", "none")
+    speculation = "mtp" if spec else "none"
     agentic = environment["IS_AGENTIC"] == "1"
     expected = {
         "engine": (engine, SINGLE_NODE_ENGINES[environment["FRAMEWORK"]]),
@@ -192,6 +208,7 @@ def runtime_arguments(config: str, environment: Mapping[str, str]) -> list[str]:
             "trt": ("max_seq_len", "max_num_tokens"),
             "atom": ("max-model-len",),
             "vllm": ("max-model-len",),
+            "tokenspeed": ("max-model-len",),
         }[environment["FRAMEWORK"]]
         for key in context_keys:
             overrides += ["--set", f"roles.agg.args.{key}={context}"]
@@ -222,6 +239,7 @@ def main() -> None:
     prepare.add_argument("recipe")
     prepare.add_argument("output", type=Path)
     add_fabric_argument(prepare)
+    add_cpu_power_source_argument(prepare)
     submitted = commands.add_parser("submission")
     submitted.add_argument("manifest", type=Path)
     parsed = parser.parse_args()
@@ -229,7 +247,9 @@ def main() -> None:
         parser.error(f"{parsed.output} would overwrite the bound recipe written beside it")
     try:
         if parsed.command == "prepare":
-            selected, recipe = select_recipe(parsed.recipe, os.environ)
+            selected, recipe = select_recipe(
+                parsed.recipe, os.environ, cpu_power_source=parsed.cpu_power_source
+            )
             recipe = resolve_fabric(recipe, parsed.fabric)
             check_setup_script(recipe, Path(parsed.recipe.partition(":")[0]), repository_root())
             arguments = runtime_arguments(parsed.recipe, os.environ)
diff --git a/inferencex-e2e/infx/srt_slurm/spec_identity.py b/inferencex-e2e/infx/srt_slurm/spec_identity.py
new file mode 100644
index 0000000000..bb63668ddb
--- /dev/null
+++ b/inferencex-e2e/infx/srt_slurm/spec_identity.py
@@ -0,0 +1,222 @@
+"""Describe a generation role's drafting and verification, and audit it against its curve.
+
+Each engine spells drafting and verification differently, and some of it is only an engine
+default. ``run_collection`` maps a role to the vocabulary of
+``infx/golden_al_distribution/identities.yaml``, labelling every fact explicit, documented,
+assumed, default or unknown. ``audit`` reports how a run differs from the curve ``curve_name``
+selects; it never changes that curve.
+
+python -m infx.srt_slurm.spec_identity snapshot MATRIX_JSON --root INFERENCEX_E2E
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Any
+
+from infx.golden_al_distribution import GOLDEN_DIR, curve_name, golden_length
+from infx.golden_al_distribution.identity import (
+    Collection,
+    Fact,
+    compare,
+    load_identities,
+    normalize_method,
+)
+from infx.srt_slurm.synthetic_acceptance import ENGINES, spec_parameters, verifier
+
+# Arguments of a generation role that describe speculative decoding, per engine spelling.
+SPEC_ARGUMENTS = (
+    "speculative", "with-mtp", "num-mtp", "method", "num-speculative-tokens", "draft-model",
+    "kv-cache-dtype", "kv_cache_dtype", "kv_cache_config",
+)  # fmt: skip
+# Spellings of one KV cache dtype; "auto" leaves the engine default.
+DTYPE_ALIASES = {"fp8_e4m3": "fp8", "bfloat16": "bf16", "auto": None}
+DEFAULT = Fact(None, "default")
+UNKNOWN = Fact(None, "unknown")
+CHAIN = Fact("chain", "documented")
+# Adaptive verification is an opt-in engine flag.
+NOT_ADAPTIVE = Fact(False, "documented")
+# A Hugging Face cache path names its repo as models--<org>--<name>.
+HF_CACHE_REPO = re.compile(r"models--([^/]+)--([^/]+)")
+
+
+def speculation_facts(model_prefix: str, spec: Mapping[str, Any]) -> tuple[str, str]:
+    """A drafting role's method in the identity vocabulary and its draft model: the repo the
+    engine loads, or ``native`` when the served checkpoint drafts for itself."""
+    model = str(spec.get("model") or "")
+    if cached := HF_CACHE_REPO.search(model):
+        model = f"{cached[1]}/{cached[2]}"
+    return normalize_method(model_prefix, str(spec.get("method", ""))), model or "native"
+
+
+def _set(value: Any) -> Fact:
+    return DEFAULT if value is None else Fact(value, "explicit")
+
+
+def _vllm(spec: Mapping[str, Any]) -> dict[str, Fact]:
+    adaptive = spec.get("enable_adaptive_verification")
+    return {
+        "draft_sample": _set(spec.get("draft_sample_method")),
+        "adaptive": (NOT_ADAPTIVE if adaptive is None else Fact(adaptive, "explicit")),
+        "topology": CHAIN,
+    }
+
+
+def _sglang(args: Mapping[str, Any], method: str) -> dict[str, Fact]:
+    topk = args.get("speculative-eagle-topk")
+    if method in ("dspark", "dflash"):
+        topology = CHAIN  # block drafters propose one sequence
+    elif isinstance(topk, int) and not isinstance(topk, bool):
+        topology = Fact("chain" if topk == 1 else f"tree-topk{topk}", "explicit")
+    else:
+        topology = DEFAULT  # SGLang chooses topk itself when it is unset
+    return {
+        "draft_sample": DEFAULT,
+        "adaptive": NOT_ADAPTIVE,
+        "topology": topology,
+    }
+
+
+def _trtllm() -> dict[str, Fact]:
+    return {"draft_sample": DEFAULT, "adaptive": NOT_ADAPTIVE, "topology": CHAIN}
+
+
+def _atom(method: str) -> dict[str, Fact]:
+    return {
+        # spec_parameters gives ATOM DSpark probabilistic drafting; ATOM has no sampler flag.
+        "draft_sample": Fact("probabilistic", "assumed") if method == "dspark" else UNKNOWN,
+        "adaptive": DEFAULT,
+        "topology": CHAIN,
+    }
+
+
+def _dtype(value: Any) -> Fact:
+    if isinstance(value, str):
+        value = DTYPE_ALIASES.get(value.lower(), value.lower())
+    return _set(value)
+
+
+def _precision(args: Mapping[str, Any], spec: Mapping[str, Any], engine: str) -> dict[str, Fact]:
+    """The draft weights' quantization and the draft's and target's KV cache dtypes."""
+    config = args.get("kv_cache_config")
+    target = args.get("kv-cache-dtype", args.get("kv_cache_dtype"))
+    if target is None and isinstance(config, Mapping):
+        target = config.get("dtype")
+    if engine == "vllm":
+        draft, draft_kv = spec.get("quantization"), spec.get("kv_cache_dtype")
+    elif engine == "sglang":
+        draft = args.get("speculative-draft-model-quantization")
+        draft_kv = args.get("speculative-draft-kv-cache-dtype")
+    else:
+        draft = draft_kv = None
+    unread = engine == "tilert"  # TileRT's draft settings are not readable here
+    return {
+        "draft_precision": UNKNOWN if unread else _set(draft),
+        "draft_kv_cache_dtype": UNKNOWN if unread else _dtype(draft_kv),
+        "kv_cache_dtype": _dtype(target),
+    }
+
+
+def _tilert() -> dict[str, Fact]:
+    return {"draft_sample": UNKNOWN, "adaptive": DEFAULT, "topology": CHAIN}
+
+
+def run_collection(model_prefix: str, role: Mapping[str, Any], framework: str) -> Collection | None:
+    """How a generation role drafts and verifies, or None when it does not speculate."""
+    engine = ENGINES.get(framework)
+    if engine is None:
+        raise ValueError(f"{framework} is not a speculative engine the connector reads")
+    spec = spec_parameters(role, engine)
+    if not spec:
+        return None
+    method = normalize_method(model_prefix, str(spec.get("method", "")))
+    args = role.get("args") or {}
+    facts = {
+        "vllm": lambda: _vllm(spec),
+        "sglang": lambda: _sglang(args, method),
+        "trtllm": _trtllm,
+        "atom": lambda: _atom(method),
+        "tilert": _tilert,
+    }[engine]()
+    facts |= _precision(args, spec, engine)
+    facts["verify"] = verifier(role, engine)
+    return Collection(engine=engine, draft=str(spec.get("model") or "native"), **facts)
+
+
+def audit(
+    model_prefix: str,
+    role: Mapping[str, Any],
+    framework: str,
+    thinking: str = "thinking_on",
+    golden_dir: Path = GOLDEN_DIR,
+) -> dict[str, Any] | None:
+    """The curve, golden AL and findings of one generation role; None when it does not draft."""
+    run = run_collection(model_prefix, role, framework)
+    if run is None:
+        return None
+    spec = spec_parameters(role, ENGINES[framework])
+    verify = run.verify.value
+    curve = curve_name(model_prefix, spec, golden_dir, verify)
+    return {
+        "curve": curve,
+        "draft_tokens": spec["num_speculative_tokens"],
+        "golden": golden_length(model_prefix, spec, thinking, golden_dir, verify),
+        "findings": [f.as_list() for f in compare(run, load_identities(golden_dir)[curve])],
+    }
+
+
+def spec_arguments(role: Mapping[str, Any]) -> dict[str, Any]:
+    """The speculative arguments of a role, as the snapshot records them."""
+    return {k: v for k, v in (role.get("args") or {}).items() if k.startswith(SPEC_ARGUMENTS)}
+
+
+def snapshot(matrix: list[Mapping[str, Any]], root: Path) -> list[dict[str, Any]]:
+    """Audit every distinct speculative generation role of a matrix's agentic rows."""
+    from infx.srt_slurm.generate import bound_variant, point_environment
+    from infx.srt_slurm.variants import expand_variants
+
+    cases: dict[str, dict[str, Any]] = {}
+    for row in matrix:
+        if row.get("scenario-type") != "agentic-coding" or not row.get("srt-recipe"):
+            continue
+        if row.get("spec-decoding", "none") == "none":
+            continue
+        _, recipe = bound_variant(row, point_environment(row), root, expand=expand_variants)
+        roles = recipe.get("roles") or {}
+        args = spec_arguments(roles.get("decode", roles.get("agg", {})))
+        case = {"model_prefix": row["model-prefix"], "framework": row["framework"], "args": args}
+        key = json.dumps(case, sort_keys=True)
+        if key not in cases:
+            cases[key] = {**case, "recipes": set(), "rows": 0}
+        cases[key]["recipes"].add(row["srt-recipe"])
+        cases[key]["rows"] += 1
+    result = []
+    for case in cases.values():
+        expected = audit(case["model_prefix"], {"args": case["args"]}, case["framework"])
+        result.append({**case, "recipes": sorted(case["recipes"]), "expected": expected})
+    return sorted(
+        result,
+        key=lambda c: (c["model_prefix"], c["framework"], json.dumps(c["args"], sort_keys=True)),
+    )
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__.split("\n\n")[0])
+    commands = parser.add_subparsers(dest="command", required=True)
+    snap = commands.add_parser("snapshot", help="audit every speculative role of a sweep matrix")
+    snap.add_argument("matrix", type=Path, help="JSON from infx.matrix.generate full-sweep")
+    snap.add_argument("--root", type=Path, required=True, help="the inferencex-e2e directory")
+    args = parser.parse_args(argv)
+    matrix = json.loads(args.matrix.read_text())
+    json.dump(snapshot(matrix, args.root.resolve()), sys.stdout, indent=1)
+    sys.stdout.write("\n")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/inferencex-e2e/infx/srt_slurm/synthetic_acceptance.py b/inferencex-e2e/infx/srt_slurm/synthetic_acceptance.py
index 7ae0f9f9ae..d3531d6043 100644
--- a/inferencex-e2e/infx/srt_slurm/synthetic_acceptance.py
+++ b/inferencex-e2e/infx/srt_slurm/synthetic_acceptance.py
@@ -18,6 +18,7 @@
 from infx import yamlio
 from infx.bench.proc import status
 from infx.golden_al_distribution import GOLDEN_DIR, golden_length
+from infx.golden_al_distribution.identity import Fact
 from infx.srt_slurm.variants import ZIP_VARIANT, without_nulls
 
 ENGINES = {
@@ -33,6 +34,7 @@
     "atom": "atom",
     "atom-disagg": "atom",
     "tilert": "tilert",
+    "tokenspeed": "tokenspeed",
 }
 SGLANG_VARIABLES = (
     "SGLANG_SIMULATE_ACC_LEN",
@@ -50,6 +52,20 @@ def spec_parameters(role: Mapping[str, Any], engine: str) -> dict[str, Any]:
     current token. Raises ValueError on a malformed or conflicting config.
     """
     args = role.get("args", {})
+    if engine == "tokenspeed":
+        if "speculative-config" in args:
+            raise ValueError(
+                "TokenSpeed AgentX requires explicit MTP flags, not speculative-config"
+            )
+        algorithm = str(args.get("speculative-algorithm", "")).lower()
+        if not algorithm:
+            return {}
+        if algorithm != "mtp":
+            raise ValueError("TokenSpeed AgentX currently supports only MTP speculation")
+        return {
+            "method": "mtp",
+            "num_speculative_tokens": args.get("speculative-num-steps"),
+        }
     if engine == "tilert":
         if args.get("with-mtp") is not True:
             return {}
@@ -113,6 +129,26 @@ def spec_parameters(role: Mapping[str, Any], engine: str) -> dict[str, Any]:
     }
 
 
+def verifier(role: Mapping[str, Any], engine: str) -> Fact:
+    """How a role verifies drafts. Block, relaxed and adaptive verification are opt-in, so an
+    unset flag means standard; a synthetic sampler becomes block on real runs. ATOM and TileRT
+    do not expose their verifier."""
+    args = role.get("args") or {}
+    if engine == "vllm":
+        method = spec_parameters(role, engine).get("rejection_sample_method")
+        if method == "synthetic":
+            return Fact("block", "documented")
+        return Fact(method, "explicit") if method else Fact("standard", "documented")
+    if engine == "sglang" and args.get("speculative-use-block-verification") is True:
+        return Fact("block", "explicit")
+    config = args.get("speculative_config") or {}
+    if engine == "trtllm" and config.get("use_relaxed_acceptance_for_thinking") is True:
+        return Fact("relaxed", "explicit")
+    if engine in ("sglang", "trtllm"):
+        return Fact("standard", "documented")
+    return Fact(None, "unknown")
+
+
 def acceptance_length(
     recipe: Mapping[str, Any],
     framework: str,
@@ -148,12 +184,8 @@ def _simulated_length(
     if engine is None:
         return None
     roles = recipe.get("roles", {})
-    synthetic = (
-        environment["EVAL_ONLY"].lower() != "true"
-        and environment["IS_AGENTIC"].lower() in ("1", "true")
-        and environment["SPEC_DECODING"] != "none"
-    )
-    generation = roles.get("decode", roles.get("agg", {}))
+    synthetic = is_synthetic(environment)
+    generation = generation_role(recipe)
     spec = spec_parameters(generation, engine)
     if not (synthetic and spec):
         return None
@@ -163,7 +195,26 @@ def _simulated_length(
         if name in ("agg", "prefill", "decode") and spec_parameters(role, engine)
     ):
         return None
-    al = golden_length(environment["MODEL_PREFIX"], spec, environment["THINKING_MODE"], golden_dir)
+    al = golden_length(
+        environment["MODEL_PREFIX"],
+        spec,
+        environment["THINKING_MODE"],
+        golden_dir,
+        verifier(generation, engine).value,
+    )
+    if engine == "tokenspeed":
+        args = generation.get("args", {})
+        drafts = args.get("speculative-num-draft-tokens")
+        if (
+            not isinstance(drafts, int)
+            or isinstance(drafts, bool)
+            or drafts != spec["num_speculative_tokens"] + 1
+        ):
+            raise ValueError(
+                "TokenSpeed speculative-num-draft-tokens must equal speculative-num-steps + 1"
+            )
+        if args.get("speculative-eagle-topk") != 1:
+            raise ValueError("TokenSpeed synthetic acceptance requires speculative-eagle-topk 1")
     if (
         engine == "sglang"
         and environment["MODEL_PREFIX"] == "qwen3.5"
@@ -179,6 +230,21 @@ def _simulated_length(
     return al
 
 
+def is_synthetic(environment: Mapping[str, str]) -> bool:
+    """AgentX speculative throughput forces golden acceptance; evals verify for real."""
+    return (
+        environment["EVAL_ONLY"].lower() != "true"
+        and environment["IS_AGENTIC"].lower() in ("1", "true")
+        and environment["SPEC_DECODING"] != "none"
+    )
+
+
+def generation_role(recipe: Mapping[str, Any]) -> Mapping[str, Any]:
+    """The worker whose drafts are verified: decode, otherwise the aggregated worker."""
+    roles = recipe.get("roles", {})
+    return roles.get("decode", roles.get("agg", {}))
+
+
 def build_overrides(
     recipe: Mapping[str, Any],
     framework: str,
@@ -245,19 +311,29 @@ def build_overrides(
                 "--set",
                 f"{prefix}.args.speculative-config={json.dumps(worker_spec)}",
             ]
+        elif worker_engine == "tokenspeed":
+            key = "synthetic-acceptance-length"
+            if worker_al is not None and worker_spec:
+                overrides += ["--set", f"{prefix}.args.{key}={worker_al:g}"]
+                overrides += ["--set", f'{prefix}.args.sampling-backend="greedy"']
+            else:
+                if key in (role.get("args") or {}):
+                    overrides += ["--unset", f"{prefix}.args.{key}"]
+                if worker_spec:
+                    overrides += ["--set", f'{prefix}.args.sampling-backend="flashinfer"']
         elif worker_engine == "atom":
             key = "spec-decode-acceptance-length"
             if worker_al is not None and worker_spec:
-                overrides += ["--set", f"{prefix}.args.{key}={worker_al:.15g}"]
+                overrides += ["--set", f"{prefix}.args.{key}={worker_al:g}"]
             elif key in (role.get("args") or {}):
                 overrides += ["--unset", f"{prefix}.args.{key}"]
         elif worker_al is not None and worker_spec:
             values = (
-                (f"{worker_al:.15g}", "match-expected", "real-draft-token")
+                (f"{worker_al:g}", "match-expected", "real-draft-token")
                 if engine == "sglang"
-                else (f"{worker_al:.15g}", "match-expected")
+                else (f"{worker_al:g}", "match-expected")
                 if engine == "tilert"
-                else (f"{worker_al - 1:.15g}",)
+                else (f"{worker_al - 1:g}",)
             )
             for key, value in zip(variables, values, strict=True):
                 overrides += ["--set", f"{prefix}.env.{key}={json.dumps(value)}"]
@@ -307,10 +383,16 @@ def selected_recipes(
 
 
 class Planned(NamedTuple):
-    """One ``srtctl apply`` command and the golden AL it simulates (None: real acceptance)."""
+    """One ``srtctl apply`` command and the golden AL it simulates (None: real acceptance).
+
+    ``al_gate`` is an agentic eval's acceptance gate (``al_gate.plan``), which ``environment``
+    adds to the submission's environment to run; None without one.
+    """
 
     command: list[str]
     acceptance_length: float | None
+    al_gate: dict[str, Any] | None = None
+    environment: tuple[tuple[str, str], ...] = ()
 
 
 def plan_commands(
@@ -322,9 +404,12 @@ def plan_commands(
     golden_dir: Path = GOLDEN_DIR,
 ) -> list[Planned]:
     """Build native arguments for every selected variant before submitting jobs."""
+    from infx.srt_slurm import al_gate
+
     command = ["srtctl", "apply", *arguments]
     if framework not in ENGINES:
-        return [Planned([*command, "--file", config], None)]
+        gate = al_gate.plan({}, framework, environment) if al_gate.requested(environment) else None
+        return [Planned([*command, "--file", config], None, gate)]
     from srtctl.core.overrides import apply_overrides_to_recipe, parse_overrides
 
     path, _, selector = config.partition(":")
@@ -353,7 +438,14 @@ def plan_commands(
         selected_recipes(materialized, variant)
         selected_file = f"{path}:{variant}" if variant is not None else path
         length = acceptance_length(recipe, framework, environment, golden_dir=golden_dir)
-        plans.append(Planned([*command, "--file", selected_file, *arguments_to_add], length))
+        gate, srt_environment = None, {}
+        if al_gate.requested(environment):
+            gate = al_gate.plan(recipe, framework, environment, golden_dir=golden_dir)
+            if gate is not None and gate.get("status") != "skipped":
+                arguments_to_add = [*arguments_to_add, *al_gate.overrides(gate, environment)]
+                srt_environment = al_gate.SRT_ENVIRONMENT
+        argv = [*command, "--file", selected_file, *arguments_to_add]
+        plans.append(Planned(argv, length, gate, tuple(srt_environment.items())))
     return plans
 
 
@@ -361,7 +453,9 @@ def main(argv: list[str] | None = None) -> int:
     """Plan srtctl commands with golden acceptance from ``argv``, run them and return the rc."""
     parser = argparse.ArgumentParser(description=__doc__)
     parser.add_argument(
-        "--record", type=Path, help="write the plan's golden acceptance length here as JSON"
+        "--record",
+        type=Path,
+        help="write the plan's golden acceptance length and acceptance gate here as JSON",
     )
     parser.add_argument("config")
     parser.add_argument("framework")
@@ -376,9 +470,13 @@ def main(argv: list[str] | None = None) -> int:
     if args.record is not None:
         lengths = {plan.acceptance_length for plan in plans}
         length = lengths.pop() if len(lengths) == 1 else None
-        args.record.write_text(json.dumps({"golden_acceptance_length": length}) + "\n")
+        gate = next((plan.al_gate for plan in plans if plan.al_gate is not None), None)
+        record = {"golden_acceptance_length": length, "al_gate": gate}
+        args.record.write_text(json.dumps(record) + "\n")
     for plan in plans:
-        result = subprocess.run(plan.command, check=False)
+        result = subprocess.run(
+            plan.command, env={**os.environ, **dict(plan.environment)}, check=False
+        )
         if result.returncode:
             return status(result.returncode)
     return 0
diff --git a/inferencex-e2e/infx/srt_slurm/workload.py b/inferencex-e2e/infx/srt_slurm/workload.py
index 145ecac83b..83bb11d034 100644
--- a/inferencex-e2e/infx/srt_slurm/workload.py
+++ b/inferencex-e2e/infx/srt_slurm/workload.py
@@ -1,7 +1,7 @@
 """Compose srt-slurm recipe fragments and bind the master-owned workload into them.
 
 A fragment holds only recipe-specific srt-slurm settings. Its lane's shared block, and the
-DCGM telemetry block for a point that measures power, is merged under it, a variant is
+GPU telemetry block for a point that measures power, is merged under it, a variant is
 selected, and the binder then writes the matrix point's and the launcher's values and
 replaces ``'@fabric.<name>'`` values with the job's cluster facts.
 """
@@ -14,7 +14,7 @@
 import re
 from collections.abc import Callable, Iterator, Mapping
 from pathlib import Path
-from typing import Any
+from typing import Any, Literal, get_args
 
 import yaml
 
@@ -22,7 +22,14 @@
 from infx.config import repository_root
 from infx.fastcopy import deepcopy
 from infx.results.metadata import parse_component_metadata
-from infx.srt_slurm.synthetic_acceptance import selected_recipes, spec_parameters
+from infx.srt_slurm.spec_identity import speculation_facts
+from infx.srt_slurm.synthetic_acceptance import (
+    ENGINES,
+    generation_role,
+    selected_recipes,
+    spec_parameters,
+)
+from infx.srt_slurm.variants import expand_variants
 
 SHARED_BLOCKS = {
     (False, False): Path("configs/srt-recipes/fixed-sequence-single.yaml"),
@@ -32,7 +39,13 @@
 }
 BOUND_RECIPE = "recipe.yaml"
 TELEMETRY_BLOCK = Path("configs/srt-recipes/telemetry-dcgm.yaml")
+# The CPU power exporter sources a cluster declares (srt-slurm.cpu-power-exporter).
+CpuPowerSource = Literal["acpi", "rapl"]
 NATIVE_TELEMETRY_BLOCK = Path("configs/srt-recipes/telemetry-native.yaml")
+# How a recipe measures GPU power: the DCGM telemetry block with its exporter on this port, or
+# NATIVE, the cluster's own GPU exporter.
+NATIVE = "native"
+GpuPower = int | Literal["native"]
 _POINT_KEYS = (
     ("model", "path"),
     ("model", "container"),
@@ -42,6 +55,7 @@
     ("benchmark", "concurrencies"),
     ("telemetry", "enabled"),
     ("telemetry", "dcgm_exporter", "port"),
+    ("telemetry", "cpu_power_exporter"),
 )
 _FIXED_ENV = ("MODEL", "ISL", "OSL", "CONC", "CONC_LIST", "RANDOM_RANGE_RATIO", "USE_CHAT_TEMPLATE")
 _AGENTIC_ENV = ("CONC", "CONC_LIST", "RESULT_DIR", "AGENTIC_OUTPUT_DIR", "HF_HUB_CACHE",
@@ -50,13 +64,16 @@
     "IMAGE", "MODEL_PREFIX", "FRAMEWORK", "PRECISION", "DISAGG", "DURATION", "MAX_MODEL_LEN",
     "KV_OFFLOAD_BACKEND", "KV_OFFLOAD_BACKEND_METADATA", "ROUTER_METADATA", "KV_P2P_TRANSFER",
     "POWER", "REQUIRE_POWER", "IS_AGENTIC", "SCENARIO_TYPE", "RUN_EVAL", "EVAL_ONLY",
+    "SPEC_ALGORITHM", "SPEC_DRAFT_MODEL",
 )  # fmt: skip
 _MULTINODE_ENV = (
     "SPEC_DECODING", "KV_OFFLOADING", "TOTAL_CPU_DRAM_GB", "DECODE_CPU_DRAM_GB", "PREFILL_DWDP_SIZE",
     *(f"{role}_{field}" for role in ("PREFILL", "DECODE")
       for field in ("NUM_WORKERS", "TP", "PP_SIZE", "DCP_SIZE", "PCP_SIZE", "EP", "DP_ATTN")),
 )  # fmt: skip
-_SINGLE_NODE_ENV = ("TP", "EP_SIZE", "PP_SIZE", "DCP_SIZE", "PCP_SIZE", "DP_ATTENTION", "GPU_COUNT")
+_SINGLE_NODE_ENV = (
+    "TP", "EP_SIZE", "PP_SIZE", "DCP_SIZE", "PCP_SIZE", "DP_ATTENTION", "GPU_COUNT", "SPEC_DECODING",
+)  # fmt: skip
 BOUND_ENV = {
     (False, False): (*_FIXED_ENV, *_WORKFLOW_ENV, *_SINGLE_NODE_ENV),
     (False, True): (*_FIXED_ENV, *_WORKFLOW_ENV, *_MULTINODE_ENV),
@@ -79,8 +96,8 @@
 }
 FABRIC_REFERENCE = "@fabric."
 INSTALLERS = {
+    "tokenspeed-nightly.sh": ("router", "smg"),
     "glm5.3-tilert-rocm.sh": ("router", "tilert-pd-router"),
-    "kimik3-b300-mooncake.sh": ("kv-offload-backend", "mooncake"),
     "vllm-mooncake.sh": ("kv-offload-backend", "mooncake"),
     "vllm-router.sh": ("router", "vllm-router"),
 }
@@ -188,23 +205,30 @@ def compose_recipe(
     agentic: bool,
     multinode: bool,
     root: Path,
-    power_port: int | None = None,
-    native_power: bool = False,
+    gpu_power: GpuPower | None = None,
+    cpu_power_source: CpuPowerSource | None = None,
 ) -> dict[str, Any]:
     """The fragment at ``path`` over its lane's shared block, under ``base`` for bundles.
 
-    ``power_port`` adds the DCGM telemetry block with its exporter on that port.
+    ``gpu_power`` adds its telemetry block, and ``cpu_power_source`` the cluster's CPU power
+    exporter to the telemetry block.
     """
     raw = yamlio.safe_load(path.read_text())
     if not isinstance(raw, dict):
         raise ValueError(f"{path}: recipe must be a mapping")
     check_fragment(raw, path, agentic=agentic, multinode=multinode)
     shared = _block(root / SHARED_BLOCKS[agentic, multinode])
-    if native_power:
+    if gpu_power == NATIVE:
         shared = merge_blocks(shared, _block(root / NATIVE_TELEMETRY_BLOCK))
-    if power_port is not None:
-        exporter = {"telemetry": {"dcgm_exporter": {"port": power_port}}}
-        shared = merge_blocks(shared, merge_blocks(_block(root / TELEMETRY_BLOCK), exporter))
+    dcgm = gpu_power if isinstance(gpu_power, int) else None
+    exporters: dict[str, Any] = {}
+    if dcgm is not None:
+        exporters["dcgm_exporter"] = {"port": dcgm}
+    if cpu_power_source is not None:
+        exporters["cpu_power_exporter"] = {"source": cpu_power_source}
+    if exporters:
+        block = _block(root / TELEMETRY_BLOCK) if dcgm is not None else {}
+        shared = merge_blocks(shared, merge_blocks(block, {"telemetry": exporters}))
     if "base" in raw:
         return {**raw, "base": merge_blocks(shared, raw["base"])}
     return merge_blocks(shared, raw)
@@ -336,9 +360,12 @@ def bind_workload(
     )
     if (bound.get("telemetry") or {}).get("enabled") is True:
         benchmark["concurrencies"] = concurrencies
+        required = environment.get("REQUIRE_POWER", "0") in {"1", "true", "TRUE", "yes", "YES"}
+        # A multi-node point measures power by default; only its power field makes srtctl skip
+        # the benchmark when telemetry fails.
+        required = required or (multinode and environment.get("POWER") == "1")
+        bound["telemetry"]["required"] = required
         if not multinode:
-            required = environment.get("REQUIRE_POWER", "0") in {"1", "true", "TRUE", "yes", "YES"}
-            bound["telemetry"]["required"] = required
             workload["REQUIRE_POWER"] = "1" if required else "0"
     if agentic and not multinode:
         workload["ENABLE_AGENTX_POWER"] = (
@@ -354,22 +381,100 @@ def bind_multinode(
     *,
     root: Path,
     expand: Callable[..., list[tuple[str | None, dict[str, Any]]]] = selected_recipes,
-    power_port: int | None = None,
+    gpu_power: GpuPower | None = None,
+    cpu_power_source: CpuPowerSource | None = None,
     client_env: Mapping[str, str] | None = None,
 ) -> tuple[str | None, dict[str, Any]]:
     """Bind the one variant ``recipe`` (``fragment[:selector]``) selects; return its name too."""
     agentic = environment["IS_AGENTIC"] == "1"
+    name, selected = select_multinode(
+        recipe,
+        agentic=agentic,
+        root=root,
+        expand=expand,
+        gpu_power=gpu_power,
+        cpu_power_source=cpu_power_source,
+    )
+    bound = bind_workload(
+        selected, environment, agentic=agentic, multinode=True, client_env=client_env
+    )
+    bind_speculation(bound, environment)
+    return name, bound
+
+
+def select_multinode(
+    recipe: str,
+    *,
+    agentic: bool,
+    root: Path,
+    expand: Callable[..., list[tuple[str | None, dict[str, Any]]]] = selected_recipes,
+    gpu_power: GpuPower | None = None,
+    cpu_power_source: CpuPowerSource | None = None,
+) -> tuple[str | None, dict[str, Any]]:
+    """The one composed, unbound variant ``recipe`` (``fragment[:selector]``) selects."""
     path, _, selector = recipe.partition(":")
     composed = compose_recipe(
-        Path(path), agentic=agentic, multinode=True, root=root, power_port=power_port
+        Path(path),
+        agentic=agentic,
+        multinode=True,
+        root=root,
+        gpu_power=gpu_power,
+        cpu_power_source=cpu_power_source,
     )
     variants = expand(composed, selector or None)
     if len(variants) != 1:
         raise ValueError(f"{recipe} selects {len(variants)} variants, not one")
-    name, selected = variants[0]
-    return name, bind_workload(
-        selected, environment, agentic=agentic, multinode=True, client_env=client_env
+    return variants[0]
+
+
+def discovery_on_dedicated_node(recipe: Mapping[str, Any]) -> bool:
+    """Whether ``recipe`` runs etcd and NATS on a node of their own.
+
+    srtctl then refuses GPU power telemetry: its samples would leave the benchmark's clock.
+    """
+    discovery = [
+        service
+        for service in recipe.get("services") or []
+        if service.get("enabled", True) and service.get("type") in ("etcd", "nats")
+    ]
+    if not discovery:
+        return bool((recipe.get("infra") or {}).get("etcd_nats_dedicated_node", False))
+    placements = {
+        (service.get("placement") or {}).get("node") == "dedicated" for service in discovery
+    }
+    if len(placements) != 1:
+        raise ValueError("Recipe etcd and nats must agree on dedicated placement")
+    return placements.pop()
+
+
+def selects_dedicated_discovery(recipe: str, *, agentic: bool, root: Path) -> bool:
+    """Whether the variant ``recipe`` (``fragment[:selector]``) selects runs etcd and NATS on a
+    node of their own.
+
+    Expands variants without srtctl, which the launcher's environment does not install.
+    """
+    _, selected = select_multinode(recipe, agentic=agentic, root=root, expand=expand_variants)
+    return discovery_on_dedicated_node(selected)
+
+
+def bind_speculation(recipe: dict[str, Any], environment: Mapping[str, str]) -> None:
+    """Fail unless the matrix's SPEC_DECODING says whether the generation worker drafts, and
+    give the client the algorithm and draft model it drafts with."""
+    engine = recipe.get("engine")
+    engine = ENGINES.get(environment["FRAMEWORK"]) or (
+        engine.get("type") if isinstance(engine, Mapping) else engine
     )
+    spec = spec_parameters(generation_role(recipe), engine)
+    label = environment["SPEC_DECODING"]
+    if bool(spec) != (label != "none"):
+        raise ValueError(
+            f"SPEC_DECODING: matrix {label!r}, but the generation worker "
+            f"{'drafts' if spec else 'does not draft'}"
+        )
+    if spec:
+        algorithm, draft_model = speculation_facts(_required(environment, "MODEL_PREFIX"), spec)
+        workload = recipe.setdefault("benchmark", {}).setdefault("env", {})
+        workload.update(SPEC_ALGORITHM=algorithm, SPEC_DRAFT_MODEL=draft_model)
 
 
 def resolve_fabric(node: Any, fabric: Mapping[str, str | None], where: str = "") -> Any:
@@ -410,6 +515,20 @@ def add_fabric_argument(parser: argparse.ArgumentParser) -> None:
     )
 
 
+def add_cpu_power_source_argument(parser: argparse.ArgumentParser) -> None:
+    """``--cpu-power-source``: the cluster's CPU power exporter source, for a cpu-power point."""
+    parser.add_argument(
+        "--cpu-power-source",
+        choices=get_args(CpuPowerSource),
+        help="bind the cluster's CPU power exporter with this source",
+    )
+
+
+def _gpu_power(text: str) -> GpuPower:
+    """Parse ``--gpu-power``: a DCGM exporter port, or NATIVE."""
+    return NATIVE if text == NATIVE else int(text)
+
+
 def _assignment(text: str) -> tuple[str, str]:
     """Split a ``NAME=VALUE`` argument, or raise ArgumentTypeError if malformed."""
     name, separator, value = text.partition("=")
@@ -424,8 +543,12 @@ def main(argv: list[str] | None = None) -> None:
     parser.add_argument("recipe", help="fragment[:selector]")
     parser.add_argument("output", type=Path)
     parser.add_argument(
-        "--power-port", type=int, help="merge the DCGM telemetry block, its exporter on this port"
+        "--gpu-power",
+        type=_gpu_power,
+        help=f"merge a GPU telemetry block: the DCGM one with its exporter on this port, or "
+        f"{NATIVE!r} for the cluster's own exporter",
     )
+    add_cpu_power_source_argument(parser)
     parser.add_argument(
         "--client-env",
         type=_assignment,
@@ -442,7 +565,8 @@ def main(argv: list[str] | None = None) -> None:
             args.recipe,
             os.environ,
             root=root,
-            power_port=args.power_port,
+            gpu_power=args.gpu_power,
+            cpu_power_source=args.cpu_power_source,
             client_env=dict(args.client_env),
         )
         bound = resolve_fabric(bound, args.fabric)
diff --git a/inferencex-e2e/infx/tests/bench/conftest.py b/inferencex-e2e/infx/tests/bench/conftest.py
index 9aca682555..3d0dc10620 100644
--- a/inferencex-e2e/infx/tests/bench/conftest.py
+++ b/inferencex-e2e/infx/tests/bench/conftest.py
@@ -14,7 +14,10 @@
 
 @pytest.fixture
 def http_server() -> Iterator[Callable[[Respond], str]]:
-    """Start local servers answering with ``respond(method, path) -> (status, json_body)``."""
+    """Start local servers answering with ``respond(method, path) -> (status, json_body)``.
+
+    A ``bytes`` body is sent as is, as plain text.
+    """
     started: list[ThreadingHTTPServer] = []
 
     def start(respond: Respond) -> str:
@@ -27,9 +30,10 @@ def do_POST(self) -> None:
                 self._reply(*respond("POST", self.path))
 
             def _reply(self, status: int, body: object) -> None:
-                payload = json.dumps(body).encode()
+                raw = isinstance(body, bytes)
+                payload = body if raw else json.dumps(body).encode()
                 self.send_response(status)
-                self.send_header("Content-Type", "application/json")
+                self.send_header("Content-Type", "text/plain" if raw else "application/json")
                 self.send_header("Content-Length", str(len(payload)))
                 self.end_headers()
                 self.wfile.write(payload)
diff --git a/inferencex-e2e/infx/tests/bench/test_al_gate.py b/inferencex-e2e/infx/tests/bench/test_al_gate.py
new file mode 100644
index 0000000000..c5f4e24626
--- /dev/null
+++ b/inferencex-e2e/infx/tests/bench/test_al_gate.py
@@ -0,0 +1,305 @@
+"""The ``al-gate`` command against a fake deployment: an AIPerf stand-in and metrics endpoints."""
+
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+from infx.bench import al_gate, speedbench
+from infx.bench.agentic.venv import Runtime
+from infx.bench.env import BenchError
+from infx.tests.bench.stubs import executable
+
+REPO_ROOT = Path(__file__).resolve().parents[3]
+PROMPTS = ["alpha", "beta gamma", "delta"]
+# sha256sum of PROMPTS as one UTF-8 JSON array; they stand in for the golden prompts.
+PROMPTS_SHA256 = "906f677089ff300758545039f784a7a09ded65f5686a7ac0491388156f2b4c2e"
+CURVE = """\
+testmodel:
+  thinking_on:
+    3: 3.2
+collection:
+  renderer: chat_template
+  modes:
+    thinking_on:
+      chat_template_kwargs: {enable_thinking: true}
+      sampling: {temperature: 0.6, top_k: 20}
+"""
+METRICS = """\
+# TYPE vllm:spec_decode_num_drafts_total counter
+vllm:spec_decode_num_drafts_total{engine="0"} %d
+vllm:spec_decode_num_drafts_created{engine="0"} 1.7e+09
+# TYPE vllm:spec_decode_num_accepted_tokens_total counter
+vllm:spec_decode_num_accepted_tokens_total{engine="0"} %d
+"""
+# Records its argv, writes AIPerf's aggregate export, and moves the engine's counters.
+FAKE_AIPERF = r"""#!/bin/sh
+printf '%s\n' "$@" > "$AIPERF_ARGV"
+while [ $# -gt 0 ]; do
+    [ "$1" = --output-artifact-dir ] && out="$2"
+    shift
+done
+mkdir -p "$out"
+printf '{"request_count": {"avg": 3}, "error_request_count": {"avg": %s}}\n' "$FAILED" \
+    > "$out/profile_export_aiperf.json"
+cp "$COUNTERS_AFTER" "$COUNTERS"
+"""
+
+
+# The shim caps the gate with coreutils timeout, which serving images have.
+NEEDS_TIMEOUT = pytest.mark.skipif(
+    shutil.which("timeout", path="/usr/bin:/bin") is None, reason="needs coreutils timeout"
+)
+
+
+class Tokenizer:
+    """Renders the user turn between role tags and records each call's options."""
+
+    def __init__(self) -> None:
+        self.calls: list[dict[str, object]] = []
+
+    def apply_chat_template(self, messages, **options):
+        self.calls.append(options)
+        return f"<user> {messages[0]['content']} <assistant>"
+
+
+@pytest.fixture
+def gate(tmp_path, http_server, monkeypatch):
+    """A served engine whose spec-decode counters the replay moves, and the gate's inputs."""
+    counters = tmp_path / "counters.txt"
+    counters.write_text(METRICS % (100, 160))
+    url = http_server(lambda method, path: (200, counters.read_bytes()))
+    (tmp_path / "golden").mkdir()
+    (tmp_path / "golden" / "testmodel_mtp.yaml").write_text(CURVE)
+    dataset = tmp_path / "speedbench_coding.jsonl"
+    rows = [{"question_id": f"q{index}", "prompt": text} for index, text in enumerate(PROMPTS)]
+    dataset.write_text("".join(json.dumps(row) + "\n" for row in rows))
+    tokenizer = Tokenizer()
+    monkeypatch.setattr(speedbench, "PROMPTS_SHA256", PROMPTS_SHA256)
+    monkeypatch.setattr(al_gate, "SETTLE_INTERVAL_S", 0.01)
+    monkeypatch.setattr(al_gate, "_tokenizer", {"test/model": tokenizer}.get)
+    # A real Runtime whose venv this process already runs, so the gate drives runtime.aiperf.
+    runtime = Runtime(tmp_path / "runtime")
+    (runtime.venv / "bin").mkdir(parents=True)
+    executable(runtime.aiperf, FAKE_AIPERF)
+    monkeypatch.setattr(sys, "executable", str(runtime.python))
+    env = {
+        "AL_GATE": "true", "AL_GATE_CURVE": "testmodel_mtp", "AL_GATE_DRAFT_TOKENS": "3",
+        "AL_GATE_DATASET": str(dataset), "AL_GATE_OUTPUT_DIR": str(tmp_path / "logs"),
+        "THINKING_MODE": "thinking_on", "RESULT_FILENAME": "gate", "MODEL": "test/model",
+        "SERVED_MODEL_NAME": "served/model", "FRAMEWORK": "vllm",
+        "AIPERF_SERVER_URL": "http://frontend:8000", "AIPERF_SERVER_METRICS_URLS": f"{url}/metrics",
+        "PATH": os.environ["PATH"], "AIPERF_ARGV": str(tmp_path / "argv"), "FAILED": "0",
+        "COUNTERS": str(counters), "COUNTERS_AFTER": str(tmp_path / "after.txt"),
+    }  # fmt: skip
+
+    def run(
+        after: tuple[int, int] = (1100, 2160), runtime: Runtime = runtime, **overrides: str
+    ) -> int:
+        (tmp_path / "after.txt").write_text(METRICS % after)
+        return al_gate.run({**env, **overrides}, runtime, golden_dir=tmp_path / "golden")
+
+    def document() -> dict[str, object]:
+        return json.loads((tmp_path / "logs" / "al_gate_gate.json").read_text())
+
+    raw, argv = tmp_path / "logs" / "al_gate", tmp_path / "argv"
+    return SimpleNamespace(run=run, document=document, tokenizer=tokenizer, raw=raw, argv=argv)
+
+
+@pytest.mark.parametrize(
+    ("after", "verdict"),
+    [
+        # 2160 - 160 accepted drafts over 1100 - 100 verifications: AL 3.0, 0.9375 x golden 3.2.
+        ((1100, 2160), {"acceptance_length": 3.0, "ratio": 0.9375, "status": "below",
+                        "accepted_tokens": 2000, "verifications": 1000}),
+        # 2360 - 160 accepted drafts over 1000 verifications: AL 3.2.
+        ((1100, 2360), {"acceptance_length": 3.2, "ratio": 1.0, "status": "pass",
+                        "accepted_tokens": 2200, "verifications": 1000}),
+    ],
+    ids=["below", "pass"],
+)  # fmt: skip
+def test_the_gate_replays_the_golden_collection_and_reports_the_verdict(gate, after, verdict):
+    assert gate.run(after) == 0
+
+    assert gate.document() == {
+        "result_filename": "gate", "framework": "vllm", "eval_framework": None,
+        "eval_suite": None, "curve": "testmodel_mtp", "thinking_mode": "thinking_on", "draft_tokens": 3, "golden_acceptance_length": 3.2,
+        "error": None, "report_only": True, **verdict,
+    }  # fmt: skip
+    # In vllm bench serve's order (random.seed(0); random.shuffle), rendered client-side.
+    sent = [json.loads(line) for line in (gate.raw / "prompts.jsonl").read_text().splitlines()]
+    assert sent == [
+        {"text": f"<user> {prompt} <assistant>", "output_length": 4096}
+        for prompt in ("alpha", "delta", "beta gamma")
+    ]
+    options = {"add_generation_prompt": True, "tokenize": False, "enable_thinking": True}
+    assert gate.tokenizer.calls == [options] * 3
+    argv = gate.argv.read_text().splitlines()
+    replay = {flag: argv[argv.index(flag) + 1] for flag in ("--request-count", "--concurrency",
+              "--extra-inputs", "--dataset-sampling-strategy")}  # fmt: skip
+    assert replay == {
+        "--request-count": "3", "--concurrency": "64",
+        "--extra-inputs": '{"temperature": 0.6, "top_k": 20}',
+        "--dataset-sampling-strategy": "sequential",
+    }  # fmt: skip
+
+
+def test_failed_requests_make_the_measurement_an_error(gate):
+    with pytest.raises(BenchError, match="1 of 3 requests failed"):
+        gate.run(FAILED="1")
+
+    document = gate.document()
+    assert (document["status"], document["error"]) == ("error", "1 of 3 requests failed")
+
+
+@pytest.mark.parametrize(("framework", "replayed"), [("sglang", True), ("tilert", False)])
+def test_without_the_generation_engines_counters_the_verdict_is_no_counters(
+    gate, framework, replayed
+):
+    # The served engine exports only vLLM's families; TileRT's engine has no counter reader.
+    assert gate.run(FRAMEWORK=framework) == 0
+
+    document = gate.document()
+    assert (document["status"], document["verifications"]) == ("no-counters", None)
+    assert (gate.raw / "prompts.jsonl").exists() == replayed
+
+
+def test_prompts_other_than_the_golden_ones_are_an_error_before_any_traffic(gate, monkeypatch):
+    monkeypatch.setattr(speedbench, "PROMPTS_SHA256", "0" * 64)
+
+    with pytest.raises(BenchError, match=f"has sha256 {PROMPTS_SHA256}, not 0+$"):
+        gate.run()
+
+    document = gate.document()
+    assert (document["status"], document["golden_acceptance_length"]) == ("error", None)
+    assert PROMPTS_SHA256 in document["error"]
+    assert not gate.raw.exists()
+
+
+def test_an_inactive_runtime_is_prepared_before_any_traffic(gate, tmp_path, monkeypatch):
+    uv_dir = tmp_path / "uv-bin"
+    uv_dir.mkdir()
+    executable(uv_dir / "uv", '#!/bin/sh\n[ "$1" = venv ] && exit 3\nexit 0\n')
+    monkeypatch.setenv("PATH", f"{uv_dir}:{os.environ['PATH']}")
+
+    assert gate.run(runtime=Runtime(tmp_path / "inactive")) == 3
+
+    document = gate.document()
+    assert (document["status"], document["error"]) == (
+        "error",
+        "creating the AIPerf runtime exited with code 3",
+    )
+    assert not gate.raw.exists()
+
+
+BOS, USER, ASSISTANT = "<｜begin▁of▁sentence｜>", "<｜User｜>", "<｜Assistant｜>"
+# DeepSeek-V4's system prefix for reasoning effort "max", from vLLM's deepseek_v4 encoder.
+MAX_EFFORT = (
+    "Reasoning Effort: Absolute maximum with no shortcuts permitted.\n"
+    "You MUST be very thorough in your thinking and comprehensively decompose the problem to "
+    "resolve the root cause, rigorously stress-testing your logic against all potential paths, "
+    "edge cases, and adversarial scenarios.\n"
+    "Explicitly write out your entire deliberation process, documenting every intermediate "
+    "step, considered alternative, and rejected hypothesis to ensure absolutely no assumption "
+    "is left unchecked.\n\n"
+)
+
+
+@pytest.mark.parametrize(
+    ("kwargs", "effort", "opening"),
+    [
+        ({"thinking": True, "reasoning_effort": "high"}, "", "<think>"),
+        # vLLM v0.21-v0.25 renders chat mode when no kwargs are sent.
+        ({}, "", "</think>"),
+        ({"thinking": True, "reasoning_effort": "none"}, "", "</think>"),
+        ({"enable_thinking": True, "reasoning_effort": "xhigh"}, MAX_EFFORT, "<think>"),
+    ],
+)
+def test_deepseek_v4_prompts_render_as_vllms_tokenizer_mode_did(kwargs, effort, opening):
+    prompt = al_gate.render("Fix it.", "deepseek_v4", kwargs, tokenizer=None)
+
+    assert prompt == f"{BOS}{effort}{USER}Fix it.{ASSISTANT}{opening}"
+
+
+@pytest.mark.parametrize(
+    ("kwargs", "effort", "opening"),
+    [
+        # DeepSeek-V4.1 thinks unless told not to, at reasoning effort high.
+        ({"thinking": True, "reasoning_effort": "high"}, 50, "<think>"),
+        ({}, 50, "<think>"),
+        ({"thinking": False}, None, "</think>"),
+        ({"thinking": True, "reasoning_effort": "none"}, None, "</think>"),
+        ({"enable_thinking": True, "reasoning_effort": "max"}, 100, "<think>"),
+    ],
+)
+def test_deepseek_v41_prompts_render_as_vllms_tokenizer_mode_did(kwargs, effort, opening):
+    prompt = al_gate.render("Fix it.", "deepseek_v41", kwargs, tokenizer=None)
+
+    prefix = (
+        f"<｜System｜>Reasoning Effort: {effort} (range 1-100, the higher the value, the more "  # noqa: RUF001
+        "thorough the reasoning)\n\n"
+        if effort
+        else ""
+    )
+    assert prompt == f"{BOS}{prefix}{USER}Fix it.{ASSISTANT}{opening}"
+
+
+@NEEDS_TIMEOUT
+def test_the_srt_shim_records_a_gate_whose_inputs_are_missing_and_exits_0(tmp_path):
+    tools = tmp_path / "tools"
+    tools.mkdir()
+    # The serving image's python3: the inputs are checked before the client venv exists.
+    (tools / "python3").symlink_to(sys.executable)
+    env = {
+        "PATH": f"{tools}:/usr/bin:/bin", "AL_GATE": "true", "AL_GATE_CURVE": "testmodel_mtp",
+        "AL_GATE_DRAFT_TOKENS": "3", "AL_GATE_OUTPUT_DIR": str(tmp_path), "RESULT_FILENAME": "gate",
+    }  # fmt: skip
+
+    run = subprocess.run(
+        ["bash", str(REPO_ROOT / "benchmarks" / "srt_al_gate.sh")],
+        env=env, capture_output=True, text=True, timeout=60, check=False,
+    )  # fmt: skip
+
+    # Report-only: the eval that follows in the same job still runs.
+    missing = "  - AL_GATE_DATASET\n  - THINKING_MODE\n  - MODEL\n  - FRAMEWORK"
+    assert (run.returncode, missing in run.stderr) == (0, True)
+    assert "AL gate exited 1 (report-only)" in run.stderr
+    document = json.loads((tmp_path / "al_gate_gate.json").read_text())
+    assert (document["curve"], document["draft_tokens"], document["status"]) == (
+        "testmodel_mtp", 3, "error",
+    )  # fmt: skip
+    assert missing in document["error"]
+
+
+@NEEDS_TIMEOUT
+def test_the_srt_shim_stops_a_stalled_gate_at_its_cap_so_the_eval_still_runs(tmp_path):
+    tools = tmp_path / "tools"
+    tools.mkdir()
+    (tools / "python3").symlink_to(sys.executable)
+    # Prompts nobody writes: the gate blocks reading them, as a stalled replay would.
+    dataset = tmp_path / "speedbench_coding.jsonl"
+    os.mkfifo(dataset)
+    env = {
+        "PATH": f"{tools}:/usr/bin:/bin", "AL_GATE_TIMEOUT_S": "2", "AL_GATE": "true",
+        "AL_GATE_CURVE": "testmodel_mtp", "AL_GATE_DRAFT_TOKENS": "3", "AL_GATE_DATASET": str(dataset),
+        "AL_GATE_OUTPUT_DIR": str(tmp_path), "THINKING_MODE": "thinking_on", "RESULT_FILENAME": "gate",
+        "MODEL": "test/model", "FRAMEWORK": "vllm", "AIPERF_SERVER_URL": "http://frontend:8000",
+        "AIPERF_SERVER_METRICS_URLS": "http://worker:9090/metrics",
+    }  # fmt: skip
+
+    run = subprocess.run(
+        ["bash", str(REPO_ROOT / "benchmarks" / "srt_al_gate.sh")],
+        env=env, capture_output=True, text=True, timeout=60, check=False,
+    )  # fmt: skip
+
+    assert run.returncode == 0
+    assert "AL gate exited 124 (report-only)" in run.stderr
+    document = json.loads((tmp_path / "al_gate_gate.json").read_text())
+    assert (document["status"], document["error"]) == ("error", "stopped at the gate's 2s time cap")
diff --git a/inferencex-e2e/infx/tests/bench/test_fixed_seq.py b/inferencex-e2e/infx/tests/bench/test_fixed_seq.py
index 1765ea4ce7..ed61d11096 100644
--- a/inferencex-e2e/infx/tests/bench/test_fixed_seq.py
+++ b/inferencex-e2e/infx/tests/bench/test_fixed_seq.py
@@ -214,6 +214,7 @@ def test_single_node_does_not_report_success_without_a_completed_window(
     ("framework", "chat_template", "args", "flags"),
     [
         ("sglang", "true", [], {"--backend": "vllm", "--use-chat-template": True}),
+        ("tokenspeed", "true", [], {"--backend": "vllm", "--use-chat-template": True}),
         ("trt", "false", ["--trust-remote-code"], {"--backend": "openai", "--trust-remote-code": True}),
     ],
 )
@@ -260,7 +261,7 @@ def test_single_node_shim_runs_one_point_with_native_power(
 @pytest.mark.parametrize(
     ("overrides", "returncode", "reported"),
     [
-        ({"EVAL_ONLY": "true"}, 0, "EVAL_ONLY mode: skipping throughput benchmark\n"),
+        ({"EVAL_ONLY": "true", "FRAMEWORK": "tokenspeed"}, 0, "EVAL_ONLY mode: skipping throughput benchmark\n"),
         ({"MODEL": None, "CONC": ""}, 1, "not set:\n  - MODEL\n  - CONC\n"),
         ({"FRAMEWORK": "no-such-framework"}, 1, "ERROR: unsupported fixed-sequence FRAMEWORK: no-such-framework\n"),
         ({"USE_CHAT_TEMPLATE": "yes"}, 1, "ERROR: USE_CHAT_TEMPLATE must be true or false, got 'yes'\n"),
diff --git a/inferencex-e2e/infx/tests/bench/test_speedbench.py b/inferencex-e2e/infx/tests/bench/test_speedbench.py
new file mode 100644
index 0000000000..a0e5258189
--- /dev/null
+++ b/inferencex-e2e/infx/tests/bench/test_speedbench.py
@@ -0,0 +1,95 @@
+"""``python -m infx.bench.speedbench`` against a stand-in for NeMo-Skills' prepare.py."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+
+import pytest
+
+from infx.bench import speedbench
+
+# The names the command uses, over a split of its own. Resolving a non-coding row fails, as
+# resolving one from a gated dataset would.
+FAKE_PREPARE_PY = """
+PLACEHOLDER = "FETCH FROM SOURCE"
+SPLITS = {
+    ("nvidia/SPEED-Bench", "qualitative", "test", "rev-under-test"): [
+        {"question_id": "q1", "category": "math", "turns": ["What is 2 + 2?"]},
+        {"question_id": "q2", "category": "coding", "turns": ["Write fizzbuzz.", "Now in Go."]},
+        {"question_id": "q3", "category": "coding", "turns": [PLACEHOLDER + " Use Python."]},
+        {"question_id": "q4", "category": "coding", "turns": ["Trie une liste à l'envers."]},
+    ]
+}
+
+
+class Dataset(list):
+    def filter(self, function):
+        return Dataset(row for row in self if function(row))
+
+
+def load_dataset(path, name, split, revision):
+    return Dataset(SPLITS[(path, name, split, revision)])
+
+
+def _resolve_external_data(dataset, speed_config):
+    def resolve(row):
+        if row["category"] != "coding" or speed_config != "qualitative":
+            raise RuntimeError(f"{row['question_id']} resolves from a gated dataset")
+        turns = [turn.replace(PLACEHOLDER, "Solve problem 7.") for turn in row["turns"]]
+        return {**row, "turns": turns}
+
+    return Dataset(resolve(row) for row in dataset)
+"""
+CODING = ["Write fizzbuzz.", "Solve problem 7. Use Python.", "Trie une liste à l'envers."]
+# sha256sum of CODING as one UTF-8 JSON array.
+CODING_SHA256 = "cc3481dc93a4b3910188bb25a29709b7ee7f63cd2a3205425f6bfa4ee2e554ff"
+
+
+@pytest.fixture
+def prepare_py(tmp_path, monkeypatch):
+    """The stand-in, served as the reviewed prepare.py; the golden prompts are CODING."""
+    path = tmp_path / "prepare.py"
+    path.write_text(FAKE_PREPARE_PY, encoding="utf-8")
+    reviewed = hashlib.sha256(path.read_bytes()).hexdigest()
+    monkeypatch.setattr(speedbench, "PREPARE_PY", path.as_uri())
+    monkeypatch.setattr(speedbench, "PREPARE_PY_SHA256", reviewed)
+    monkeypatch.setattr(speedbench, "SPEED_BENCH_REVISION", "rev-under-test")
+    monkeypatch.setattr(speedbench, "PROMPTS_SHA256", CODING_SHA256)
+    return path
+
+
+def test_the_coding_rows_first_user_messages_are_written_in_order(tmp_path, prepare_py):
+    out = tmp_path / "out"
+
+    assert speedbench.main(["--output-dir", str(out)]) == 0
+
+    lines = (out / "speedbench_coding.jsonl").read_text(encoding="utf-8").splitlines()
+    assert [json.loads(line) for line in lines] == [
+        {"question_id": "q2", "prompt": CODING[0]},
+        {"question_id": "q3", "prompt": CODING[1]},
+        {"question_id": "q4", "prompt": CODING[2]},
+    ]
+    # Gate containers read the same prompts back.
+    assert speedbench.load(out / "speedbench_coding.jsonl") == CODING
+
+
+def test_prompts_other_than_the_golden_ones_are_not_written(tmp_path, prepare_py, monkeypatch):
+    # SPEED-Bench or a source it resolves from changed since the golden collections.
+    monkeypatch.setattr(speedbench, "PROMPTS_SHA256", "0" * 64)
+
+    with pytest.raises(SystemExit, match=f"3 prompts with sha256 {CODING_SHA256}, not 0+$"):
+        speedbench.main(["--output-dir", str(tmp_path / "out")])
+
+    assert not (tmp_path / "out").exists()
+
+
+def test_only_the_reviewed_prepare_py_runs(tmp_path, prepare_py):
+    ran = tmp_path / "ran"
+    prepare_py.write_text(f"{FAKE_PREPARE_PY}open({str(ran)!r}, 'w').close()\n", encoding="utf-8")
+
+    with pytest.raises(SystemExit, match="prepare.py has sha256"):
+        speedbench.main(["--output-dir", str(tmp_path / "out")])
+
+    assert not ran.exists()
+    assert not (tmp_path / "out").exists()
diff --git a/inferencex-e2e/infx/tests/bench/test_speedbench_al.py b/inferencex-e2e/infx/tests/bench/test_speedbench_al.py
deleted file mode 100644
index e1a8279550..0000000000
--- a/inferencex-e2e/infx/tests/bench/test_speedbench_al.py
+++ /dev/null
@@ -1,151 +0,0 @@
-import json
-
-import pytest
-import yaml
-
-from infx.bench import speedbench_al
-from infx.bench.env import BenchError, InputError
-from infx.bench.speedbench_al import levels, read_acceptance, select_category, write_matrix
-
-
-def test_select_category_preserves_all_matching_prompts(tmp_path):
-    source = tmp_path / "source.jsonl"
-    source.write_text(
-        "\n".join(
-            json.dumps(
-                {
-                    "category": category,
-                    "messages": [{"role": "user", "content": content}],
-                }
-            )
-            for category, content in [("coding", "one"), ("math", "two"), ("coding", "three")]
-        )
-    )
-    destination = tmp_path / "selected.jsonl"
-    assert select_category(source, destination, "coding") == 2
-    assert [json.loads(row) for row in destination.read_text().splitlines()] == [
-        {"category": "coding", "messages": [{"role": "user", "content": "one"}]},
-        {"category": "coding", "messages": [{"role": "user", "content": "three"}]},
-    ]
-    with pytest.raises(BenchError, match="No SPEED-Bench"):
-        select_category(source, destination, "missing")
-
-
-@pytest.mark.parametrize(
-    "messages",
-    [
-        [],
-        [{"role": "system", "content": "instruction"}, {"role": "user", "content": "question"}],
-        [{"role": "user", "content": ""}],
-        [{"role": "user", "content": ["multimodal"]}],
-    ],
-)
-def test_select_category_rejects_invalid_first_turn(tmp_path, messages):
-    source = tmp_path / "source.jsonl"
-    source.write_text(json.dumps({"category": "coding", "messages": messages}))
-    with pytest.raises(BenchError, match="start with"):
-        select_category(source, tmp_path / "selected.jsonl", "coding")
-
-
-def test_select_category_preserves_multiturn_rows_for_native_vllm_loader(tmp_path):
-    source = tmp_path / "source.jsonl"
-    row = {
-        "category": "coding",
-        "messages": [
-            {"role": "user", "content": "Write a parser"},
-            {"role": "user", "content": "Add error handling"},
-        ],
-    }
-    source.write_text(json.dumps(row))
-    destination = tmp_path / "selected.jsonl"
-    assert select_category(source, destination, "coding") == 1
-    assert json.loads(destination.read_text()) == row
-
-
-def test_wait_gpu_idle_waits_for_workers(monkeypatch):
-    readings = iter(["15000\n16000\n", "1000\n1900\n"])
-    monkeypatch.setattr(speedbench_al.subprocess, "check_output", lambda *a, **kw: next(readings))
-    waits = []
-    monkeypatch.setattr(speedbench_al.time, "sleep", waits.append)
-    speedbench_al.wait_gpu_idle()
-    assert waits == [3]
-
-
-@pytest.mark.parametrize("output", ["", "3000\n4000\n"])
-def test_wait_gpu_idle_fails_closed(monkeypatch, output):
-    monkeypatch.setattr(speedbench_al.subprocess, "check_output", lambda *a, **kw: output)
-    clock = iter([0, 121])
-    monkeypatch.setattr(speedbench_al.time, "monotonic", lambda: next(clock))
-    with pytest.raises(BenchError, match="did not drain"):
-        speedbench_al.wait_gpu_idle()
-
-
-def test_acceptance_and_matrix(tmp_path):
-    result = tmp_path / "result.json"
-    result.write_text(
-        json.dumps(
-            {
-                "completed": 20,
-                "total_output_tokens": 100,
-                "spec_decode_acceptance_length": 2.3456789,
-                "spec_decode_num_drafts": 10000000,
-                "spec_decode_accepted_tokens": 13456789,
-            }
-        )
-    )
-    value = read_acceptance(result, expected=20, mtp=3)
-    matrix = tmp_path / "matrix.yaml"
-    write_matrix(matrix, "zai-org/GLM-5.3-Flash", {3: value}, tmp_path / "provenance.json")
-    assert yaml.safe_load(matrix.read_text()) == {"glm-5.3-flash": {"thinking_on": {3: 2.345679}}}
-
-
-@pytest.mark.parametrize(
-    "updates",
-    [
-        {"completed": 19},
-        {"total_output_tokens": 0},
-        {"failed": 1},
-        {"spec_decode_acceptance_length": None},
-        {"spec_decode_acceptance_length": "N/A"},
-        {"spec_decode_acceptance_length": float("nan")},
-        {"spec_decode_acceptance_length": float("inf")},
-        {"spec_decode_acceptance_length": True},
-        {"spec_decode_acceptance_length": 0.99},
-        {"spec_decode_acceptance_length": 4.01},
-        {"spec_decode_num_drafts": 0},
-        {"spec_decode_num_drafts": None},
-        {"spec_decode_accepted_tokens": -1},
-        {"spec_decode_accepted_tokens": 301},
-    ],
-)
-def test_reject_incomplete_or_invalid_measurements(tmp_path, updates):
-    result = tmp_path / "result.json"
-    result.write_text(
-        json.dumps(
-            {
-                "completed": 20,
-                "total_output_tokens": 100,
-                "spec_decode_acceptance_length": 2.5,
-                "spec_decode_num_drafts": 200,
-                "spec_decode_accepted_tokens": 300,
-            }
-            | updates
-        )
-    )
-    with pytest.raises(BenchError):
-        read_acceptance(result, expected=20, mtp=3)
-
-
-@pytest.mark.parametrize("content", ["", "{}\n{}\n"])
-def test_reject_missing_or_stale_results(tmp_path, content):
-    result = tmp_path / "result.jsonl"
-    result.write_text(content)
-    with pytest.raises(BenchError, match="Expected one"):
-        read_acceptance(result, expected=20, mtp=3)
-
-
-def test_levels():
-    assert levels("1 3 8") == [1, 3, 8]
-    for invalid in ("", "1 1", "0", "-1", "a"):
-        with pytest.raises(InputError):
-            levels(invalid)
diff --git a/inferencex-e2e/infx/tests/golden_al_distribution/test_golden_al_distribution.py b/inferencex-e2e/infx/tests/golden_al_distribution/test_golden_al_distribution.py
index dbab825262..8a15662012 100644
--- a/inferencex-e2e/infx/tests/golden_al_distribution/test_golden_al_distribution.py
+++ b/inferencex-e2e/infx/tests/golden_al_distribution/test_golden_al_distribution.py
@@ -2,8 +2,11 @@
 
 import json
 import math
+import re
+from pathlib import Path
 
 import pytest
+import yaml
 
 from infx.golden_al_distribution import (
     GOLDEN_DIR,
@@ -11,14 +14,19 @@
     curve_name,
     golden_length,
     list_curves,
+    load_curve,
 )
 from infx.golden_al_distribution.__main__ import main
 
+SOURCE_RUN = r"https://github\.com/SemiAnalysisAI/InferenceX/actions/runs/\d+"
+
 
 def test_every_committed_curve_is_valid() -> None:
     curves = list_curves()
-    assert {curve.name for curve in curves} == {path.stem for path in GOLDEN_DIR.glob("*.yaml")}
+    stems = {path.stem for path in GOLDEN_DIR.glob("*.yaml")} - {"identities"}
+    assert {curve.name for curve in curves} == stems
     for curve in curves:
+        assert re.fullmatch(SOURCE_RUN, curve.source_run or ""), curve.name
         assert set(curve.modes) <= set(THINKING_MODES), curve.name
         for mode in curve.modes:
             assert curve.tokens(mode), (curve.name, mode)
@@ -28,23 +36,77 @@ def test_every_committed_curve_is_valid() -> None:
                 assert 1 <= value <= tokens + 1
 
 
+def test_collection_settings_sit_beside_the_model(tmp_path: Path) -> None:
+    collection = {
+        "renderer": "deepseek_v4",
+        "modes": {"thinking_on": {"chat_template_kwargs": None, "sampling": {"temperature": 1.0}}},
+    }
+    curves = {
+        "recorded": {
+            "source_run": "https://github.com/SemiAnalysisAI/InferenceX/actions/runs/1",
+            "deepseek-v4-pro": {"thinking_on": {3: 3.01}},
+            "collection": collection,
+        },
+        "unrecorded": {"kimi-k3": {"thinking_on": {7: 3.78}}},
+        "two_models": {"a": {"thinking_on": {1: 1.5}}, "b": {}, "collection": collection},
+    }
+    for name, document in curves.items():
+        (tmp_path / f"{name}.yaml").write_text(yaml.safe_dump(document))
+    recorded = load_curve("recorded", tmp_path)
+    assert (recorded.model, recorded.acceptance("thinking_on", 3)) == ("deepseek-v4-pro", 3.01)
+    assert recorded.collection == collection
+    assert recorded.source_run == "https://github.com/SemiAnalysisAI/InferenceX/actions/runs/1"
+    unrecorded = load_curve("unrecorded", tmp_path)
+    assert (unrecorded.collection, unrecorded.source_run) == (None, None)
+    with pytest.raises(ValueError, match="Expected one model in golden curve two_models.yaml"):
+        load_curve("two_models", tmp_path)
+
+
 @pytest.mark.parametrize(
     ("model", "spec", "expected"),
     [
-        ("qwen3.5", {"method": "mtp"}, "qwen3.5_mtp"),
-        ("qwen3.5", {"method": "NEXTN"}, "qwen3.5_mtp"),
-        ("glm5.2", {"method": "eagle"}, "glm5.2_mtp"),
-        ("minimaxm3", {"method": "eagle"}, "minimaxm3_eagle3"),
-        ("minimaxm3", {"method": "eagle3", "model": "org/MiniMax-M3-EAGLE3-GQA"}, "minimaxm3_eagle3_gqa"),
-        ("dsv4dsparkprob", {"method": "dspark"}, "dsv4-pro-0813-dspark"),
-        ("dsv41flash", {"method": "dspark"}, "dsv41flash_dspark"),
-        ("musespark", {"method": "dflash"}, "musespark_dflash"),
-        ("minimaxm31flash", {"method": "dspark"}, "minimaxm31flash_dspark"),
-        ("kimik3", {"method": "dspark", "draft_sample_method": "greedy"}, "kimik3_dspark"),
+        ("qwen3.5", {"method": "mtp"}, "qwen3.5-397b-a17b-nvfp4__mtp__native__default-default"),
+        ("qwen3.5", {"method": "NEXTN"}, "qwen3.5-397b-a17b-nvfp4__mtp__native__default-default"),
+        ("glm5.2", {"method": "eagle"}, "glm-5.2-fp8__mtp__native__default-default"),
+        (
+            "minimaxm3",
+            {"method": "eagle"},
+            "minimax-m3__eagle3__minimax-m3-eagle3__default-default",
+        ),
+        (
+            "minimaxm3",
+            {"method": "eagle3", "model": "org/MiniMax-M3-EAGLE3-GQA"},
+            "minimax-m3__eagle3__minimax-m3-eagle3-gqa__default-default",
+        ),
+        (
+            "dsv4dsparkprob",
+            {"method": "dspark"},
+            "deepseek-v4-pro-0813__dspark__native__probabilistic-default",
+        ),
+        (
+            "dsv41flash",
+            {"method": "dspark"},
+            "deepseek-v4.1-flash__dspark__native__probabilistic-block",
+        ),
+        (
+            "musespark",
+            {"method": "dflash"},
+            "muse-spark-open-816b-a42b-nvfp4__dflash__muse-spark-open-dflash2__default-default",
+        ),
+        (
+            "minimaxm31flash",
+            {"method": "dspark"},
+            "minimax-m3.1-flash__dspark__native__probabilistic-block",
+        ),
+        (
+            "kimik3",
+            {"method": "dspark", "draft_sample_method": "greedy"},
+            "kimi-k3__dspark__kimi-k3-dspark__default-default",
+        ),
         (
             "kimik3",
             {"method": "dspark", "draft_sample_method": "probabilistic"},
-            "kimik3_dspark_probabilistic_sample_method_block_rejection_sample_method",
+            "kimi-k3__dspark__kimi-k3-dspark__probabilistic-block",
         ),
     ],
 )
@@ -56,10 +118,16 @@ def test_curve_name_resolves_committed_curves(model, spec, expected) -> None:
 @pytest.mark.parametrize(
     ("spec", "message"),
     [
-        ({"method": "dspark", "num_speculative_tokens": 7}, "Kimi DSpark golden curve"),
-        ({"method": "dspark", "draft_sample_method": "greedy", "num_speculative_tokens": 0}, "positive integer"),
-        ({"method": "dspark", "draft_sample_method": "greedy", "num_speculative_tokens": 99}, "No golden acceptance"),
-        ({"method": "eagle3", "num_speculative_tokens": 3}, "No committed golden curve"),
+        ({"method": "dspark", "num_speculative_tokens": 7}, "No kimik3 dspark golden curve"),
+        (
+            {"method": "dspark", "draft_sample_method": "greedy", "num_speculative_tokens": 0},
+            "positive integer",
+        ),
+        (
+            {"method": "dspark", "draft_sample_method": "greedy", "num_speculative_tokens": 99},
+            "No golden acceptance",
+        ),
+        ({"method": "eagle3", "num_speculative_tokens": 3}, "No golden curve for model prefix"),
     ],
 )
 def test_golden_length_rejects_unknown_cells(spec, message) -> None:
@@ -69,12 +137,19 @@ def test_golden_length_rejects_unknown_cells(spec, message) -> None:
 
 def test_cli_lookup_matches_library(capsys) -> None:
     assert main(["lookup", "qwen3.5", "eagle", "3", "--thinking", "thinking_off"]) == 0
-    expected = golden_length("qwen3.5", {"method": "mtp", "num_speculative_tokens": 3}, "thinking_off")
+    expected = golden_length(
+        "qwen3.5", {"method": "mtp", "num_speculative_tokens": 3}, "thinking_off"
+    )
     assert float(capsys.readouterr().out) == expected
 
-    assert main(["lookup", "kimik3", "dspark", "7", "--draft-sample-method", "probabilistic", "--json"]) == 0
+    assert (
+        main(
+            ["lookup", "kimik3", "dspark", "7", "--draft-sample-method", "probabilistic", "--json"]
+        )
+        == 0
+    )
     result = json.loads(capsys.readouterr().out)
-    assert result["curve"] == "kimik3_dspark_probabilistic_sample_method_block_rejection_sample_method"
+    assert result["curve"] == "kimi-k3__dspark__kimi-k3-dspark__probabilistic-block"
     assert result["tokens"] == 7
 
 
@@ -83,8 +158,8 @@ def test_cli_list_and_show(capsys) -> None:
     listed = json.loads(capsys.readouterr().out)
     assert [row["curve"] for row in listed] == [curve.name for curve in list_curves()]
 
-    assert main(["show", "glm5.3_mtp"]) == 0
-    assert "glm-5.3-fp8" in capsys.readouterr().out
+    assert main(["show", "glm-5.3-nvfp4__mtp__native__default-default"]) == 0
+    assert "glm-5.3-nvfp4" in capsys.readouterr().out
 
 
 def test_cli_reports_errors(capsys) -> None:
@@ -102,6 +177,16 @@ def test_cli_show_rejects_a_curve_outside_the_golden_dir(tmp_path, capsys) -> No
 
 
 def test_a_thinking_mode_written_as_a_list_is_rejected(tmp_path) -> None:
+    fact = "{value: null, source: default}"
+    (tmp_path / "identities.yaml").write_text(
+        "m_mtp:\n  select: {model_prefixes: [m], method: mtp}\n  collection:\n"
+        "    engine: vllm\n    draft: native\n"
+        + "".join(f"    {field}: {fact}\n" for field in (
+            "draft_sample", "verify", "adaptive", "draft_precision", "draft_kv_cache_dtype",
+            "kv_cache_dtype",
+        ))
+        + "    topology: {value: chain, source: documented}\n"
+    )
     (tmp_path / "m_mtp.yaml").write_text("m:\n  thinking_on: [1.5, 2.3, 2.9]\n")
     spec = {"method": "mtp", "num_speculative_tokens": 2}
 
diff --git a/inferencex-e2e/infx/tests/golden_al_distribution/test_spec_identity.py b/inferencex-e2e/infx/tests/golden_al_distribution/test_spec_identity.py
new file mode 100644
index 0000000000..b4f1854ab3
--- /dev/null
+++ b/inferencex-e2e/infx/tests/golden_al_distribution/test_spec_identity.py
@@ -0,0 +1,178 @@
+"""Curve identities, identity-based selection, run normalization and the audit."""
+
+import pytest
+import yaml
+
+from infx.golden_al_distribution import GOLDEN_DIR, curve_name, load_curve
+from infx.golden_al_distribution.identity import (
+    Fact,
+    canonical_name,
+    load_identities,
+    parse_identity,
+)
+from infx.srt_slurm.spec_identity import audit, run_collection
+
+DEFAULT = {"value": None, "source": "default"}
+CHAIN = {"value": "chain", "source": "documented"}
+
+
+def _role(**args):
+    return {"args": args}
+
+
+def _identity(prefix: str) -> dict:
+    return {
+        "select": {"model_prefixes": [prefix], "method": "mtp"},
+        "collection": {
+            "engine": "vllm", "draft": "native", "draft_sample": DEFAULT, "verify": DEFAULT,
+            "adaptive": DEFAULT, "topology": CHAIN, "draft_precision": DEFAULT,
+            "draft_kv_cache_dtype": DEFAULT, "kv_cache_dtype": DEFAULT,
+        },
+    }  # fmt: skip
+
+
+def test_every_curve_file_has_an_identity_matching_its_name() -> None:
+    identities = load_identities()
+    assert set(identities) == {path.stem for path in GOLDEN_DIR.glob("*.yaml")} - {"identities"}
+    for name, identity in identities.items():
+        assert canonical_name(load_curve(name).model, identity) == name
+
+
+def test_overlapping_selectors_are_rejected(tmp_path) -> None:
+    (tmp_path / "identities.yaml").write_text(yaml.safe_dump({"a": _identity("m"), "b": _identity("m")}))
+    with pytest.raises(ValueError, match="several golden curves"):
+        curve_name("m", {"method": "mtp"}, tmp_path)
+
+
+def test_verify_selector_wins_and_unknown_verifiers_keep_the_general_curve(tmp_path) -> None:
+    block = _identity("m")
+    block["select"]["verify"] = "block"
+    identities = {"general": _identity("m"), "block": block}
+    (tmp_path / "identities.yaml").write_text(yaml.safe_dump(identities))
+    spec = {"method": "mtp"}
+    assert curve_name("m", spec, tmp_path, "block") == "block"
+    assert curve_name("m", spec, tmp_path, "standard") == "general"
+    assert curve_name("m", spec, tmp_path, None) == "general"
+    del identities["general"]
+    (tmp_path / "identities.yaml").write_text(yaml.safe_dump(identities))
+    with pytest.raises(ValueError, match="verify None; curves need verify=block"):
+        curve_name("m", spec, tmp_path, None)
+
+
+@pytest.mark.parametrize(
+    ("field", "fact", "message"),
+    [
+        ("verify", {"value": "block"}, "verify must be"),
+        ("verify", {"value": None, "source": "explicit"}, "null value exactly"),
+    ],
+)
+def test_malformed_fact_is_rejected(field, fact, message) -> None:
+    data = _identity("m")
+    data["collection"][field] = fact
+    with pytest.raises(ValueError, match=message):
+        parse_identity("bad", data)
+
+
+def test_vllm_unset_settings_and_synthetic_sampler() -> None:
+    role = _role(**{"speculative-config": {"method": "mtp", "num_speculative_tokens": 3}})
+    run = run_collection("qwen3.5", role, "vllm")
+    assert run.draft_sample == Fact(None, "default")
+    assert run.verify == Fact("standard", "documented")
+    assert run.adaptive == Fact(False, "documented")
+    synthetic = {
+        "method": "dspark", "num_speculative_tokens": 6, "draft_sample_method": "probabilistic",
+        "rejection_sample_method": "synthetic", "synthetic_acceptance_length": 3.77,
+    }  # fmt: skip
+    assert run_collection("dsv4", _role(**{"speculative-config": synthetic}), "vllm").verify == (
+        Fact("block", "documented")
+    )
+
+
+def test_same_engine_defaults_agree_but_cross_engine_defaults_are_unverified() -> None:
+    spec = {"method": "mtp", "num_speculative_tokens": 3}
+    assert audit("qwen3.5", _role(**{"speculative-config": spec, "kv-cache-dtype": "fp8"}), "vllm")[
+        "findings"
+    ] == []
+    args = {
+        "speculative-algorithm": "NEXTN", "speculative-num-steps": 3, "speculative-eagle-topk": 1,
+        "kv-cache-dtype": "fp8",
+    }  # fmt: skip
+    findings = audit("qwen3.5", _role(**args), "sglang")["findings"]
+    assert [f[:2] for f in findings] == [
+        ["unverified", "draft_sample"], ["unverified", "draft_precision"],
+        ["unverified", "draft_kv_cache_dtype"], ["engine", "engine"],
+    ]  # fmt: skip
+
+
+def test_verifier_mismatch_is_reported() -> None:
+    spec = {"method": "dspark", "num_speculative_tokens": 4, "draft_sample_method": "probabilistic"}
+    findings = audit("dsv41flash", _role(**{"speculative-config": spec}), "vllm")
+    assert findings["curve"] == "deepseek-v4.1-flash__dspark__native__probabilistic-block"
+    assert ["mismatch", "verify", "standard (documented)", "block (explicit)"] in findings["findings"]
+
+
+def test_verifier_specific_curve_wins() -> None:
+    spec = {"method": "dspark", "num_speculative_tokens": 4, "draft_sample_method": "probabilistic"}
+    role = _role(**{"speculative-config": spec, "kv-cache-dtype": "fp8"})
+    findings = audit("kimik3", role, "vllm")
+    assert findings["curve"] == "kimi-k3__dspark__kimi-k3-dspark__probabilistic-default"
+    assert [f for f in findings["findings"] if f[1] == "verify"] == []
+    block = {**spec, "rejection_sample_method": "block"}
+    role = _role(**{"speculative-config": block, "kv-cache-dtype": "fp8"})
+    assert audit("kimik3", role, "vllm")["curve"] == (
+        "kimi-k3__dspark__kimi-k3-dspark__probabilistic-block"
+    )
+
+
+def test_sglang_block_verification_and_topk() -> None:
+    args = {
+        "speculative-algorithm": "EAGLE", "speculative-num-steps": 3,
+        "speculative-eagle-topk": 4, "speculative-use-block-verification": True,
+    }  # fmt: skip
+    run = run_collection("glm5.2", _role(**args), "sglang")
+    assert run.verify == Fact("block", "explicit")
+    assert run.topology == Fact("tree-topk4", "explicit")
+    del args["speculative-eagle-topk"]
+    assert run_collection("glm5.2", _role(**args), "sglang").topology.source == "default"
+
+
+def test_trtllm_relaxed_acceptance_is_its_own_verifier() -> None:
+    config = {"decoding_type": "MTP", "max_draft_len": 3, "use_relaxed_acceptance_for_thinking": True}
+    run = run_collection("dsv4", _role(speculative_config=config), "dynamo-trt")
+    assert run.verify == Fact("relaxed", "explicit")
+
+
+def test_atom_verifier_is_unknown_and_reported_unverified() -> None:
+    args = {"method": "dspark", "num-speculative-tokens": 4, "draft-model": "Inferact/Kimi-K3-DSpark"}
+    findings = audit("kimik3", _role(**args), "atom")["findings"]
+    assert ["unverified", "verify", "unknown", "block (explicit)"] in findings
+
+
+def test_adaptive_run_is_reported() -> None:
+    spec = {
+        "method": "dspark", "num_speculative_tokens": 5, "draft_sample_method": "probabilistic",
+        "rejection_sample_method": "block", "enable_adaptive_verification": True,
+    }  # fmt: skip
+    findings = audit("dsv41flash", _role(**{"speculative-config": spec}), "vllm")["findings"]
+    assert findings[0] == ["adaptive", "adaptive", "True (explicit)", "False (explicit)"]
+
+
+def test_precision_and_kv_cache_dtypes_are_read_per_engine() -> None:
+    spec = {
+        "method": "dspark", "num_speculative_tokens": 7, "kv_cache_dtype": "fp8",
+        "draft_sample_method": "probabilistic", "rejection_sample_method": "block",
+    }  # fmt: skip
+    role = _role(**{"speculative-config": spec, "kv-cache-dtype": "nvfp4"})
+    assert audit("minimaxm31flash", role, "vllm")["findings"] == []
+    args = {
+        "speculative-algorithm": "DSPARK", "speculative-dspark-block-size": 7,
+        "speculative-draft-model-quantization": "nvfp4_online",
+        "speculative-draft-kv-cache-dtype": "fp8_e4m3", "kv-cache-dtype": "auto",
+    }  # fmt: skip
+    run = run_collection("minimaxm31flash", _role(**args), "sglang")
+    assert run.draft_precision == Fact("nvfp4_online", "explicit")
+    assert run.draft_kv_cache_dtype == Fact("fp8", "explicit")
+    assert run.kv_cache_dtype == Fact(None, "default")
+    config = {"decoding_type": "MTP", "max_draft_len": 3}
+    trt = _role(speculative_config=config, kv_cache_config={"dtype": "fp8"})
+    assert run_collection("dsv4", trt, "dynamo-trt").kv_cache_dtype == Fact("fp8", "explicit")
diff --git a/inferencex-e2e/infx/tests/launch/fake_slurm.py b/inferencex-e2e/infx/tests/launch/fake_slurm.py
index ad49e8f722..f05c420f7f 100644
--- a/inferencex-e2e/infx/tests/launch/fake_slurm.py
+++ b/inferencex-e2e/infx/tests/launch/fake_slurm.py
@@ -97,7 +97,7 @@
 import yaml
 argv = sys.argv[1:]
 keep = ("RUNNER_NAME", "INFMAX_WORKSPACE", "MODEL_PATH", "SERVED_MODEL_NAME", "VIRTUAL_ENV",
-        "UCX_NET_DEVICES", "ENROOT_ROOTFS_WRITABLE", "SRT_SRUN_OPTIONS")
+        "UCX_NET_DEVICES", "ENROOT_ROOTFS_WRITABLE", "SRT_SRUN_OPTIONS", "EVAL_ONLY", "RUN_EVAL")
 record = {"argv": argv, "cwd": os.getcwd(), "env": {name: os.environ.get(name) for name in keep}}
 with open(os.path.join(os.environ["FAKE_LOG_DIR"], "srtctl.jsonl"), "a") as handle:
     handle.write(json.dumps(record) + "\n")
@@ -128,6 +128,11 @@
     for conc in os.environ["CONC_LIST"].split():
         (workspace / f"{result}_conc{conc}.json").write_text(json.dumps({"conc": int(conc)}))
         (logs / "agentic" / f"conc_{conc}").mkdir(parents=True)
+elif mode == "gate":
+    # What an eval's acceptance gate writes to AL_GATE_OUTPUT_DIR (/logs in the container).
+    (logs / f"al_gate_{result}.json").write_text(json.dumps({"status": "below", "result_filename": result}))
+    (logs / "al_gate" / "aiperf_artifacts").mkdir(parents=True)
+    (logs / "al_gate" / "aiperf_artifacts" / "server_metrics_export.json").write_text("{}")
 if os.environ.get("RUN_EVAL") == "true" or os.environ.get("EVAL_ONLY") == "true":
     (logs / "eval_results").mkdir()
     (logs / "eval_results" / "results_gsm8k.json").write_text("{}")
diff --git a/inferencex-e2e/infx/tests/launch/test_launch_artifacts.py b/inferencex-e2e/infx/tests/launch/test_launch_artifacts.py
index 6c85895c50..473b08e4b2 100644
--- a/inferencex-e2e/infx/tests/launch/test_launch_artifacts.py
+++ b/inferencex-e2e/infx/tests/launch/test_launch_artifacts.py
@@ -1,7 +1,9 @@
 """Workspace staging behavior of the launcher artifact helpers."""
 
+import json
 import os
 import stat
+import sys
 import tarfile
 
 import pytest
@@ -11,6 +13,7 @@
     bundle_server_logs,
     collect_agentic_power_results,
     copy_agentic_results,
+    copy_al_gate_result,
     copy_fixed_sequence_results,
     copy_to_workspace,
 )
@@ -65,6 +68,19 @@ def test_agentic_results_require_a_match(tmp_path):
         copy_agentic_results(tmp_path / "src", tmp_path, "point")
 
 
+def test_an_eval_gate_verdict_is_staged_when_the_job_ran_one(tmp_path):
+    logs, workspace = tmp_path / "logs", tmp_path / "ws"
+    logs.mkdir()
+    workspace.mkdir()
+    copy_al_gate_result(logs, workspace, "point")
+    assert not (workspace / "al_gate_point.json").exists()
+    (logs / "al_gate" / "scrapes").mkdir(parents=True)
+    (logs / "al_gate_point.json").write_text('{"status": "pass"}\n')
+    copy_al_gate_result(logs, workspace, "point")
+    assert (workspace / "al_gate_point.json").read_text() == '{"status": "pass"}\n'
+    assert not (workspace / "al_gate").exists()  # raw replay files stay in the server logs
+
+
 def test_bundle_skips_empty_logs_and_archives_contents(tmp_path):
     logs = tmp_path / "logs"
     logs.mkdir()
@@ -115,3 +131,53 @@ def test_power_collection_records_the_job_status_and_stages_results_either_way(t
 
     assert (logs / "power" / "native-job-status.txt").read_text() == f"42|{status.raw}\n"
     assert (workspace / "point_conc4.json").exists()
+
+
+def test_agentic_collection_requires_declared_cpu_and_keeps_gpu_valid(tmp_path):
+    from infx.tests.results.power.test_aggregate_power_multinode import (
+        PRODUCER_SHA,
+        build_package,
+    )
+
+    pkg = build_package(tmp_path / "captured")
+    result_dir = pkg.logs_root / "agentic/conc_4"
+    result_dir.mkdir(parents=True)
+    formal_result = result_dir / "agentic_power_concurrency_4.json"
+    formal_result.write_bytes(pkg.original_result.read_bytes())
+    [window_path] = pkg.windows_dir.glob("*.json")
+    window = json.loads(window_path.read_text())
+    window["result_path"] = str(formal_result.relative_to(pkg.logs_root))
+    window_path.unlink()
+    window_path = pkg.windows_dir / formal_result.name
+    window_path.write_text(json.dumps(window))
+    manifest_path = pkg.power_dir / "manifest.json"
+    manifest = json.loads(manifest_path.read_text())
+    manifest["window_validations"][0]["window_file"] = f"windows/{formal_result.name}"
+    for device in manifest["expected_devices"]:
+        device["assignments"][0].update(worker_role="agg", het_group=0)
+    manifest_path.write_text(json.dumps(manifest))
+    source, workspace = tmp_path / "source", tmp_path / "output"
+    source.mkdir()
+    workspace.mkdir()
+    (source / "point_conc4.json").write_text(
+        json.dumps({"disagg": False, "num_prefill_gpu": 4, "num_decode_gpu": 0})
+    )
+    status = JobStatus(JobState.SUCCEEDED, "COMPLETED|0:0", 0)
+    assert collect_agentic_power_results(
+        status,
+        "42",
+        pkg.logs_root,
+        source,
+        workspace,
+        "point",
+        PRODUCER_SHA,
+        [4],
+        results_python=sys.executable,
+        expected_cpu=True,
+    ) == 1
+    result = json.loads((workspace / "point_conc4.json").read_text())
+    assert result["power_valid"] == 1
+    assert result["cpu_power_valid"] == 0
+    assert result["total_gpu_energy_j"] == 84000.0
+    assert result["power_audit"]["source"] == "LOGS/agentic/conc_4/power_validation.json"
+    assert result["power_audit"]["cpu"]["reason_codes"] == ["cpu_artifacts_missing"]
diff --git a/inferencex-e2e/infx/tests/launch/test_launch_policy.py b/inferencex-e2e/infx/tests/launch/test_launch_policy.py
index e005c2a058..7751a3f3ef 100644
--- a/inferencex-e2e/infx/tests/launch/test_launch_policy.py
+++ b/inferencex-e2e/infx/tests/launch/test_launch_policy.py
@@ -5,6 +5,7 @@
 import pytest
 
 from infx.clusters import load_inventory
+from infx.clusters.slurm import SrtSlurmSettings
 from infx.launch import drivers, policy
 from infx.launch.__main__ import launch
 from infx.launch.context import LaunchError
@@ -12,11 +13,10 @@
 from infx.launch.drivers.srt import models, power
 from infx.launch.drivers.srt.power import PowerPolicyError, decide_power
 from infx.launch.lifecycle import Lifecycle
-from infx.launch.policy import LaunchPath, Match, salloc_time_limit
+from infx.launch.policy import LaunchPath, salloc_time_limit
 from infx.launch.request import LaunchRequest, MultiNodeRequest, RequestError
 
-DCGM, AGENTX, ADAPTER, ERR = "dcgm", "agentx", "adapter", "error"
-MULTI, NATIVE = LaunchPath.SRT_MULTI, LaunchPath.SRT_NATIVE
+MULTI = LaunchPath.SRT_MULTI
 
 
 def _request(**env):
@@ -31,68 +31,75 @@ def _multinode(**env):
     })
 
 
-CASES = [
-    ("gb200-nv", MULTI, "1", "glm5.2", "fp4", "dynamo-sglang", AGENTX),
-    ("gb200-nv", MULTI, "1", "kimik3", "fp4", "dynamo-vllm", AGENTX),
-    ("gb200-nv", MULTI, "0", "dsr1", "fp8", "dynamo-sglang", DCGM),
-    ("gb200-nv", MULTI, "0", "dsv4", "fp4", "dynamo-vllm", ERR),
-    ("gb300-nv", MULTI, "1", "kimik3", "fp4", "dynamo-vllm", AGENTX),
-    ("gb300-nv", MULTI, "1", "glm5.2", "fp4", "dynamo-sglang", DCGM),
-    ("gb300-nv", MULTI, "0", "qwen3.5", "fp8", "dynamo-trt", ERR),
-    ("b300-dsxe", MULTI, "0", "dsv4", "fp4", "dynamo-vllm", ERR),
-    ("b200-nscale", NATIVE, "1", "kimik3", "fp4", "dynamo-vllm", AGENTX),
-    ("b200-nscale", NATIVE, "0", "dsv4", "fp4", "dynamo-sglang", ERR),
-    ("b200-nscale", NATIVE, "0", "glm5.2", "fp4", "dynamo-vllm", ERR),
-    ("b200-nscale", MULTI, "1", "qwen3.5", "fp8", "dynamo-sglang", AGENTX),
-    ("b200-nscale", MULTI, "1", "kimik3", "fp4", "dynamo-vllm", ERR),
-    ("b200-nscale", MULTI, "0", "dsv4", "fp4", "dynamo-vllm", ERR),
-    ("h200-dgxc", MULTI, "1", "kimik3", "fp4", "vllm", AGENTX),
-    ("h200-dgxc", MULTI, "1", "glm5.2", "fp8", "dynamo-sglang", ADAPTER),
-    ("h200-dgxc", MULTI, "0", "glm5.2", "fp8", "dynamo-sglang", ERR),
-    ("h200-dgxc", MULTI, "1", "dsv4", "fp8", "dynamo-sglang", ERR),
-    ("h200-dgxc", MULTI, "1", "kimik3", "fp4", "dynamo-vllm", ERR),
-]
+def _srt(**settings) -> SrtSlurmSettings:
+    return SrtSlurmSettings.model_validate({"network-interface": "", **settings})
 
 
-@pytest.mark.parametrize(
-    ("cluster", "path", "agentic", "prefix", "precision", "framework", "expected"), CASES
-)
-def test_power_eligibility_of_each_cluster_lane(
-    cluster, path, agentic, prefix, precision, framework, expected
-):
-    env = dict(IS_AGENTIC=agentic, MODEL_PREFIX=prefix, PRECISION=precision, FRAMEWORK=framework)
+EXPORTER = {"extra": {"default_gpu_exporter": {"container_image": "exporter:test"}}}
+GPU_ONLY = _srt(**EXPORTER, **{"power-exporter-port": 9401})
+WITH_CPU = _srt(**EXPORTER, **{"power-exporter-port": 9401, "cpu-power-exporter": {"source": "acpi"}})
+
+
+def _point(agentic: str, prefix: str = "dsv4", framework: str = "dynamo-vllm", **env):
     if agentic == "1":
         env.update(CONC="4", CONC_LIST="4", IS_MULTINODE="true")
-    if expected == ERR:
-        with pytest.raises(PowerPolicyError):
-            decide_power(cluster, path, _multinode(**env, POWER="1"))
-        return
-    decision = decide_power(cluster, path, _multinode(**env, POWER="1"))
-    assert (decision.dcgm, decision.agentx, decision.adapter) == (
-        True, expected == AGENTX, expected == ADAPTER,
-    )  # fmt: skip
-    assert decision.require is (prefix == "kimik3" and cluster in ("gb200-nv", "gb300-nv"))
-    assert not decide_power(cluster, path, _multinode(**env, POWER="0")).dcgm
-
-
-def test_gb200_reports_agentic_misses_distinctly():
-    request = _multinode(IS_AGENTIC="1", MODEL_PREFIX="dsv4", PRECISION="fp4",
-                         FRAMEWORK="dynamo-sglang", CONC="4", CONC_LIST="4", POWER="1")  # fmt: skip
-    with pytest.raises(PowerPolicyError, match="AgentX dcgm-power requires GLM-5.2"):
-        decide_power("gb200-nv", MULTI, request)
-
-
-def test_a_power_lane_needs_its_clusters_exporter_port(monkeypatch):
+    return _multinode(
+        IS_AGENTIC=agentic, MODEL_PREFIX=prefix, PRECISION="fp8", FRAMEWORK=framework, **env
+    )
+
+
+@pytest.mark.parametrize(("srt", "cpu"), [(GPU_ONLY, False), (WITH_CPU, True)])
+@pytest.mark.parametrize("agentic", ["0", "1"])
+def test_a_cluster_with_a_gpu_exporter_measures_every_benchmark_point_without_failing_it(
+    srt, cpu, agentic
+):
+    point = _point(agentic)
+    assert decide_power("c", MULTI, srt, point) == power.PowerDecision(
+        dcgm=True, agentx=agentic == "1", cpu=cpu, best_effort=True
+    )
+    assert decide_power("c", MULTI, srt, point, lambda: True) == power.NO_POWER
+    evaluation = _point(agentic, EVAL_ONLY="true")
+    assert decide_power("c", MULTI, srt, evaluation) == power.NO_POWER
+
+
+def test_power_the_cluster_cannot_measure_is_refused_only_when_the_point_asks_for_it():
+    no_exporter = _srt()
+    assert decide_power("c", MULTI, no_exporter, _point("1")) == power.NO_POWER
+    with pytest.raises(PowerPolicyError, match="measures no GPU power"):
+        decide_power("c", MULTI, no_exporter, _point("1", POWER="1"))
+    with pytest.raises(PowerPolicyError, match="no srt-slurm.cpu-power-exporter"):
+        decide_power("c", MULTI, GPU_ONLY, _point("1", POWER="1", CPU_POWER="1"))
+
+
+def test_the_power_field_keeps_invalid_power_fatal():
+    explicit = _point("1", POWER="1", CPU_POWER="1")
+    assert decide_power("c", MULTI, WITH_CPU, explicit) == power.PowerDecision(
+        dcgm=True, agentx=True, cpu=True, expect_cpu=True
+    )
+    assert decide_power("c", MULTI, WITH_CPU, _point("1", POWER="1"), lambda: True).dcgm
+    workflow = _point("1", REQUIRE_POWER="1")
+    assert not decide_power("c", MULTI, WITH_CPU, workflow).best_effort
+
+
+def test_a_lane_rule_changes_how_its_matching_agentx_points_measure_power():
+    matching = _point("1", prefix="glm5.2", framework="dynamo-sglang")
+    decision = decide_power("h200-dgxc", MULTI, GPU_ONLY, matching)
+    assert (decision.agentx, decision.adapter) == (False, True)
+    other = decide_power("h200-dgxc", MULTI, GPU_ONLY, _point("1", framework="dynamo-sglang"))
+    assert (other.agentx, other.adapter) == (True, False)
+
+
+def test_a_power_lane_needs_its_clusters_gpu_exporter(monkeypatch):
     labels = {"cluster:c": ["c_0"]}
     srt = {"network-interface": ""}
     record = {**RECORD, "slurm": {**RECORD["slurm"], "srt-slurm": srt}}
     clusters = load_inventory({"labels": labels, "clusters": {"c": record}}).clusters
     monkeypatch.setitem(drivers.srt.lanes.SRT_LANES, ("c", MULTI), drivers.srt.lanes.SrtLane())
-    monkeypatch.setitem(power.POWER_LANES, ("c", MULTI), power.PowerLane(rules=(), error="x"))
+    monkeypatch.setitem(power.POWER_LANES, ("c", MULTI), power.PowerLane(rules=()))
     assert drivers.srt.table_problems(clusters, "c") == [
-        "POWER_LANES['c', srt-multi]: no srt-slurm.power-exporter-port"
+        "POWER_LANES['c', srt-multi]: no srt-slurm.extra.default_gpu_exporter"
     ]
-    srt["power-exporter-port"] = 9401
+    srt.update(EXPORTER)
     clusters = load_inventory({"labels": labels, "clusters": {"c": record}}).clusters
     assert drivers.srt.table_problems(clusters, "c") == []
 
diff --git a/inferencex-e2e/infx/tests/launch/test_srt_collect_staging.py b/inferencex-e2e/infx/tests/launch/test_srt_collect_staging.py
index 4064bcebca..307eb21c50 100644
--- a/inferencex-e2e/infx/tests/launch/test_srt_collect_staging.py
+++ b/inferencex-e2e/infx/tests/launch/test_srt_collect_staging.py
@@ -35,7 +35,7 @@ def _point(tmp_path: Path, *, require_power: bool) -> tuple[SimpleNamespace, Sim
     workspace.mkdir()
     for name in (EXPORTER_PROVENANCE, "power-producer-sha.txt"):
         (workspace / name).write_text(f"{name}\n")
-    request = SimpleNamespace(eval_only=False, require_power=require_power, result_filename="point")
+    request = SimpleNamespace(eval_only=False, al_gate=False, require_power=require_power, result_filename="point")
     run = SimpleNamespace(backend=_Backend(output), request=request, workspace=workspace, life=Lifecycle())
     submitted = SimpleNamespace(recover=lambda backend: object())
     return run, submitted, workspace
diff --git a/inferencex-e2e/infx/tests/launch/test_srt_config.py b/inferencex-e2e/infx/tests/launch/test_srt_config.py
index 44cb3cfa41..ffb72b5010 100644
--- a/inferencex-e2e/infx/tests/launch/test_srt_config.py
+++ b/inferencex-e2e/infx/tests/launch/test_srt_config.py
@@ -1,10 +1,12 @@
 """srtslurm.yaml rendering from controlled cluster records."""
 
+import getpass
+import os
 import shutil
 import subprocess
 import sys
-from types import SimpleNamespace
 from pathlib import Path
+from types import SimpleNamespace
 
 import pytest
 import yaml
@@ -12,7 +14,7 @@
 from infx.clusters import Cluster, load_inventory
 from infx.clusters.slurm import slurm_settings
 from infx.launch.backends.slurm import SlurmBackend
-from infx.launch.context import Launch
+from infx.launch.context import Launch, LaunchError
 from infx.launch.drivers.srt.checkout import Checkout, compute_workspace
 from infx.launch.drivers.srt.config import SrtJob, binder_inputs, pyxis_spelling, render, write
 from infx.launch.drivers.srt.lanes import SrtLane
@@ -118,6 +120,76 @@ def test_rendered_exporter_defaults_resolve_for_native_telemetry(exporter):
     assert resolve_config_with_defaults(recipe, config)["telemetry"]["dcgm_exporter"]["port"] == exporter["port"]
 
 
+HOOK = {"host-setup": {"script": "runners/hooks/setup.sh", "timeout-s": 1200}}
+
+
+@pytest.mark.parametrize(("srt", "hook"), [(HOOK, ["bash /ws/runners/hooks/setup.sh"]), ({}, [])])
+def test_a_rapl_cpu_exporter_grants_after_the_cluster_hook_and_restores_at_teardown(srt, hook):
+    config = render(cluster(srt=srt), job(single_node=True, cpu_power_source="rapl"))
+    ClusterConfig.Schema().load(config)
+    resolved = resolve_config_with_defaults({"schema": 2, "name": "point"}, config)["host_setup"]
+    assert resolved["commands"][: len(hook)] == hook
+    assert len(resolved["commands"]) == len(hook) + 1
+    assert resolved["teardown"] == ["sudo -n chown root /sys/class/powercap/intel-rapl/intel-rapl:*/energy_uj"]
+    assert not resolved.get("ignore_failure")
+
+
+@pytest.mark.parametrize(("slurm", "srt"), [({"exclusive": False}, {}), ({}, {"single-node-exclusive": False})])
+def test_a_rapl_cpu_exporter_on_shared_nodes_fails_the_inventory(slurm, srt):
+    rapl = {"cpu-power-exporter": {"source": "rapl"}}
+    with pytest.raises(ValueError, match="rapl cpu-power-exporter needs exclusive"):
+        cluster(slurm=slurm, srt={**rapl, **srt})
+    assert cluster(slurm=slurm, srt={**srt, "cpu-power-exporter": {"source": "acpi"}})
+
+
+@pytest.fixture
+def run_rapl_grant(tmp_path):
+    """Run the rendered grant under bash against counters in ``tmp_path`` with a fake sudo."""
+    sudo = tmp_path / "bin" / "sudo"
+    sudo.parent.mkdir()
+    sudo.write_text(f'#!/bin/sh\nprintf "%s\\n" "$*" >> {tmp_path / "sudo.log"}\nexit "$SUDO_RC"\n')
+    sudo.chmod(0o755)
+    root = tmp_path / "powercap"
+
+    def run(counters: dict[str, int], sudo_rc: int = 0):
+        for zone, mode in counters.items():
+            counter = root / "intel-rapl" / zone / "energy_uj"
+            counter.parent.mkdir(parents=True)
+            counter.write_text("1")
+            counter.chmod(mode)
+        (grant,) = render(cluster(), job(cpu_power_source="rapl"))["default_host_setup"]["commands"]
+        env = {"PATH": f"{sudo.parent}:/usr/bin:/bin", "SUDO_RC": str(sudo_rc)}
+        script = grant.replace("/sys/class/powercap", str(root))
+        result = subprocess.run(["bash", "-c", script], env=env, capture_output=True, text=True)
+        log = tmp_path / "sudo.log"
+        return result, log.read_text().splitlines() if log.exists() else []
+
+    return run
+
+
+@pytest.mark.skipif(os.geteuid() == 0, reason="root reads mode-000 counters")
+def test_the_rapl_grant_chowns_only_unreadable_package_counters(run_rapl_grant, tmp_path):
+    result, calls = run_rapl_grant({"intel-rapl:0": 0o444, "intel-rapl:1": 0o000, "intel-rapl:1/intel-rapl:1:0": 0o000})
+    counter = tmp_path / "powercap/intel-rapl/intel-rapl:1/energy_uj"
+    assert (result.returncode, calls) == (0, [f"-n chown {getpass.getuser()} {counter}"])
+
+
+@pytest.mark.skipif(os.geteuid() == 0, reason="root reads mode-000 counters")
+@pytest.mark.parametrize("counters", [{"intel-rapl:0": 0o000}, {}], ids=["sudo-refused", "no-rapl"])
+def test_a_failed_rapl_grant_warns_without_failing_the_job(run_rapl_grant, counters):
+    result, _ = run_rapl_grant(counters, sudo_rc=1)
+    assert result.returncode == 0
+    assert "CPU power will be missing" in result.stderr
+
+
+@pytest.mark.parametrize("source", [None, "acpi"])
+def test_a_job_without_a_rapl_cpu_exporter_keeps_the_cluster_host_setup(source):
+    config = render(cluster(srt=HOOK), job(cpu_power_source=source))
+    assert config["default_host_setup"] == {
+        "commands": ["bash /ws/runners/hooks/setup.sh"], "timeout_seconds": 1200,
+    }  # fmt: skip
+
+
 @pytest.mark.parametrize("source,target", [("/absolute", "/config"), ("../escape", "/config"), ("", "/config"), ("config.json", "relative")])
 def test_workspace_mounts_reject_paths_outside_the_repository_or_container(source, target):
     with pytest.raises(ValueError, match="workspace-mounts"):
@@ -251,7 +323,9 @@ def test_the_cpu_request_follows_the_clusters_unit():
 @pytest.mark.skipif(shutil.which("rsync") is None, reason="needs rsync")
 def test_the_staged_workspace_drops_run_artifacts_but_keeps_srt_slurm_sources(tmp_path):
     workspace = tmp_path / "workspace"
-    kept = ["runners/srt-slurm/hooks/common.sh", "benchmarks/multi_node/srt-slurm-recipes/r.yaml"]
+    # The acceptance gate's container reads the run's prepared prompts from the workspace.
+    kept = ["runners/srt-slurm/hooks/common.sh", "benchmarks/multi_node/srt-slurm-recipes/r.yaml",
+            "al_gate_dataset/speedbench_coding.jsonl"]  # fmt: skip
     dropped = ["srt-slurm-1-1-abc/recipe.yaml", "utils/srt-slurm/pyproject.toml", ".venv/bin/python",
                "outputs/42/log", "LOGS/sweep.log", "image.sqsh"]  # fmt: skip
     for name in kept + dropped:
@@ -292,9 +366,10 @@ def test_the_agentx_client_measures_power_exactly_when_the_launcher_collects_it(
         "CONC_LIST": "4",
     })  # fmt: skip
 
-    port, client_env = binder_inputs(
+    port, cpu_source, client_env = binder_inputs(
         record, slurm_settings(record).srt_slurm, SrtLane(), request, decision
     )
+    assert cpu_source is None
 
     switches = (
         client_env.get("IS_MULTINODE"),
@@ -302,3 +377,26 @@ def test_the_agentx_client_measures_power_exactly_when_the_launcher_collects_it(
         client_env.get("REQUIRE_POWER"),
     )
     assert (port, *switches) == expected
+
+
+@pytest.mark.parametrize("declared", [True, False])
+def test_cpu_power_binds_the_clusters_grace_exporter_or_fails_before_binding(tmp_path, declared):
+    srt = {"power-exporter-port": 9401}
+    if declared:
+        srt["cpu-power-exporter"] = {"source": "acpi"}
+    record = cluster(srt=srt)
+    request = MultiNodeRequest.from_env({
+        "RUNNER_NAME": "c_0", "GITHUB_WORKSPACE": str(tmp_path), "IMAGE": "i",
+        "FRAMEWORK": "dynamo-sglang", "MODEL_PREFIX": "m", "PRECISION": "fp8",
+        "SPEC_DECODING": "none", "RESULT_FILENAME": "r", "IS_AGENTIC": "0", "RUN_EVAL": "false",
+        "EVAL_ONLY": "false", "SRT_RECIPE": "r.yaml",
+    })  # fmt: skip
+    settings = slurm_settings(record).srt_slurm
+    cpu = PowerDecision(dcgm=True, agentx=False, cpu=True)
+    if not declared:
+        with pytest.raises(LaunchError, match=r"no srt-slurm\.cpu-power-exporter"):
+            binder_inputs(record, settings, SrtLane(), request, cpu)
+        return
+    assert binder_inputs(record, settings, SrtLane(), request, cpu)[:2] == (9401, "acpi")
+    gpu_only = PowerDecision(dcgm=True, agentx=False)
+    assert binder_inputs(record, settings, SrtLane(), request, gpu_only)[:2] == (9401, None)
diff --git a/inferencex-e2e/infx/tests/launch/test_srt_driver.py b/inferencex-e2e/infx/tests/launch/test_srt_driver.py
index 42b777843a..8b946b6428 100644
--- a/inferencex-e2e/infx/tests/launch/test_srt_driver.py
+++ b/inferencex-e2e/infx/tests/launch/test_srt_driver.py
@@ -19,9 +19,11 @@
 
 from infx.launch.__main__ import main
 from infx.launch.drivers.srt import lanes, models
+from infx.launch.drivers.srt.checkout import CPU_POWER_EXPORTER_RELEASE
 from infx.launch.drivers.srt.lanes import LaneMount, SrtLane
 from infx.launch.drivers.srt.models import Override
 from infx.launch.policy import LaunchPath, Match
+from infx.srt_slurm.workload import BOUND_RECIPE
 from infx.tests.launch.fake_slurm import (
     ROOT,
     base_env,
@@ -97,6 +99,14 @@ def single_node_env(harness, cluster_id: str, **overrides: str) -> dict[str, str
     return {**harness.env, **POINT_ENV, "RUNNER_NAME": runner, **overrides}
 
 
+def set_cpu_power_exporter(config: Path, cluster_id: str, exporter: dict) -> None:
+    """Give ``cluster_id`` the CPU power exporter ``exporter`` on exclusive nodes."""
+    records = yaml.safe_load(config.read_text())
+    records["clusters"][cluster_id]["slurm"]["exclusive"] = True
+    records["clusters"][cluster_id]["slurm"]["srt-slurm"]["cpu-power-exporter"] = exporter
+    config.write_text(yaml.safe_dump(records))
+
+
 def lane_env(harness, cluster_id: str, recipe: str = LANE_FRAGMENT, **overrides: str) -> dict[str, str]:
     """Environment of a multi-node point whose recipe lives in the workspace mirror.
 
@@ -120,6 +130,15 @@ def srtslurm(root: Path) -> dict:
     return yaml.safe_load(path.read_text())
 
 
+def job_recipe(raw: dict, argv: list[str]) -> dict:
+    """The recipe an ``srtctl apply argv`` job runs: ``raw`` overridden."""
+    sets = [value for flag, value in zip(argv, argv[1:]) if flag == "--set"]
+    unsets = [value for flag, value in zip(argv, argv[1:]) if flag == "--unset"]
+    document = json.loads(json.dumps(raw))
+    apply_overrides_to_recipe(document, parse_overrides(sets, unsets))
+    return document
+
+
 WORKDIR = 'srun_options.container-workdir="/infmax-workspace"'
 
 
@@ -193,11 +212,14 @@ def test_single_node_point_stages_workflow_artifacts(harness):
 
 
 @pytest.mark.parametrize("require_power", ["0", "1"])
-@pytest.mark.parametrize(("cluster_id", "kind", "port"), [
-    ("mi355x-amds", "custom", 19500), ("h100-cw", "dcgm", 9401),
+@pytest.mark.parametrize(("cluster_id", "kind", "port", "cpu_exporter"), [
+    ("mi355x-amds", "custom", 19500, {"source": "rapl"}), ("h100-cw", "dcgm", 9401, None),
 ])  # fmt: skip
-def test_single_node_native_power_is_bound_and_retained(harness, require_power, cluster_id, kind, port):
-    env = single_node_env(harness, cluster_id, REQUIRE_POWER=require_power)
+def test_single_node_native_power_is_bound_and_retained(
+    harness, require_power, cluster_id, kind, port, cpu_exporter
+):
+    cpu_power = "1" if cpu_exporter else "0"
+    env = single_node_env(harness, cluster_id, REQUIRE_POWER=require_power, CPU_POWER=cpu_power)
     assert_ok(launch(env, harness.config, harness.workspace))
 
     workspace = harness.workspace
@@ -212,6 +234,7 @@ def test_single_node_native_power_is_bound_and_retained(harness, require_power,
     apply_overrides_to_recipe(variant, parse_overrides(sets, []))
     resolved = resolve_config_with_defaults(variant, rendered)
     telemetry = resolved["telemetry"]
+    assert telemetry.get("cpu_power_exporter") == cpu_exporter
     assert telemetry["enabled"] is True
     assert telemetry["required"] is (require_power == "1")
     assert telemetry["storage_subdir"] == "power"
@@ -450,13 +473,13 @@ def test_multinode_lane_stages_workflow_artifacts(harness, monkeypatch, cluster_
     assert outputs.exists() is not outputs.is_relative_to(checkout)
 
 
-@pytest.mark.parametrize(("model_prefix", "precision", "framework", "model", "require_power", "lane"), [
-    ("kimik3", "fp4", "vllm", "moonshotai/Kimi-K3", "0", "agentx"),
-    ("glm5.2", "fp8", "dynamo-sglang", "zai-org/GLM-5.2-FP8", "1", "adapter"),
-    ("glm5.2", "fp8", "dynamo-sglang", "zai-org/GLM-5.2-FP8", "0", "adapter"),
+@pytest.mark.parametrize(("cluster", "precision", "model", "require_power", "lane"), [
+    ("gb200-nv", "fp4", "zai-org/GLM-5.2", "0", "agentx"),
+    ("h200-dgxc", "fp8", "zai-org/GLM-5.2-FP8", "1", "adapter"),
+    ("h200-dgxc", "fp8", "zai-org/GLM-5.2-FP8", "0", "adapter"),
 ])  # fmt: skip
 def test_power_lane_stages_provenance_and_validates_each_concurrency(
-    harness, model_prefix, precision, framework, model, require_power, lane
+    harness, cluster, precision, model, require_power, lane
 ):
     adapter = harness.tmp / "results-python"
     adapter.write_text(
@@ -464,8 +487,8 @@ def test_power_lane_stages_provenance_and_validates_each_concurrency(
     )
     adapter.chmod(0o755)
     env = lane_env(
-        harness, "h200-dgxc", LANE_FRAGMENT + POWER_TELEMETRY,
-        MODEL_PREFIX=model_prefix, PRECISION=precision, FRAMEWORK=framework, MODEL=model,
+        harness, cluster, LANE_FRAGMENT + POWER_TELEMETRY,
+        MODEL_PREFIX="glm5.2", PRECISION=precision, FRAMEWORK="dynamo-sglang", MODEL=model,
         IS_AGENTIC="1", ISL="0", OSL="0", CONC="4", CONC_LIST="4", FAKE_RESULTS="agentic",
         REQUIRE_POWER=require_power, INFERENCEX_RESULTS_PYTHON=str(adapter), POWER="1",
     )  # fmt: skip
@@ -474,7 +497,8 @@ def test_power_lane_stages_provenance_and_validates_each_concurrency(
     workspace = harness.workspace
     commit = harness.env["FAKE_SRT_COMMIT"]
     assert (workspace / "power-producer-sha.txt").read_text() == commit + "\n"
-    [checkout] = workspace.glob("srt-slurm-9001-*")
+    [call] = srtctl_calls(harness.logs)
+    checkout = Path(call["cwd"]).resolve()
     exporter = srtslurm(checkout)["containers"]["dcgm-exporter"]
     provenance = (workspace / "exporter-image.sha256").read_text()
     assert provenance.endswith(f"  {exporter}\n")
@@ -486,6 +510,9 @@ def test_power_lane_stages_provenance_and_validates_each_concurrency(
     assert bound["benchmark"]["env"]["REQUIRE_POWER"] == require_power
     assert bound["telemetry"]["collector_join_timeout_seconds"] == 12
     assert (bound["telemetry"]["enabled"], bound["telemetry"]["dcgm_exporter"]["port"]) == (True, 9401)
+    nvl72 = cluster == "gb200-nv"
+    assert ("cpu_power_exporter" in bound["telemetry"]) is nvl72
+    assert any("CPU_POWER_EXPORTER_RELEASE" in call for call in lines(harness.logs, "make")) is nvl72
 
     runs = lines(harness.logs, "adapter")
     assert [run.split("--result-dir ")[1].split()[0].rsplit("/", 1)[1] for run in runs] == ["conc_4"]
@@ -497,6 +524,50 @@ def test_power_lane_stages_provenance_and_validates_each_concurrency(
         assert status == "42|COMPLETED|0:0\n"
 
 
+@pytest.mark.parametrize(("point", "required"), [
+    ({"MODEL_PREFIX": "qwen3.5", "FRAMEWORK": "dynamo-trt", "MODEL": "nvidia/Qwen3.5-397B-A17B-NVFP4"}, False),
+    ({"MODEL_PREFIX": "qwen3.5", "FRAMEWORK": "dynamo-trt", "MODEL": "nvidia/Qwen3.5-397B-A17B-NVFP4", "REQUIRE_POWER": "1"}, True),
+])  # fmt: skip
+def test_nvl72_agentx_point_measures_gpu_and_cpu_power_by_default(harness, point, required):
+    adapter = harness.tmp / "results-python"
+    adapter.write_text("#!/bin/bash\nprintf '%s\\n' \"$*\" >> \"$FAKE_LOG_DIR/adapter.log\"\n")
+    adapter.chmod(0o755)
+    env = lane_env(
+        harness, "gb300-nv", LANE_FRAGMENT + POWER_TELEMETRY, PRECISION="fp4", IS_AGENTIC="1",
+        ISL="0", OSL="0", CONC="4", CONC_LIST="4", FAKE_RESULTS="agentic",
+        INFERENCEX_RESULTS_PYTHON=str(adapter), **point,
+    )  # fmt: skip
+    assert_ok(launch(env, harness.config, harness.workspace))
+
+    [checkout] = harness.workspace.glob("srt-slurm-9001-*")
+    bound = yaml.safe_load((checkout / "recipe.yaml").read_text())
+    assert bound["telemetry"]["dcgm_exporter"]["port"] == 19401
+    assert bound["telemetry"]["cpu_power_exporter"] == {"source": "acpi"}
+    assert bound["benchmark"]["env"]["ENABLE_AGENTX_POWER"] == "1"
+    assert bound["benchmark"]["env"]["REQUIRE_POWER"] == ("1" if required else "0")
+    [setup] = [call for call in lines(harness.logs, "make") if call.startswith("setup ")]
+    assert f"CPU_POWER_EXPORTER_RELEASE={CPU_POWER_EXPORTER_RELEASE}" in setup.split()
+    runs = lines(harness.logs, "adapter")
+    assert runs and all(run.endswith("--require-power") is required for run in runs)
+    assert all("--expected-cpu-power" not in run for run in runs)
+
+
+def test_nvl72_point_with_dedicated_discovery_skips_default_power(harness):
+    dedicated = "services:\n" + "".join(
+        f"  - type: {kind}\n    placement:\n      node: dedicated\n" for kind in ("etcd", "nats")
+    )
+    env = lane_env(
+        harness, "gb300-nv", LANE_FRAGMENT + dedicated, MODEL_PREFIX="qwen3.5", PRECISION="fp8",
+        FRAMEWORK="dynamo-sglang", MODEL="Qwen/Qwen3.5-397B-A17B-FP8",
+    )  # fmt: skip
+    assert_ok(launch(env, harness.config, harness.workspace))
+
+    [checkout] = harness.workspace.glob("srt-slurm-9001-*")
+    assert "telemetry" not in yaml.safe_load((checkout / "recipe.yaml").read_text())
+    [setup] = [call for call in lines(harness.logs, "make") if call.startswith("setup ")]
+    assert "CPU_POWER_EXPORTER_RELEASE" not in setup
+
+
 @pytest.mark.parametrize("shape", ["single", "multi"])
 def test_submission_failure_code_propagates_and_cancels_the_job(harness, shape):
     active = harness.tmp / "active"
@@ -622,7 +693,7 @@ def test_a_batch_wrapped_point_exits_with_the_wrapped_launchs_code(harness):
 def test_tilert_uses_upstream_submission_and_prepared_weights(harness):
     env = lane_env(
         harness, "mi355x-amds", MODEL_PREFIX="glm5.3", PRECISION="fp8", FRAMEWORK="tilert",
-        MODEL="zai-org/GLM-5.3", SPEC_DECODING="mtp", PREFILL_IMAGE="prefill:tag",
+        MODEL="zai-org/GLM-5.3", SPEC_DECODING="none", PREFILL_IMAGE="prefill:tag",
     )  # fmt: skip
     assert_ok(launch(env, harness.config, harness.workspace))
 
@@ -632,7 +703,13 @@ def test_tilert_uses_upstream_submission_and_prepared_weights(harness):
     assert "--no-preflight" not in call["argv"]
     config = srtslurm(Path(call["cwd"]))
     assert config["default_health_check"]["max_attempts"] > 0
-    assert {"test:tag", "prefill:tag"} <= set(config["containers"])
+    assert {"test:tag", "prefill:tag", config["default_gpu_exporter"]["container_image"]} <= set(
+        config["containers"]
+    )
+    telemetry = yaml.safe_load((Path(call["cwd"]) / BOUND_RECIPE).read_text())["telemetry"]
+    assert (telemetry["enabled"], telemetry["required"], "dcgm_exporter" in telemetry) == (
+        True, False, False,
+    )
     assert config["default_mounts"][str(harness.workspace)] == "/infmax-workspace"
     assert "/models" in config["default_mounts"].values()
     [point] = harness.workspace.glob("point-identity_sweep_*.json")
@@ -653,7 +730,7 @@ def test_eval_only_runs_the_eval_recipe_with_real_verification(harness):
     }  # fmt: skip
     env = lane_env(
         harness, "gb300-nv", MODEL_PREFIX="glm5.2", PRECISION="fp4", FRAMEWORK="dynamo-trt",
-        MODEL="nvidia/GLM-5.2-NVFP4", IS_AGENTIC="1", SPEC_DECODING="mtp", ISL="0", OSL="0",
+        MODEL="nvidia/GLM-5.2-NVFP4", IS_AGENTIC="1", SPEC_DECODING="none", ISL="0", OSL="0",
         EVAL_ONLY="true", EVAL_SRT_RECIPE=f"{MIRROR}/test/eval.yaml", FAKE_RESULTS="eval",
         EVAL_CONC="4 8", RECIPE_FINGERPRINT="recipe-fixture", FAKE_EVAL_META=json.dumps(staged),
     )  # fmt: skip
@@ -680,6 +757,62 @@ def test_eval_only_runs_the_eval_recipe_with_real_verification(harness):
         "glm5.2", "recipe-fixture", "dynamo-trt",
     )
     assert list(workspace.glob("point-identity_*.json")) == []
+    # The point does not draft, so it has no acceptance gate.
+    assert list(workspace.glob("al_gate_*.json")) == []
+
+
+GATE_DATASET = "al_gate_dataset/speedbench_coding.jsonl"
+DRAFTING_LANE = LANE_FRAGMENT.replace(
+    "  decode:\n    args:\n",
+    "  decode:\n    args:\n      speculative-config: '{\"method\": \"mtp\", \"num_speculative_tokens\": 3}'\n",
+)
+
+
+def test_an_agentic_eval_runs_the_acceptance_gate_as_its_benchmark_stage(harness):
+    dataset = harness.workspace / GATE_DATASET
+    dataset.parent.mkdir()
+    dataset.write_text("{}\n")
+    env = lane_env(
+        harness, "gb300-nv", DRAFTING_LANE, MODEL_PREFIX="dsv4", PRECISION="fp4",
+        FRAMEWORK="dynamo-vllm", MODEL="deepseek-ai/DeepSeek-V4-Pro", IS_AGENTIC="1",
+        SPEC_DECODING="mtp", ISL="0", OSL="0", EVAL_ONLY="true", FAKE_RESULTS="gate",
+        EVAL_CONC="4", AL_GATE_DATASET=GATE_DATASET,
+    )  # fmt: skip
+    assert_ok(launch(env, harness.config, harness.workspace))
+
+    [call] = srtctl_calls(harness.logs)
+    argv = call["argv"]
+    # One job: srt-slurm runs the gate as its benchmark stage, then the eval on that server.
+    assert (call["env"]["EVAL_ONLY"], call["env"]["RUN_EVAL"]) == ("false", "true")
+    assert 'benchmark.command="bash /infmax-workspace/benchmarks/srt_al_gate.sh"' in argv
+    assert 'benchmark.env.AL_GATE_CURVE="deepseek-v4-pro__mtp__native__default-default"' in argv
+    assert f'benchmark.env.AL_GATE_DATASET="{GATE_DATASET}"' in argv
+    assert argv[argv.index("telemetry") - 1] == "--unset"
+    passthrough = next(a for a in argv if a.startswith("post_eval.passthrough_env="))
+    assert "EVAL_AL_GATE" in json.loads(passthrough.partition("=")[2])
+    # The eval's results and the gate's verdict are both staged; its raw files stay in the logs.
+    workspace = harness.workspace
+    assert (workspace / "results_gsm8k.json").read_text() == "{}"
+    verdict = json.loads((workspace / f"al_gate_{env['RESULT_FILENAME']}.json").read_text())
+    assert verdict == {"status": "below", "result_filename": env["RESULT_FILENAME"]}
+    assert not (workspace / "al_gate").exists()
+
+
+def test_an_agentic_eval_without_staged_prompts_runs_alone_and_records_why(harness):
+    env = lane_env(
+        harness, "gb300-nv", DRAFTING_LANE, MODEL_PREFIX="dsv4", PRECISION="fp4",
+        FRAMEWORK="dynamo-vllm", MODEL="deepseek-ai/DeepSeek-V4-Pro", IS_AGENTIC="1",
+        SPEC_DECODING="mtp", ISL="0", OSL="0", EVAL_ONLY="true", FAKE_RESULTS="eval",
+        EVAL_CONC="4",
+    )  # fmt: skip
+    assert_ok(launch(env, harness.config, harness.workspace))
+
+    [call] = srtctl_calls(harness.logs)
+    assert "bash /infmax-workspace/benchmarks/srt_al_gate.sh" not in " ".join(call["argv"])
+    skipped = json.loads(
+        (harness.workspace / f"al_gate_{env['RESULT_FILENAME']}.json").read_text()
+    )
+    assert (skipped["status"], skipped["error"]) == ("skipped", "no SPEED-Bench prompts at ''")
 
 
 def test_bundle_variants_take_the_lane_job_edits(harness, monkeypatch):
@@ -731,6 +864,45 @@ def test_a_setup_failure_without_a_bad_archive_is_not_retried(harness):
     assert (error["stage"], error["type"], error["evidence"]) == ("prepare", "SetupFailed", "srt-setup.log")
 
 
+RAPL_RESTORE = "sudo -n chown root /sys/class/powercap/intel-rapl/intel-rapl:*/energy_uj"
+CPU_POWER_POINTS = {
+    "native": lambda harness, cluster_id: single_node_env(harness, cluster_id, MAX_MODEL_LEN="1024"),
+    "eval-only": lambda harness, cluster_id: single_node_env(
+        harness, cluster_id, EVAL_ONLY="true", MAX_MODEL_LEN="1024"
+    ),
+    "multi-node": lambda harness, cluster_id: lane_env(
+        harness, cluster_id, LANE_FRAGMENT + POWER_TELEMETRY, MODEL_PREFIX="qwen3.5", PRECISION="fp8",
+        FRAMEWORK="dynamo-sglang", MODEL="Qwen/Qwen3.5-397B-A17B-FP8", POWER="1",
+    ),
+}  # fmt: skip
+
+
+@pytest.mark.parametrize(("point", "cluster_id", "cpu_power", "bound"), [
+    ("native", "mi355x-amds", "1", True),
+    ("native", "mi355x-amds", "0", True),
+    ("eval-only", "mi355x-amds", "1", False),
+    ("multi-node", "gb300-nv", "1", True),
+])  # fmt: skip
+def test_a_power_point_on_a_rapl_cluster_binds_the_exporter_and_grants_its_counters(
+    harness, point, cluster_id, cpu_power, bound
+):
+    set_cpu_power_exporter(harness.config, cluster_id, {"source": "rapl"})
+    env = {**CPU_POWER_POINTS[point](harness, cluster_id), "CPU_POWER": cpu_power}
+    assert_ok(launch(env, harness.config, harness.workspace))
+
+    [setup] = [call for call in lines(harness.logs, "make") if call.startswith("setup ")]
+    assert (f"CPU_POWER_EXPORTER_RELEASE={CPU_POWER_EXPORTER_RELEASE}" in setup.split()) is bound
+    [call] = srtctl_calls(harness.logs)
+    argv = call["argv"]
+    submitted = yaml.safe_load(Path(argv[argv.index("--file" if "--file" in argv else "-f") + 1]).read_text())
+    assert ("cpu_power_exporter" in submitted.get("telemetry", {})) is bound
+    if bound:
+        assert submitted["telemetry"]["cpu_power_exporter"] == {"source": "rapl"}
+    host_setup = srtslurm(harness.workspace).get("default_host_setup", {})
+    assert (host_setup.get("teardown") == [RAPL_RESTORE]) is bound
+    assert ("powercap" in " ".join(host_setup.get("commands", []))) is bound
+
+
 def test_a_setup_step_killed_by_a_signal_exits_128_plus_the_signal(harness):
     fakes = Path(harness.env["PATH"].split(os.pathsep)[0])
     (fakes / "make").write_text("#!/bin/bash\nkill -KILL $$\n")
@@ -864,3 +1036,49 @@ def test_multinode_eval_overrides_image_offline_mode_and_host_model_path(harness
         "http://worker:8000",
         str(harness.workspace),
     ]
+
+
+def test_launch_cpu_expectation_reaches_fixed_sequence_processor(harness, monkeypatch):
+    from infx.results.fixed_sequence import aggregate_power_result
+    from infx.tests.results.power.test_aggregate_power_multinode import (
+        PRODUCER_SHA,
+        build_package,
+    )
+
+    env = lane_env(
+        harness,
+        "gb300-nv",
+        LANE_FRAGMENT + POWER_TELEMETRY,
+        MODEL_PREFIX="qwen3.5",
+        PRECISION="fp8",
+        FRAMEWORK="dynamo-sglang",
+        MODEL="Qwen/Qwen3.5-397B-A17B-FP8",
+        REQUIRE_POWER="1",
+        POWER="1",
+        CPU_POWER="1",
+    )
+    assert_ok(launch(env, harness.config, harness.workspace))
+    [checkout] = harness.workspace.glob("srt-slurm-9001-*")
+    bound = yaml.safe_load((checkout / "recipe.yaml").read_text())
+    assert bound["telemetry"]["cpu_power_exporter"] == {"source": "acpi"}
+    assert bound["telemetry"]["dcgm_exporter"]["port"] == 19401
+    [setup] = [call for call in lines(harness.logs, "make") if call.startswith("setup ")]
+    assert f"CPU_POWER_EXPORTER_RELEASE={CPU_POWER_EXPORTER_RELEASE}" in setup.split()
+    pkg = build_package(harness.tmp / "power-input")
+    monkeypatch.chdir(harness.tmp)
+    # The workflow exports CPU_POWER once; the launcher and the processor both read it.
+    result_env = {
+        "CPU_POWER": "1",
+        "REQUIRE_POWER": "1",
+        "IS_MULTINODE": "true",
+        "RESULT_FILENAME": "fixture",
+        "PREFILL_GPUS": "2",
+        "DECODE_GPUS": "2",
+        "POWER_PRODUCER_SHA": PRODUCER_SHA,
+        "POWER_ARTIFACT_DIR": str(pkg.power_dir),
+        "POWER_RESULT_ROOT": str(pkg.logs_root),
+    }
+    assert aggregate_power_result(result_env, pkg.bench_result, pkg.agg_result) == 1
+    aggregate = pkg.agg()
+    assert aggregate["power_valid"] == 1
+    assert aggregate["cpu_power_valid"] == 0
diff --git a/inferencex-e2e/infx/tests/matrix/test_generate_sweep_configs.py b/inferencex-e2e/infx/tests/matrix/test_generate_sweep_configs.py
index 127789b69d..d7f1ab8a42 100644
--- a/inferencex-e2e/infx/tests/matrix/test_generate_sweep_configs.py
+++ b/inferencex-e2e/infx/tests/matrix/test_generate_sweep_configs.py
@@ -2646,6 +2646,24 @@ def agentic_config(request, sample_single_node_config):
 
 
 class TestAgenticGeneration:
+    @pytest.mark.parametrize("power_key", ["require-power", "require_power"])
+    def test_required_power_reaches_benchmarks_but_not_evals(
+        self, power_key, agentic_config, sample_runner_config, generate_agentic_sweep,
+    ):
+        from infx.matrix.generate import select_matrix_evals
+        from infx.matrix.validation import AgenticCodingSearchSpaceEntry
+
+        config, benchmark = agentic_config
+        benchmark["conc-list"] = [1, 4, 8]
+        before = generate_agentic_sweep(config, sample_runner_config)
+        benchmark[power_key] = True
+        AgenticCodingSearchSpaceEntry.model_validate(benchmark)
+        after = generate_agentic_sweep(config, sample_runner_config)
+        assert after == [{**row, "require-power": True} for row in before]
+        evals = select_matrix_evals(copy.deepcopy(after), mode="all")
+        assert evals
+        assert all("require-power" not in row for row in evals)
+
     def test_point_order_and_input_preservation(
         self, agentic_config, sample_runner_config, generate_agentic_sweep,
     ):
@@ -3434,6 +3452,38 @@ def test_require_power_is_scoped_to_one_multinode_fixed_sequence(
         expand_full_sweep(config, sample_runner_config)
 
 
+def test_cpu_power_reaches_the_planner_row_beside_power(
+    sample_multinode_config, sample_runner_config
+):
+    from infx.matrix.generate import expand_full_sweep
+
+    config = sample_multinode_config
+    point = next(iter(config.values()))["scenarios"]["fixed-seq-len"][0]["search-space"][0]
+    point["power"] = True
+    rows = expand_full_sweep(config, sample_runner_config)
+    assert rows
+    assert all(row["power"] is True and "cpu-power" not in row for row in rows)
+    point["cpu-power"] = True
+    rows = expand_full_sweep(config, sample_runner_config)
+    assert all(row["cpu-power"] is True for row in rows)
+
+
+def test_single_node_cpu_power_reaches_the_planner_row_without_power(
+    sample_single_node_config, sample_runner_config
+):
+    from infx.matrix.generate import expand_full_sweep
+
+    config = sample_single_node_config
+    point = next(iter(config.values()))["scenarios"]["fixed-seq-len"][-1]["search-space"][0]
+    rows = expand_full_sweep(config, sample_runner_config)
+    assert rows
+    assert all("cpu-power" not in row and "power" not in row for row in rows)
+    point["cpu-power"] = True
+    rows = expand_full_sweep(config, sample_runner_config)
+    assert {row["isl"] for row in rows if row.get("cpu-power") is True} == {8192}
+    assert all("power" not in row for row in rows)
+
+
 def test_single_node_fixed_sequence_rejects_require_power(sample_single_node_config):
     from infx.matrix.validation import validate_master_config
 
diff --git a/inferencex-e2e/infx/tests/matrix/test_validation.py b/inferencex-e2e/infx/tests/matrix/test_validation.py
index 696a0652d0..dca37b0e92 100644
--- a/inferencex-e2e/infx/tests/matrix/test_validation.py
+++ b/inferencex-e2e/infx/tests/matrix/test_validation.py
@@ -680,6 +680,13 @@ def test_valid_aggregate_worker(self):
         assert entry.prefill is None
         assert entry.decode is None
 
+    def test_cpu_power_rides_on_power(self):
+        row = {"worker": {"tp": 8, "ep": 1, "dp-attn": False}, "num-nodes": 2,
+               "conc-list": [1], "cpu-power": True}  # fmt: skip
+        with pytest.raises(ValidationError, match="cpu-power requires power"):
+            MultiNodeSearchSpaceEntry(**row)
+        assert MultiNodeSearchSpaceEntry(**{**row, "power": True}).cpu_power is True
+
     def test_missing_conc_specification(self):
         with pytest.raises(ValidationError):
             MultiNodeSearchSpaceEntry(**{
@@ -1518,3 +1525,11 @@ def test_only_multinode_agentic_rows_measure_power(topology, accepted):
     else:
         with pytest.raises(ValidationError, match="Only multinode entries measure DCGM power"):
             AgenticCodingSearchSpaceEntry(**row)
+
+
+def test_agentic_cpu_power_rides_on_power():
+    worker = {"worker": {"num-worker": 1, "tp": 8, "ep": 1, "dp-attn": False}}
+    row = {"srt-recipe": "r.yaml", "conc-list": [4], "cpu-power": True, **worker}
+    with pytest.raises(ValidationError, match="cpu-power requires power"):
+        AgenticCodingSearchSpaceEntry(**row)
+    assert AgenticCodingSearchSpaceEntry(**{**row, "power": True}).cpu_power is True
diff --git a/inferencex-e2e/infx/tests/results/agentic/test_power_adapter.py b/inferencex-e2e/infx/tests/results/agentic/test_power_adapter.py
index 9715c0729d..95daa39a7d 100644
--- a/inferencex-e2e/infx/tests/results/agentic/test_power_adapter.py
+++ b/inferencex-e2e/infx/tests/results/agentic/test_power_adapter.py
@@ -54,7 +54,7 @@ def test_single_node_collector_finalizes_native_agentx_power(
     env = {**os.environ, "INFERENCEX_RESULTS_PYTHON": sys.executable,
            "REQUIRE_POWER": str(int(require_power)),
            "PYTHONPATH": str(Path(__file__).resolve().parents[4])}
-    request = SimpleNamespace(is_agentic=True, eval_only=False, run_eval=False,
+    request = SimpleNamespace(is_agentic=True, eval_only=False, al_gate=False, run_eval=False,
                               require_power=require_power, inferencex_results_python=sys.executable,
                               result_filename="point", env=env)
     run = SimpleNamespace(request=request, env=env, workspace=tmp_path, life=Lifecycle())
diff --git a/inferencex-e2e/infx/tests/results/agentic/test_process_agentic_result.py b/inferencex-e2e/infx/tests/results/agentic/test_process_agentic_result.py
index 363ce7ba1a..cb7354a534 100644
--- a/inferencex-e2e/infx/tests/results/agentic/test_process_agentic_result.py
+++ b/inferencex-e2e/infx/tests/results/agentic/test_process_agentic_result.py
@@ -1041,6 +1041,49 @@ def test_server_metrics_reject_unknown_backend() -> None:
         )
 
 
+@pytest.mark.parametrize("with_occupancy", [True, False])
+def test_processor_normalizes_tokenspeed_metrics_without_inventing_cache_counters(
+    tmp_path: Path, with_occupancy: bool,
+) -> None:
+    result_dir = _write_fixture(tmp_path)
+    metrics = {
+        "tokenspeed:num_requests_running": {
+            "type": "gauge",
+            "series": [{"stats": {"max": 5}}],
+        },
+        "tokenspeed:iteration_tokens_total": {
+            "type": "histogram",
+            "series": [{"stats": {"sum": 123456}}],
+        },
+    }
+    if with_occupancy:
+        metrics["tokenspeed:kv_cache_usage_perc"] = {
+            "type": "gauge",
+            "series": [
+                {"labels": {"dp_rank": "0"}, "stats": {"max": 0.25, "avg": 0.1}},
+                {"labels": {"dp_rank": "1"}, "stats": {"max": 0.8, "avg": 0.3}},
+            ],
+        }
+    (result_dir / "aiperf_artifacts/server_metrics_export.json").write_text(
+        json.dumps({"metrics": metrics}),
+    )
+
+    agg = _run_processor(result_dir, tmp_path / "out", env_overrides={"FRAMEWORK": "tokenspeed"})
+    server = agg["server_metrics"]
+
+    assert server["adapter"] == "tokenspeed"
+    assert server["kv_cache"]["gpu_usage_pct"] == (0.8 if with_occupancy else None)
+    assert server["kv_cache"]["gpu_total_tokens"] is None
+    assert server["kv_cache"]["cpu_usage_pct"] is None
+    assert server["cache"]["gpu_cache_hit_rate"] is None
+    assert server["cache"]["cpu_cache_hit_rate"] is None
+    assert server["cache"]["overall_cache_hit_rate"] is None
+    assert server["tokens"]["prompt_total"] == 840
+    assert server["tokens"]["generation_total"] == 275
+    assert server["tokens"]["requests_completed"] == 5
+    _assert_stable_server_metrics_schema(agg)
+
+
 def test_processor_excludes_warmup_phase_records(tmp_path: Path):
     result_dir = tmp_path / "results"
     artifact = result_dir / "aiperf_artifacts"
diff --git a/inferencex-e2e/infx/tests/results/agentic/test_spec_decode.py b/inferencex-e2e/infx/tests/results/agentic/test_spec_decode.py
new file mode 100644
index 0000000000..7d806e98fe
--- /dev/null
+++ b/inferencex-e2e/infx/tests/results/agentic/test_spec_decode.py
@@ -0,0 +1,125 @@
+"""Realized speculative acceptance from two Prometheus scrapes of the engines' counters."""
+
+from __future__ import annotations
+
+import pytest
+
+from infx.results.agentic.spec_decode import READERS, increase, parse
+
+WORKER = "http://10.0.0.1:8000/metrics"
+OTHER = "http://10.0.0.2:8000/metrics"
+
+
+def test_counter_samples_are_read_under_their_family_names() -> None:
+    # prometheus_client's text format: samples carry _total, and _created timestamps come along.
+    # Label values stay escaped; their order does not matter.
+    text = r"""
+# HELP vllm:spec_decode_num_drafts_total Number of spec decoding drafts.
+# TYPE vllm:spec_decode_num_drafts_total counter
+vllm:spec_decode_num_drafts_total{engine="0",model_name="m"} 1100.0
+vllm:spec_decode_num_drafts_created{engine="0",model_name="m"} 1.7598e+09
+trtllm_spec_decode_drafted_tokens_total{token_position="0", path="a\"b,c}\n"} 1e3 1712345678000
+"""
+    assert parse(text) == {
+        "vllm:spec_decode_num_drafts": {frozenset({("engine", "0"), ("model_name", "m")}): 1100},
+        "trtllm_spec_decode_drafted_tokens": {
+            frozenset({("token_position", "0"), ("path", r"a\"b,c}\n")}): 1000
+        },
+    }
+
+
+def test_text_that_is_not_prometheus_exposition_is_rejected() -> None:
+    # trtllm-serve's /metrics is JSON iteration stats.
+    with pytest.raises(ValueError, match="line 2 is not Prometheus text exposition"):
+        parse('# comment\n[{"iterationCounter": 3}]')
+
+
+def test_each_series_increase_survives_resets_new_series_and_shared_labels() -> None:
+    before = {
+        WORKER: 'x_total{a="1"} 900\nx_total{a="2"} 500\n',
+        OTHER: 'x_total{a="1"} 10\n',
+    }
+    after = {
+        WORKER: 'x_total{a="1"} 1000\nx_total{a="2"} 40\nx_total{a="3"} 700\n',
+        OTHER: 'x_total{a="1"} 15\n',
+    }
+
+    # a=2 went backwards, so its engine restarted: Prometheus counts the new value. a=3 is new.
+    assert increase(before, after) == {
+        "x": [({"a": "1"}, 100), ({"a": "2"}, 40), ({"a": "3"}, 700), ({"a": "1"}, 5)]
+    }
+
+
+@pytest.mark.parametrize(
+    ("engine", "after", "expected"),
+    [
+        (
+            "vllm",
+            'vllm:spec_decode_num_accepted_tokens_total{engine="0"} 2840\n'
+            'vllm:spec_decode_num_drafts_total{engine="0"} 1000\n',
+            (2840, 1000),
+        ),
+        (
+            "tokenspeed",
+            'tokenspeed:spec_decode_num_accepted_tokens_total{model_name="m"} 2840\n'
+            'tokenspeed:spec_decode_num_drafts_total{model_name="m"} 1000\n'
+            'tokenspeed:spec_decode_num_draft_tokens_total{model_name="m"} 3000\n',
+            (2840, 1000),
+        ),
+        # Decode emitted 4100 tokens for 100 requests in 1000 verifications: 4100 - 100 - 1000
+        # accepted drafts. Prefill workers' series never verify.
+        (
+            "sglang",
+            'sglang:spec_verify_calls_total{engine_type="decode"} 1000\n'
+            'sglang:spec_verify_calls_total{engine_type="prefill"} 0\n'
+            'sglang:generation_tokens_total{engine_type="decode"} 4100\n'
+            'sglang:generation_tokens_total{engine_type="prefill"} 500\n'
+            'sglang:num_requests_total{engine_type="decode"} 100\n'
+            'sglang:num_requests_total{engine_type="prefill"} 100\n',
+            (3000, 1000),
+        ),
+        # Each verification drafts position 0; accepted tokens count at every position.
+        (
+            "trtllm",
+            'trtllm_spec_decode_drafted_tokens_total{token_position="0"} 1000\n'
+            'trtllm_spec_decode_drafted_tokens_total{token_position="1"} 800\n'
+            'trtllm_spec_decode_accepted_tokens_total{token_position="0"} 900\n'
+            'trtllm_spec_decode_accepted_tokens_total{token_position="1"} 700\n',
+            (1600, 1000),
+        ),
+        (
+            "atom",
+            'atom:mtp_decode_steps_total{accepted_tokens="0"} 100\n'
+            'atom:mtp_decode_steps_total{accepted_tokens="1"} 300\n'
+            "atom:mtp_accepted_tokens_total 500\n",
+            (500, 400),
+        ),
+        ("atom", "atom_mtp_decode_steps_total 40\natom_mtp_accepted_tokens_total 70\n", (70, 40)),
+    ],
+    ids=["vllm", "tokenspeed", "sglang-disagg", "trtllm", "atom", "atom-underscore"],
+)
+def test_each_engine_reads_its_accepted_drafts_and_verifications(engine, after, expected) -> None:
+    assert READERS[engine](increase({WORKER: ""}, {WORKER: after})) == expected
+
+
+@pytest.mark.parametrize("engine", ["vllm", "tokenspeed", "sglang", "trtllm", "atom"])
+def test_an_engine_without_its_counters_reads_nothing(engine) -> None:
+    # Another engine's spec-decode families never give this one's reading.
+    other = (
+        "sglang:spec_verify_calls_total 5\n"
+        if engine == "vllm"
+        else "vllm:spec_decode_num_drafts_total 5\n"
+    )
+
+    assert READERS[engine](increase({WORKER: ""}, {WORKER: other})) is None
+
+
+def test_sglang_without_decode_workers_tokens_reads_nothing() -> None:
+    # Deriving it anyway would read 1 + (0 - 100 - 1000) / 1000 = -0.1.
+    after = (
+        'sglang:spec_verify_calls_total{engine_type="decode"} 1000\n'
+        'sglang:generation_tokens_total{engine_type="prefill"} 100\n'
+        'sglang:num_requests_total{engine_type="decode"} 100\n'
+    )
+
+    assert READERS["sglang"](increase({WORKER: ""}, {WORKER: after})) is None
diff --git a/inferencex-e2e/infx/tests/results/power/test_aggregate_power.py b/inferencex-e2e/infx/tests/results/power/test_aggregate_power.py
index a1fd53410a..87fd4141fd 100644
--- a/inferencex-e2e/infx/tests/results/power/test_aggregate_power.py
+++ b/inferencex-e2e/infx/tests/results/power/test_aggregate_power.py
@@ -33,6 +33,7 @@ def test_power_replacement_removes_stale_metrics(tmp_path, patch_validated_power
         "hw": "fixture", "avg_power_w": 99, "total_gpu_energy_j": 50,
         "power_invalid_reasons": ["stale"],
         "power_audit": {"source": "previous-run.json"},
+        "cpu_power_valid": 1, "total_cpu_energy_j": 1.0, "workers": [{"role": "agg"}],
     }))
     patch_validated_power(path, power_valid=valid, metrics={
         "avg_power_w": 12.34567, "joules_per_output_token": 0.12345678,
diff --git a/inferencex-e2e/infx/tests/results/power/test_aggregate_power_multinode.py b/inferencex-e2e/infx/tests/results/power/test_aggregate_power_multinode.py
index ec2198f047..99d12ffe94 100644
--- a/inferencex-e2e/infx/tests/results/power/test_aggregate_power_multinode.py
+++ b/inferencex-e2e/infx/tests/results/power/test_aggregate_power_multinode.py
@@ -11,10 +11,13 @@
 import json
 import shutil
 from pathlib import Path
+from typing import get_args
 
 import pytest
 
 from infx.results.power import multinode as apm
+from infx.results.power.cpu_side import SOCKET_METERS
+from infx.srt_slurm.workload import CpuPowerSource
 
 PRODUCER_SHA = "a" * 40
 WINDOW_START = 1000.0
@@ -61,6 +64,7 @@ def run(
         aggregate_gpus=0,
         sha=PRODUCER_SHA,
         require_power=False,
+        expected_cpu=False,
     ):
         return apm.run(
             self.power_dir,
@@ -73,6 +77,7 @@ def run(
             logs_root=self.logs_root,
             validation_result=self.validation_result,
             require_power=require_power,
+            expected_cpu=expected_cpu,
         )
 
     def agg(self):
@@ -358,6 +363,12 @@ def test_emits_all_metrics_exactly(self, tmp_path):
         assert agg["joules_per_input_token"] == 2.563477
         assert agg["joules_per_output_token"] == 20.507812
         assert agg["joules_per_total_token"] == 2.278646
+        assert agg["workers"] == [
+            {"role": "decode", "worker_idx": 0, "hosts": ["node-d"],
+             "num_gpus": 2, "avg_power_w": 300.0},
+            {"role": "prefill", "worker_idx": 0, "hosts": ["node-p"],
+             "num_gpus": 2, "avg_power_w": 400.0},
+        ]
         assert agg["prefill_gpu_energy_j"] == 48000.0
         assert agg["decode_gpu_energy_j"] == 36000.0
         assert agg["prefill_avg_power_w"] == 400.0
@@ -423,6 +434,26 @@ def test_aggregate_topology_emits_only_whole_deployment_metrics(self, tmp_path):
         assert agg["total_gpu_energy_j"] == 84000.0
         assert set(apm.ROLE_METRIC_KEYS).isdisjoint(agg)
         assert set(pkg.sidecar()["per_gpu_role"].values()) == {"agg"}
+        # One worker across two hosts: one entry per host, both with its manifest index.
+        assert agg["workers"] == [
+            {"role": "agg", "worker_idx": 0, "hosts": ["node-d"],
+             "num_gpus": 2, "avg_power_w": 300.0},
+            {"role": "agg", "worker_idx": 0, "hosts": ["node-p"],
+             "num_gpus": 2, "avg_power_w": 400.0},
+        ]
+
+    def test_gpu_shared_by_two_workers_omits_workers(self, tmp_path):
+        pkg = build_package(tmp_path)
+        manifest_path = pkg.power_dir / "manifest.json"
+        manifest = json.loads(manifest_path.read_text())
+        shared = manifest["expected_devices"][0]["assignments"]
+        shared.append({**shared[0], "worker_index": 1, "worker_process": 1})
+        manifest_path.write_text(json.dumps(manifest, indent=2))
+
+        assert pkg.run() == 0
+        agg = pkg.agg()
+        assert agg["power_valid"] == 1
+        assert "workers" not in agg
 
     def test_agentx_adapter_consumes_a_real_custom_benchmark_package(self, tmp_path):
         from infx.results.agentic.power_adapter import run_native_agentic_power
@@ -768,3 +799,307 @@ def test_non_object_aggregate_is_recorded_as_unwritable(tmp_path, aggregate):
     assert sidecar["metrics"] == {}
     assert pkg.agg_result.read_text() == aggregate
     assert pkg.run(require_power=True) == 1
+
+
+CPU_HOSTS = tuple(sorted({host for host, *_ in DEVICES}))
+CPU_HEADER = [
+    "schema_version", "timestamp_unix", "hostname", "source", "sensor", "socket_id",
+    "power_w", "cpu_rail_w", "soc_w", "dram_w", "total_power_w",
+]
+CPU_HEADER_V3 = [*CPU_HEADER[:-1], "module_w", "total_power_w"]
+GRACE_W = {"node-d": 500.0, "node-p": 700.0}
+DCGM_W = 300.0
+# Component rails never feed a headline metric; the values are chosen so any
+# leak into a headline key is visible against the Grace constants.
+RAILS_W = {"cpu_rail": 200.0, "soc": 50.0}
+# NVML superchip module power per socket, distinct from the Grace and rail
+# constants so a leak into a CPU key is visible.
+MODULE_W = 1500.0
+RAPL_W = 250.0
+# srt-slurm cpu_rails.SENSOR_SUFFIXES: the Grace socket meter, the DCGM CPU rail and the
+# AMD RAPL package counter.
+GRACE_SENSOR = "CPU{s}:cpuSidePowerUsageW"
+DCGM_SENSOR = "CPU{s}:cpuPowerUsageW"
+RAPL_SENSOR = "CPU{s}:packagePowerUsageW"
+
+
+def _cpu_row(ts, host, socket, kind, watts):
+    if kind == "dcgm":
+        return [2, repr(ts), host, "dcgm", DCGM_SENSOR.format(s=socket), socket, repr(watts), "", "", "", ""]
+    if kind == "rapl":
+        return [2, repr(ts), host, "rapl", RAPL_SENSOR.format(s=socket), socket, repr(watts), "", "", "", ""]
+    rails = [repr(w) for w in RAILS_W.values()]
+    return [2, repr(ts), host, "acpi", GRACE_SENSOR.format(s=socket), socket, repr(watts), *rails, "", ""]
+
+
+def _cpu_rows(kinds_by_host=None, *, hosts=CPU_HOSTS):
+    """One row per (scrape, host, socket, kind); ``None`` watts means the Grace constant."""
+    kinds_by_host = kinds_by_host or {host: {"grace": None} for host in hosts}
+    rows = []
+    ts = FIRST_TS
+    while ts <= LAST_TS:
+        for host in hosts:
+            for socket in (0, 1):
+                for kind, watts in kinds_by_host.get(host, {}).items():
+                    watts = GRACE_W[host] if watts is None else watts
+                    rows.append(_cpu_row(ts, host, socket, kind, watts))
+        ts += 1.0
+    return rows
+
+
+def _v3(rows, module_w=MODULE_W):
+    """The same scrapes in srt-slurm v2.59.0+'s schema 3; ``None`` leaves module_w blank."""
+    module = "" if module_w is None else repr(module_w)
+    return [[3, *row[1:-1], module, row[-1]] for row in rows]
+
+
+def add_cpu_package(pkg, rows, header=CPU_HEADER):
+    cpu_dir = pkg.power_dir / "cpu"
+    cpu_dir.mkdir()
+    with open(cpu_dir / "samples.csv", "w", newline="") as handle:
+        writer = csv.writer(handle)
+        writer.writerow(header)
+        writer.writerows(rows)
+
+
+def _gpu_fields(agg):
+    return {k: v for k, v in agg.items() if k != "cpu_power_valid" and k not in apm.CPU_METRIC_KEYS}
+
+
+def _reference_agg(tmp_path):
+    """The GPU-only aggregate every CPU-leg outcome must reproduce field for field."""
+    reference = build_package(tmp_path / "reference")
+    assert reference.run() == 0
+    return reference.agg()
+
+
+def assert_grace_keys(agg):
+    assert agg["cpu_power_valid"] == 1
+    assert agg["avg_cpu_socket_power_w"] == 600.0
+    assert agg["avg_total_cpu_power_w"] == 2400.0
+    assert agg["total_cpu_energy_j"] == 144000.0
+
+
+class TestCpuSidePower:
+    def test_grace_total_emits_cpu_keys_and_provenance(self, tmp_path):
+        from infx.results.power.audit import audit_summary
+
+        pkg = build_package(tmp_path)
+        rows = _cpu_rows()
+        add_cpu_package(pkg, rows)
+        assert pkg.run(require_power=True) == 0
+
+        agg = pkg.agg()
+        assert_grace_keys(agg)
+        assert agg["avg_total_cpu_rail_power_w"] == 800.0
+        assert agg["total_cpu_rail_energy_j"] == 48000.0
+        assert agg["avg_total_cpu_sysio_power_w"] == 200.0
+        assert agg["total_cpu_sysio_energy_j"] == 12000.0
+        assert _gpu_fields(agg) == _reference_agg(tmp_path)
+
+        cpu = pkg.sidecar()["cpu"]
+        assert cpu["cpu_power_valid"] is True
+        assert cpu["reason_codes"] == []
+        assert cpu["sensor_kind"] == "grace_socket"
+        assert cpu["source"] == "acpi"
+        assert cpu["expected_sockets"] == 4
+        assert cpu["observed_sockets"] == 4
+        assert cpu["sample_row_count"] == len(rows)
+        assert set(cpu["per_series_energy_j"]) == {
+            f"{host}/socket{socket}/{kind}"
+            for host in CPU_HOSTS
+            for socket in (0, 1)
+            for kind in ("grace_socket", "cpu_rail", "cpu_sysio")
+        }
+        assert audit_summary(pkg.sidecar(), "power_validation.json")["power_audit"]["cpu"] == {
+            "sensor_kind": "grace_socket",
+            "source": "acpi",
+            "expected_sockets": 4,
+            "observed_sockets": 4,
+            "sample_row_count": len(rows),
+            "reason_codes": [],
+        }
+
+    def test_rapl_package_emits_cpu_keys_without_rails(self, tmp_path):
+        from infx.results.power.audit import audit_summary
+
+        pkg = build_package(tmp_path)
+        add_cpu_package(pkg, _cpu_rows({host: {"rapl": RAPL_W} for host in CPU_HOSTS}))
+        assert pkg.run(require_power=True, expected_cpu=True) == 0
+
+        agg = pkg.agg()
+        assert agg["cpu_power_valid"] == 1
+        assert agg["avg_cpu_socket_power_w"] == 250.0
+        assert agg["avg_total_cpu_power_w"] == 1000.0
+        assert agg["total_cpu_energy_j"] == 60000.0
+        assert {key for key in apm.CPU_METRIC_KEYS if key in agg} == {
+            "avg_cpu_socket_power_w", "avg_total_cpu_power_w", "total_cpu_energy_j",
+        }  # fmt: skip
+        assert _gpu_fields(agg) == _reference_agg(tmp_path)
+        cpu = pkg.sidecar()["cpu"]
+        assert set(cpu["per_series_energy_j"]) == {
+            f"{host}/socket{socket}/rapl_package" for host in CPU_HOSTS for socket in (0, 1)
+        }
+        summary = audit_summary(pkg.sidecar(), "power_validation.json")["power_audit"]["cpu"]
+        assert (summary["sensor_kind"], summary["source"]) == ("rapl_package", "rapl")
+
+    def test_rail_gap_drops_only_that_rail(self, tmp_path):
+        pkg = build_package(tmp_path)
+        rows = _cpu_rows()
+        for row in rows:
+            if row[2] == "node-d" and row[5] == 0 and 1020.0 <= float(row[1]) <= 1030.0:
+                row[7] = ""
+        add_cpu_package(pkg, rows)
+        assert pkg.run(require_power=True) == 0
+        agg = pkg.agg()
+        assert_grace_keys(agg)
+        assert "avg_total_cpu_rail_power_w" not in agg
+        assert agg["avg_total_cpu_sysio_power_w"] == 200.0
+
+    def test_v3_module_rail_is_published_apart_from_cpu_keys(self, tmp_path):
+        pkg = build_package(tmp_path)
+        add_cpu_package(pkg, _v3(_cpu_rows()), CPU_HEADER_V3)
+        assert pkg.run(require_power=True) == 0
+        agg = pkg.agg()
+        assert_grace_keys(agg)
+        assert agg["avg_total_module_power_w"] == 6000.0
+        assert agg["total_module_energy_j"] == 360000.0
+        assert _gpu_fields(agg) == _reference_agg(tmp_path)
+        module_series = {f"{host}/socket{socket}/module" for host in CPU_HOSTS for socket in (0, 1)}
+        assert module_series <= set(pkg.sidecar()["cpu"]["per_series_energy_j"])
+
+    @pytest.mark.parametrize("module", ["blank", "gap"])
+    def test_v3_incomplete_module_drops_only_module_keys(self, tmp_path, module):
+        pkg = build_package(tmp_path)
+        if module == "blank":
+            # The musl exporter build cannot load NVML and leaves module_w empty.
+            rows = _v3(_cpu_rows(), module_w=None)
+        else:
+            rows = _v3(_cpu_rows())
+            for row in rows:
+                if row[2] == "node-d" and row[5] == 0 and 1020.0 <= float(row[1]) <= 1030.0:
+                    row[10] = ""
+        add_cpu_package(pkg, rows, CPU_HEADER_V3)
+        assert pkg.run(require_power=True) == 0
+        agg = pkg.agg()
+        assert_grace_keys(agg)
+        assert agg["avg_total_cpu_rail_power_w"] == 800.0
+        assert agg["avg_total_cpu_sysio_power_w"] == 200.0
+        assert {"avg_total_module_power_w", "total_module_energy_j"}.isdisjoint(agg)
+
+    @pytest.mark.parametrize(
+        "cpu, require_power",
+        [("missing", True), ("complete", True), ("missing", False), ("dcgm_only", True)],
+    )
+    def test_expected_acpi_cpu_controls_strict_exit_without_changing_gpu(
+        self, tmp_path, cpu, require_power
+    ):
+        pkg = build_package(tmp_path)
+        if cpu == "complete":
+            add_cpu_package(pkg, _cpu_rows())
+        elif cpu == "dcgm_only":
+            add_cpu_package(pkg, _cpu_rows({host: {"dcgm": DCGM_W} for host in CPU_HOSTS}))
+        assert pkg.run(require_power=require_power, expected_cpu=True) == int(
+            require_power and cpu != "complete"
+        )
+        assert _gpu_fields(pkg.agg()) == _reference_agg(tmp_path)
+        assert pkg.sidecar()["power_valid"] is True
+        assert pkg.agg()["cpu_power_valid"] == int(cpu == "complete")
+        if cpu == "complete":
+            assert_grace_keys(pkg.agg())
+        else:
+            assert set(apm.CPU_METRIC_KEYS).isdisjoint(pkg.agg())
+            assert pkg.sidecar()["cpu"]["reason_codes"]
+            if cpu == "dcgm_only":
+                # The DCGM CPU rail is not the Grace socket meter: no socket series.
+                assert pkg.sidecar()["cpu"]["reason_codes"] == ["cpu_socket_count_mismatch"]
+
+    @pytest.mark.parametrize(
+        "reason, window_trusted",
+        [
+            # srt-slurm power/windows.py _check_coverage: GPU coverage only.
+            ("measurement_window_not_bracketed", True),
+            ("sample_gap_exceeded", True),
+            ("gpu_uuid_changed", True),
+            ("sample_loss_exceeded", True),
+            # The window's own contract: the CPU leg has no window either.
+            ("measurement_window_clock_mismatch", False),
+        ],
+    )
+    def test_only_gpu_coverage_failures_leave_the_cpu_window_bound(self, reason, window_trusted):
+        window = {"benchmark_type": "sa-bench", "concurrency": 4}
+        validations = [{**window, "reason_codes": [reason], "power_coverage_valid": False}]
+        assert apm._window_contract_holds(window, validations) is window_trusted
+
+    def test_package_without_cpu_dir_emits_no_cpu_fields(self, tmp_path):
+        pkg = build_package(tmp_path)
+        assert pkg.run() == 0
+        agg = pkg.agg()
+        assert "cpu_power_valid" not in agg
+        assert set(apm.CPU_METRIC_KEYS).isdisjoint(agg)
+        assert "cpu" not in pkg.sidecar()
+
+    def _drop(self, rows, host, socket, predicate):
+        return [
+            row
+            for row in rows
+            if not (row[2] == host and row[5] == socket and predicate(float(row[1])))
+        ]
+
+    @pytest.fixture
+    def tampered(self, request, tmp_path):
+        kind = request.param
+        pkg = build_package(tmp_path)
+        rows = _cpu_rows()
+        header = CPU_HEADER
+        if kind == "socket":
+            rows = self._drop(rows, "node-p", 1, lambda ts: True)
+        elif kind == "gap":
+            rows = self._drop(rows, "node-d", 0, lambda ts: 1020.0 <= ts <= 1024.0)
+        elif kind == "mixed":
+            rows = _cpu_rows({"node-d": {"grace": None}, "node-p": {"dcgm": DCGM_W}})
+        elif kind == "mixed_meters":
+            rows = _cpu_rows({"node-d": {"grace": None}, "node-p": {"rapl": RAPL_W}})
+        elif kind == "malformed":
+            rows.append(_cpu_row(FIRST_TS, "node-d", 0, "grace", "n/a"))
+        elif kind == "version":
+            rows, header = _v3(rows), CPU_HEADER_V3
+            rows[0][0] = 2
+        add_cpu_package(pkg, rows, header)
+        return pkg
+
+    @pytest.mark.parametrize(
+        "tampered, reason",
+        [
+            ("socket", "cpu_socket_count_mismatch"),
+            ("gap", "cpu_sample_gap_exceeded"),
+            ("mixed", "cpu_socket_count_mismatch"),
+            ("mixed_meters", "cpu_samples_malformed"),
+            ("malformed", "cpu_samples_malformed"),
+            ("version", "cpu_samples_malformed"),
+        ],
+        indirect=["tampered"],
+    )
+    def test_cpu_leg_failures_leave_gpu_fields_untouched(self, tmp_path, tampered, reason):
+        pkg = tampered
+        # Without an expected CPU source, REQUIRE_POWER gates only the GPU leg.
+        assert pkg.run(require_power=True) == 0
+        agg = pkg.agg()
+        assert agg["cpu_power_valid"] == 0
+        assert set(apm.CPU_METRIC_KEYS).isdisjoint(agg)
+        assert _gpu_fields(agg) == _reference_agg(tmp_path)
+        cpu = pkg.sidecar()["cpu"]
+        assert cpu["cpu_power_valid"] is False
+        assert reason in cpu["reason_codes"]
+        assert pkg.sidecar()["power_valid"] is True
+
+
+def test_each_cluster_cpu_source_reads_the_socket_meter_srt_slurm_writes(monkeypatch):
+    monkeypatch.syspath_prepend(str(Path(__file__).resolve().parents[4] / "utils/srt-slurm/src"))
+    from srtctl.core.power.cpu_rails import SENSOR_SUFFIXES
+    from srtctl.core.power.cpu_sample import PRIMARY_KIND_BY_SOURCE
+
+    sources = get_args(CpuPowerSource)
+    assert set(SOCKET_METERS) == set(sources)
+    for source in sources:
+        assert SOCKET_METERS[source].sensor_suffix == SENSOR_SUFFIXES[PRIMARY_KIND_BY_SOURCE[source]]
diff --git a/inferencex-e2e/infx/tests/srt_slurm/test_al_gate_plan.py b/inferencex-e2e/infx/tests/srt_slurm/test_al_gate_plan.py
new file mode 100644
index 0000000000..b57e2477ca
--- /dev/null
+++ b/inferencex-e2e/infx/tests/srt_slurm/test_al_gate_plan.py
@@ -0,0 +1,219 @@
+"""Plan the report-only acceptance gate of an agentic speculative eval from its resolved recipe."""
+
+import copy
+import json
+import sys
+from pathlib import Path
+from typing import Any
+
+import pytest
+import yaml
+
+from infx.golden_al_distribution import GOLDEN_DIR
+from infx.srt_slurm import al_gate
+from infx.srt_slurm.synthetic_acceptance import plan_commands
+
+ROOT = Path(__file__).resolve().parents[3]
+sys.path.insert(0, str(ROOT / "utils/srt-slurm/src"))
+
+from srtctl.core.overrides import apply_overrides_to_recipe, parse_overrides  # noqa: E402
+
+DSV4 = "deepseek-v4-pro__mtp__native__default-default"
+EVAL = {
+    "MODEL_PREFIX": "dsv4", "FRAMEWORK": "vllm", "IS_AGENTIC": "1", "SPEC_DECODING": "mtp",
+    "EVAL_ONLY": "true", "RUN_EVAL": "true", "THINKING_MODE": "thinking_on",
+    "RESULT_FILENAME": "point", "EVAL_FRAMEWORK": "lm-eval", "RUNNER_TYPE": "cluster:test",
+    "AL_GATE_DATASET": "al_gate_dataset/speedbench_coding.jsonl", "EVAL_AL_GATE": "true",
+}  # fmt: skip
+COLLECTION = {
+    "renderer": "chat_template",
+    "modes": {"thinking_on": {"chat_template_kwargs": None, "sampling": {"temperature": 1.0}}},
+}
+
+
+@pytest.fixture
+def golden_dir(tmp_path: Path) -> Path:
+    directory = tmp_path / "golden"
+    directory.mkdir()
+    (directory / "identities.yaml").write_text((GOLDEN_DIR / "identities.yaml").read_text())
+    curve = {"deepseek-v4-pro": {"thinking_on": {3: 2.4}}, "collection": COLLECTION}
+    (directory / f"{DSV4}.yaml").write_text(yaml.safe_dump(curve))
+    glm = {"glm-5.3-nvfp4": {"thinking_on": {3: 2.94}}}
+    (directory / "glm-5.3-nvfp4__mtp__native__default-default.yaml").write_text(yaml.safe_dump(glm))
+    for name in ("probabilistic-block", "probabilistic-default"):
+        kimi = {"kimi-k3": {"thinking_on": {3: 3.0}}, "collection": COLLECTION}
+        (directory / f"kimi-k3__dspark__kimi-k3-dspark__{name}.yaml").write_text(yaml.safe_dump(kimi))
+    return directory
+
+
+def vllm_recipe(spec: dict[str, Any] | None = None, **args: Any) -> dict[str, Any]:
+    if spec:
+        args["speculative-config"] = json.dumps(spec)
+    return {"roles": {"agg": {"args": args}}, "benchmark": {"type": "custom"}, "telemetry": {}}
+
+
+def apply_native(recipe: dict[str, Any], argv: list[str]) -> dict[str, Any]:
+    result = copy.deepcopy(recipe)
+    sets = [argv[i + 1] for i, arg in enumerate(argv[:-1]) if arg == "--set"]
+    unsets = [argv[i + 1] for i, arg in enumerate(argv[:-1]) if arg == "--unset"]
+    apply_overrides_to_recipe(result, parse_overrides(sets, unsets))
+    return result
+
+
+MTP3 = {"method": "mtp", "num_speculative_tokens": 3}
+
+
+def test_a_drafting_eval_recipe_plans_the_gate_of_its_golden_curve(golden_dir):
+    gate = al_gate.plan(vllm_recipe(MTP3), "vllm", EVAL, golden_dir=golden_dir)
+
+    assert gate == {"curve": DSV4, "draft_tokens": 3, "golden_acceptance_length": 2.4}
+
+
+@pytest.mark.parametrize(
+    ("verify", "curve"),
+    [
+        ({}, "kimi-k3__dspark__kimi-k3-dspark__probabilistic-default"),
+        ({"rejection_sample_method": "block"}, "kimi-k3__dspark__kimi-k3-dspark__probabilistic-block"),
+    ],
+    ids=["standard", "block"],
+)
+def test_the_gate_measures_the_curve_of_the_recipes_verifier(golden_dir, verify, curve):
+    spec = {"method": "dspark", "num_speculative_tokens": 3, "draft_sample_method": "probabilistic"}
+    recipe = vllm_recipe({**spec, **verify}, **{"kv-cache-dtype": "fp8"})
+
+    gate = al_gate.plan(recipe, "vllm", {**EVAL, "MODEL_PREFIX": "kimik3"}, golden_dir=golden_dir)
+
+    assert gate == {"curve": curve, "draft_tokens": 3, "golden_acceptance_length": 3.0}
+
+
+def test_a_dynamo_trtllm_decode_role_plans_its_gate(golden_dir):
+    # srtctl publishes TRT-LLM metrics by default; a recipe without them reports no-counters.
+    spec = {"decoding_type": "MTP", "max_draft_len": 3}
+    recipe = {"roles": {"prefill": {}, "decode": {"args": {"speculative_config": spec}}}}
+
+    gate = al_gate.plan(recipe, "dynamo-trt", EVAL, golden_dir=golden_dir)
+
+    assert gate == {"curve": DSV4, "draft_tokens": 3, "golden_acceptance_length": 2.4}
+
+
+def test_a_recipe_that_does_not_draft_has_no_gate(golden_dir):
+    assert al_gate.plan(vllm_recipe(), "vllm", EVAL, golden_dir=golden_dir) is None
+
+
+@pytest.mark.parametrize(
+    ("framework", "prefix", "reason"),
+    [
+        ("tilert", "dsv4", "TileRT"),
+        ("vllm", "glm5.3", "records no collection to replay"),
+        ("vllm", "minimaxm3", "no golden AL"),
+    ],
+)
+def test_a_gate_that_cannot_run_is_skipped_with_its_reason(golden_dir, framework, prefix, reason):
+    environment = {**EVAL, "MODEL_PREFIX": prefix}
+
+    gate = al_gate.plan(vllm_recipe(MTP3), framework, environment, golden_dir=golden_dir)
+
+    assert (gate["status"], gate["result_filename"], gate["eval_framework"]) == (
+        "skipped", "point", "lm-eval",
+    )  # fmt: skip
+    assert reason in gate["error"]
+
+
+def dp_recipe(dp: int, tp: int, gpus_per_node: int | None, pp: int = 1) -> dict[str, Any]:
+    """A vLLM recipe whose generation worker runs ``dp`` replicas of TP x PP GPUs."""
+    args = {"data-parallel-size": dp, "tensor-parallel-size": tp, "pipeline-parallel-size": pp}
+    recipe = vllm_recipe(MTP3, **args)
+    if gpus_per_node is not None:
+        recipe["resources"] = {"gpus_per_node": gpus_per_node}
+    return recipe
+
+
+@pytest.mark.parametrize(
+    ("framework", "recipe", "cluster_gpus", "skipped"),
+    [
+        # Eight data-parallel ranks over two 4-GPU nodes run as two processes.
+        ("dynamo-vllm", dp_recipe(dp=8, tp=1, gpus_per_node=4), 8, True),
+        ("dynamo-vllm", dp_recipe(dp=2, tp=2, pp=2, gpus_per_node=4), 8, True),
+        # One 8-GPU node runs a single process for every rank.
+        ("dynamo-vllm", dp_recipe(dp=8, tp=1, gpus_per_node=8), 4, False),
+        # A replica wider than a node keeps a single API leader for every rank.
+        ("dynamo-vllm", dp_recipe(dp=2, tp=8, gpus_per_node=4), 4, False),
+        # Without resources.gpus_per_node, srtctl uses the cluster's node size.
+        ("dynamo-vllm", dp_recipe(dp=8, tp=1, gpus_per_node=None), 4, True),
+        # Only Dynamo hands the benchmark one leader's metrics.
+        ("vllm-disagg", dp_recipe(dp=8, tp=1, gpus_per_node=4), 4, False),
+    ],
+)
+def test_dynamo_vllm_data_parallel_workers_across_nodes_are_skipped(
+    tmp_path, monkeypatch, golden_dir, framework, recipe, cluster_gpus, skipped
+):
+    cluster = {"gpus-per-node": cluster_gpus, "arch": "x86_64", "scheduler": "slurm",
+               "slurm": {"partition": "batch", "exclusive": True}}  # fmt: skip
+    runners = {"labels": {"cluster:test": ["test_0"]}, "clusters": {"test": cluster}}
+    (tmp_path / "configs").mkdir(exist_ok=True)
+    (tmp_path / "configs/runners.yaml").write_text(yaml.safe_dump(runners))
+    monkeypatch.setenv("INFERENCEX_REPOSITORY_ROOT", str(tmp_path))
+
+    gate = al_gate.plan(recipe, framework, EVAL, golden_dir=golden_dir)
+
+    assert (gate.get("status") == "skipped") is skipped
+    if skipped:
+        assert "only the leader's metrics" in gate["error"]
+
+
+def test_the_gate_runs_as_the_benchmark_stage_before_the_eval(tmp_path, golden_dir):
+    recipe = vllm_recipe(MTP3)
+    path = tmp_path / "recipe.yaml"
+    path.write_text(yaml.safe_dump(recipe))
+
+    [planned] = plan_commands(str(path), "vllm", [], EVAL, golden_dir=golden_dir)
+
+    assert planned.acceptance_length is None  # the eval's server verifies for real
+    assert planned.al_gate["curve"] == DSV4
+    assert dict(planned.environment) == {"EVAL_ONLY": "false", "RUN_EVAL": "true"}
+    result = apply_native(recipe, planned.command)
+    assert "telemetry" not in result
+    assert result["benchmark"] == {
+        "type": "custom",
+        "command": "bash /infmax-workspace/benchmarks/srt_al_gate.sh",
+        "env": {
+            "AL_GATE": "true", "AL_GATE_CURVE": DSV4, "AL_GATE_DRAFT_TOKENS": "3",
+            "AL_GATE_DATASET": "al_gate_dataset/speedbench_coding.jsonl",
+            "AL_GATE_OUTPUT_DIR": "/logs", "THINKING_MODE": "thinking_on",
+            "EVAL_FRAMEWORK": "lm-eval",
+        },
+    }  # fmt: skip
+
+
+@pytest.mark.parametrize("environment", [{"EVAL_AL_GATE": ""}, {"MODEL_PREFIX": "glm5.3"}])
+def test_an_eval_without_a_runnable_gate_is_submitted_unchanged(
+    tmp_path, golden_dir, environment
+):
+    path = tmp_path / "recipe.yaml"
+    path.write_text(yaml.safe_dump(vllm_recipe(MTP3)))
+
+    [planned] = plan_commands(str(path), "vllm", [], {**EVAL, **environment}, golden_dir=golden_dir)
+
+    assert planned.environment == ()
+    assert "benchmark" not in " ".join(planned.command)
+
+
+def test_the_summary_tabulates_every_downloaded_gate(tmp_path, capsys):
+    measured = {
+        "result_filename": "b", "eval_framework": "lm-eval", "eval_suite": None,
+        "curve": DSV4, "draft_tokens": 3, "golden_acceptance_length": 2.4,
+        "acceptance_length": 2.2, "ratio": 0.9167, "status": "below", "error": None,
+    }  # fmt: skip
+    skipped = al_gate.skipped("no SPEED-Bench prompts at ''", {"RESULT_FILENAME": "a"})
+    (tmp_path / "eval_x").mkdir()
+    (tmp_path / "eval_x" / "al_gate_b.json").write_text(json.dumps(measured))
+    (tmp_path / "al_gate_a.json").write_text(json.dumps(skipped))
+    (tmp_path / "eval_x" / "al_gate_c.json").write_text("{")
+
+    assert al_gate.main(["summarize", str(tmp_path)]) == 0
+
+    assert capsys.readouterr().out.splitlines()[-2:] == [
+        "| `a` | - | - | - | - | - | - | skipped: no SPEED-Bench prompts at '' |",
+        f"| `b` | lm-eval | {DSV4} | 3 | 2.40 | 2.20 | 0.917 | below |",
+    ]
+    assert al_gate.summarize([]) == ""
diff --git a/inferencex-e2e/infx/tests/srt_slurm/test_generate.py b/inferencex-e2e/infx/tests/srt_slurm/test_generate.py
index 200015fb41..d5751eecba 100644
--- a/inferencex-e2e/infx/tests/srt_slurm/test_generate.py
+++ b/inferencex-e2e/infx/tests/srt_slurm/test_generate.py
@@ -7,8 +7,8 @@
 import yaml
 
 from infx.cli import main
-from infx.launch.drivers.srt import lanes, power
-from infx.launch.policy import LaunchPath, Match
+from infx.launch.drivers.srt import lanes
+from infx.launch.policy import LaunchPath
 
 ROOT = Path(__file__).resolve().parents[3]
 FRAGMENT = {
@@ -105,14 +105,10 @@ def project(tmp_path):
 
 @pytest.fixture
 def power_lane(monkeypatch):
-    """The fixture cluster's multi-node lane, measuring AgentX power."""
+    """The fixture cluster's multi-node lane."""
     monkeypatch.setitem(
         lanes.SRT_LANES, ("fixture", LaunchPath.SRT_MULTI), lanes.SrtLane(agentic_result_dir="/results")
     )
-    rules = (power.PowerRule(Match(agentic=True), agentx=True),)
-    monkeypatch.setitem(
-        power.POWER_LANES, ("fixture", LaunchPath.SRT_MULTI), power.PowerLane(rules, error="no power")
-    )
 
 
 def generate(project: Path, output: Path, key: str = "fixture-*") -> int:
@@ -145,6 +141,7 @@ def test_each_point_gets_its_bound_variant_and_a_manifest_entry(project, tmp_pat
     assert recipe["benchmark"] == {"type": "custom", "command": "bash client.sh", "env": {
         "CONC": "4", "ISL": "1024", "OSL": "128", "MODEL": "org/model",
         "RANDOM_RANGE_RATIO": "0.8", "USE_CHAT_TEMPLATE": "true", "REQUIRE_POWER": "0",
+        "SPEC_ALGORITHM": "mtp", "SPEC_DRAFT_MODEL": "native",
     }, "concurrencies": [4]}  # fmt: skip
     assert recipe["roles"]["agg"]["env"] == {"NCCL_SOCKET_IFNAME": "eth7"}
 
@@ -188,7 +185,7 @@ def test_a_multinode_agentx_power_point_gets_its_clusters_exporter_port_and_clie
 
     [(record, recipe)] = written(output)
     assert record["cluster"] == "fixture"
-    assert recipe["telemetry"] == {"enabled": True, "dcgm_exporter": {
+    assert recipe["telemetry"] == {"enabled": True, "required": True, "dcgm_exporter": {
         "container_image": "dcgm-exporter", "command": "dcgm-exporter --address :{port}", "port": 9555,
     }}  # fmt: skip
     assert recipe["benchmark"]["env"] == {
@@ -198,29 +195,112 @@ def test_a_multinode_agentx_power_point_gets_its_clusters_exporter_port_and_clie
     assert recipe["benchmark"]["concurrencies"] == [8]
 
 
-def test_a_multinode_agentx_point_without_power_turns_its_clients_power_off(
-    project, power_lane, tmp_path
+@pytest.mark.parametrize("declared", [True, False])
+def test_a_cpu_power_point_binds_the_clusters_grace_exporter_or_fails(
+    project, power_lane, tmp_path, capsys, declared
+):
+    master = project / "configs/master.yaml"
+    config = yaml.safe_load(master.read_text())
+    config["agentx-multi"]["scenarios"]["agentic-coding"][0]["search-space"][0]["cpu-power"] = True
+    master.write_text(yaml.safe_dump(config))
+    if declared:
+        runners = project / "configs/runners.yaml"
+        inventory = yaml.safe_load(runners.read_text())
+        srt = inventory["clusters"]["fixture"]["slurm"]["srt-slurm"]
+        srt["cpu-power-exporter"] = {"source": "acpi"}
+        runners.write_text(yaml.safe_dump(inventory))
+    output = tmp_path / "out"
+
+    if not declared:
+        with pytest.raises(SystemExit):
+            generate(project, output, "agentx-multi")
+        assert "declares no srt-slurm.cpu-power-exporter" in capsys.readouterr().err
+        assert not output.exists()
+        return
+    assert generate(project, output, "agentx-multi") == 0
+    [(_, recipe)] = written(output)
+    assert recipe["telemetry"]["cpu_power_exporter"] == {"source": "acpi"}
+    assert recipe["telemetry"]["dcgm_exporter"]["port"] == 9555
+
+
+@pytest.mark.parametrize("declared", [True, False])
+def test_a_single_node_cpu_power_point_binds_the_clusters_rapl_exporter_or_fails(
+    project, tmp_path, capsys, declared
+):
+    master = project / "configs/master.yaml"
+    config = yaml.safe_load(master.read_text())
+    config["fixture-sglang"]["scenarios"]["fixed-seq-len"][0]["search-space"][0]["cpu-power"] = True
+    master.write_text(yaml.safe_dump(config))
+    if declared:
+        runners = project / "configs/runners.yaml"
+        inventory = yaml.safe_load(runners.read_text())
+        inventory["clusters"]["fixture"]["slurm"]["srt-slurm"]["cpu-power-exporter"] = {"source": "rapl"}
+        runners.write_text(yaml.safe_dump(inventory))
+    output = tmp_path / "out"
+
+    if not declared:
+        with pytest.raises(SystemExit):
+            generate(project, output, "fixture-sglang")
+        assert "declares no srt-slurm.cpu-power-exporter" in capsys.readouterr().err
+        assert not output.exists()
+        return
+    assert generate(project, output, "fixture-sglang") == 0
+    recipes = [recipe for _, recipe in written(output)]
+    assert [recipe["telemetry"]["cpu_power_exporter"] for recipe in recipes] == [{"source": "rapl"}] * 2
+
+
+@pytest.mark.parametrize("declared", [True, False])
+def test_a_single_node_point_measures_cpu_power_by_default_where_its_cluster_declares_it(
+    project, tmp_path, declared
+):
+    if declared:
+        runners = project / "configs/runners.yaml"
+        inventory = yaml.safe_load(runners.read_text())
+        inventory["clusters"]["fixture"]["slurm"]["srt-slurm"]["cpu-power-exporter"] = {"source": "rapl"}
+        runners.write_text(yaml.safe_dump(inventory))
+    output = tmp_path / "out"
+
+    assert generate(project, output, "fixture-sglang") == 0
+    recipes = [recipe for _, recipe in written(output)]
+    exporters = [recipe.get("telemetry", {}).get("cpu_power_exporter") for recipe in recipes]
+    assert exporters == [{"source": "rapl"} if declared else None] * 2
+
+
+def _drop_srt_slurm(project: Path, key: str) -> None:
+    runners = project / "configs/runners.yaml"
+    inventory = yaml.safe_load(runners.read_text())
+    del inventory["clusters"]["fixture"]["slurm"]["srt-slurm"][key]
+    runners.write_text(yaml.safe_dump(inventory))
+
+
+@pytest.mark.parametrize("port", [True, False])
+def test_a_multinode_agentx_point_without_power_measures_it_with_its_clusters_exporter(
+    project, power_lane, tmp_path, port
 ):
     master = project / "configs/master.yaml"
     config = yaml.safe_load(master.read_text())
     del config["agentx-multi"]["scenarios"]["agentic-coding"][0]["search-space"][0]["power"]
     master.write_text(yaml.safe_dump(config))
+    if not port:
+        _drop_srt_slurm(project, "power-exporter-port")
     output = tmp_path / "out"
     assert generate(project, output, "agentx-multi") == 0
 
     [(_, recipe)] = written(output)
-    assert recipe["benchmark"]["env"]["ENABLE_AGENTX_POWER"] == "0"
+    env = recipe["benchmark"]["env"]
+    assert (env["ENABLE_AGENTX_POWER"], env["REQUIRE_POWER"]) == ("1", "0")
+    assert (recipe["telemetry"]["enabled"], recipe["telemetry"]["required"]) == (True, False)
+    assert recipe["telemetry"].get("dcgm_exporter", {}).get("port") == (9555 if port else None)
 
 
-def test_a_power_point_its_lane_refuses_fails_without_writing(
-    project, power_lane, monkeypatch, tmp_path, capsys
+def test_a_power_point_its_cluster_cannot_measure_fails_without_writing(
+    project, power_lane, tmp_path, capsys
 ):
-    refusing = power.PowerLane(rules=(), error="this lane measures no AgentX power")
-    monkeypatch.setitem(power.POWER_LANES, ("fixture", LaunchPath.SRT_MULTI), refusing)
+    _drop_srt_slurm(project, "extra")
     output = tmp_path / "out"
     with pytest.raises(SystemExit):
         generate(project, output, "agentx-multi")
-    assert "this lane measures no AgentX power" in capsys.readouterr().err
+    assert "measures no GPU power" in capsys.readouterr().err
     assert not output.exists()
 
 
diff --git a/inferencex-e2e/infx/tests/srt_slurm/test_setup_scripts.py b/inferencex-e2e/infx/tests/srt_slurm/test_setup_scripts.py
index 028405e64f..d1999ce731 100644
--- a/inferencex-e2e/infx/tests/srt_slurm/test_setup_scripts.py
+++ b/inferencex-e2e/infx/tests/srt_slurm/test_setup_scripts.py
@@ -66,3 +66,24 @@ def test_an_installer_installs_exactly_the_bound_version(tmp_path, script, env,
 
     assert result.returncode == 0, result.stdout + result.stderr
     assert expected <= set(installs[0])
+
+
+def test_tokenspeed_installer_uses_direct_private_wheels_and_one_public_index(tmp_path):
+    result, installs = run(tmp_path, "tokenspeed-nightly.sh", {
+        "TOKENSPEED_WHEEL_URL": "https://example.test/tokenspeed.whl#sha256=abc",
+        "TOKENSPEED_KERNEL_WHEEL_URL": "https://example.test/kernel.whl#sha256=def",
+        "TOKENSPEED_ENGINE_WHEEL_URL": "https://example.test/engine.whl#sha256=123",
+        "TOKENSPEED_SCHEDULER_VERSION": "0.1.48",
+        "ROUTER_VERSION": "1.13.0.post20261027",
+    })
+
+    assert result.returncode == 0, result.stdout + result.stderr
+    assert installs == [[
+        "-m", "pip", "install", "--break-system-packages", "--upgrade",
+        "--index-url", "https://pypi.org/simple",
+        "https://example.test/tokenspeed.whl#sha256=abc",
+        "https://example.test/kernel.whl#sha256=def",
+        "https://example.test/engine.whl#sha256=123",
+        "tokenspeed-scheduler==0.1.48",
+        "tokenspeed-smg==1.13.0.post20261027",
+    ]]
diff --git a/inferencex-e2e/infx/tests/srt_slurm/test_srt_single_node.py b/inferencex-e2e/infx/tests/srt_slurm/test_srt_single_node.py
index 7e1751e72b..726df51bc1 100644
--- a/inferencex-e2e/infx/tests/srt_slurm/test_srt_single_node.py
+++ b/inferencex-e2e/infx/tests/srt_slurm/test_srt_single_node.py
@@ -69,6 +69,43 @@ def test_native_binding_submits_one_point_and_keeps_server_settings(point):
     }
 
 
+def test_tokenspeed_binding_preserves_native_args_and_eval_context(point):
+    path, recipe, env = point
+    recipe["engine"] = "tokenspeed"
+    recipe["roles"]["agg"]["args"] = {
+        "attn-tp-size": 2, "data-parallel-size": 2, "ep-size": 4,
+        "pipeline-parallel-size": 1, "max-model-len": 512,
+        "speculative-algorithm": "MTP", "speculative-num-steps": 3,
+        "speculative-num-draft-tokens": 4, "sampling-backend": "flashinfer",
+        "kvstore-size": 80, "kvstore-write-policy": "write_back",
+    }
+    path.write_text(yaml.safe_dump({"base": recipe}))
+    env = {**env, "FRAMEWORK": "tokenspeed", "EP_SIZE": "4", "DP_ATTENTION": "true",
+           "SPEC_DECODING": "mtp", "EVAL_ONLY": "true", "MAX_MODEL_LEN": "1024"}
+    _, bound = select_recipe(f"{path}:base", env)
+    argv = runtime_arguments(f"{path}:base", env)
+    apply_overrides_to_recipe(bound, parse_overrides(argv[1::2], []))
+    assert bound["roles"]["agg"]["args"] == {
+        "attn-tp-size": 2, "data-parallel-size": 2, "ep-size": 4,
+        "pipeline-parallel-size": 1, "max-model-len": 1024,
+        "speculative-algorithm": "MTP", "speculative-num-steps": 3,
+        "speculative-num-draft-tokens": 4, "sampling-backend": "flashinfer",
+        "kvstore-size": 80, "kvstore-write-policy": "write_back",
+    }
+    assert bound["benchmark"]["env"]["USE_CHAT_TEMPLATE"] == "true"
+    for field, value, message in [
+        ("TP", "2", "attention TP x DP"),
+        ("EP_SIZE", "1", "ep-size"),
+        ("DP_ATTENTION", "false", "DP_ATTENTION"),
+    ]:
+        with pytest.raises(ValueError, match=message):
+            select_recipe(f"{path}:base", {**env, field: value})
+    recipe["roles"]["agg"]["args"]["pipeline-parallel-size"] = 2
+    path.write_text(yaml.safe_dump({"base": recipe}))
+    with pytest.raises(ValueError, match="pipeline-parallel-size"):
+        select_recipe(f"{path}:base", env)
+
+
 @pytest.mark.parametrize("field,value,message", [
     ("TP", "2", "tensor-parallel-size"), ("RUN_EVAL", "yes", "RUN_EVAL"),
     ("PP_SIZE", "2", "PP_SIZE"), ("RESULT_FILENAME", "", "Missing runtime input"),
diff --git a/inferencex-e2e/infx/tests/srt_slurm/test_synthetic_acceptance.py b/inferencex-e2e/infx/tests/srt_slurm/test_synthetic_acceptance.py
index 0a309f4047..bfca6bf560 100644
--- a/inferencex-e2e/infx/tests/srt_slurm/test_synthetic_acceptance.py
+++ b/inferencex-e2e/infx/tests/srt_slurm/test_synthetic_acceptance.py
@@ -3,6 +3,7 @@
 import copy
 import json
 import os
+import shutil
 import subprocess
 import sys
 from pathlib import Path
@@ -11,6 +12,7 @@
 import pytest
 import yaml
 
+from infx.golden_al_distribution import GOLDEN_DIR
 from infx.srt_slurm.synthetic_acceptance import (
     acceptance_length,
     build_overrides,
@@ -39,20 +41,35 @@
 def golden_dir(tmp_path: Path) -> Path:
     directory = tmp_path / "golden"
     directory.mkdir()
+    shutil.copy(GOLDEN_DIR / "identities.yaml", directory)
     for filename, model, acceptance in [
-        ("dsv4_mtp.yaml", "deepseek-v4-pro", 2.4),
-        ("qwen3.5_mtp.yaml", "qwen3.5", 2.6),
-        ("dsv4-pro-0813-dspark.yaml", "deepseek-v4-pro-0813", 2.7),
-        ("kimik3_dspark.yaml", "kimi-k3", 2.8),
+        ("deepseek-v4-pro__mtp__native__default-default.yaml", "deepseek-v4-pro", 2.4),
+        ("qwen3.5-397b-a17b-nvfp4__mtp__native__default-default.yaml", "qwen3.5", 2.6),
         (
-            "kimik3_dspark_probabilistic_sample_method_block_rejection_sample_method.yaml",
+            "deepseek-v4-pro-0813__dspark__native__probabilistic-default.yaml",
+            "deepseek-v4-pro-0813",
+            2.7,
+        ),
+        ("kimi-k3__dspark__kimi-k3-dspark__default-default.yaml", "kimi-k3", 2.8),
+        (
+            "kimi-k3__dspark__kimi-k3-dspark__probabilistic-block.yaml",
             "kimi-k3",
             2.9,
         ),
-        ("minimaxm3_eagle3.yaml", "minimax-m3", 2.5),
-        ("minimaxm3_eagle3_gqa.yaml", "minimax-m3", 2.6),
-        ("glm5.3_mtp.yaml", "glm-5.3", 3.2),
-        ("musespark_dflash.yaml", "muse-spark-open", 3.4),
+        (
+            "kimi-k3__dspark__kimi-k3-dspark__probabilistic-default.yaml",
+            "kimi-k3",
+            3.0,
+        ),
+        ("minimax-m3__eagle3__minimax-m3-eagle3__default-default.yaml", "minimax-m3", 2.5),
+        ("minimax-m3__eagle3__minimax-m3-eagle3-gqa__default-default.yaml", "minimax-m3", 2.6),
+        ("minimax-m3__eagle3__minimax-m3-eagle3-gqa__default-block.yaml", "minimax-m3", 2.7),
+        ("glm-5.3-nvfp4__mtp__native__default-default.yaml", "glm-5.3", 3.2),
+        (
+            "muse-spark-open-816b-a42b-nvfp4__dflash__muse-spark-open-dflash2__default-default.yaml",
+            "muse-spark-open",
+            3.4,
+        ),
     ]:
         (directory / filename).write_text(
             yaml.safe_dump(
@@ -75,6 +92,88 @@ def apply_native(recipe: dict[str, Any], argv: list[str]) -> dict[str, Any]:
     return result
 
 
+def test_tokenspeed_plan_uses_effective_mtp_depth_and_restores_real_sampling(
+    tmp_path: Path, golden_dir: Path
+) -> None:
+    recipe = {
+        "roles": {"agg": {"args": {
+            "speculative-algorithm": "MTP", "speculative-num-steps": 2,
+            "speculative-num-draft-tokens": 3, "speculative-eagle-topk": 1,
+            "synthetic-acceptance-length": 99, "sampling-backend": "flashinfer",
+            "kv-cache-dtype": "bfloat16", "kvstore-size": 80,
+        }, "env": {"KEEP": "worker"}}},
+    }
+    original = copy.deepcopy(recipe)
+    path = tmp_path / "tokenspeed.yaml"
+    path.write_text(yaml.safe_dump(recipe))
+    plans = plan_commands(
+        str(path), "tokenspeed",
+        ["--set", "roles.agg.args.speculative-num-steps=3",
+         "--set", "roles.agg.args.speculative-num-draft-tokens=4"],
+        ENV, golden_dir=golden_dir,
+    )
+    assert len(plans) == 1
+    assert plans[0].acceptance_length == 2.4
+    throughput = apply_native(recipe, plans[0].command)
+    assert throughput["roles"]["agg"]["args"] == {
+        "speculative-algorithm": "MTP", "speculative-num-steps": 3,
+        "speculative-num-draft-tokens": 4, "speculative-eagle-topk": 1,
+        "synthetic-acceptance-length": 2.4, "sampling-backend": "greedy",
+        "kv-cache-dtype": "bfloat16", "kvstore-size": 80,
+    }
+    evaluation = apply_native(throughput, build_overrides(
+        throughput, "tokenspeed", {**ENV, "EVAL_ONLY": "true"},
+        golden_dir=tmp_path / "absent",
+    ))
+    assert "synthetic-acceptance-length" not in evaluation["roles"]["agg"]["args"]
+    assert evaluation["roles"]["agg"]["args"]["sampling-backend"] == "flashinfer"
+    assert evaluation["roles"]["agg"]["env"] == {"KEEP": "worker"}
+    assert recipe == original
+
+
+@pytest.mark.parametrize("environment", [{"IS_AGENTIC": "0"}, {"SPEC_DECODING": "none"}])
+def test_tokenspeed_non_synthetic_runs_remove_forced_acceptance(
+    tmp_path: Path, environment: dict[str, str]
+) -> None:
+    recipe = {"roles": {"agg": {"args": {
+        "speculative-algorithm": "MTP", "synthetic-acceptance-length": 2.5,
+        "sampling-backend": "greedy",
+    }}}}
+    result = apply_native(recipe, build_overrides(
+        recipe, "tokenspeed", {**ENV, **environment}, golden_dir=tmp_path / "absent",
+    ))
+    assert result["roles"]["agg"]["args"] == {
+        "speculative-algorithm": "MTP", "sampling-backend": "flashinfer",
+    }
+
+
+@pytest.mark.parametrize("change,message", [
+    ({"speculative-num-draft-tokens": 3}, "must equal"),
+    ({"speculative-num-draft-tokens": True}, "must equal"),
+    ({"speculative-eagle-topk": 2}, "topk 1"),
+    ({"speculative-algorithm": "DFLASH"}, "only MTP"),
+    ({"speculative-config": {"method": "mtp"}}, "explicit MTP flags"),
+])
+def test_tokenspeed_rejects_unsupported_speculation(golden_dir: Path, change, message) -> None:
+    recipe = {"roles": {"agg": {"args": {
+        "speculative-algorithm": "MTP", "speculative-num-steps": 3,
+        "speculative-num-draft-tokens": 4, "speculative-eagle-topk": 1, **change,
+    }}}}
+    with pytest.raises(ValueError, match=message):
+        build_overrides(recipe, "tokenspeed", ENV, golden_dir=golden_dir)
+
+
+def test_tokenspeed_without_speculation_keeps_the_selected_sampler(tmp_path: Path) -> None:
+    recipe = {"roles": {"agg": {"args": {
+        "sampling-backend": "flashinfer", "synthetic-acceptance-length": 2,
+    }}}}
+    result = apply_native(recipe, build_overrides(
+        recipe, "tokenspeed", {**ENV, "SPEC_DECODING": "none"},
+        golden_dir=tmp_path / "absent",
+    ))
+    assert result["roles"]["agg"]["args"] == {"sampling-backend": "flashinfer"}
+
+
 def vllm_recipe(method: str = "mtp", **extra: Any) -> dict[str, Any]:
     return {
         "roles": {
@@ -95,9 +194,15 @@ def vllm_recipe(method: str = "mtp", **extra: Any) -> dict[str, Any]:
         ("dsv4", "mtp", {}, 2.4),
         ("dsv4", "dspark", {}, 2.7),
         ("kimik3", "dspark", {"draft_sample_method": "greedy"}, 2.8),
-        ("kimik3", "dspark", {"draft_sample_method": "probabilistic"}, 2.9),
+        ("kimik3", "dspark", {"draft_sample_method": "probabilistic"}, 3.0),
         ("minimaxm3", "eagle3", {"model": "Inferact/MiniMax-M3-EAGLE3"}, 2.5),
         ("minimaxm3", "eagle3", {"model": "Inferact/MiniMax-M3-EAGLE3-GQA"}, 2.6),
+        (
+            "minimaxm3",
+            "eagle3",
+            {"model": "Inferact/MiniMax-M3-EAGLE3-GQA", "rejection_sample_method": "block"},
+            2.7,
+        ),
     ],
 )
 def test_automatic_curve_selection_preserves_json(
@@ -186,9 +291,7 @@ def test_adaptive_dspark_skips_golden_acceptance_on_throughput(golden_dir: Path)
         ),
     )
     assert result == original
-    tp8_recipe = vllm_recipe(
-        "dspark", num_speculative_tokens=3, enable_adaptive_verification=False
-    )
+    tp8_recipe = vllm_recipe("dspark", num_speculative_tokens=3, enable_adaptive_verification=False)
     tp8 = apply_native(
         tp8_recipe,
         build_overrides(
@@ -207,7 +310,11 @@ def test_adaptive_verification_records_no_golden_acceptance(golden_dir: Path) ->
     adaptive = {
         "args": {
             "speculative-config": json.dumps(
-                {"method": "dspark", "num_speculative_tokens": 5, "enable_adaptive_verification": True}
+                {
+                    "method": "dspark",
+                    "num_speculative_tokens": 5,
+                    "enable_adaptive_verification": True,
+                }
             )
         }
     }
@@ -244,7 +351,7 @@ def test_kimi_curve_requires_an_explicit_supported_sampler(
     golden_dir: Path, sampling: str | None
 ) -> None:
     fields = {} if sampling is None else {"draft_sample_method": sampling}
-    with pytest.raises(ValueError, match="Kimi DSpark golden curve for draft sampling"):
+    with pytest.raises(ValueError, match="No kimik3 dspark golden curve"):
         build_overrides(
             vllm_recipe("dspark", **fields),
             "vllm",
@@ -539,7 +646,9 @@ def test_missing_or_invalid_golden_rejects_injection(
     tmp_path: Path, curve: dict[str, dict[int, float]] | None
 ) -> None:
     if curve is not None:
-        (tmp_path / "dsv4_mtp.yaml").write_text(yaml.safe_dump({"deepseek-v4-pro": curve}))
+        shutil.copy(GOLDEN_DIR / "identities.yaml", tmp_path)
+        curve_file = tmp_path / "deepseek-v4-pro__mtp__native__default-default.yaml"
+        curve_file.write_text(yaml.safe_dump({"deepseek-v4-pro": curve}))
     with pytest.raises(
         ValueError,
         match=r"(?:No committed golden curve|No golden acceptance|Invalid golden acceptance)",
@@ -604,7 +713,7 @@ def test_variants_use_resolved_tokens_and_preserve_caller_arguments(
         golden_dir=golden_dir,
     )
     assert len(commands) == 2
-    for index, (command, length) in enumerate(commands):
+    for index, (command, length, *_) in enumerate(commands):
         assert command[:2] == ["srtctl", "apply"]
         assert command[command.index("--tags") + 1] == "x y"
         selector = f"zip_override_test[{index}]"
@@ -667,8 +776,18 @@ def test_cli_forwards_options_and_submission_failure(
     record = tmp_path / "acceptance.json"
     result = subprocess.run(
         [
-            sys.executable, "-m", "infx.srt_slurm.synthetic_acceptance", "--record", str(record),
-            str(recipe), "vllm", "--", "-f", str(recipe), "--tags", "a b",
+            sys.executable,
+            "-m",
+            "infx.srt_slurm.synthetic_acceptance",
+            "--record",
+            str(record),
+            str(recipe),
+            "vllm",
+            "--",
+            "-f",
+            str(recipe),
+            "--tags",
+            "a b",
         ],  # fmt: skip
         cwd=tmp_path,
         env={
@@ -683,7 +802,7 @@ def test_cli_forwards_options_and_submission_failure(
         text=True,
     )
     assert result.returncode == returncode, result.stderr
-    assert json.loads(record.read_text()) == {"golden_acceptance_length": None}
+    assert json.loads(record.read_text()) == {"golden_acceptance_length": None, "al_gate": None}
     argv = json.loads(result.stdout)
     assert argv[:5] == ["apply", "-f", str(recipe), "--tags", "a b"]
     result_recipe = apply_native(yaml.safe_load(recipe.read_text()), argv)
@@ -762,42 +881,6 @@ def test_sglang_abbreviated_algorithm_selects_golden(
     }
 
 
-@pytest.mark.parametrize(
-    ("engine", "args", "key", "expected"),
-    [
-        (
-            "sglang",
-            {"speculative-algorithm": "EAGLE", "speculative-num-steps": 3},
-            "SGLANG_SIMULATE_ACC_LEN",
-            "3.603536",
-        ),
-        (
-            "tilert",
-            {"with-mtp": True, "num-mtp": 3},
-            "TILERT_SIMULATE_ACC_LEN",
-            "3.603536",
-        ),
-        (
-            "trt",
-            {"speculative_config": {"decoding_type": "mtp", "max_draft_len": 3}},
-            "TLLM_SPEC_DECODE_FORCE_NUM_ACCEPTED_TOKENS",
-            "2.603536",
-        ),
-    ],
-)
-def test_precise_golden_length_survives_native_overrides(
-    golden_dir: Path, engine: str, args: dict[str, Any], key: str, expected: str
-) -> None:
-    (golden_dir / "dsv4_mtp.yaml").write_text(
-        yaml.safe_dump({"deepseek-v4-pro": {"thinking_on": {3: 3.603536}}})
-    )
-    recipe = {"roles": {"decode": {"args": args}}}
-    result = apply_native(
-        recipe, build_overrides(recipe, engine, ENV, golden_dir=golden_dir)
-    )
-    assert result["roles"]["decode"]["env"][key] == expected
-
-
 def test_sglang_conflicting_algorithm_aliases_fail(golden_dir: Path) -> None:
     recipe = {
         "roles": {
@@ -833,9 +916,7 @@ def test_qwen_mtp_checks_effective_generation_window(tmp_path: Path, golden_dir:
     raw = {
         "schema": 2,
         "roles": {
-            "prefill": {
-                "args": {"speculative-algorithm": "NEXTN", "speculative-num-steps": 2}
-            },
+            "prefill": {"args": {"speculative-algorithm": "NEXTN", "speculative-num-steps": 2}},
             "decode": {
                 "args": {
                     "speculative-algorithm": "NEXTN",
@@ -886,3 +967,14 @@ def test_qwen_real_verification_does_not_require_mtp_window(
         ),
     )
     assert result["roles"]["agg"]["env"] == {"KEEP": "worker"}
+
+
+def test_an_eval_server_verifies_for_real(tmp_path: Path) -> None:
+    # An agentic eval and its acceptance gate measure the recipe's real acceptance.
+    spec = {"method": "mtp", "num_speculative_tokens": 3}
+    forced = {**spec, "rejection_sample_method": "synthetic", "synthetic_acceptance_length": 8}
+    recipe = {"roles": {"agg": {"args": {"speculative-config": json.dumps(forced)}}}}
+    env = {**ENV, "EVAL_ONLY": "true", "EVAL_AL_GATE": "true"}
+    overrides = build_overrides(recipe, "dynamo-vllm", env, golden_dir=tmp_path / "absent")
+    real = apply_native(recipe, overrides)["roles"]["agg"]["args"]
+    assert json.loads(real["speculative-config"]) == {**spec, "rejection_sample_method": "block"}
diff --git a/inferencex-e2e/infx/tests/srt_slurm/test_workload.py b/inferencex-e2e/infx/tests/srt_slurm/test_workload.py
index b2aca470eb..564d4b86ca 100644
--- a/inferencex-e2e/infx/tests/srt_slurm/test_workload.py
+++ b/inferencex-e2e/infx/tests/srt_slurm/test_workload.py
@@ -13,11 +13,13 @@
 from infx.clusters.slurm import Fabric
 from infx.srt_slurm.synthetic_acceptance import selected_recipes
 from infx.srt_slurm.workload import (
+    bind_multinode,
     bind_workload,
     check_setup_script,
     compose_recipe,
     parse_concurrencies,
     resolve_fabric,
+    selects_dedicated_discovery,
 )
 
 ROOT = Path(__file__).resolve().parents[3]
@@ -94,6 +96,8 @@ def test_bundles_take_the_shared_block_under_base_and_keep_their_variants(projec
     ({"base": {}, "override_c": {"benchmark": {"concurrencies": [4]}}}, False, False,
      "override_c.benchmark.concurrencies (= [4])"),
     ({"telemetry": {"enabled": True}}, False, True, "telemetry.enabled (= True)"),
+    ({"base": {"telemetry": {"cpu_power_exporter": {"source": "acpi"}}}}, True, True,
+     "base.telemetry.cpu_power_exporter (= {'source': 'acpi'})"),
     ({"benchmark": {"env": {"HF_HUB_CACHE": "/elsewhere"}}}, True, True,
      "benchmark.env.HF_HUB_CACHE (= '/elsewhere')"),
     ({"base": {"benchmark": {"env": {"RESULT_DIR": "/logs"}}}}, True, False,
@@ -108,6 +112,8 @@ def test_bundles_take_the_shared_block_under_base_and_keep_their_variants(projec
      True, True, "override_c.services[0].env.KV_OFFLOAD_BACKEND_VERSION (= '1')"),
     ({"benchmark": {"env": {"REQUIRE_POWER": "1", "MODEL": "/model"}}}, True, True,
      "benchmark.env.MODEL (= '/model'), benchmark.env.REQUIRE_POWER (= '1')"),
+    ({"base": {}, "override_c24": {"benchmark": {"env": {"SPEC_DECODING": "mtp"}}}}, True, False,
+     "override_c24.benchmark.env.SPEC_DECODING (= 'mtp')"),
 ])  # fmt: skip
 def test_a_fragment_that_sets_a_bound_key_is_rejected(project, data, agentic, multinode, reported):
     path = fragment(project, data)
@@ -153,21 +159,40 @@ def test_agentx_binding_writes_the_launchers_client_paths_without_lengths():
     assert bound["benchmark"]["env"] == {"HF_HOME": "/logs/hf", "RESULT_DIR": "/logs/agentic"}
 
 
+def test_the_launcher_reads_dedicated_discovery_without_srtctl(project, monkeypatch):
+    monkeypatch.setitem(sys.modules, "srtctl.core.config", None)
+    dedicated = [{"type": kind, "placement": {"node": "dedicated"}} for kind in ("etcd", "nats")]
+    path = fragment(project, {
+        "base": {"name": "bundle"},
+        "override_head": {"roles": {"agg": {"nodes": 2}}},
+        "override_infra": {"services": dedicated},
+    })
+
+    assert selects_dedicated_discovery(f"{path}:override_infra", agentic=True, root=project)
+    assert not selects_dedicated_discovery(f"{path}:override_head", agentic=True, root=project)
+
+
 def test_a_power_point_gets_telemetry_and_its_concurrencies_on_a_bundle_variant(project):
     path = fragment(project, {
         "base": {"name": "bundle", "telemetry": {"collector_join_timeout_seconds": 12}},
         "override_c8": {"roles": {"agg": {"nodes": 2}}},
     })
 
-    composed = compose_recipe(path, agentic=True, multinode=True, root=project, power_port=19401)
+    composed = compose_recipe(path, agentic=True, multinode=True, root=project, gpu_power=19401)
     [(_, variant)] = selected_recipes(composed, "override_c8")
-    bound = bind_workload(variant, AGENTX_ENV, agentic=True, multinode=True)
+    bound = bind_workload(variant, {**AGENTX_ENV, "POWER": "1"}, agentic=True, multinode=True)
 
     assert bound["telemetry"] == {
         "collector_join_timeout_seconds": 12, "enabled": True, "required": True,
         "dcgm_exporter": {"container_image": "dcgm-exporter", "port": 19401},
     }  # fmt: skip
     assert bound["benchmark"]["concurrencies"] == [8]
+    by_default = bind_workload(variant, AGENTX_ENV, agentic=True, multinode=True)
+    assert by_default["telemetry"]["required"] is False
+    with_cpu = compose_recipe(
+        path, agentic=True, multinode=True, root=project, gpu_power=19401, cpu_power_source="acpi"
+    )
+    assert with_cpu["base"]["telemetry"]["cpu_power_exporter"] == {"source": "acpi"}
     unpowered = compose_recipe(path, agentic=True, multinode=True, root=project)["base"]
     assert "concurrencies" not in bind_workload(unpowered, AGENTX_ENV, agentic=True, multinode=True)[
         "benchmark"
@@ -258,6 +283,7 @@ def test_the_multinode_binder_writes_the_one_selected_variant(project, tmp_path)
     })
     output = tmp_path / "bound.yaml"
     env = {**os.environ, **MULTI_ENV, "IS_AGENTIC": "0", "INFERENCEX_REPOSITORY_ROOT": str(project),
+           "FRAMEWORK": "dynamo-sglang", "SPEC_DECODING": "none",
            "PYTHONPATH": os.pathsep.join([str(ROOT), str(ROOT / "utils/srt-slurm/src")])}  # fmt: skip
 
     def bind(*arguments: str) -> subprocess.CompletedProcess[str]:
@@ -284,6 +310,35 @@ def bind(*arguments: str) -> subprocess.CompletedProcess[str]:
     assert bound["roles"]["decode"]["env"] == {"UCX": "mlx5_0:1,mlx5_1:1"}
 
 
+EAGLE = {"speculative-algorithm": "EAGLE", "speculative-num-steps": 3}
+DFLASH = {
+    "speculative-algorithm": "DFLASH", "speculative-num-steps": 7,
+    "speculative-draft-model-path": "/hf_hub_cache/models--Org--Drafter-DFlash2/snapshots/46c90f4",
+}  # fmt: skip
+
+
+@pytest.mark.parametrize(("label", "decode_args", "expected"), [
+    ("mtp", EAGLE, {"SPEC_ALGORITHM": "mtp", "SPEC_DRAFT_MODEL": "native"}),
+    ("draft_model", DFLASH, {"SPEC_ALGORITHM": "dflash", "SPEC_DRAFT_MODEL": "Org/Drafter-DFlash2"}),
+    ("none", {}, {}),
+    ("mtp", {}, "matrix 'mtp', but the generation worker does not draft"),
+    ("none", EAGLE, "matrix 'none', but the generation worker drafts"),
+])  # fmt: skip
+def test_a_multinode_spec_label_must_match_the_decode_worker(project, label, decode_args, expected):
+    path = fragment(project, {"name": "job", "roles": {
+        "prefill": {"args": {}}, "decode": {"args": decode_args},
+    }})  # fmt: skip
+    env = {**MULTI_ENV, "IS_AGENTIC": "1", "FRAMEWORK": "dynamo-sglang", "MODEL_PREFIX": "glm5.2",
+           "SPEC_DECODING": label}  # fmt: skip
+    if isinstance(expected, str):
+        with pytest.raises(ValueError, match=re.escape(expected)):
+            bind_multinode(str(path), env, root=project)
+        return
+    _, bound = bind_multinode(str(path), env, root=project)
+    workload = bound["benchmark"]["env"]
+    assert {key: workload[key] for key in workload if key.startswith("SPEC_")} == expected
+
+
 def test_fabric_references_take_the_clusters_rendering_in_env_args_and_services():
     fabric = Fabric.model_validate({
         "rdma-device-ports": ["mlx5_0:1", "mlx5_1:1"], "rdma-devices": ["rdma0", "rdma1"],
diff --git a/inferencex-e2e/infx/tests/workflows/test_ci_priority.py b/inferencex-e2e/infx/tests/workflows/test_ci_priority.py
index 13997e4447..3c0a8541ca 100644
--- a/inferencex-e2e/infx/tests/workflows/test_ci_priority.py
+++ b/inferencex-e2e/infx/tests/workflows/test_ci_priority.py
@@ -1,7 +1,4 @@
-import json
-import shlex
 from decimal import Decimal
-from pathlib import Path
 
 import pytest
 import yaml
@@ -12,11 +9,8 @@
     calculate_priority,
     load_policy,
     queue_token,
-    supported_criteria,
 )
 
-ROOT = Path(__file__).resolve().parents[4]
-
 
 @pytest.fixture
 def policy():
@@ -232,21 +226,3 @@ def test_queue_tokens_are_stable_for_reordered_keys_but_distinct_for_duplicate_j
 @pytest.mark.parametrize("framework,expected", [("vllm", "15"), ("vllm-disagg", "15"), ("vllmish", "10")])
 def test_framework_prefix_matching_requires_a_separator(policy, framework, expected):
     assert calculate_priority({"framework": framework}, policy) == Decimal(expected)
-
-
-def test_sweep_classifier_enum_covers_every_weighted_model_prefix():
-    """A model prefix missing from the classifier enum silently drops its weight from PR sweeps."""
-    workflow = yaml.safe_load((ROOT / ".github/workflows/run-sweep.yml").read_text())
-    [classify] = [
-        step
-        for job in workflow["jobs"].values()
-        for step in job.get("steps", [])
-        if step.get("name") == "Classify priority criteria"
-    ]
-    args = shlex.split(classify["with"]["claude_args"])
-    schema = json.loads(args[args.index("--json-schema") + 1])
-    enum = schema["properties"]["criteria"]["items"]["enum"]
-    assert len(enum) == len(set(enum))
-    policy = load_policy(ROOT / "inferencex-e2e/configs/ci-priority.yaml")
-    assert set(enum) <= supported_criteria(policy)
-    assert set(policy["adjustments"]["model-prefix"]) <= set(enum)
diff --git a/inferencex-e2e/infx/tests/workflows/test_find_reusable_sweep_run.py b/inferencex-e2e/infx/tests/workflows/test_find_reusable_sweep_run.py
index 95e2bc697e..3e4e5efb8c 100644
--- a/inferencex-e2e/infx/tests/workflows/test_find_reusable_sweep_run.py
+++ b/inferencex-e2e/infx/tests/workflows/test_find_reusable_sweep_run.py
@@ -559,7 +559,7 @@ def test_main_reports_recorded_external_head_and_ignores_current_labels(
     (identity_zip(head_sha="f" * 40), "disagrees with its title"),
     (identity_zip(agentx_fast="false"), "malformed source-identity"),
     (b"not a zip", "unreadable source-identity"),
-])
+], ids=["evals-only", "pr-number", "head-sha", "malformed", "unreadable"])
 def test_main_rejects_by_recorded_external_identity(monkeypatch, tmp_path, archive, reason) -> None:
     with pytest.raises(RuntimeError, match=reason):
         run_external_reuse(monkeypatch, tmp_path, EXTERNAL_RUN, identity=archive)
diff --git a/inferencex-e2e/infx/tests/workflows/test_launch_layout.py b/inferencex-e2e/infx/tests/workflows/test_launch_layout.py
index 1e3ab04092..35ee44124c 100644
--- a/inferencex-e2e/infx/tests/workflows/test_launch_layout.py
+++ b/inferencex-e2e/infx/tests/workflows/test_launch_layout.py
@@ -28,7 +28,7 @@
 Path(result + ".json").write_text("{}\\n")
 Path(result + "_conc1.json").write_text('{"num_requests_successful": 1}\\n')
 Path("profile_" + result + ".trace.json.gz").write_bytes(b"fixture trace")
-Path("speedbench-reference-al.yaml").write_text("fixture: 1\\n")
+Path("speedbench-reference-al.yaml").write_text("fixture:\\n  thinking_on:\\n    1: 1.50\\n")
 """
 
 
@@ -130,7 +130,7 @@ def test_launch_runs_the_python_entrypoint_from_the_project_root(tmp_path, workf
     exported = dict(line.split("=", 1) for line in github_env.read_text().splitlines())
     assert exported["INFERENCEX_E2E_ROOT"] == str(project.resolve())
     if workflow == "speedbench-al.yml":
-        assert "fixture: 1" in summary.read_text()
+        assert "    1: 1.50" in summary.read_text()
     else:
         assert (project / (exported["RESULT_FILENAME"] + ".json")).read_text() == "{}\n"
     if workflow == "profile.yml":
diff --git a/inferencex-e2e/infx/tests/workflows/test_pr_checklist.py b/inferencex-e2e/infx/tests/workflows/test_pr_checklist.py
new file mode 100644
index 0000000000..f54a449afb
--- /dev/null
+++ b/inferencex-e2e/infx/tests/workflows/test_pr_checklist.py
@@ -0,0 +1,44 @@
+import pytest
+
+from infx.workflows.pr_checklist import checklist_complete
+
+TEMPLATE = """## Summary
+
+- [ ] Unrelated task outside the checklist
+
+<details>
+<summary>PR checklist and change type</summary>
+
+## Type of Change
+
+- [ ] Bug fix
+
+## Checklist
+
+- [{tested}] I have tested my changes locally
+- [{changelog}] **If `python -m infx.matrix.changed` lists affected config keys, I have appended one entry**
+- [ ] **Before merging via reuse, an authorized maintainer has commented `/use <run_id>`**
+
+</details>
+
+- [ ] Trailing task after the section
+"""
+
+
+@pytest.mark.parametrize(
+    ("tested", "changelog", "expected"),
+    [
+        ("x", "x", True),
+        ("X", " ", True),
+        (" ", "x", False),
+    ],
+)
+def test_only_conditional_items_may_stay_unchecked(tested, changelog, expected):
+    body = TEMPLATE.format(tested=tested, changelog=changelog)
+
+    assert checklist_complete(body) is expected
+
+
+def test_missing_or_empty_checklist_is_incomplete():
+    assert checklist_complete("## Summary\n\n- [x] Done\n") is False
+    assert checklist_complete("## Checklist\n\nNothing here.\n\n## Notes\n- [x] Done\n") is False
diff --git a/inferencex-e2e/infx/tests/workflows/test_signoff_facts.py b/inferencex-e2e/infx/tests/workflows/test_signoff_facts.py
index e8fc0572ee..21c154d75b 100644
--- a/inferencex-e2e/infx/tests/workflows/test_signoff_facts.py
+++ b/inferencex-e2e/infx/tests/workflows/test_signoff_facts.py
@@ -240,8 +240,8 @@ def test_image_refs_normalize_registry_separator():
 
 @pytest.mark.parametrize(("framework", "setting", "pinned", "matches"), [("dynamo-trt", 2.5, 2.5, True), ("vllm", 3.5, 2.5, False)])
 def test_golden_al_subtracts_bonus_token_only_for_trt(monkeypatch, framework, setting, pinned, matches):
-    monkeypatch.setattr(signoff_facts.curves, "curve_name", lambda model, spec: "m_mtp")
-    monkeypatch.setattr(signoff_facts.curves, "golden_length", lambda model, spec, thinking: 3.5)
+    monkeypatch.setattr(signoff_facts.curves, "curve_name", lambda model, spec, verify=None: "m_mtp")
+    monkeypatch.setattr(signoff_facts.curves, "golden_length", lambda model, spec, thinking, verify=None: 3.5)
     report = signoff_facts.golden_al("m", {}, "thinking_on", framework, pinned)
     assert report["expected_setting"] == setting
     assert report["matches"] is matches
diff --git a/inferencex-e2e/infx/workflows/ci_priority.py b/inferencex-e2e/infx/workflows/ci_priority.py
index 8f3b5a7220..1982ec8e6b 100755
--- a/inferencex-e2e/infx/workflows/ci_priority.py
+++ b/inferencex-e2e/infx/workflows/ci_priority.py
@@ -252,9 +252,17 @@ def main() -> int:
         type=Path,
         help="Read matrix JSON from this file instead of stdin",
     )
+    parser.add_argument(
+        "--list-criteria",
+        action="store_true",
+        help="Print the policy's supported criteria as a JSON array and exit",
+    )
     args = parser.parse_args()
 
     policy = load_policy(args.policy)
+    if args.list_criteria:
+        print(json.dumps(sorted(supported_criteria(policy))))
+        return 0
     context = PriorityContext(
         event_name=args.event_name,
         queue_namespace=args.queue_namespace,
diff --git a/inferencex-e2e/infx/workflows/pr_checklist.py b/inferencex-e2e/infx/workflows/pr_checklist.py
new file mode 100644
index 0000000000..039e1342e3
--- /dev/null
+++ b/inferencex-e2e/infx/workflows/pr_checklist.py
@@ -0,0 +1,42 @@
+"""Decide whether a PR description's author checklist is complete.
+
+The checklist is the task list under the ``## Checklist`` heading of the PR template.
+Every item must be checked except conditional ones ("If ...", "Before merging ..."),
+which may stay unchecked until they apply.
+"""
+
+from __future__ import annotations
+
+import re
+import sys
+
+CHECKLIST_HEADING = re.compile(r"^#{1,6}\s+Checklist\s*$")
+ANY_HEADING = re.compile(r"^#{1,6}\s")
+SECTION_END = re.compile(r"^\s*</details>")
+TASK_ITEM = re.compile(r"^- \[([ xX])\]\s+(.*)$")
+CONDITIONAL = re.compile(r"^(If|Before merging)\b")
+
+
+def checklist_complete(body: str) -> bool:
+    """Return True when the Checklist section exists and every unconditional item is checked."""
+    items: list[tuple[bool, str]] = []
+    in_section = False
+    for line in body.splitlines():
+        if CHECKLIST_HEADING.match(line):
+            in_section = True
+            continue
+        if in_section and (ANY_HEADING.match(line) or SECTION_END.match(line)):
+            break
+        if in_section and (match := TASK_ITEM.match(line)):
+            items.append((match.group(1) != " ", match.group(2).lstrip("*").strip()))
+    return bool(items) and all(checked or CONDITIONAL.match(text) for checked, text in items)
+
+
+def main() -> int:
+    """Read a PR description from stdin and print true or false."""
+    print("true" if checklist_complete(sys.stdin.read()) else "false")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/inferencex-e2e/infx/workflows/signoff_facts.py b/inferencex-e2e/infx/workflows/signoff_facts.py
index c5d32549bf..22c9ba31a1 100644
--- a/inferencex-e2e/infx/workflows/signoff_facts.py
+++ b/inferencex-e2e/infx/workflows/signoff_facts.py
@@ -603,10 +603,15 @@ def _inspect(reference: str) -> dict[str, Any]:
 
 
 def golden_al(
-    model: str, spec: dict[str, Any], thinking: str, framework: str, pinned: float | None
+    model: str,
+    spec: dict[str, Any],
+    thinking: str,
+    framework: str,
+    pinned: float | None,
+    verify: str | None = None,
 ) -> dict[str, Any]:
-    name = curves.curve_name(model, spec)
-    expected = curves.golden_length(model, spec, thinking)
+    name = curves.curve_name(model, spec, verify=verify)
+    expected = curves.golden_length(model, spec, thinking, verify=verify)
     trt = "trt" in framework.lower()
     setting = expected - 1 if trt else expected
     report = {
@@ -814,6 +819,7 @@ def main(argv: list[str] | None = None) -> None:
     al.add_argument("--framework", required=True)
     al.add_argument("--draft-model", default="")
     al.add_argument("--draft-sample-method")
+    al.add_argument("--verify", choices=("standard", "block", "relaxed"))
     al.add_argument("--pinned", type=float, help="value set in the recipe")
 
     args = parser.parse_args(argv)
@@ -849,7 +855,9 @@ def main(argv: list[str] | None = None) -> None:
             "draft_sample_method": args.draft_sample_method,
         }
         try:
-            report = golden_al(args.model, spec, args.thinking, args.framework, args.pinned)
+            report = golden_al(
+                args.model, spec, args.thinking, args.framework, args.pinned, args.verify
+            )
         except ValueError as error:
             parser.exit(1, f"no golden AL: {error}\n")
     json.dump(report, sys.stdout, separators=(",", ":"), default=str)
diff --git a/inferencex-e2e/perf-changelog.yaml b/inferencex-e2e/perf-changelog.yaml
index 51fbda91ac..ed22487f59 100644
--- a/inferencex-e2e/perf-changelog.yaml
+++ b/inferencex-e2e/perf-changelog.yaml
@@ -11771,9 +11771,286 @@
   pr-link: https://github.com/SemiAnalysisAI/InferenceX/pull/4686
 
 - config-keys:
-    - glm5.3flash-fp8-gb300-sglang-agentic-mtp
+    - glm5.2-fp4-mi355x-sglang-agentic-mtp
+  scenario-type:
+    - agentic-coding
+  description:
+    - "Update the image for all three arms (TP4/EP4 HiCache, TP4/EP4 DCP4, TP8/EP1) from lmsysorg/sglang:v0.5.22-rocm720-mi35x (digest-pinned release) to the lmsysorg/sglang-rocm:v0.5.22-rocm720-mi35x-20261028 nightly, built from SGLang main e0df901d."
+    - "Add TP4/EP4 points with decode context parallelism (DCP4) at concurrency 16, 24, 40 and 48. The latent KV is striped across the four ranks, so these points keep KV on the GPU without HiCache, which SGLang rejects with DCP."
+    - "DCP4 points keep the base recipe: EAGLE with 5 steps, top-k 1 and 6 draft tokens, an FP8 KV cache and the Triton DSA prefill and decode backends. Admission (max-running-requests) is 32, 48, 80 and 96, twice the concurrency, and the decode CUDA graph limit is 32, 48, 64 and 64."
+    - "The new image adds sgl-project/sglang#44322, which enables DCP on the Triton sparse-MLA backend on ROCm, including FP8 KV writes and MTP draft sharding. It also adds DSA fixes for MTP draft decode (#42565) and GLM-5.2 CUDA-graph side-stream replay (#45349). #43735 (DSA DCP with MTP) was already in v0.5.22."
+    - "Draft data types are unchanged: the MTP layer 78 ships in BF16 and is listed in the checkpoint's Quark exclude list, so SGLang loads it unquantized at both the old and new commits. Its KV cache is FP8, shared with the target."
+  pr-link: https://github.com/SemiAnalysisAI/InferenceX/pull/4064
+
+- config-keys:
+    - minimaxm31flash-fp4-mi355x-sglang-agentic-dspark
+  description:
+    - "Conc 48 and 64 move to the cookbook's High-Throughput cell: HiCache with 180 GB of host KV per rank written back on eviction (KV_OFFLOADING=dram, 734 GB declared for 4 of 8 GPUs), mem-fraction-static 0.8, default bf16 draft KV."
+    - "Back the HiCache host pools with hipHostMalloc (HSA_USERPTR_FOR_PAGED_MEM=0) instead of registered pageable memory, which faulted at the first HiCache write on MI355X."
+    - "Set HF_HOME so srtctl pre-downloads the model into the shared HF cache, which lacked preprocessor_config.json and stopped every MI355X server at startup."
+  pr-link: https://github.com/SemiAnalysisAI/InferenceX/pull/4694
+  scenario-type: [agentic-coding]
+
+- config-keys:
+    - minimaxm31flash-fp4-mi355x-vllm-agentic-dspark
+  scenario-type: [agentic-coding]
+  description:
+    - "Image unchanged: vllm/vllm-openai-rocm:minimax-m31-flash (vLLM 0.32.0rc1.dev364+g8d0f05a0c) on amd/MiniMax-M3.1-Flash-Quark-MXFP4, so no upstream framework change."
+    - "Search space: TP4 c1-c32 without KV offloading, and c64 moves to a new TP4 point with host-DRAM KV offload (vllm-simple, agentic.yaml:override_tp4_dspark3_c64_offload); dram-utilization 0.80 -> 0.90."
+    - "C1-C8 are unchanged (DSpark 7, mono decode, FP8 KV and indexer caches, 0.85 memory utilization)."
+    - "C16/C32 (from #4537): DSpark 3 -> 7 on the NVFP4 KV cache with DBO, max-num-seqs 32/64; the base gpu-memory-utilization drops 0.9 -> 0.85 for DBO prefill headroom. Throughput runs use the minimaxm31flash_dspark golden AL, which covers 7 drafts."
+    - "C64 (from #4463): DSpark 3 at 0.9 memory utilization, max-num-seqs 128, plus SimpleCPUOffloadConnector (eager, cpu_bytes_to_use 1349 GB): 185,025 CPU blocks (about 23.7M tokens) beside the 14.6M-token GPU KV cache in run 41003224750."
+    - "C64 also sets PYTHONHASHSEED=42 and VLLM_ROCM_MINIMAX_M3_SP_PREFILL=1. Sequence-parallel prefill stays off on this checkpoint: at 8d0f05a0c it needs an MXFP8 kernel on layer.quant_method.kernel, which the Quark linear method does not expose, and every rank logs it as off."
+    - "Draft data types unchanged: the dspark/ draft loads with its own MXFP8 config (FP8 E4M3 attention and FFN projections with 1x32 UE8M0 scales; BF16 fc, Markov and confidence heads, norms) and an FP8 draft KV cache. Only its length changes, at C16/C32."
+  pr-link: https://github.com/SemiAnalysisAI/InferenceX/pull/4671
+
+- config-keys:
+    - minimaxm31flash-fp4-gb300-dynamo-sglang-agentic-dspark-agg
+    - minimaxm31flash-fp4-gb300-dynamo-sglang-agentic-dspark-disagg
+  scenario-type: [agentic-coding]
+  description:
+    - "Add aggregated SGLang behind Dynamo for MiniMax-M3.1-Flash AgentX on GB300 with lmsysorg/sglang:nightly-cu134-20261030-e371881: TP4 at conc 1-16; TP4 with HiCache 180 GB per rank, shortest-prefill-first and prefill-decode interval 32 at conc 24; TP2 with HiCache 180 GB per rank at conc 40 (with and without shortest-prefill-first) and 44."
+    - "Disagg prefill chunk 16384 (8192 per DP rank); add 4 DEP2 prefill workers with a DEP8 decode at conc 224 and 256, 8 DEP2 prefill workers with a DEP8 decode at conc 440 and 480, conc 340 on the 6 DEP2 + DEP8 shape, and conc 360 and 400 on the 6 DEP2 + DEP16 shape."
+  pr-link: https://github.com/SemiAnalysisAI/InferenceX/pull/4698
+
+- config-keys:
+    - qwen3.5-fp4-b200-sglang
+    - qwen3.5-fp4-b200-sglang-mtp
+    - qwen3.5-fp4-b200-trt
+    - qwen3.5-fp4-b200-trt-mtp
+    - qwen3.5-fp4-b300-sglang
+    - qwen3.5-fp4-b300-sglang-mtp
+    - qwen3.5-fp4-gb200-dynamo-sglang-mtp
+    - qwen3.5-fp4-gb300-dynamo-sglang
+    - qwen3.5-fp4-gb300-dynamo-trt
+    - qwen3.5-fp4-gb300-dynamo-trt-mtp
+    - qwen3.5-fp4-mi355x-atom
+    - qwen3.5-fp4-mi355x-sglang
+    - qwen3.5-fp4-mi355x-sglang-disagg
+    - qwen3.5-fp4-mi355x-sglang-mtp
+    - qwen3.5-fp8-b200-sglang
+    - qwen3.5-fp8-b200-sglang-mtp
+    - qwen3.5-fp8-b300-sglang
+    - qwen3.5-fp8-b300-sglang-mtp
+    - qwen3.5-fp8-gb200-dynamo-sglang
+    - qwen3.5-fp8-gb200-dynamo-sglang-mtp
+    - qwen3.5-fp8-gb300-dynamo-sglang
+    - qwen3.5-fp8-gb300-dynamo-sglang-mtp
+    - qwen3.5-fp8-h100-sglang
+    - qwen3.5-fp8-h100-sglang-mtp
+    - qwen3.5-fp8-h200-sglang
+    - qwen3.5-fp8-h200-sglang-mtp
+    - qwen3.5-fp8-mi300x-sglang
+    - qwen3.5-fp8-mi325x-sglang
+    - qwen3.5-fp8-mi325x-sglang-mtp
+    - qwen3.5-fp8-mi355x-atom
+    - qwen3.5-fp8-mi355x-atom-mtp
+    - qwen3.5-fp8-mi355x-sglang
+    - qwen3.5-fp8-mi355x-sglang-disagg
+    - qwen3.5-fp8-mi355x-sglang-mtp
+  retired: true
+  description:
+    - "Retire Qwen3.5 8k1k serving configurations across NVIDIA and AMD and remove their unused recipes."
+    - "Keep Qwen3.5 AgentX coverage, SPEED-Bench collectors, and historical results unchanged."
+  pr-link: https://github.com/SemiAnalysisAI/InferenceX/pull/4697
+
+- config-keys:
+    - dsv41flash-fp4-mi355x-vllm-agentic-dspark-tp8-c1
+  scenario-type:
+    - agentic-coding
+  description:
+    - "New key on vllm/vllm-openai-rocm:nightly-335dd77b09161c5d63139b4e7ae51bb9928305b1 (2026-10-30, digest sha256:3c634cc2c51eda7eb840a236b1f09a5ecf6a4b0cb92c4b8486e2158770507291, the same digest as nightly-rocm100-335dd77b09161c5d63139b4e7ae51bb9928305b1). The TP4/TP2 key dsv41flash-fp4-mi355x-vllm-agentic-dspark stays on nightly-e68efc685ab1e6f1eda004ced7157e3ca411da2f."
+    - "Add one point: TP8, concurrency 1, no KV offloading. The TP4/TP2 search space is unchanged and is not rerun."
+    - "The new override_tp8_c1 recipe variant uses the same settings as TP4 c1: tensor-parallel-size 8, GPU-resident Engram tables, max-num-seqs 1, max-cudagraph-capture-size 8 and max-num-batched-tokens 32768. Shared settings are unchanged: --monokernel, five-token DSpark with probabilistic drafting, block size 128, the MXFP4 sparse-logits indexer and INT4 quick all-reduce."
+    - "The image carries vllm-project/vllm#64101, which lets the mono decode kernels run at TP8 on gfx950 (each rank's 8 heads are padded into one 16-head MFMA tile); earlier nightlies stop at startup with --monokernel outside TP2/TP4. Compared with e68efc685 it also includes #63885 (SWA decode metadata in one launch), #60154 (inverse RoPE and MXFP8 quant fused into the AITER sparse MLA), #63179 and #63915 (MXFP8 activation quant fused into small-M linears), #63576 and #63689 (mono decode fixes), and #63047 (prefill memory budget)."
+    - "Draft data types unchanged: the DSpark draft (mtp.0-2 in the target checkpoint) loads with the checkpoint's FP8 config, as shipped (FP8 E4M3 with 32x32 UE8M0 scales for attention, shared experts and main_proj, MXFP4 routed experts, BF16 gate, norms and heads), inherits the target fp8_ds_mla KV cache, and the mono draft kernels read those weights in place."
+  pr-link: https://github.com/SemiAnalysisAI/InferenceX/pull/4666
+
+- config-keys:
+    - dsv41flash-fp4-mi355x-vllm-agentic-dspark
+    - dsv41flash-fp4-mi355x-vllm-agentic-dspark-tp8-c1
+  scenario-type: [agentic-coding]
+  description:
+    - "Disable integer QuickReduce in the shared DeepSeek-V4.1-Flash MI355X vLLM recipe by setting VLLM_ROCM_QUICK_REDUCE_QUANTIZATION to NONE instead of INT4."
+    - "This supersedes the preceding entry's INT4 setting and TP8-only sweep scope: rerun both the existing TP4/TP2 grid and the new TP8 c1 point with integer QuickReduce disabled. Images, search spaces and draft precision are unchanged."
+  pr-link: https://github.com/SemiAnalysisAI/InferenceX/pull/4666
+
+- config-keys:
+    - qwen3.8next-fp4-mi355x-sglang-agentic-mtp
+  scenario-type:
+    - agentic-coding
+  description:
+    - "Move the MI355X Qwen3.8-Flash-Next SGLang AgentX recipe to lmsysorg/sglang-rocm:v0.5.23-rocm10-mi35x-20261031@sha256:3867dc07ba2530f914e1f210ed829f7a572a75286c8c362dbc22cbecf9b5a7e6. This nightly's SGLang pins sgl-amd-mono at b10f3b71 (sglang #47483, the merge of sgl-amd-mono #29), so the checkout setup script is removed and no patch is applied."
+    - "c1, c2, c4 and c8 enable the FlyDSL monokernel (--enable-amd-monokernel) for MTP target verify and draft. The kernel writes the per-draft intermediate SSM states and reads the PLE table on the GPU, so those points drop ReplaySSM and PLE offload and admit CONC requests (max-running-requests = cuda-graph-max-bs-decode = 1, 2, 4 and 8). c12 and c16 stay on the round 03 default path: ReplaySSM, PLE offload, and 2x CONC admission. Integer all-reduce stays off (ROCM_QUICK_REDUCE_QUANTIZATION=NONE)."
+    - "The monokernel reads the FP8 and MXFP4 weights in place, keeps per-token FP8 activations for the W8A8 projections and runs the MoE on BF16 activations (a16w4), where the default path quantizes them to MXFP4. c1-c8 also set SGLANG_USE_AITER=1, which the monokernel requires and the image already sets, so they get their own GSM8K eval at c8."
+    - "Every point now serves the model's default thinking-on chat template: the recipe no longer passes --default-chat-template-kwargs '{\"enable_thinking\": false}', so the served mode matches the thinking_on golden AL (2.32 at 3 draft tokens) and the other qwen3.8next recipes."
+  pr-link: https://github.com/SemiAnalysisAI/InferenceX/pull/4542
+
+- config-keys:
+    - minimaxm31flash-fp4-gb300-dynamo-sglang-agentic-dspark-disagg
+    - minimaxm31flash-fp4-gb300-dynamo-sglang-agentic-dspark-agg
+  description:
+    - "Add 6P DEP2 + DEP16 points at conc 220, 240 and 260, and a TP4 MonoKernel point at conc 1."
+  pr-link: https://github.com/SemiAnalysisAI/InferenceX/pull/4750
+  scenario-type: [agentic-coding]
+  append-only: true
+
+- config-keys:
+    - glm5.2-fp8-b300-sglang-agentic-mtp
+  description:
+    - "Rerun the unchanged FP8 config to collect GPU-board power. Its published curve (2026-10-14) predates B300 single-node power collection and carries no power fields."
+  pr-link: https://github.com/SemiAnalysisAI/InferenceX/pull/4702
+  scenario-type: [agentic-coding]
+
+- config-keys:
+    - dsv41flash-fp4-mi355x-atom-agentic-dspark
+  description:
+    - "Rerun the unchanged config to collect GPU-board power. Its published curve (2026-10-13) predates MI355X ATOM power collection and carries no power fields."
+  pr-link: https://github.com/SemiAnalysisAI/InferenceX/pull/4703
+  scenario-type: [agentic-coding]
+
+- config-keys:
+    - glm5.2-fp4-b200-dynamo-sglang-agentic-agg
+    - glm5.2-fp4-b200-dynamo-sglang-agentic-disagg
+  description:
+    - "Collect GPU-board power for the six aggregated and two disaggregated GLM-5.2 B200 Dynamo-SGLang AgentX points, which currently publish no power."
+    - "Move the disaggregated key from the pruned lmsysorg/sglang:nightly-dev-20260910-00840301 tag (Docker Hub 404) to the digest-pinned v0.5.22-cu130 image the aggregated key already serves."
+    - "Concurrency points and evaluation coverage are unchanged."
+  pr-link: https://github.com/SemiAnalysisAI/InferenceX/pull/4656
+  scenario-type: [agentic-coding]
+
+- config-keys:
+    - qwen3.8next-fp4-gb300-sglang-agentic-mtp
+  description:
+    - "Require valid measured GPU power for the Qwen3.8 GB300 AgentX sweep."
+  pr-link: https://github.com/SemiAnalysisAI/InferenceX/pull/4552
+  scenario-type: [agentic-coding]
+
+- config-keys:
+    - qwen3.8next-fp4-b300-sglang-agentic-mtp
+  scenario-type:
+    - agentic-coding
+  description:
+    - "Update Qwen3.8-Flash-Next FP4 B300 SGLang AgentX to nvidia/Qwen3.8-Flash-Next-NVFP4 on lmsysorg/sglang:nightly-dev-cu13-20261028-586355a8 (digest-pinned)."
+    - "Update the search space to TP4/EP4 at concurrency 1 and 2, TP1/EP1 at concurrency 1, 2, 12 and 24, and TP1/EP1 with HiCache at concurrency 48 and 80."
+    - "Switch the target and draft KV caches from BF16 to FP8 E4M3 at concurrency 12, 24, 48 and 80."
+  pr-link: https://github.com/SemiAnalysisAI/InferenceX/pull/4683
+
+- config-keys:
+    - dsv41flash-fp4-gb300-sglang-agentic-dspark
+  description:
+    - "Update the SGLang image from nightly-dev-cu13-20261021-c1c287a4 to nightly-dev-cu13-20261030-302b78cc, pinned by digest. The image includes sgl-project/sglang#46404 (DSpark simulated-acceptance bonus drawn at the simulated row), #46840 (simulated acceptance keeps the real verify accept cost), #46891 (no host sync in DSpark draft-block metadata) and sgl-nvidia-mega 54b428921749 (megakernel API 2, sgl-project/sglang#47145)."
+    - "TP4 c1 runs the NVIDIA megakernel (fp8_e4m3 KV cache, mem-fraction-static 0.91, decode graph batch 1, Engram host table) with SGLANG_ENABLE_NV_MEGA_RUNTIME_OPTIMIZATION=1 (sgl-project/sglang#47105), which enables the DSpark and Qwen3.5/EAGLE megakernel runtime optimizations; DSpark simulated draws run ahead of the draft launch (SGLANG_OPT_DSV41_DSPARK_SIM_DRAW_AHEAD)."
+    - "TP4 c1/c4/c16 and TP2/EP2 c16/c32 pin dsv4-attn-backend flashmla; auto resolves to MegaAttention, which zero-pads per-rank attention heads to 64. DP-attention points are unchanged."
+  pr-link: https://github.com/SemiAnalysisAI/InferenceX/pull/4603
+  scenario-type: [agentic-coding]
+
+- config-keys:
+    - minimaxm31flash-fp4-b300-sglang-agentic-dspark
+  description:
+    - "Add TP4 points with DRAM KV offload at conc 20, 44, 52 and 60, and a TP4 point without offload at conc 16, using shortest-prefill-first with a prefill-decode interval of 32."
+    - "Add a TP2 point with DRAM KV offload at conc 44 using shortest-prefill-first with a prefill-decode interval of 32."
+    - "Add TP2 points with DRAM KV offload and a larger HBM KV pool (mem-fraction-static 0.93) at conc 50 and 52 using shortest-prefill-first with a prefill-decode interval of 20."
+  pr-link: https://github.com/SemiAnalysisAI/InferenceX/pull/4726
+  scenario-type: [agentic-coding]
+  append-only: true
+
+- config-keys:
+    - minimaxm31flash-fp4-gb300-vllm-agentic-dspark
+  description:
+    - "Retune TP4 c8 and c16 with CUDA graph capture sizes, add TP4 c24 and c40 points, and add TP2 c28, c32 and c36 points with CPU KV offload."
+    - "Image and speculative config are unchanged."
+  pr-link: https://github.com/SemiAnalysisAI/InferenceX/pull/4662
   scenario-type: [agentic-coding]
+
+- config-keys:
+    - kimik3-fp4-gb300-dynamo-vllm-agentic-dspark-mooncake-dcp8-agg
+  scenario-type:
+    - agentic-coding
+  description:
+    - "Collect Grace CPU power on the Kimi K3 GB300 aggregate AgentX recipe, with cpu-power-exporter v2.66.1."
+    - "Publish CPU socket, rail, SysIO and module power over the GPU window, independent of the GPU verdict, and per-host GPU power in workers[]."
+  pr-link: https://github.com/SemiAnalysisAI/InferenceX/pull/3296
+
+- config-keys:
+    - musespark-fp4-b300-sglang-agentic-dflash
+  scenario-type:
+    - agentic-coding
+  description:
+    - "Update the Muse Spark Open B300 curve to lmsysorg/sglang:nightly-dev-cu13-20261030-302b78cc; run TP8/EP8 at concurrency 1, 4, 7, 16, 20, 24 and TP4/EP4 HiCache at concurrency 16, 28, 32, 38, 48."
+    - "Disable prefill CUDA graphs at TP4 with mem-fraction-static 0.92 and keep breakable prefill graphs at TP8; retune request admission, prefill-decode interval and stream interval per concurrency, with 250 GB per-rank HiCache and SWA/full ratio 0.2 at concurrency 32 and 38."
+  pr-link: https://github.com/SemiAnalysisAI/InferenceX/pull/4725
+
+- config-keys:
+    - musespark-fp4-gb300-sglang-agentic-dflash
+  scenario-type:
+    - agentic-coding
+  description:
+    - "Update the Muse Spark Open GB300 curve to lmsysorg/sglang:nightly-dev-cu13-20261030-302b78cc and retune request admission, prefill-decode interval, scheduling and host cache per concurrency."
+    - "Add TP4/EP4 concurrency 4 and 40; drop concurrency 5, 28 and 34."
+  pr-link: https://github.com/SemiAnalysisAI/InferenceX/pull/4724
+
+- config-keys:
+    - kimik3-fp4-mi355x-atom-agentic-mtp
+    - kimik3-fp4-mi355x-vllm-agentic-mtp
+    - kimik3-fp4-mi355x-vllm-disagg-agentic
+    - kimik3-fp4-h200-vllm-agentic-latency
+    - kimik3-fp4-h200-vllm-agentic-balanced
+    - kimik3-fp4-h200-vllm-agentic-simple
+    - kimik3-fp4-b300-vllm-agentic-dspark
+    - kimik3-fp4-gb200-dynamo-vllm-agentic
+    - kimik3-fp4-gb200-dynamo-vllm-agentic-dspark-mooncake-dcp16-agg
+    - kimik3-fp4-gb200-dynamo-vllm-agentic-mooncake-dcp16-agg
+    - kimik3-fp4-gb200-dynamo-vllm-agentic-dspark-mooncake-tp8pp2
+    - kimik3-fp4-gb300-dynamo-vllm-agentic-dspark-mooncake-dcp8-disagg
+    - kimik3-fp4-gb300-dynamo-vllm-agentic-dspark-mooncake-dep16-disagg
+    - kimik3-fp4-gb300-dynamo-vllm-agentic-dspark-mooncake-dcp8-agg
+    - kimik3-fp4-b200-dynamo-vllm-agentic-dspark
+    - kimik3-fp4-gb200-dynamo-vllm-agentic-dspark-mooncake-dcp16-disagg
+  description:
+    - "Retire all Kimi-K3 serving benchmarks and remove unused recipes and launch routing."
+    - "Keep historical results, SPEED-Bench collectors, golden AL curves, vendor evals and OperatorX shapes."
+  pr-link: https://github.com/SemiAnalysisAI/InferenceX/pull/4762
+  retired: true
+
+- config-keys:
+    - dsr1-fp8-mi300x-sglang
+    - dsr1-fp8-mi325x-sglang
+    - dsr1-fp8-mi355x-sglang-mtp
+  description:
+    - "Collect per-socket AMD EPYC CPU package power beside GPU power on the MI300X, MI325X and MI355X srt-slurm clusters. Native power points on a cluster that declares a cpu-power-exporter measure CPU power by default; these 8k1k rows set cpu-power, so a missing CPU leg counts as invalid. RAPL jobs get the root-only counters until teardown, and setup installs the pinned cpu-power-exporter release."
+    - "Integrate each package over the formal GPU measurement window and emit cpu_power_valid, avg_cpu_socket_power_w, avg_total_cpu_power_w, and total_cpu_energy_j with sensor_kind rapl_package; RAPL reports no component rails. Concurrency points and evaluation coverage are unchanged."
+  pr-link: https://github.com/SemiAnalysisAI/InferenceX/pull/4154
+  scenario-type: [fixed-seq-len]
+
+- config-keys:
+    - kimik3.1-fp4-b300-sglang-agentic-dflash
+  description:
+    - "Add Kimi K3.1 Pro B300 SGLang AgentX day-0 points: TP8 (c1-c16) and TP8 DCP8 EP2 (c24-c70), HiCache host offload, RadixArk DFLASH draft with block verification."
+  pr-link: https://github.com/SemiAnalysisAI/InferenceX/pull/4803
+
+- config-keys:
+    - kimik3.1-fp4-b300-vllm-agentic-dspark
+  description:
+    - "Add Kimi-K3.1-Pro day-0 vLLM AgentX on B300: TP8 x DCP8 with DSpark (Inferact/Kimi-K3.1-Pro-DSpark-preview) and Simple CPU KV offload, conc 1-70."
+  pr-link: https://github.com/SemiAnalysisAI/InferenceX/pull/4796
+
+- config-keys:
+    - kimik3.1-fp4-mi355x-sglang-agentic-dflash
+  scenario-type:
+    - agentic-coding
+  description:
+    - "Add Kimi-K3.1-Pro MXFP4 AgentX on one 8x MI355X node with SGLang (lmsysorg/sglang:dev-kimi-k31-pro-mi35x) and the DFlash2 draft at 5 draft tokens with block verification."
+    - "TP8 monokernel at concurrency 1 and 4 with GPU-resident KV; TP8/DCP8 with the HiCache host tier at concurrency 8, 16, 32 and 48."
+  pr-link: https://github.com/SemiAnalysisAI/InferenceX/pull/4808
+
+- config-keys:
+    - glm5.3flash-fp8-gb300-sglang-agentic-mtp
+    - glm5.3flash-fp4-gb300-sglang-agentic-mtp
+  scenario-type:
+    - agentic-coding
   description:
-    - "Add native SGLang GLM-5.3-Flash FP8 AgentX on GB300 with the official ARM64-capable v0.5.22-cu130 image, TP4/EP1, TRT-LLM DSA, FP8 E4M3 KV cache, and embedded EAGLE MTP 5/1/6."
-    - "Run the full AgentX corpus and 1048576-token context at concurrency 1, 2, 4, 8, 12, 16, 24, 32, 48, and 64 with shared measured golden acceptance and canonical real evals."
+    - "Add native SGLang GLM-5.3-Flash AgentX on one GB300 tray (TP4/EP1) with lmsysorg/sglang:v0.5.22-cu130, FP8 (zai-org/GLM-5.3-Flash) and NVFP4 (nvidia/GLM-5.3-Flash-NVFP4), embedded EAGLE MTP 5/1/6."
+    - "SGLang cookbook GB300 recipe: TRT-LLM DSA prefill and decode, FP8 E4M3 KV cache, flashinfer_trtllm MoE, auto reasoning and tool-call parsers; NVFP4 adds modelopt_fp4 quantization."
+    - "GPU-resident KV at concurrency 1, 4, 8, 16, 24 and 32; auto-sized HiCache host tier (--hicache-host-memory-fraction 0.90, 712.5 GB per node) at concurrency 40, 44 and 48."
   pr-link: https://github.com/SemiAnalysisAI/InferenceX/pull/4715
diff --git a/inferencex-e2e/runners/srt-slurm/hooks/common.sh b/inferencex-e2e/runners/srt-slurm/hooks/common.sh
index 5dbc215dfd..ecedaf2668 100644
--- a/inferencex-e2e/runners/srt-slurm/hooks/common.sh
+++ b/inferencex-e2e/runners/srt-slurm/hooks/common.sh
@@ -2,12 +2,12 @@
 
 # Shared host checks. Sourcing this file only defines functions.
 
-# Poll VRAM usage every 10s for up to 15 minutes. A stricter threshold is useful
-# when the engine sizes its KV cache from device-wide free memory.
+# Poll VRAM usage every 10s for up to $2 minutes (default 15). A stricter threshold
+# is useful when the engine sizes its KV cache from device-wide free memory.
 wait_for_amd_gpu_clean() {
-    local threshold="${1:-10}"
+    local threshold="${1:-10}" minutes="${2:-15}"
     local gpu_clean=false vram_max i
-    for i in $(seq 1 90); do
+    for i in $(seq 1 $((minutes * 6))); do
         vram_max=$(rocm-smi --showmemuse 2>/dev/null \
             | grep -oE "GPU Memory Allocated \(VRAM%\): [0-9]+" \
             | awk '{if ($NF > m) m = $NF} END {print m+0}')
@@ -20,7 +20,7 @@ wait_for_amd_gpu_clean() {
         sleep 10
     done
     if [ "$gpu_clean" != "true" ]; then
-        echo "Error: GPUs still draining prior job's memory after 15min" >&2
+        echo "Error: GPUs still draining prior job's memory after ${minutes}min" >&2
         return 1
     fi
 }
diff --git a/inferencex-e2e/runners/srt-slurm/hooks/mi355x-amds/setup.sh b/inferencex-e2e/runners/srt-slurm/hooks/mi355x-amds/setup.sh
index 2c281bf90b..b064419cc0 100755
--- a/inferencex-e2e/runners/srt-slurm/hooks/mi355x-amds/setup.sh
+++ b/inferencex-e2e/runners/srt-slurm/hooks/mi355x-amds/setup.sh
@@ -8,7 +8,11 @@ bash "$(dirname "${BASH_SOURCE[0]}")/check-rdma.sh"
 # the next model load fail much later with a misleading OOM.
 # shellcheck source=runners/srt-slurm/hooks/common.sh
 source "$(dirname "${BASH_SOURCE[0]}")/../common.sh"
-wait_for_amd_gpu_clean
+# After a vLLM job ends, a node can hold 3-7% VRAM per GPU with no process attached
+# for more than 30 minutes before it drains. vLLM then fails its startup free-memory
+# check, and SGLang silently caps max_running_requests below the benchmark's
+# concurrency. Clean nodes read 0%, so wait for that.
+wait_for_amd_gpu_clean 2 60
 
 # Some MI355X experiments reserve large 2 MiB HugeTLB pools and leave the
 # reservation behind after their Slurm allocation exits. Those free hugepages
diff --git a/inferencex-e2e/utils/srt-slurm b/inferencex-e2e/utils/srt-slurm
index 59920ea16a..acfb4dcc3b 160000
--- a/inferencex-e2e/utils/srt-slurm
+++ b/inferencex-e2e/utils/srt-slurm
@@ -1 +1 @@
-Subproject commit 59920ea16a13017a990e449d034a495c0b05bc57
+Subproject commit acfb4dcc3bd48fd6a1e7b615e849e7954c0c3852
diff --git a/operatorx/perf-changelog.yaml b/operatorx/perf-changelog.yaml
index a58360935f..80a3f997c2 100644
--- a/operatorx/perf-changelog.yaml
+++ b/operatorx/perf-changelog.yaml
@@ -21,3 +21,12 @@
   description-zh:
     - 新增明确标注的 Kimi K3 vLLM 基准测试配置，测量 BF16 EP8/TP8 路由专家内核。
     - 在计时前生成本地均匀路由，不包含共享专家、通信或原生 K3 的latent 投影及 SITU 层。
+- date: 2026-11-03
+  pr-link: https://github.com/SemiAnalysisAI/InferenceX/pull/4762
+  operators: [all]
+  pools: [mi355x, b300]
+  description:
+    - "Kimi-K3 serving retirement removes its inherited vLLM recipe image, env and engine args from OperatorX cases; retain the shapes and remove stale recipe names from moe_small.json."
+    - "All unmatched vLLM cases on MI355X now select vllm/vllm-openai-rocm:nightly-e68efc685ab1e6f1eda004ced7157e3ca411da2f@sha256:520e098f54ec96837228aaddea0a833cbf6374dbdffd480c1d65f26ffab7701b instead of vllm/vllm-openai-rocm:nightly-rocm100-df6603f0583375f244d1ac6d36265462b7490392."
+    - "All unmatched vLLM cases on B300 now select vllm/vllm-openai:minimax-m31-flash@sha256:86f582dae25ea92802353727164ae4eb03b37b18baf9119b805ffaec2a7ef07c instead of vllm/vllm-openai:nightly-dev-x86_64-cu13-3696c77."
+    - "No GPU performance or compatibility evidence is claimed for these runtime changes; new results must retain image and recipe provenance."
diff --git a/operatorx/testlists/moe_small.json b/operatorx/testlists/moe_small.json
index dc85519c60..b23eebaceb 100644
--- a/operatorx/testlists/moe_small.json
+++ b/operatorx/testlists/moe_small.json
@@ -2004,9 +2004,6 @@
     },
     "sources": [
       "moonshotai/Kimi-K3/block_sparse_moe"
-    ],
-    "recipes": [
-      "kimik3-fp4-mi355x-vllm-agentic-mtp"
     ]
   },
   {
@@ -5881,9 +5878,6 @@
     },
     "sources": [
       "moonshotai/Kimi-K3/block_sparse_moe"
-    ],
-    "recipes": [
-      "kimik3-fp4-mi355x-vllm-agentic-mtp"
     ]
   },
   {
@@ -5966,9 +5960,6 @@
     },
     "sources": [
       "moonshotai/Kimi-K3/block_sparse_moe"
-    ],
-    "recipes": [
-      "kimik3-fp4-mi355x-vllm-agentic-mtp"
     ]
   },
   {
@@ -6051,9 +6042,6 @@
     },
     "sources": [
       "moonshotai/Kimi-K3/block_sparse_moe"
-    ],
-    "recipes": [
-      "kimik3-fp4-mi355x-vllm-agentic-mtp"
     ]
   },
   {
@@ -6136,9 +6124,6 @@
     },
     "sources": [
       "moonshotai/Kimi-K3/block_sparse_moe"
-    ],
-    "recipes": [
-      "kimik3-fp4-mi355x-vllm-agentic-mtp"
     ]
   },
   {

From 6417fae7864f4ed9168f82565c17cd4deec9a5c7 Mon Sep 17 00:00:00 2001
From: Oseltamivir <58582368+Oseltamivir@users.noreply.github.com>
Date: Thu, 5 Nov 2026 20:15:20 +0800
Subject: [PATCH 12/14] feat(bench): move GLM-5.3-Flash GB300 lanes to SGLang
 v0.5.23

Pin lmsysorg/sglang:v0.5.23-cu130 for the FP8 and NVFP4 GB300 lanes and
declare the expected SGLang version and FP8 checkpoint revision in the
recipe identities.
---
 .../glm5.3flash/sglang/gb300-fp4-mtp/agentic.yaml           | 2 ++
 .../glm5.3flash/sglang/gb300-fp8-mtp/agentic.yaml           | 6 ++++++
 inferencex-e2e/configs/nvidia-master.yaml                   | 4 ++--
 inferencex-e2e/perf-changelog.yaml                          | 2 +-
 4 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/glm5.3flash/sglang/gb300-fp4-mtp/agentic.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/glm5.3flash/sglang/gb300-fp4-mtp/agentic.yaml
index 6fc8305bf6..c511341d04 100644
--- a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/glm5.3flash/sglang/gb300-fp4-mtp/agentic.yaml
+++ b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/glm5.3flash/sglang/gb300-fp4-mtp/agentic.yaml
@@ -5,6 +5,8 @@ base:
     model:
       revision: 1d00738646cbb0c6d0a9eb403dac5f366f1473a7
     container: {}
+    frameworks:
+      sglang: 0.5.23
   resources:
     gpu_type: gb300
     gpus_per_node: 4
diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/glm5.3flash/sglang/gb300-fp8-mtp/agentic.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/glm5.3flash/sglang/gb300-fp8-mtp/agentic.yaml
index 53e68a3168..b54ee6e7a7 100644
--- a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/glm5.3flash/sglang/gb300-fp8-mtp/agentic.yaml
+++ b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/glm5.3flash/sglang/gb300-fp8-mtp/agentic.yaml
@@ -1,6 +1,12 @@
 base:
   schema: 2
   name: glm5.3flash-fp8-gb300-sglang-agentic-mtp
+  identity:
+    model:
+      revision: 46a050bec13002ad29ee795c16e61cf4fa3c4a9c
+    container: {}
+    frameworks:
+      sglang: 0.5.23
   resources:
     gpu_type: gb300
     gpus_per_node: 4
diff --git a/inferencex-e2e/configs/nvidia-master.yaml b/inferencex-e2e/configs/nvidia-master.yaml
index 0e860fc14b..dce6d88ce8 100644
--- a/inferencex-e2e/configs/nvidia-master.yaml
+++ b/inferencex-e2e/configs/nvidia-master.yaml
@@ -5251,7 +5251,7 @@ glm5.2-fp4-gb300-dynamo-trt-agentic-disagg-mtp:
           dp-attn: true
 
 glm5.3flash-fp8-gb300-sglang-agentic-mtp:
-  image: lmsysorg/sglang:v0.5.22-cu130@sha256:e3a4f06001a29542fc4a8638536d9ffc5eb9c9942b08603c09b19a56eae4a1ae
+  image: lmsysorg/sglang:v0.5.23-cu130@sha256:f832b5c39559c9caa900b22ad37c76fcce66470676855c42052102c537812f1f
   model: zai-org/GLM-5.3-Flash
   model-prefix: glm5.3flash
   runner: cluster:gb300-nv
@@ -5268,7 +5268,7 @@ glm5.3flash-fp8-gb300-sglang-agentic-mtp:
       - { tp: 4, ep: 1, spec-decoding: mtp, kv-offloading: dram, kv-offload-backend: { name: hicache }, conc-list: [40, 44, 48], srt-recipe: "agentic.yaml:override_hicache" }
 
 glm5.3flash-fp4-gb300-sglang-agentic-mtp:
-  image: lmsysorg/sglang:v0.5.22-cu130@sha256:e3a4f06001a29542fc4a8638536d9ffc5eb9c9942b08603c09b19a56eae4a1ae
+  image: lmsysorg/sglang:v0.5.23-cu130@sha256:f832b5c39559c9caa900b22ad37c76fcce66470676855c42052102c537812f1f
   model: nvidia/GLM-5.3-Flash-NVFP4
   model-prefix: glm5.3flash
   runner: cluster:gb300-nv
diff --git a/inferencex-e2e/perf-changelog.yaml b/inferencex-e2e/perf-changelog.yaml
index ed22487f59..c369763935 100644
--- a/inferencex-e2e/perf-changelog.yaml
+++ b/inferencex-e2e/perf-changelog.yaml
@@ -12050,7 +12050,7 @@
   scenario-type:
     - agentic-coding
   description:
-    - "Add native SGLang GLM-5.3-Flash AgentX on one GB300 tray (TP4/EP1) with lmsysorg/sglang:v0.5.22-cu130, FP8 (zai-org/GLM-5.3-Flash) and NVFP4 (nvidia/GLM-5.3-Flash-NVFP4), embedded EAGLE MTP 5/1/6."
+    - "Add native SGLang GLM-5.3-Flash AgentX on one GB300 tray (TP4/EP1) with lmsysorg/sglang:v0.5.23-cu130, FP8 (zai-org/GLM-5.3-Flash) and NVFP4 (nvidia/GLM-5.3-Flash-NVFP4), embedded EAGLE MTP 5/1/6."
     - "SGLang cookbook GB300 recipe: TRT-LLM DSA prefill and decode, FP8 E4M3 KV cache, flashinfer_trtllm MoE, auto reasoning and tool-call parsers; NVFP4 adds modelopt_fp4 quantization."
     - "GPU-resident KV at concurrency 1, 4, 8, 16, 24 and 32; auto-sized HiCache host tier (--hicache-host-memory-fraction 0.90, 712.5 GB per node) at concurrency 40, 44 and 48."
   pr-link: https://github.com/SemiAnalysisAI/InferenceX/pull/4715

From 07c5546866eabcefd79de701dc0177aeb70bb2e0 Mon Sep 17 00:00:00 2001
From: Oseltamivir <58582368+Oseltamivir@users.noreply.github.com>
Date: Thu, 5 Nov 2026 20:18:51 +0800
Subject: [PATCH 13/14] revert GLM-5.3-Flash GB300 lanes to SGLang v0.5.22

Return both GB300 lanes to lmsysorg/sglang:v0.5.22-cu130 and declare
SGLang 0.5.22 in the recipe identities.
---
 .../glm5.3flash/sglang/gb300-fp4-mtp/agentic.yaml             | 2 +-
 .../glm5.3flash/sglang/gb300-fp8-mtp/agentic.yaml             | 2 +-
 inferencex-e2e/configs/nvidia-master.yaml                     | 4 ++--
 inferencex-e2e/perf-changelog.yaml                            | 2 +-
 4 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/glm5.3flash/sglang/gb300-fp4-mtp/agentic.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/glm5.3flash/sglang/gb300-fp4-mtp/agentic.yaml
index c511341d04..b27a420d2f 100644
--- a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/glm5.3flash/sglang/gb300-fp4-mtp/agentic.yaml
+++ b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/glm5.3flash/sglang/gb300-fp4-mtp/agentic.yaml
@@ -6,7 +6,7 @@ base:
       revision: 1d00738646cbb0c6d0a9eb403dac5f366f1473a7
     container: {}
     frameworks:
-      sglang: 0.5.23
+      sglang: 0.5.22
   resources:
     gpu_type: gb300
     gpus_per_node: 4
diff --git a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/glm5.3flash/sglang/gb300-fp8-mtp/agentic.yaml b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/glm5.3flash/sglang/gb300-fp8-mtp/agentic.yaml
index b54ee6e7a7..17f27639d4 100644
--- a/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/glm5.3flash/sglang/gb300-fp8-mtp/agentic.yaml
+++ b/inferencex-e2e/benchmarks/single_node/srt-slurm-recipes/glm5.3flash/sglang/gb300-fp8-mtp/agentic.yaml
@@ -6,7 +6,7 @@ base:
       revision: 46a050bec13002ad29ee795c16e61cf4fa3c4a9c
     container: {}
     frameworks:
-      sglang: 0.5.23
+      sglang: 0.5.22
   resources:
     gpu_type: gb300
     gpus_per_node: 4
diff --git a/inferencex-e2e/configs/nvidia-master.yaml b/inferencex-e2e/configs/nvidia-master.yaml
index dce6d88ce8..0e860fc14b 100644
--- a/inferencex-e2e/configs/nvidia-master.yaml
+++ b/inferencex-e2e/configs/nvidia-master.yaml
@@ -5251,7 +5251,7 @@ glm5.2-fp4-gb300-dynamo-trt-agentic-disagg-mtp:
           dp-attn: true
 
 glm5.3flash-fp8-gb300-sglang-agentic-mtp:
-  image: lmsysorg/sglang:v0.5.23-cu130@sha256:f832b5c39559c9caa900b22ad37c76fcce66470676855c42052102c537812f1f
+  image: lmsysorg/sglang:v0.5.22-cu130@sha256:e3a4f06001a29542fc4a8638536d9ffc5eb9c9942b08603c09b19a56eae4a1ae
   model: zai-org/GLM-5.3-Flash
   model-prefix: glm5.3flash
   runner: cluster:gb300-nv
@@ -5268,7 +5268,7 @@ glm5.3flash-fp8-gb300-sglang-agentic-mtp:
       - { tp: 4, ep: 1, spec-decoding: mtp, kv-offloading: dram, kv-offload-backend: { name: hicache }, conc-list: [40, 44, 48], srt-recipe: "agentic.yaml:override_hicache" }
 
 glm5.3flash-fp4-gb300-sglang-agentic-mtp:
-  image: lmsysorg/sglang:v0.5.23-cu130@sha256:f832b5c39559c9caa900b22ad37c76fcce66470676855c42052102c537812f1f
+  image: lmsysorg/sglang:v0.5.22-cu130@sha256:e3a4f06001a29542fc4a8638536d9ffc5eb9c9942b08603c09b19a56eae4a1ae
   model: nvidia/GLM-5.3-Flash-NVFP4
   model-prefix: glm5.3flash
   runner: cluster:gb300-nv
diff --git a/inferencex-e2e/perf-changelog.yaml b/inferencex-e2e/perf-changelog.yaml
index c369763935..ed22487f59 100644
--- a/inferencex-e2e/perf-changelog.yaml
+++ b/inferencex-e2e/perf-changelog.yaml
@@ -12050,7 +12050,7 @@
   scenario-type:
     - agentic-coding
   description:
-    - "Add native SGLang GLM-5.3-Flash AgentX on one GB300 tray (TP4/EP1) with lmsysorg/sglang:v0.5.23-cu130, FP8 (zai-org/GLM-5.3-Flash) and NVFP4 (nvidia/GLM-5.3-Flash-NVFP4), embedded EAGLE MTP 5/1/6."
+    - "Add native SGLang GLM-5.3-Flash AgentX on one GB300 tray (TP4/EP1) with lmsysorg/sglang:v0.5.22-cu130, FP8 (zai-org/GLM-5.3-Flash) and NVFP4 (nvidia/GLM-5.3-Flash-NVFP4), embedded EAGLE MTP 5/1/6."
     - "SGLang cookbook GB300 recipe: TRT-LLM DSA prefill and decode, FP8 E4M3 KV cache, flashinfer_trtllm MoE, auto reasoning and tool-call parsers; NVFP4 adds modelopt_fp4 quantization."
     - "GPU-resident KV at concurrency 1, 4, 8, 16, 24 and 32; auto-sized HiCache host tier (--hicache-host-memory-fraction 0.90, 712.5 GB per node) at concurrency 40, 44 and 48."
   pr-link: https://github.com/SemiAnalysisAI/InferenceX/pull/4715

From 2be9b6270c0d444ab660e30b9fb796deeb8c7dfd Mon Sep 17 00:00:00 2001
From: Oseltamivir <58582368+Oseltamivir@users.noreply.github.com>
Date: Fri, 6 Nov 2026 09:55:55 +0800
Subject: [PATCH 14/14] fix(bench): record measured GB300 HiCache DRAM for
 GLM-5.3-Flash

Set dram-utilization to 0.7495 (723 GB per node) on both GB300 lanes,
covering the 708.7-722.9 GB per node the auto-sized HiCache pools
allocated in run 42026173061.
---
 inferencex-e2e/configs/nvidia-master.yaml | 8 ++++----
 inferencex-e2e/perf-changelog.yaml        | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/inferencex-e2e/configs/nvidia-master.yaml b/inferencex-e2e/configs/nvidia-master.yaml
index 9a2a98d3fe..a31011febd 100644
--- a/inferencex-e2e/configs/nvidia-master.yaml
+++ b/inferencex-e2e/configs/nvidia-master.yaml
@@ -5724,8 +5724,8 @@ glm5.3flash-fp8-gb300-sglang-agentic-mtp:
   srt-recipe-dir: glm5.3flash/sglang/gb300-fp8-mtp
   scenarios:
     agentic-coding:
-    # HiCache auto-sizes at fraction 0.90: 4 ranks x 178.13 GB = 712.5 GB of 964.7 GB (920,000 MiB).
-    - dram-utilization: 0.7386
+    # HiCache auto-sizes at fraction 0.90; run 42026173061 measured 708.7-722.9 GB per node (4 ranks) of 964.7 GB.
+    - dram-utilization: 0.7495
       search-space:
       - { tp: 4, ep: 1, spec-decoding: mtp, kv-offloading: none, conc-list: [1, 4, 8, 16, 24, 32], srt-recipe: "agentic.yaml:override_gpu_kv" }
       - { tp: 4, ep: 1, spec-decoding: mtp, kv-offloading: dram, kv-offload-backend: { name: hicache }, conc-list: [40, 44, 48], srt-recipe: "agentic.yaml:override_hicache" }
@@ -5741,8 +5741,8 @@ glm5.3flash-fp4-gb300-sglang-agentic-mtp:
   srt-recipe-dir: glm5.3flash/sglang/gb300-fp4-mtp
   scenarios:
     agentic-coding:
-    # HiCache auto-sizes at fraction 0.90: 4 ranks x 178.13 GB = 712.5 GB of 964.7 GB (920,000 MiB).
-    - dram-utilization: 0.7386
+    # HiCache auto-sizes at fraction 0.90; run 42026173061 measured 708.7-722.9 GB per node (4 ranks) of 964.7 GB.
+    - dram-utilization: 0.7495
       search-space:
       - { tp: 4, ep: 1, spec-decoding: mtp, kv-offloading: none, conc-list: [1, 4, 8, 16, 24, 32], srt-recipe: "agentic.yaml:override_gpu_kv" }
       - { tp: 4, ep: 1, spec-decoding: mtp, kv-offloading: dram, kv-offload-backend: { name: hicache }, conc-list: [40, 44, 48], srt-recipe: "agentic.yaml:override_hicache" }
diff --git a/inferencex-e2e/perf-changelog.yaml b/inferencex-e2e/perf-changelog.yaml
index 4a06580a96..115c736df7 100644
--- a/inferencex-e2e/perf-changelog.yaml
+++ b/inferencex-e2e/perf-changelog.yaml
@@ -12214,5 +12214,5 @@
   description:
     - "Add native SGLang GLM-5.3-Flash AgentX on one GB300 tray (TP4/EP1) with lmsysorg/sglang:v0.5.22-cu130, FP8 (zai-org/GLM-5.3-Flash) and NVFP4 (nvidia/GLM-5.3-Flash-NVFP4), embedded EAGLE MTP 5/1/6."
     - "SGLang cookbook GB300 recipe: TRT-LLM DSA prefill and decode, FP8 E4M3 KV cache, flashinfer_trtllm MoE, auto reasoning and tool-call parsers; NVFP4 adds modelopt_fp4 quantization."
-    - "GPU-resident KV at concurrency 1, 4, 8, 16, 24 and 32; auto-sized HiCache host tier (--hicache-host-memory-fraction 0.90, 712.5 GB per node) at concurrency 40, 44 and 48."
+    - "GPU-resident KV at concurrency 1, 4, 8, 16, 24 and 32; auto-sized HiCache host tier (--hicache-host-memory-fraction 0.90, recorded as 723 GB per node, the measured maximum) at concurrency 40, 44 and 48."
   pr-link: https://github.com/SemiAnalysisAI/InferenceX/pull/4715