Audit SGLang interfaces and refresh validated kernel solutions

README.md

@@ -13,9 +13,9 @@ tags:
 
 Every published tensor input references a complete `safetensors` snapshot. Python scalar arguments use scalar descriptors. There are no random-input descriptors or synthetic activation generators. `captures.jsonl` joins each workload UUID to its model revision, request, engine operation, input adaptations, actual outputs, and validation results.
 
-**1,104 real workloads cover all 21 definitions:** 133 Qwen Image, 384 Qwen Flash-Next, 226 DeepSeek, 207 LTX, and 154 Qwen3-Next from the MLSys 2026 contest. The 950 SGLang captures pass complete-output replay; the contest publishes no engine outputs, so its workloads are checked by running the reference. The complete dataset is published at [humanfia-lab/inference-kernels](https://huggingface.co/datasets/humanfia-lab/inference-kernels), including definitions, workloads, capture records, baseline solutions, and tensors. The 5,506 tensor paths contain 5,124 unique snapshots of inputs, complete engine outputs, and auxiliary capture tensors. Fetch them with Git LFS before running workloads.
+**1,104 real workloads cover all 21 definitions:** 133 Qwen Image, 384 Qwen Flash-Next, 226 DeepSeek, 207 LTX, and 154 Qwen3-Next from the MLSys 2026 contest. The 950 SGLang captures pass complete-output replay; the contest publishes no engine outputs, so its workloads are checked by running the reference. The complete dataset is published at [humanfia-lab/inference-kernels](https://huggingface.co/datasets/humanfia-lab/inference-kernels), including definitions, workloads, capture records, baseline solutions, and tensors. The 5,493 tensor paths contain 5,111 unique snapshots of inputs, complete engine outputs, and auxiliary capture tensors. Fetch them with Git LFS before running workloads.
 
-The dataset was regenerated from full pinned checkpoints through SGLang on NVIDIA B300 GPUs. Definitions, reference code, tolerances, and baseline solutions are unchanged, apart from the [curation](#curation) for kernels that real inference uses.
+The dataset was regenerated from full pinned checkpoints through SGLang on NVIDIA B300 GPUs. The [interface and implementation audit](docs/interface-audit/README.md) records all 21 call boundaries, the feasible interface simplifications, current implementation updates, validation evidence and remaining integration work. This audit does not change task tolerances, dev UUIDs or input tensor values.
 
 ## Kernels
 
@@ -39,7 +39,7 @@ BF16, FP16, FP32, and FP64 mean 16-bit Brain Floating Point, IEEE half precision
 
 Definitions describe complete logical operators. Captures preserve all model heads and experts; distributed shards must be gathered before publication. Backend padding, layout changes, and page remapping are recorded explicitly. Cache snapshots retain every referenced page, including its unused tail; unreachable allocator pages are omitted. Tensor strides are normalized to contiguous storage without changing values.
 
-The gated delta definitions are the MLSys 2026 contest's: Q/K/V with the gate inputs `A_log`, `a`, `dt_bias` and `b`, and the k-last state layout `[sequence, value head, value dimension, key dimension]`. Prefill takes variable-length sequences through `cu_seqlens`. These are unchanged Qwen3-Next TP=4 contest contracts, not a layout conversion of the removed Qwen Flash-Next captures. Their references do not perform Q/K L2 normalization, and they accept per-batch states rather than the original SGLang state pool and slot indices.
+The gated delta definitions are the MLSys 2026 contest's: Q/K/V with the gate inputs `A_log`, `a`, `dt_bias` and `b`, and the k-last state layout `[sequence, value head, value dimension, key dimension]`. Prefill takes variable-length sequences through `cu_seqlens`. These are unchanged Qwen3-Next TP=4 contest contracts, not a layout conversion of the removed Qwen Flash-Next captures. Their references do not perform Q/K L2 normalization. Decode accepts per-batch states rather than the mutable SGLang state pool and slot indices. The actual SGLang FlashInfer prefill leaf already accepts gathered per-batch states, but uses normalized Q/K, precomputed gates, preallocated outputs and optional checkpoints. See the [per-definition audit](docs/interface-audit/interfaces.json).
 
 Quantized byte carriers use `int8` because the trace schema lacks unsigned-byte and exponent-only scale types. The byte patterns remain unchanged. Grouped matrix multiplication uses logical scale layouts with one scale per 32 K elements. Mixed attention preserves the engine's physical pages: each page stores all payload rows followed by all scale rows. Both cache formats share the softmax denominator, including the zero-value attention sink.
 
@@ -100,21 +100,22 @@ Each is submitted with 1, 2, and 4 requested outputs, at 24 frames per second. M
 
 `solutions/` contains native FlashInfer Trace Solution JSON files, with embedded source code, entry points, and pinned dependencies. Each solution accepts the definition's complete inputs and returns its complete outputs. GPU layout conversions, padding, sparse gathers, and output reordering are included in the solution call.
 
-The existing baseline implementations and B200 measurements come from the original 768-workload dataset. They are retained unchanged. The regenerated dataset's SGLang captures have passed complete engine-output replay against the independent references; baseline solutions have not been rebenchmarked on this new dataset.
+Historical B200 measurements below describe the original 768-workload dataset. Current B300 validation and comparisons are reported separately in the [audit](docs/interface-audit/README.md). Version currency alone does not establish a fastest implementation, and a standalone pass does not prove direct engine integration.
 
 | Kernels | Open-source implementation |
 |---|---|
-| Dense and grouped matrix multiplication | [DeepGEMM](https://github.com/deepseek-ai/DeepGEMM/tree/1fc9c66975ee322d628b3288534ca0e9ce12a64d); selected small dense shapes use [FlashInfer](https://github.com/flashinfer-ai/flashinfer) 0.7.2 CuTe DSL |
+| Dense and grouped matrix multiplication | [DeepGEMM](https://github.com/deepseek-ai/DeepGEMM/tree/1fc9c66975ee322d628b3288534ca0e9ce12a64d); native PyTorch linear is selected on three measured large-M B300 shapes |
 | Sparse MLA prefill and mixed-format MLA decode | [FlashMLA](https://github.com/deepseek-ai/FlashMLA/tree/0f11e178da1f67becb087a324b400854931ec3e3) |
-| Dense, block-causal, and sparse grouped-query attention | [FlashAttention-4](https://github.com/Dao-AILab/flash-attention) 4.0.0b35, with runtime masks or sparse-input adapters |
-| Gated delta recurrence | The MLSys 2026 contest's FlashInfer prefill and decode wrappers, unchanged |
-| Sparse index scoring and selection | SGLang TileLang scoring, exact-threshold Top-512, and Triton compaction that preserves lower-ID ties |
-| Expert router | FlashInfer CUTLASS FP32-output projection and compiled PyTorch scoring/selection |
+| Dense and block-causal attention | [FlashAttention-4](https://github.com/Dao-AILab/flash-attention) 4.0.0b35; tiny audio self-attention uses native SDPA |
+| Sparse grouped-query attention | Current SGLang/FlashInfer TRT-LLM paged attention, plus the FA4 sparse-gather alternative |
+| Gated delta recurrence | Maintained FlashInfer prefill/decode APIs; the contest recurrence, normalization boundary and state output contract remain explicit |
+| Sparse index scoring and selection | Maintained SGLang TileLang scoring, exact-threshold Top-512, stable Triton compaction, and a score-free short-context path |
+| Expert router | SGLang FP32-output projection and fused modality-aware Top-6 gate, with a combined Triton output ordering kernel |
 | Three-dimensional neighborhood attention | [NATTEN](https://github.com/SHI-Labs/NATTEN/tree/39375ea1d2f3b1bb284315fa5f79f6ecbebb6382) 0.21.7 Blackwell fused neighborhood attention |
 
-Local B200 comparisons covered 45 dense GEMM shapes across 147 backend/shape pairs, nine grouped GEMM shapes with five implementations/configurations each, and all 19 sparse-index workloads. Dense dispatch selects the fastest tested backend per captured shape; DeepGEMM won all nine grouped comparisons. The index adapter was 1.21–2.58× faster than full stable sorting while returning exactly the same IDs. These measurements describe the tested B200 configurations.
+Historical B200 comparisons covered 45 dense GEMM shapes across 147 backend/shape pairs, nine grouped GEMM shapes with five implementations/configurations each, and all 19 sparse-index workloads. Dense dispatch selects the fastest tested backend per captured shape; DeepGEMM won all nine grouped comparisons. The index adapter was 1.21–2.58× faster than full stable sorting while returning exactly the same IDs. These measurements describe the tested B200 configurations.
 
-The audio-attention solution uses FP16 computation and converts the output back to BF16 to reduce attention-probability rounding error. In the original B200 validation, all 96 audio workloads passed the unchanged reference tolerances, and their inputs remained finite after conversion with maximum conversion error below `3e-8`. These measurements refer to the original tensors.
+The current audio-attention solution uses BF16 FA4 directly, with native SDPA for self-attention tiles of at most 64 tokens. Both alternatives pass all 108 current audio workloads under the existing `required_matched_ratio=0.9999` policy. The former FP16 input/output conversions are removed; no tolerance was relaxed. Historical all-element B200 validation used different input tensors and the former FP16 computation.
 
 Install the dependencies listed in each solution's `spec` before running it. The historical B200 baseline environment used PyTorch 2.11.0, CUDA 13.2, Triton 3.6.0, CUTLASS DSL 4.7.1, Quack 0.6.5, TileLang 0.1.15, and TVM FFI 0.1.12. NATTEN and FlashMLA were built from their pinned sources for Blackwell. FlashMLA's CUDA 13.2 build required its upstream `FLASH_MLA_SKIP_REG_SPILL_CHECK=1` option; timings include that build.
 
@@ -128,13 +129,15 @@ The runner uses the native Trace builder, validates every output element against
 
 ### SGLang baselines
 
-Each SGLang-captured definition also has `solutions/<family>/sglang_<definition>.json`: SGLang's own implementation at the capture commit `684fea8a`, called the way the engine calls it, so that a kernel can be timed against what serving actually runs. The module docstring cites the engine call path. Run these solutions inside the capture image `lmsysorg/sglang@sha256:ddae0e399d3d94f7827f16183301cf8dac4cf0eae0ef25590b7dac5881d713d8`. Each module also exposes `prepare(*inputs)`, which does the host-side setup the engine does once (layouts, block masks, workspaces) and returns a zero-argument `launch`; `run(*inputs)` does both.
+Each SGLang-captured definition also has `solutions/<family>/sglang_<definition>.json`: the capture-commit SGLang implementation behind an explicit dataset-to-engine adapter. These provide a serving implementation comparison, not a declaration that the dataset already has every native interface. The module docstring cites the engine call path. Run these solutions inside the capture image `lmsysorg/sglang@sha256:ddae0e399d3d94f7827f16183301cf8dac4cf0eae0ef25590b7dac5881d713d8`. Each module also exposes `prepare(*inputs)`, which does the host-side setup the engine does once (layouts, block masks, workspaces) and returns a zero-argument `launch`; `run(*inputs)` does both.
 
 The SGLang solutions adapt the dataset's independent operator interfaces to the pinned engine implementations. Those adapters include padding, layouts, per-rank calls, metadata and output ordering where needed; their module docstrings describe the boundary. A passing standalone workload does not establish that a candidate can replace an engine call without integration work.
 
+The [audit runner](scripts/audit_solutions.py) can validate the complete packaged call, check byte-level input immutability, and compare eager and prepared-launch CUDA Graph timing under the task's exact tolerance. `scripts/benchmark_solutions.py` also reads `tasks/` for acceptance instead of applying a generic FP32 fallback.
+
 ### Task acceptance configs
 
-`tasks/<definition>.json` is how KDA (Kernel Design Agents) judges a candidate kernel on that definition. The definition's reference is the truth. SGLang tasks time their engine baseline with only `launch` timed; imported GDN tasks time the complete packaged contest baseline call. The fields are:
+`tasks/<definition>.json` is how KDA (Kernel Design Agents) judges a candidate kernel on that definition. The definition's reference is the truth. SGLang tasks time their engine baseline with only `launch` timed; imported GDN tasks time the complete maintained FlashInfer baseline call. The fields are:
 - `tolerance`: `atol` and `rtol` apply per element. A non-null `required_matched_ratio` is the fraction of elements that must pass; the LTX dense attention uses 0.9999 because fused attention kernels round the probabilities to BF16 and miss the every-element bound on 1–3 of up to 10⁹ elements.
 - `dev`: UUIDs selecting at most ten existing workloads for quick iteration. These UUIDs resolve in the listed workload files; they are not additional workloads. Final judgments use every workload, not just this subset.
 - `tolerance.comparison`: absent means `abs_error <= atol + rtol * abs(reference)`. The GDN configs explicitly use `absolute_or_relative`, matching the pinned FlashInfer-Bench evaluator: `abs_error <= atol` or `abs_error / (abs(reference) + 1e-8) <= rtol`. Nonfinite values fail.
@@ -147,7 +150,7 @@ A task config selects the definition, workload files, timed baseline and accepta
 This revision curates inference operator tasks for KDA (Kernel Design Agents). Per-shape definitions, workload files and solution names stay separate; model dimensions remain constant axes. Captured interface adaptations are retained explicitly.
 - **Removed `dense_gemm_bf16_nt_n64_k4096` and `dense_gemm_bf16_nt_n4096_k64`.** These are the image output and input projections: memory-bound 8–45 µs GEMMs that run once per forward.
 - **Removed `grouped_gemm_fp8_fp4_e384_n2304_k5120_g32`.** It was cut from the columns of the concatenated gate/up GEMM; no engine runs a separate gate or up GEMM.
-- **Replaced the gated delta definitions.** `gated_delta_rule_prefill_h48_dk128_dv128` pre-repeated 16 Q/K heads to 48; the old decode kept 16 raw Q/K heads and included normalization and gating. Both captures extracted states from the engine pool and transposed them to `[B, H, K, V]`. They are replaced by the [MLSys 2026 FlashInfer contest](https://huggingface.co/datasets/flashinfer-ai/mlsys26-contest/tree/5e832ce88dd1013032b22a0e942979d7d2769cc3) definitions `gdn_{decode,prefill}_qk4_v8_d128_k_last`, with their workloads and FlashInfer baselines unchanged. Each input tensor is stored in its own content-addressed file. Each receipt records the source workload, plus a check that the reference returns finite outputs of the declared shapes.
+- **Replaced the gated delta definitions.** `gated_delta_rule_prefill_h48_dk128_dv128` pre-repeated 16 Q/K heads to 48; the old decode kept 16 raw Q/K heads and included normalization and gating. Both captures extracted states from the engine pool and transposed them to `[B, H, K, V]`. They are replaced by the [MLSys 2026 FlashInfer contest](https://huggingface.co/datasets/flashinfer-ai/mlsys26-contest/tree/5e832ce88dd1013032b22a0e942979d7d2769cc3) definitions `gdn_{decode,prefill}_qk4_v8_d128_k_last`, with their workloads and independent references preserved. The audit subsequently replaces the legacy vendored wrappers with maintained FlashInfer API calls. Each input tensor is stored in its own content-addressed file. Each receipt records the source workload, plus a check that the reference returns finite outputs of the declared shapes.
 - **The three remaining dense GEMMs keep only their `M >= 4096` rows.** The `M <= 32` rows were 11–27 µs launches.
 - **The LTX dense attention definitions drop the dense `[B, H, Nq, Nk]` visibility mask.** It was all True on every captured call (up to 839 MB). On one GPU the engine passes no mask, or an all-visible prompt mask. Replay against the captured engine outputs still passes.
 - **Receipts and tensors.** The receipts of removed workloads are dropped, along with every tensor that nothing references.
@@ -232,7 +235,7 @@ BF16 comparisons use `rtol=0.016, atol=0.005`; FP32 uses `rtol=1e-4, atol=2e-5`;
 
 One complete router workload is excluded from the 279 DeepSeek raw captures: at two rows of a 4,096-row call, FP32 ranking ties produce different expert selections. The original FP32 reference and exact selected-set requirement remain unchanged. This call was also absent from the original dataset. No rows are removed from published tensors. All nine LTX requests pass and are included.
 
-Tensor files are published directly as `blob/workloads/<definition>/<hash>.safetensors` through Git LFS. Every workload and capture record references tensors under its definition directory. Shared snapshots have identical LFS objects across directories: 5,506 paths contain 5,124 unique snapshots totaling 146.34 GB (146.44 GB when materialized at every path).
+Tensor files are published directly as `blob/workloads/<definition>/<hash>.safetensors` through Git LFS. Every workload and capture record references tensors under its definition directory. Shared snapshots have identical LFS objects across directories: 5,493 paths contain 5,111 unique snapshots totaling 146.34 GB (146.44 GB when materialized at every path).
 
 ```bash
 git clone https://huggingface.co/datasets/humanfia-lab/inference-kernels

blob/workloads/prefix_cached_block_causal_h32_d128/24beab98031b196a75c75450cb46208fcb182fd30a7033e98807bd3bbcfdbe9c.safetensors

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:9dc54d679a03210068bf873cc41dbdd118c9072c8b98d80c4aa82a5400797496
-size 16564

blob/workloads/prefix_cached_block_causal_h32_d128/520f23a9d39a934f770e8cd0738b7c138afb297a1673242a8c7a74b240925220.safetensors

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:b179f21a2df8d3efa310357baf635a1b4019c79a576a2a567a030656da266106
-size 4201

blob/workloads/prefix_cached_block_causal_h32_d128/634581f36b1de16bed0751230b45f5608b474b687879d22c8aecb083d9ef6e51.safetensors

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:0ee3434d35bc583597d0cb8d9ee4522bad4ffc5244ad34f5343332f5c4024173
-size 8301

blob/workloads/prefix_cached_block_causal_h32_d128/999a7517ad2b3237796e3467752e4a46a4860d2d7710f7994e8ccebb2694f920.safetensors

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:4d3d1704df157ad89beb91feebb4c35c8c4c84b73b459e8e6c18193c75637722
-size 32964

blob/workloads/prefix_cached_block_causal_h32_d128/a8b23c1dff21615d068e1505a14d17d38abb297be8fbf2c9155288b08b11aa06.safetensors

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:5b204a1b9d61966e711684924afc1d3bdd4fc158529c3436c1aeead2b645e320
-size 6254

blob/workloads/prefix_cached_block_causal_h32_d128/b11ce9761bedd8e9e8a13b99754b6773f7bbe82882a27d474519c32b253afb60.safetensors

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:07de2595b4db5c4cf99fb0b334fa3d185241af7d12f092e1b7eebe2759d64c7d
-size 24776

blob/workloads/prefix_cached_block_causal_h32_d128/d0bb365b82b6c21ea904fc9846b2f05d643af7ff2cfa2cf3970394fdf751be05.safetensors

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:73838b70d506019c83a0fbba52a3a42de97a12278b52cb142e10cb499adcb402
-size 4208

blob/workloads/prefix_cached_block_causal_h32_d128/f98afd86600ad282fb4a1694aa5049808185ac822bdc6f330eab95be46d92bea.safetensors

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:38a5217b228357f983ee83bb73bc31d4d017b6d99d18530ba7a5e9fb7a8592e0
-size 16592

blob/workloads/prefix_cached_block_causal_h32_d128_prefix0/607c76ea2c419ada0a021bacec4bac55dd9917cd9470a4005c461b2820a4c668.safetensors

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:1d260ae51283fece71010a7d5ad6bb3c6c85fe4b6d531bf0a4d3c4dd75d0129d
-size 80

blob/workloads/prefix_cached_block_causal_h32_d128_prefix0/73eb58664f39fa614a66165a80639e5ec0d06c90738d6101c6eebf185b9c68d6.safetensors

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:cf9f5bb5735a2adced8cb3ff460f768d24713fab5168b10e347e7c4acdf960ee
-size 4205

blob/workloads/prefix_cached_block_causal_h32_d128_prefix0/ac0de5352c580d07d8610324784802a5251137eca7461cad96656e36c7f1e883.safetensors

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:3733af1da5d567aa09b7c304f9e79f1f408b83e0f1a852602773a4066e37e3b9
-size 104

blob/workloads/prefix_cached_block_causal_h32_d128_prefix0/f3c2e24c613a2705414da699d8160e74518c9364384391094e3a8d7a1944fec6.safetensors

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:35d109d5b313aec365c9b681cb80c4c32f442d03e3ed426101b2aa4524befe48
-size 102

blob/workloads/prefix_cached_block_causal_h32_d128_prefix0/f7d9a8bf454a6461eec5eccd97dbdcd326027a6e6bfd2ab34d093c8e184b7a7d.safetensors

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:ad2b659e721e3f5425248fa6eeed957c412e070d7ccc36d3ca6051c2dd3a57b0
-size 97

definitions/block_causal_attention/prefix_cached_block_causal_h32_d128.json

@@ -1,7 +1,7 @@
 {
   "name": "prefix_cached_block_causal_h32_d128",
   "op_type": "block_causal_attention",
-  "description": "Prefix-cached block-causal attention: allow j <= Np+i or matching nonnegative image IDs, then intersect key_valid. Text and different image blocks are causal; same-image tokens are bidirectional. Np=0 covers initial full evaluation. Prefix K/V are already computed; changed target-image K/V must be supplied as current inputs.",
+  "description": "SGLang Qwen-Image target-image attention with a nonempty replicated KV prefix. All current queries belong to one image block and attend to every prefix/current key. Q/K/V keep the engine layout; scale is fixed to 1/sqrt(128).",
   "tags": [
     "model:qwen-image-2.1-turbo",
     "status:draft",
@@ -18,11 +18,7 @@
     },
     "Np": {
       "type": "var",
-      "description": "Runtime cached prefix length, possibly zero."
-    },
-    "Nall": {
-      "type": "var",
-      "description": "Total prefix and current length."
+      "description": "Runtime nonempty cached prefix length."
     },
     "H": {
       "type": "const",
@@ -43,61 +39,41 @@
       ],
       "dtype": "bfloat16"
     },
-    "K_current": {
+    "K_prefix": {
       "shape": [
         "B",
-        "Nq",
+        "Np",
         "H",
         "D"
       ],
       "dtype": "bfloat16"
     },
-    "V_current": {
+    "V_prefix": {
       "shape": [
         "B",
-        "Nq",
+        "Np",
         "H",
         "D"
       ],
       "dtype": "bfloat16"
     },
-    "K_prefix": {
+    "K_current": {
       "shape": [
         "B",
-        "Np",
+        "Nq",
         "H",
         "D"
       ],
       "dtype": "bfloat16"
     },
-    "V_prefix": {
+    "V_current": {
       "shape": [
         "B",
-        "Np",
+        "Nq",
         "H",
         "D"
       ],
       "dtype": "bfloat16"
-    },
-    "image_ids": {
-      "shape": [
-        "Nall"
-      ],
-      "dtype": "int32",
-      "description": "Text=-1; nonnegative IDs identify distinct contiguous image blocks. Shared batch layout."
-    },
-    "key_valid": {
-      "shape": [
-        "B",
-        "Nall"
-      ],
-      "dtype": "bool",
-      "description": "Key padding visibility mask; each query must see a key."
-    },
-    "sm_scale": {
-      "shape": null,
-      "dtype": "float32",
-      "description": "Model default 1/sqrt(128)."
     }
   },
   "outputs": {
@@ -114,8 +90,7 @@
   "constraints": [
     "B >= 1",
     "Nq >= 1",
-    "Np >= 0",
-    "Nall == Np + Nq"
+    "Np >= 1"
   ],
-  "reference": "import math\nimport torch\n\n@torch.no_grad()\ndef run(Q, K_current, V_current, K_prefix, V_prefix, image_ids, key_valid, sm_scale):\n    \"\"\"Causal across blocks/text, bidirectional within each nonnegative image ID.\"\"\"\n    nprefix, nquery = K_prefix.shape[1], Q.shape[1]\n    keys = torch.cat((K_prefix, K_current), dim=1).float()\n    values = torch.cat((V_prefix, V_current), dim=1).float()\n    positions = torch.arange(keys.shape[1], device=Q.device)\n    query_positions = positions[nprefix:]\n    query_images = image_ids[nprefix:]\n    same_image = (query_images[:, None] == image_ids[None, :]) & (query_images[:, None] >= 0)\n    allowed = (positions[None, :] <= query_positions[:, None]) | same_image\n    allowed = allowed[None, :, :] & key_valid[:, None, :]\n    assert bool(allowed.any(dim=-1).all()), \"Each query needs a visible key\"\n    scores = torch.einsum(\"bqhd,bkhd->bhqk\", Q.float(), keys) * float(sm_scale)\n    scores = scores.masked_fill(~allowed[:, None], -torch.inf)\n    return torch.einsum(\"bhqk,bkhd->bqhd\", scores.softmax(-1), values).to(torch.bfloat16)\n"
+  "reference": "import torch\n\n@torch.no_grad()\ndef run(Q, K_prefix, V_prefix, K_current, V_current):\n    \"\"\"One SGLang target-image attention call; the current image sees every key.\"\"\"\n    keys = torch.cat((K_prefix, K_current), dim=1).float()\n    values = torch.cat((V_prefix, V_current), dim=1).float()\n    scores = torch.einsum(\"bqhd,bkhd->bhqk\", Q.float(), keys) * (128 ** -0.5)\n    return torch.einsum(\"bhqk,bkhd->bqhd\", scores.softmax(-1), values).to(torch.bfloat16)\n"
 }

definitions/block_causal_attention/prefix_cached_block_causal_h32_d128_prefix0.json

@@ -1,7 +1,7 @@
 {
   "name": "prefix_cached_block_causal_h32_d128_prefix0",
   "op_type": "block_causal_attention",
-  "description": "Prefix-cached block-causal attention: allow j <= Np+i or matching nonnegative image IDs, then intersect key_valid. Text and different image blocks are causal; same-image tokens are bidirectional. Np=0 covers initial full evaluation. Prefix K/V are already computed; changed target-image K/V must be supplied as current inputs. Empty-prefix specialization: Np is a constant zero.",
+  "description": "Prefix-cached block-causal attention: allow j <= Np+i or matching nonnegative image IDs, then intersect key_valid. Text and different image blocks are causal; same-image tokens are bidirectional. Np=0 covers initial full evaluation. Prefix K/V are already computed; changed target-image K/V must be supplied as current inputs. Empty-prefix specialization: Np is a constant zero. Empty prefix tensors, the all-visible key-valid input and the fixed scale are omitted. image_ids still represents the engine segment list, so this remains a composed operator contract.",
   "tags": [
     "model:qwen-image-2.1-turbo",
     "status:draft",
@@ -16,14 +16,6 @@
       "type": "var",
       "description": "Runtime current query/token count."
     },
-    "Np": {
-      "type": "const",
-      "value": 0
-    },
-    "Nall": {
-      "type": "var",
-      "description": "Total prefix and current length."
-    },
     "H": {
       "type": "const",
       "value": 32
@@ -61,43 +53,12 @@
       ],
       "dtype": "bfloat16"
     },
-    "K_prefix": {
-      "shape": [
-        "B",
-        "Np",
-        "H",
-        "D"
-      ],
-      "dtype": "bfloat16"
-    },
-    "V_prefix": {
-      "shape": [
-        "B",
-        "Np",
-        "H",
-        "D"
-      ],
-      "dtype": "bfloat16"
-    },
     "image_ids": {
       "shape": [
-        "Nall"
+        "Nq"
       ],
       "dtype": "int32",
       "description": "Text=-1; nonnegative IDs identify distinct contiguous image blocks. Shared batch layout."
-    },
-    "key_valid": {
-      "shape": [
-        "B",
-        "Nall"
-      ],
-      "dtype": "bool",
-      "description": "Key padding visibility mask; each query must see a key."
-    },
-    "sm_scale": {
-      "shape": null,
-      "dtype": "float32",
-      "description": "Model default 1/sqrt(128)."
     }
   },
   "outputs": {
@@ -113,8 +74,7 @@
   },
   "constraints": [
     "B >= 1",
-    "Nq >= 1",
-    "Nall == Nq"
+    "Nq >= 1"
   ],
-  "reference": "import math\nimport torch\n\n@torch.no_grad()\ndef run(Q, K_current, V_current, K_prefix, V_prefix, image_ids, key_valid, sm_scale):\n    \"\"\"Causal across blocks/text, bidirectional within each nonnegative image ID.\"\"\"\n    nprefix, nquery = K_prefix.shape[1], Q.shape[1]\n    keys = torch.cat((K_prefix, K_current), dim=1).float()\n    values = torch.cat((V_prefix, V_current), dim=1).float()\n    positions = torch.arange(keys.shape[1], device=Q.device)\n    query_positions = positions[nprefix:]\n    query_images = image_ids[nprefix:]\n    same_image = (query_images[:, None] == image_ids[None, :]) & (query_images[:, None] >= 0)\n    allowed = (positions[None, :] <= query_positions[:, None]) | same_image\n    allowed = allowed[None, :, :] & key_valid[:, None, :]\n    assert bool(allowed.any(dim=-1).all()), \"Each query needs a visible key\"\n    scores = torch.einsum(\"bqhd,bkhd->bhqk\", Q.float(), keys) * float(sm_scale)\n    scores = scores.masked_fill(~allowed[:, None], -torch.inf)\n    return torch.einsum(\"bhqk,bkhd->bqhd\", scores.softmax(-1), values).to(torch.bfloat16)\n"
+  "reference": "import torch\n\n@torch.no_grad()\ndef run(Q, K_current, V_current, image_ids):\n    \"\"\"The uncached prefix's segmented text/image visibility, without empty state inputs.\"\"\"\n    positions = torch.arange(Q.shape[1], device=Q.device)\n    same_image = (image_ids[:, None] == image_ids[None, :]) & (image_ids[:, None] >= 0)\n    allowed = (positions[None, :] <= positions[:, None]) | same_image\n    scores = torch.einsum(\"bqhd,bkhd->bhqk\", Q.float(), K_current.float()) * (128 ** -0.5)\n    scores = scores.masked_fill(~allowed[None, None], -torch.inf)\n    return torch.einsum(\"bhqk,bkhd->bqhd\", scores.softmax(-1), V_current.float()).to(torch.bfloat16)\n"
 }

definitions/dense_attention/noncausal_dense_attention_h32_d128.json

@@ -1,7 +1,7 @@
 {
   "name": "noncausal_dense_attention_h32_d128",
   "op_type": "dense_attention",
-  "description": "Noncausal self/cross attention with FP32 accumulation and BF16 output. Self attention uses Nq=Nk; cross attention allows unequal lengths. No dropout. Projection, normalization, rotary embeddings and output gates are outside the definition. No mask: every captured call's expanded visibility mask was all True (on one GPU the engine passes no mask, or an all-visible prompt mask), so KDA drops the dataset's mask input.",
+  "description": "Noncausal self/cross attention with FP32 accumulation and BF16 output. Self attention uses Nq=Nk; cross attention allows unequal lengths. No dropout. Projection, normalization, rotary embeddings and output gates are outside the definition. No mask: every captured call's expanded visibility mask was all True (on one GPU the engine passes no mask, or an all-visible prompt mask), so KDA drops the dataset's mask input. The SGLang call fixes scale to head_dim**-0.5; no runtime scale argument is exposed.",
   "tags": [
     "model:ltx-2.5",
     "status:draft",
@@ -56,11 +56,6 @@
         "D"
       ],
       "dtype": "bfloat16"
-    },
-    "sm_scale": {
-      "shape": null,
-      "dtype": "float32",
-      "description": "Model default 1/sqrt(128)."
     }
   },
   "outputs": {
@@ -79,5 +74,5 @@
     "Nq >= 1",
     "Nk >= 1"
   ],
-  "reference": "import math\nimport torch\n\n@torch.no_grad()\ndef run(Q, K, V, sm_scale):\n    \"\"\"Noncausal attention without a mask.\"\"\"\n    scores = torch.einsum(\"bqhd,bkhd->bhqk\", Q.float(), K.float())\n    scores = scores * float(sm_scale)\n    probabilities = torch.softmax(scores, dim=-1)\n    return torch.einsum(\"bhqk,bkhd->bqhd\", probabilities, V.float()).to(torch.bfloat16)\n"
+  "reference": "import math\nimport torch\n\n@torch.no_grad()\ndef run(Q, K, V):\n    \"\"\"Noncausal attention without a mask.\"\"\"\n    scores = torch.einsum(\"bqhd,bkhd->bhqk\", Q.float(), K.float())\n    scores = scores * (128 ** -0.5)\n    probabilities = torch.softmax(scores, dim=-1)\n    return torch.einsum(\"bhqk,bkhd->bqhd\", probabilities, V.float()).to(torch.bfloat16)\n"
 }

definitions/dense_attention/noncausal_dense_attention_h32_d64.json

@@ -1,7 +1,7 @@
 {
   "name": "noncausal_dense_attention_h32_d64",
   "op_type": "dense_attention",
-  "description": "Noncausal self/cross attention with FP32 accumulation and BF16 output. Self attention uses Nq=Nk; cross attention allows unequal lengths. No dropout. Projection, normalization, rotary embeddings and output gates are outside the definition. No mask: every captured call's expanded visibility mask was all True (on one GPU the engine passes no mask, or an all-visible prompt mask), so KDA drops the dataset's mask input.",
+  "description": "Noncausal self/cross attention with FP32 accumulation and BF16 output. Self attention uses Nq=Nk; cross attention allows unequal lengths. No dropout. Projection, normalization, rotary embeddings and output gates are outside the definition. No mask: every captured call's expanded visibility mask was all True (on one GPU the engine passes no mask, or an all-visible prompt mask), so KDA drops the dataset's mask input. The SGLang call fixes scale to head_dim**-0.5; no runtime scale argument is exposed.",
   "tags": [
     "model:ltx-2.5",
     "status:draft",
@@ -56,11 +56,6 @@
         "D"
       ],
       "dtype": "bfloat16"
-    },
-    "sm_scale": {
-      "shape": null,
-      "dtype": "float32",
-      "description": "Model default 1/sqrt(64)."
     }
   },
   "outputs": {
@@ -79,5 +74,5 @@
     "Nq >= 1",
     "Nk >= 1"
   ],
-  "reference": "import math\nimport torch\n\n@torch.no_grad()\ndef run(Q, K, V, sm_scale):\n    \"\"\"Noncausal attention without a mask.\"\"\"\n    scores = torch.einsum(\"bqhd,bkhd->bhqk\", Q.float(), K.float())\n    scores = scores * float(sm_scale)\n    probabilities = torch.softmax(scores, dim=-1)\n    return torch.einsum(\"bhqk,bkhd->bqhd\", probabilities, V.float()).to(torch.bfloat16)\n"
+  "reference": "import math\nimport torch\n\n@torch.no_grad()\ndef run(Q, K, V):\n    \"\"\"Noncausal attention without a mask.\"\"\"\n    scores = torch.einsum(\"bqhd,bkhd->bhqk\", Q.float(), K.float())\n    scores = scores * (64 ** -0.5)\n    probabilities = torch.softmax(scores, dim=-1)\n    return torch.einsum(\"bhqk,bkhd->bqhd\", probabilities, V.float()).to(torch.bfloat16)\n"
 }

docs/gdn-prefill-numerics.md

@@ -1,4 +1,4 @@
-# GDN prefill numerical analysis
+# Historical GDN prefill numerical analysis
 
 The imported contest baseline returns an FP32 state but performs several state-update matrix products with BF16 intermediate operands. Returning FP32 does not make those intermediate operations FP32-accurate. The independent reference instead updates the recurrence one token at a time in FP32.
 
@@ -25,4 +25,27 @@ The earlier standalone package had no explicit GDN task configuration. It applie
 
 The [contest evaluation commands](https://github.com/flashinfer-ai/flashinfer-bench-starter-kit/blob/75ccd05cafceb0fd1f86be4cd0f2117249463c66/EVALUATION.md) do not override GDN error tolerances. The pinned [FlashInfer-Bench defaults](https://github.com/flashinfer-ai/flashinfer-bench/blob/15618a67e8d7b7f49ca61b5ba3b9f26a876d0bee/flashinfer_bench/bench/config.py) use `atol=rtol=0.01` and require all elements. Its [error test](https://github.com/flashinfer-ai/flashinfer-bench/blob/15618a67e8d7b7f49ca61b5ba3b9f26a876d0bee/flashinfer_bench/bench/utils.py) accepts an element when the absolute error is within `atol` or the relative error, divided by `abs(reference)+1e-8`, is within `rtol`. Nonfinite outputs fail.
 
-Both GDN definitions now have explicit configs in `tasks/` with that policy and pinned source links. The 19 existing SGLang task tolerances are unchanged. Definitions, references, imported baseline implementations and workload tensors are unchanged. The six-token reproduction passes the configured contest bound while continuing to fail the separately retained strict FP32 diagnostic.
+Both GDN definitions now have explicit configs in `tasks/` with that policy and pinned source links. The 19 existing SGLang task tolerances are unchanged. The audit preserves the definitions, independent references, workload tensors and tolerance policies, while replacing the legacy imported baseline implementation with maintained FlashInfer calls. The historical measurements above describe the original imported kernel. The six-token reproduction passes the configured contest bound while continuing to fail the separately retained strict FP32 diagnostic.
+
+## Maintained FlashInfer baseline in the interface audit
+
+The replacement baseline uses FlashInfer 0.7.2 with CUTLASS DSL 4.8.0. All 100
+prefill and 54 decode workloads pass the existing explicit contest policy, and
+inputs remain byte-identical. Prefill forwards the requested runtime scale;
+decode clones state before calling the maintained in-place API so the task's
+input state is not mutated.
+
+This does not make FP32 prefill state fully FP32-accurate. On the same six-token
+workload, the maintained baseline has maximum state error
+`0.0012151896953582764`; **3,909 / 131,072** elements still fail the historical
+`rtol=1e-4, atol=2e-5` diagnostic. All ten tested prefill dev workloads fail that
+strict diagnostic while passing the unchanged contest bound. The earlier
+4,143-element failure and its original measurements above remain historical
+evidence for the original imported implementation.
+
+The current FlashInfer development snapshot's raw-gate API was also evaluated
+on all ten prefill dev workloads, including a nondefault scale probe. It passed
+the contest policy but did not improve measured graph latency over the release
+API in this environment, and still failed the strict FP32 state diagnostic.
+The baseline therefore keeps the tested release API. No tolerance, reference or
+input data was changed to obtain these passes.

docs/interface-audit/README.md

@@ -0,0 +1,196 @@
+# SGLang interface and implementation audit — 2026-10-19
+
+The 21 definitions are **not all direct replacements for current SGLang calls**.
+Seven have tensor operands matching a specialized attention leaf, three dense
+GEMMs flatten the engine's leading dimensions, and eleven retain structural
+adapters. No full serving run with substituted candidate kernels has been
+performed. Saved inputs are materialized contiguous tensors: original storage
+offsets, aliasing and arbitrary engine strides are not retained by safetensors.
+A matching shape/dimension order therefore does not prove storage-ABI parity.
+Standalone correctness and native tensor-layout correspondence are
+reported separately from integration.
+
+The complete, per-definition record is [interfaces.json](interfaces.json). It
+lists every native call, pinned source link, remaining adapter and required
+integration work. It covers all 21 definitions, including both GDN variants.
+
+## Sources and scope
+
+The capture used SGLang `684fea8af3b11a5b51ec9966c02959a32ad3421c`.
+Current calls were inspected at
+[`0025f939`](https://github.com/sgl-project/sglang/tree/0025f9394421451aa09ec192a4a6e7928e14736b),
+with the [0.5.22 release](https://github.com/sgl-project/sglang/releases/tag/v0.5.22)
+checked separately. New SGLang-based solutions pin the inspected commit;
+capture baselines intentionally retain their original commit. A final
+[head recheck](upstream-head-recheck.json) at 11:43 UTC found SGLang one commit
+ahead (`ed0b8f43`); its [examined diff](sglang-head-recheck-diff.json) changes
+an NPU output-gate guard and the Ascend MoE runner, not these NVIDIA operator
+boundaries. The other five upstream heads were unchanged. The tested commit
+remains pinned rather than silently replacing it with untested code.
+
+The current DeepGEMM `1fc9c669`, FlashMLA `0f11e178`, NATTEN 0.21.7 and FA4
+4.0.0b35 already match the inspected upstream snapshots/releases. FlashInfer
+0.7.2 is the current stable release. Its current development snapshot
+`f64b4ba8` was also tested for raw-gate GDN prefill; it did not beat the release
+path on the ten dev workloads. CUTLASS DSL 4.8.0 matches the tested SGLang
+runtime; this audit does not infer a speed advantage from the newer 4.8.1
+version number. Exact source metadata is in [upstreams.json](upstreams.json). The explicit
+[preferred solution list](preferred-solutions.json) identifies one measured
+choice per definition; serving baselines remain separate.
+
+These are current maintained implementations and scoped comparisons among the
+tested alternatives. This is not evidence of global optimality across all
+possible implementations, devices or serving configurations. In particular,
+the newer FlashMLA MegaAttention fusion needs pre-RoPE/normalization inputs,
+positions and weight preparation absent from the existing MLA definitions.
+It cannot be applied faithfully by changing only the packaged function.
+
+## Feasible changes
+
+- Dense attention now accepts only Q/K/V. The scale was fixed by head dimension
+  in all 162 workloads. The SGLang wrapper returns the native output view
+  without a gratuitous contiguous copy.
+- Cached-prefix attention now accepts Q, prefix K/V and current K/V in native
+  positional order. All 28 calls have full visibility; artificial image IDs,
+  the all-true key mask and fixed scale are removed. Its FA4 implementation
+  consequently needs no custom mask.
+- The twelve prefix-zero workloads drop empty prefix K/V tensors, the all-true
+  key mask and fixed scale. Their image IDs still encode a composed sequence of
+  native text/image segment calls; this remaining difference is explicit.
+- All 202 changed attention contracts were replayed against their original
+  saved engine outputs, without relaxing the replay tolerance. Workload UUIDs,
+  surviving tensor values and saved outputs are preserved. Thirteen unused
+  tensor files are removed; previous replay records remain in provenance.
+- Audio attention removes the FP16 conversions and uses BF16 FA4, with native
+  SDPA for self-attention tiles up to 64 tokens. Both paths pass all 108 current
+  workloads under the pre-existing 99.99% matched-element requirement.
+- GDN uses maintained FlashInfer calls instead of the vendored wrappers.
+  Decode copies the input state before invoking the mutating API. Both paths
+  honor runtime scale, preserve the contest's disabled Q/K normalization, and
+  pass all 154 workloads without input mutation. See the separate
+  [precision report](../gdn-prefill-numerics.md): strict FP32 prefill state
+  accuracy remains unresolved.
+- QSA index uses current SGLang scoring and native fast Top-K only to discover
+  the threshold. Deterministic Triton compaction restores lower-ID ties and
+  ascending IDs, independent of the native unordered selection. Capacities at
+  most 512 skip scoring altogether. All 192 actual workloads pass exactly;
+  all-tied, empty, short and padded rows are checked separately.
+- The router uses native FP32-output projection and fused sqrt-softplus,
+  modality selection, Top-6, normalization and routed scale. One Triton kernel
+  performs the required output ordering/int64 conversion. All 50 workloads
+  retain exact selected IDs and the original strict FP32 weight tolerance.
+- A current native TRT-LLM sparse-GQA solution is added alongside FA4; its 192
+  workloads pass. Its cache/layout preparation is explicit rather than being
+  described as a direct replacement for the serving backend.
+- The four SGLang neighborhood wrappers now honor the engine's NATTEN branch
+  when available, retaining the existing FlexAttention fallback. All 45 actual
+  workloads pass both the default NATTEN and SGLang/NATTEN paths.
+- The BF16 N=12288/K=4096 solution uses native linear on the three measured
+  large-M B300 shapes where it beat DeepGEMM; other shapes and B200 retain
+  DeepGEMM.
+- The retained dense GEMM cannot enter the old M<=4/M=32 branch, so the branch
+  and its conflicting CUTLASS dependency are removed. FA4 dependencies are
+  aligned with the tested CUTLASS DSL 4.8.0 environment.
+
+## Remaining interface differences
+
+| Definitions | Native boundary still missing or adapted |
+|---|---|
+| GDN decode | Mutable state pool and slot indices, Q/K L2 normalization, actual serving model/head configuration |
+| GDN prefill | Normalized Q/K, prepared alpha/beta, output buffers/checkpoints and serving model configuration. The native FlashInfer prefill leaf already gets gathered per-batch state; claiming it always takes a full pool would be incorrect. |
+| Two grouped GEMMs | Four global expert shards combined into one task, padding removed, logical scale bytes and row order replacing per-rank physical buffers/m_indices |
+| Two sparse MLA and mixed MLA | Four ranks' real heads combined; native per-rank zero padding/output slices, original cache pools, explicit lengths and scheduling metadata reconstructed |
+| QSA index | Zero query heads removed, live-page compaction, ordered task IDs versus native unordered IDs |
+| Sparse GQA | Snapshot after current-token KV write, compact pools, request maps and physical packing reconstructed |
+| Router | Projection plus routing combined; boolean modality replaces token IDs; int64 sorted IDs and applied scaling differ from native outputs |
+| Prefix-zero attention | Several text/image leaf calls combined into one block-causal operation |
+| Three dense GEMMs | Original batch/sequence dimensions flattened into M |
+
+Changing these definitions to the full native contracts requires new native
+captures or an explicit integration API, especially for pool side effects and
+per-rank operands. Identity indices, invented padding or fabricated missing
+inputs would not prove interface parity. The current inputs and references are
+preserved instead of silently changing the task's mathematical meaning.
+
+## Validation and timing
+
+All task tolerances, dev UUIDs, timing parameters and reference mathematical
+operations are preserved. The four attention references only specialize inputs
+whose invariants were checked for every affected workload. Both validation
+runners read the explicit task tolerance, including the GDN absolute-or-relative
+rule. Matched-element fractions use integer counts, and nonfinite outputs fail.
+The historical strict GDN diagnostic is reported separately and is not marked
+as passing.
+
+The native input checker verifies all 21 definitions, 1,104 workloads and 5,493
+tensor paths: shape, dtype, content hash, constraints, provenance and absence of
+unreferenced files. The dataset has 5,111 unique snapshots. The complete changed
+attention replay covers 202 workloads. Per-workload validation and scoped
+comparisons are summarized in [performance.md](performance.md) and recorded in
+[results.jsonl](results.jsonl) and
+[summary.json](summary.json); source hashes identify earlier and final variants.
+
+GPU measurements use B300, PyTorch 2.14.1+cu130 and the dependencies recorded in
+the summary. Eager timings and prepared-launch graph timings are separate.
+Graph timings include GPU conversions/padding/gathers within launch; only
+explicit prepare work is excluded. In particular a prepared serving baseline
+is not compared silently with an untimed preparation of the candidate.
+Compilation, reference execution and input loading occur outside timing.
+Measurements are standalone; they do not establish end-to-end serving speedups.
+
+The initial QSA compatibility experiment used TileLang 0.1.12, as required by
+current SGLang, and the old custom implementation mismatched 45 workloads.
+Rechecking its declared TileLang 0.1.15 produced **192/192 exact passes**.
+Therefore those failures are a dependency-version incompatibility, not evidence
+that the old implementation fails with its declared environment. The final
+implementation uses the current native scoring path on 0.1.12 and is compared
+with the old implementation on its actual declared 0.1.15 dependency.
+
+## Reproduce
+
+Install the selected solution's pinned dependencies and materialize the dataset
+with Git LFS. Different historical solutions can require separate environments.
+Run the audit from the repository root:
+
+```bash
+python scripts/audit_solutions.py \
+  --gpu GPU-UUID --lock-directory /path/to/locks \
+  --suite all --reference-cache --graph-timing \
+  --report results/audit.jsonl
+
+# Inspect GDN's historical strict bound in addition to formal acceptance.
+python scripts/audit_solutions.py \
+  --gpu GPU-UUID --lock-directory /path/to/locks \
+  --definition gdn_prefill_qk4_v8_d128_k_last \
+  --suite dev --strict-diagnostic --scale-probe \
+  --report results/gdn-diagnostics.jsonl
+
+python scripts/check_workload_inputs.py
+python -m unittest discover -s tests
+```
+
+`--data-root` can point to separately materialized tensors; `--cache-directory`
+selects a writable reference/module cache. `--solution` and `--definition` are
+repeatable. `--validation-only` skips timing. `--candidate /path/to/main.py`
+compares an extra implementation on one selected definition. The script exits
+nonzero on load or correctness failure; graph-capture failures are reported
+separately from numerical correctness.
+
+## Build details
+
+NATTEN 0.21.7 was built for SM103 with `CXX_STD=20` in its CMake cache:
+PyTorch 2.14 headers require C++20, while the upstream build defaults to C++17.
+The kernel sources were unchanged. `NATTEN_BUILD_DIR` must name an existing
+directory for that cache setting to be used.
+
+FlashMLA was built at the recorded commit and its CUTLASS submodule
+`4faf1a1568cf1e4ad8ff71846a13e16f2a6a6f6b`. CUDA 13.0 cannot compile that source;
+the upstream minimum is 13.1. Both isolated 13.1.115 and 13.3.73 compiler builds
+were evaluated on all 72 workloads. The 13.3 build triggered upstream's
+register-spill performance guard for sparse FP8 decode; its documented
+`FLASH_MLA_SKIP_REG_SPILL_CHECK=1` build option was used for the additional
+comparison. This skips a compiler performance guard, not output validation.
+All 72 numerical/input-immutability checks passed for both builds. The 13.3
+build gives about 3.3% geometric-mean improvement for the 42 mixed-decode
+workloads and about 0.6% for the two sparse-prefill groups in this measurement.
+These are compiler-specific results, not an algorithm or interface change.

docs/interface-audit/interfaces.json

@@ -0,0 +1,345 @@
+{
+  "date": "2026-10-19",
+  "sglang_capture_commit": "684fea8af3b11a5b51ec9966c02959a32ad3421c",
+  "sglang_audit_commit": "0025f9394421451aa09ec192a4a6e7928e14736b",
+  "all_drop_in": false,
+  "full_engine_substitution_tested": false,
+  "counts": {
+    "reshaped_tensor_operands": 3,
+    "specialized_leaf_operands": 7,
+    "structural_adapter_required": 11
+  },
+  "definitions": [
+    {
+      "definition": "prefix_cached_block_causal_h32_d128",
+      "inputs": [
+        "Q",
+        "K_prefix",
+        "V_prefix",
+        "K_current",
+        "V_current"
+      ],
+      "integration_verified": false,
+      "boundary": "specialized_leaf_operands",
+      "native_call": "forward_with_replicated_kv_prefix(q, k_prefix, v_prefix, k_suffix, v_suffix)",
+      "source": "https://github.com/sgl-project/sglang/blob/0025f9394421451aa09ec192a4a6e7928e14736b/python/sglang/multimodal_gen/runtime/layers/attention/layer.py#L2134",
+      "adaptation": "After this PR all five tensor operands occur in native positional order. All 28 captured target-image calls have full visibility. The fixed scale, all-valid keys and artificial image IDs are removed. The serving method additionally obtains attention context and supports sequence parallelism; captures use one GPU.",
+      "next_step": "Integrate at this specialized single-GPU boundary and test the serving context; distributed prefix attention remains outside these captures."
+    },
+    {
+      "definition": "prefix_cached_block_causal_h32_d128_prefix0",
+      "inputs": [
+        "Q",
+        "K_current",
+        "V_current",
+        "image_ids"
+      ],
+      "integration_verified": false,
+      "boundary": "structural_adapter_required",
+      "native_call": "QwenImage21Attention.attend_sample: several local_attn calls followed by cat_outputs",
+      "source": "https://github.com/sgl-project/sglang/blob/0025f9394421451aa09ec192a4a6e7928e14736b/python/sglang/multimodal_gen/runtime/models/dits/qwen_image21.py#L719",
+      "adaptation": "The dataset combines the entire prefix into one block-causal operation. The engine calls attention once per text/image segment with different Q/K ranges and text causal masks. image_ids encodes the segment list. Empty prefix tensors, the all-true key mask and fixed scale are removed, but the composed call boundary remains.",
+      "next_step": "Recapture individual segment calls or introduce explicit segment metadata and a composed-operator integration API; do not label the existing definition a direct leaf replacement."
+    },
+    {
+      "definition": "noncausal_dense_attention_h32_d128",
+      "inputs": [
+        "Q",
+        "K",
+        "V"
+      ],
+      "integration_verified": false,
+      "boundary": "specialized_leaf_operands",
+      "native_call": "SDPAImpl.forward(query, key, value, attn_metadata)",
+      "source": "https://github.com/sgl-project/sglang/blob/0025f9394421451aa09ec192a4a6e7928e14736b/python/sglang/multimodal_gen/runtime/layers/attention/backends/sdpa.py#L89",
+      "adaptation": "The three tensor operands and their [B,N,H,D] layouts match the noncausal no-mask leaf. Head-dependent scale, dropout=0 and causal=False are fixed configuration; the engine passes its own context metadata. This PR removes the redundant runtime scale.",
+      "next_step": "Integrate the candidate through the existing attention backend/context dispatch; no full-engine replacement has been tested."
+    },
+    {
+      "definition": "noncausal_dense_attention_h32_d64",
+      "inputs": [
+        "Q",
+        "K",
+        "V"
+      ],
+      "integration_verified": false,
+      "boundary": "specialized_leaf_operands",
+      "native_call": "SDPAImpl.forward(query, key, value, attn_metadata)",
+      "source": "https://github.com/sgl-project/sglang/blob/0025f9394421451aa09ec192a4a6e7928e14736b/python/sglang/multimodal_gen/runtime/layers/attention/backends/sdpa.py#L89",
+      "adaptation": "The three tensor operands and their [B,N,H,D] layouts match the noncausal no-mask leaf. Head-dependent scale, dropout=0 and causal=False are fixed configuration; the engine passes its own context metadata. This PR removes the redundant runtime scale.",
+      "next_step": "Integrate the candidate through the existing attention backend/context dispatch; no full-engine replacement has been tested."
+    },
+    {
+      "definition": "gdn_decode_qk4_v8_d128_k_last",
+      "inputs": [
+        "q",
+        "k",
+        "v",
+        "state",
+        "A_log",
+        "a",
+        "dt_bias",
+        "b",
+        "scale"
+      ],
+      "integration_verified": false,
+      "boundary": "structural_adapter_required",
+      "native_call": "FlashInferGDNKernel.decode",
+      "source": "https://github.com/sgl-project/sglang/blob/0025f9394421451aa09ec192a4a6e7928e14736b/python/sglang/srt/layers/attention/linear/kernels/gdn_flashinfer.py#L387",
+      "adaptation": "The contest decode reads per-batch K-last state and returns a separate new_state, with Q/K normalization disabled. SM100 SGLang instead passes the complete mutable state pool plus slot indices, enables Q/K L2 normalization and writes the pool. The contest model TP/head configuration also differs.",
+      "next_step": "Capture the real current SGLang boundary, retaining normalization, pool/state-index side effects where present, prefill output buffers/checkpoints and the actual model configuration. Adding identity slot indices to contest tensors would not prove native parity."
+    },
+    {
+      "definition": "gdn_prefill_qk4_v8_d128_k_last",
+      "inputs": [
+        "q",
+        "k",
+        "v",
+        "state",
+        "A_log",
+        "a",
+        "dt_bias",
+        "b",
+        "cu_seqlens",
+        "scale"
+      ],
+      "integration_verified": false,
+      "boundary": "structural_adapter_required",
+      "native_call": "FlashInferGDNKernel.extend",
+      "source": "https://github.com/sgl-project/sglang/blob/0025f9394421451aa09ec192a4a6e7928e14736b/python/sglang/srt/layers/attention/linear/kernels/gdn_flashinfer.py#L481",
+      "adaptation": "K-last layout matches. Importantly, the actual SGLang FlashInfer prefill leaf already receives a gathered per-batch state, not the whole pool. However SGLang prepares normalized Q/K and linear decay alpha, passes preallocated output/state buffers and optional checkpoint metadata, and scatters states back. The contest definition instead accepts raw A_log/a/dt_bias/b and unnormalized Q/K, with a different model/head configuration.",
+      "next_step": "Capture the real current SGLang boundary, retaining normalization, pool/state-index side effects where present, prefill output buffers/checkpoints and the actual model configuration. Adding identity slot indices to contest tensors would not prove native parity."
+    },
+    {
+      "definition": "dense_gemm_bf16_nt_n12288_k4096",
+      "inputs": [
+        "A",
+        "W"
+      ],
+      "integration_verified": false,
+      "boundary": "reshaped_tensor_operands",
+      "native_call": "torch.nn.functional.linear(input, weight, bias=None)",
+      "source": "https://github.com/sgl-project/sglang/blob/0025f9394421451aa09ec192a4a6e7928e14736b/python/sglang/multimodal_gen/runtime/models/dits/qwen_image21.py",
+      "adaptation": "Capture flattens batch/sequence dimensions into M; restore the original leading dimensions at the model boundary. Two-dimensional GEMM operands and BF16 output match the bias-free linear leaf.",
+      "next_step": "Retain original leading shapes in per-call captures for direct high-level F.linear replacement."
+    },
+    {
+      "definition": "dense_gemm_bf16_nt_n4096_k12288",
+      "inputs": [
+        "A",
+        "W"
+      ],
+      "integration_verified": false,
+      "boundary": "reshaped_tensor_operands",
+      "native_call": "torch.nn.functional.linear(input, weight, bias=None)",
+      "source": "https://github.com/sgl-project/sglang/blob/0025f9394421451aa09ec192a4a6e7928e14736b/python/sglang/multimodal_gen/runtime/models/dits/qwen_image21.py",
+      "adaptation": "Capture flattens batch/sequence dimensions into M; restore the original leading dimensions at the model boundary. Two-dimensional GEMM operands and BF16 output match the bias-free linear leaf.",
+      "next_step": "Retain original leading shapes in per-call captures for direct high-level F.linear replacement."
+    },
+    {
+      "definition": "dense_gemm_bf16_nt_n4096_k4096",
+      "inputs": [
+        "A",
+        "W"
+      ],
+      "integration_verified": false,
+      "boundary": "reshaped_tensor_operands",
+      "native_call": "torch.nn.functional.linear(input, weight, bias=None)",
+      "source": "https://github.com/sgl-project/sglang/blob/0025f9394421451aa09ec192a4a6e7928e14736b/python/sglang/multimodal_gen/runtime/models/dits/qwen_image21.py",
+      "adaptation": "Capture flattens batch/sequence dimensions into M; restore the original leading dimensions at the model boundary. Two-dimensional GEMM operands and BF16 output match the bias-free linear leaf.",
+      "next_step": "Retain original leading shapes in per-call captures for direct high-level F.linear replacement."
+    },
+    {
+      "definition": "grouped_gemm_fp8_fp4_e384_n4608_k5120_g32",
+      "inputs": [
+        "Aq",
+        "Wq_packed",
+        "scale_A",
+        "scale_W",
+        "expert_id"
+      ],
+      "integration_verified": false,
+      "boundary": "structural_adapter_required",
+      "native_call": "deep_gemm_wrapper.grouped_gemm_nt_f8f8bf16_contig(lhs, rhs, out, m_indices, recipe_a, recipe_b)",
+      "source": "https://github.com/sgl-project/sglang/blob/0025f9394421451aa09ec192a4a6e7928e14736b/python/sglang/srt/layers/deep_gemm_wrapper/entrypoint.py#L132",
+      "adaptation": "Capture gathers four EP ranks (96 experts each) into a global 384-expert task, removes -1 padded rows, sorts valid rows by expert and serializes UE8M0 scale bytes. The native kernel consumes per-rank padded buffers, packed physical scale layouts, m_indices and a destination buffer. The packaged SGLang baseline reconstructs all four calls.",
+      "next_step": "Recapture per-rank padded operands, physical scales, output buffers and row maps. Complete logical MoE projection is preserved; the removed half-gate task is not restored.",
+      "capture_recipe_note": "The capture can expand group-128 activation scales into four identical logical group-32 scale bytes. Original physical scale layout and original group-size metadata are not native task arguments; the packaged baseline reconstructs a group-32 path."
+    },
+    {
+      "definition": "grouped_gemm_fp8_fp4_e384_n5120_k2304_g32",
+      "inputs": [
+        "Aq",
+        "Wq_packed",
+        "scale_A",
+        "scale_W",
+        "expert_id"
+      ],
+      "integration_verified": false,
+      "boundary": "structural_adapter_required",
+      "native_call": "deep_gemm_wrapper.grouped_gemm_nt_f8f8bf16_contig(lhs, rhs, out, m_indices, recipe_a, recipe_b)",
+      "source": "https://github.com/sgl-project/sglang/blob/0025f9394421451aa09ec192a4a6e7928e14736b/python/sglang/srt/layers/deep_gemm_wrapper/entrypoint.py#L132",
+      "adaptation": "Capture gathers four EP ranks (96 experts each) into a global 384-expert task, removes -1 padded rows, sorts valid rows by expert and serializes UE8M0 scale bytes. The native kernel consumes per-rank padded buffers, packed physical scale layouts, m_indices and a destination buffer. The packaged SGLang baseline reconstructs all four calls.",
+      "next_step": "Recapture per-rank padded operands, physical scales, output buffers and row maps. Complete logical MoE projection is preserved; the removed half-gate task is not restored.",
+      "capture_recipe_note": "The capture can expand group-128 activation scales into four identical logical group-32 scale bytes. Original physical scale layout and original group-size metadata are not native task arguments; the packaged baseline reconstructs a group-32 path."
+    },
+    {
+      "definition": "mixed_mla_decode_deepseek41_h64_d512_k8128_k4512",
+      "inputs": [
+        "Q",
+        "KV8",
+        "KV4",
+        "indices8",
+        "indices4",
+        "attn_sink",
+        "sm_scale"
+      ],
+      "integration_verified": false,
+      "boundary": "structural_adapter_required",
+      "native_call": "sgl_kernel.flash_mla.flash_mla_with_kvcache",
+      "source": "https://github.com/sgl-project/sglang/blob/0025f9394421451aa09ec192a4a6e7928e14736b/python/sglang/srt/layers/attention/deepseek_v4_backend.py",
+      "adaptation": "The four-rank real-head gather differs from native per-rank zero padding. Only reachable physical KV pages are retained; topk lengths and scheduler metadata are reconstructed. Upstream FlashMLA and the serving fork use different FP8 page byte layouts, requiring the packaged conversion. The engine also has mutable scheduling/workspace state.",
+      "next_step": "Recapture per-rank Q/sink, original cache pools, explicit valid lengths and scheduler metadata. The newer optional MegaAttention path needs missing pre-RoPE/normalization inputs and positions."
+    },
+    {
+      "definition": "moe_router_gemm_topk_deepseek41_d5120_e384_topk6",
+      "inputs": [
+        "X",
+        "W",
+        "bias_text",
+        "bias_image",
+        "is_image_token",
+        "routed_scale"
+      ],
+      "integration_verified": false,
+      "boundary": "structural_adapter_required",
+      "native_call": "MoEGate.forward followed by vision_topk / moe_fused_gate",
+      "source": "https://github.com/sgl-project/sglang/blob/0025f9394421451aa09ec192a4a6e7928e14736b/python/sglang/srt/multimodal/dsv41/vl_routing.py",
+      "adaptation": "One task combines projection and routing. A boolean image selector replaces original token IDs; output IDs are sorted int64 rather than native unordered int32, and deferred routed scaling is applied. The new solution uses the native projection and fused gate, accepts the boolean directly and combines output ordering in one Triton launch.",
+      "next_step": "Either integrate this composed operation with its explicit output adapter, or split projection/routing captures and retain native token IDs and output dtypes/ordering."
+    },
+    {
+      "definition": "neighborhood_attention_3d_h16_d64_kt3_ky7_kx7",
+      "inputs": [
+        "Q",
+        "K",
+        "V"
+      ],
+      "integration_verified": false,
+      "boundary": "specialized_leaf_operands",
+      "native_call": "natten.functional.na3d(query, key, value, kernel_size=self.kernel_size, scale=1.0)",
+      "source": "https://github.com/sgl-project/sglang/blob/0025f9394421451aa09ec192a4a6e7928e14736b/python/sglang/multimodal_gen/runtime/models/decoders/ltx_2_5_diffusion_decoder.py#L421",
+      "adaptation": "Tensor layout [B,T,Y,X,H,D] already matches na3d. Q includes the model scale. Kernel size and scale=1 are fixed configuration. The SGLang wrapper now selects NATTEN when installed and otherwise uses the original FlexAttention fallback.",
+      "next_step": "Bind the fixed keyword configuration and test within the VAE block; no full model substitution is claimed."
+    },
+    {
+      "definition": "neighborhood_attention_3d_h32_d64_kt3_ky7_kx7",
+      "inputs": [
+        "Q",
+        "K",
+        "V"
+      ],
+      "integration_verified": false,
+      "boundary": "specialized_leaf_operands",
+      "native_call": "natten.functional.na3d(query, key, value, kernel_size=self.kernel_size, scale=1.0)",
+      "source": "https://github.com/sgl-project/sglang/blob/0025f9394421451aa09ec192a4a6e7928e14736b/python/sglang/multimodal_gen/runtime/models/decoders/ltx_2_5_diffusion_decoder.py#L421",
+      "adaptation": "Tensor layout [B,T,Y,X,H,D] already matches na3d. Q includes the model scale. Kernel size and scale=1 are fixed configuration. The SGLang wrapper now selects NATTEN when installed and otherwise uses the original FlexAttention fallback.",
+      "next_step": "Bind the fixed keyword configuration and test within the VAE block; no full model substitution is claimed."
+    },
+    {
+      "definition": "neighborhood_attention_3d_h4_d64_kt11_ky11_kx11",
+      "inputs": [
+        "Q",
+        "K",
+        "V"
+      ],
+      "integration_verified": false,
+      "boundary": "specialized_leaf_operands",
+      "native_call": "natten.functional.na3d(query, key, value, kernel_size=self.kernel_size, scale=1.0)",
+      "source": "https://github.com/sgl-project/sglang/blob/0025f9394421451aa09ec192a4a6e7928e14736b/python/sglang/multimodal_gen/runtime/models/decoders/ltx_2_5_diffusion_decoder.py#L421",
+      "adaptation": "Tensor layout [B,T,Y,X,H,D] already matches na3d. Q includes the model scale. Kernel size and scale=1 are fixed configuration. The SGLang wrapper now selects NATTEN when installed and otherwise uses the original FlexAttention fallback.",
+      "next_step": "Bind the fixed keyword configuration and test within the VAE block; no full model substitution is claimed."
+    },
+    {
+      "definition": "neighborhood_attention_3d_h8_d64_kt3_ky5_kx5",
+      "inputs": [
+        "Q",
+        "K",
+        "V"
+      ],
+      "integration_verified": false,
+      "boundary": "specialized_leaf_operands",
+      "native_call": "natten.functional.na3d(query, key, value, kernel_size=self.kernel_size, scale=1.0)",
+      "source": "https://github.com/sgl-project/sglang/blob/0025f9394421451aa09ec192a4a6e7928e14736b/python/sglang/multimodal_gen/runtime/models/decoders/ltx_2_5_diffusion_decoder.py#L421",
+      "adaptation": "Tensor layout [B,T,Y,X,H,D] already matches na3d. Q includes the model scale. Kernel size and scale=1 are fixed configuration. The SGLang wrapper now selects NATTEN when installed and otherwise uses the original FlexAttention fallback.",
+      "next_step": "Bind the fixed keyword configuration and test within the VAE block; no full model substitution is claimed."
+    },
+    {
+      "definition": "qsa_index_topk_decode_qwen38_h4_d128_topk512_c4",
+      "inputs": [
+        "Q_idx",
+        "Kc_pages",
+        "page_table",
+        "num_complete_blocks"
+      ],
+      "integration_verified": false,
+      "boundary": "structural_adapter_required",
+      "native_call": "QSAIndexer.select_decode_tokens -> qsa_mqa_decode + fast_topk",
+      "source": "https://github.com/sgl-project/sglang/blob/0025f9394421451aa09ec192a4a6e7928e14736b/python/sglang/srt/layers/attention/qsa/qsa_indexer.py#L491",
+      "adaptation": "Capture removes four zero-padded query heads (8 to 4), compacts live cache pages and changes unordered native IDs to ascending logical IDs with -1 suffix. The new default reuses maintained scoring and exact stable compaction; its score-free short path preserves the task's output contract.",
+      "next_step": "Capture the native padded query/cache/page-table boundary and explicitly support the engine's output ordering, or keep the documented adapters. Do not weaken exact selected-set or lower-ID-tie semantics."
+    },
+    {
+      "definition": "qsa_sparse_gqa_decode_qwen38_h24_kv2_d256_topk512_c4",
+      "inputs": [
+        "Q",
+        "K_pages",
+        "V_pages",
+        "page_table",
+        "block_ids",
+        "context_lens"
+      ],
+      "integration_verified": false,
+      "boundary": "structural_adapter_required",
+      "native_call": "QwenSparseAttnBackend.forward_decode -> TRT-LLM paged attention",
+      "source": "https://github.com/sgl-project/sglang/blob/0025f9394421451aa09ec192a4a6e7928e14736b/python/sglang/srt/layers/attention/qwen_sparse_attn_backend.py",
+      "adaptation": "Inputs are compacted page snapshots after the current-token KV write. The engine receives the original pool, request-to-token metadata and current KV, and fuses sparse block expansion/cache packing. The standalone adapter reconstructs that metadata and physical packing.",
+      "next_step": "Retain the original pools, request maps, current-token KV writes and the exact fused-call metadata in new captures. The native TRT-LLM solution is provided as a faster measured alternative to FA4, with adapters still explicit."
+    },
+    {
+      "definition": "sparse_mla_prefill_h64_d512_k128",
+      "inputs": [
+        "Q",
+        "KV",
+        "indices",
+        "topk_length",
+        "attn_sink",
+        "sm_scale"
+      ],
+      "integration_verified": false,
+      "boundary": "structural_adapter_required",
+      "native_call": "sgl_kernel.flash_mla.flash_mla_sparse_fwd",
+      "source": "https://github.com/sgl-project/sglang/blob/0025f9394421451aa09ec192a4a6e7928e14736b/python/sglang/srt/layers/attention/deepseek_v4_backend.py",
+      "adaptation": "Capture gathers 16 real query heads from each of four TP ranks into 64 real heads. The engine passes each rank's 16 heads in a zero-padded 64-head buffer and keeps its first 16 outputs. The SGLang adapter repeats four native calls and concatenates their outputs.",
+      "next_step": "Recapture per-rank padded Q/sink and output slices. Current optional MegaAttention further fuses normalization/RoPE and needs pre-transform inputs not present in this definition."
+    },
+    {
+      "definition": "sparse_mla_prefill_h64_d512_k640",
+      "inputs": [
+        "Q",
+        "KV",
+        "indices",
+        "topk_length",
+        "attn_sink",
+        "sm_scale"
+      ],
+      "integration_verified": false,
+      "boundary": "structural_adapter_required",
+      "native_call": "sgl_kernel.flash_mla.flash_mla_sparse_fwd",
+      "source": "https://github.com/sgl-project/sglang/blob/0025f9394421451aa09ec192a4a6e7928e14736b/python/sglang/srt/layers/attention/deepseek_v4_backend.py",
+      "adaptation": "Capture gathers 16 real query heads from each of four TP ranks into 64 real heads. The engine passes each rank's 16 heads in a zero-padded 64-head buffer and keeps its first 16 outputs. The SGLang adapter repeats four native calls and concatenates their outputs.",
+      "next_step": "Recapture per-rank padded Q/sink and output slices. Current optional MegaAttention further fuses normalization/RoPE and needs pre-transform inputs not present in this definition."
+    }
+  ],
+  "snapshot_limit": "CaptureWriter materializes contiguous CPU tensors; original storage offsets, aliasing and arbitrary engine strides are not represented by the safetensors inputs. Tensor-dimension correspondence does not prove storage-ABI parity."
+}

docs/interface-audit/performance.md

@@ -0,0 +1,17 @@
+# Recorded B300 comparisons
+
+Ratios are paired geometric-mean speedups in the recorded standalone CUDA Graph scope. Prepared launch is used where available; eager timings remain in the raw results. These are not end-to-end serving speedups or proofs of global optimality.
+
+| Comparison | Paired workloads | Speedup |
+|---|---:|---:|
+| B300 GEMM large-M native-linear dispatch versus DeepGEMM-only | 31 | 0.44× |
+| Audio final versus original FP16-conversion solution | 108 | 4.03× |
+| Current fused router versus original CUTLASS/torch solution | 50 | 5.00× |
+| Cached-prefix FA4 versus serving implementation adapter | 28 | 3.81× |
+| QSA index final versus original on its declared TileLang 0.1.15 | 10 | 2.28× |
+| Native paged sparse GQA versus FA4 sparse gather | 10 | 1.90× |
+| FlashMLA CUDA 13.3 versus CUDA 13.1 compiler build | 10 | 1.01× |
+| FlashMLA CUDA 13.3 versus CUDA 13.1 compiler build | 20 | 1.01× |
+| FlashMLA CUDA 13.3 versus CUDA 13.1 compiler build | 42 | 1.03× |
+
+The old QSA implementation is measured with its declared TileLang 0.1.15, rather than the incompatible 0.1.12 experiment. Current SGLang-based solutions use 0.1.12. See [summary.json](summary.json) for ranges, source run identifiers and coverage; [results.jsonl](results.jsonl) retains separate eager and prepared timings.

docs/interface-audit/preferred-solutions.json

@@ -0,0 +1,132 @@
+{
+  "date": "2026-10-19",
+  "hardware": "NVIDIA_B300",
+  "definitions": [
+    {
+      "definition": "prefix_cached_block_causal_h32_d128",
+      "solution": "fa4_prefix_h32_d128",
+      "path": "solutions/block_causal_attention/fa4_prefix_h32_d128.json",
+      "scope": "B300 current captured workloads; selected maintained path after scoped comparisons, not a fastest-for-every-shape or global-optimality claim"
+    },
+    {
+      "definition": "prefix_cached_block_causal_h32_d128_prefix0",
+      "solution": "fa4_prefix0_h32_d128",
+      "path": "solutions/block_causal_attention/fa4_prefix0_h32_d128.json",
+      "scope": "B300 current captured workloads; selected maintained path after scoped comparisons, not a fastest-for-every-shape or global-optimality claim"
+    },
+    {
+      "definition": "noncausal_dense_attention_h32_d128",
+      "solution": "fa4_noncausal_h32_d128",
+      "path": "solutions/dense_attention/fa4_noncausal_h32_d128.json",
+      "scope": "B300 current captured workloads; selected maintained path after scoped comparisons, not a fastest-for-every-shape or global-optimality claim"
+    },
+    {
+      "definition": "noncausal_dense_attention_h32_d64",
+      "solution": "fa4_noncausal_h32_d64",
+      "path": "solutions/dense_attention/fa4_noncausal_h32_d64.json",
+      "scope": "B300 current captured workloads; selected maintained path after scoped comparisons, not a fastest-for-every-shape or global-optimality claim"
+    },
+    {
+      "definition": "gdn_decode_qk4_v8_d128_k_last",
+      "solution": "flashinfer_gdn_decode",
+      "path": "solutions/gdn/flashinfer_gdn_decode.json",
+      "scope": "B300 current captured workloads; selected maintained path after scoped comparisons, not a fastest-for-every-shape or global-optimality claim"
+    },
+    {
+      "definition": "gdn_prefill_qk4_v8_d128_k_last",
+      "solution": "flashinfer_gdn_prefill",
+      "path": "solutions/gdn/flashinfer_gdn_prefill.json",
+      "scope": "B300 current captured workloads; selected maintained path after scoped comparisons, not a fastest-for-every-shape or global-optimality claim"
+    },
+    {
+      "definition": "dense_gemm_bf16_nt_n12288_k4096",
+      "solution": "deepgemm_bf16_n12288_k4096",
+      "path": "solutions/gemm/deepgemm_bf16_n12288_k4096.json",
+      "scope": "B300 current captured workloads; selected maintained path after scoped comparisons, not a fastest-for-every-shape or global-optimality claim"
+    },
+    {
+      "definition": "dense_gemm_bf16_nt_n4096_k12288",
+      "solution": "deepgemm_bf16_n4096_k12288",
+      "path": "solutions/gemm/deepgemm_bf16_n4096_k12288.json",
+      "scope": "B300 current captured workloads; selected maintained path after scoped comparisons, not a fastest-for-every-shape or global-optimality claim"
+    },
+    {
+      "definition": "dense_gemm_bf16_nt_n4096_k4096",
+      "solution": "hybrid_bf16_n4096_k4096",
+      "path": "solutions/gemm/hybrid_bf16_n4096_k4096.json",
+      "scope": "B300 current captured workloads; selected maintained path after scoped comparisons, not a fastest-for-every-shape or global-optimality claim"
+    },
+    {
+      "definition": "grouped_gemm_fp8_fp4_e384_n4608_k5120_g32",
+      "solution": "deepgemm_n4608_k5120",
+      "path": "solutions/grouped_gemm/deepgemm_n4608_k5120.json",
+      "scope": "B300 current captured workloads; selected maintained path after scoped comparisons, not a fastest-for-every-shape or global-optimality claim"
+    },
+    {
+      "definition": "grouped_gemm_fp8_fp4_e384_n5120_k2304_g32",
+      "solution": "deepgemm_n5120_k2304",
+      "path": "solutions/grouped_gemm/deepgemm_n5120_k2304.json",
+      "scope": "B300 current captured workloads; selected maintained path after scoped comparisons, not a fastest-for-every-shape or global-optimality claim"
+    },
+    {
+      "definition": "mixed_mla_decode_deepseek41_h64_d512_k8128_k4512",
+      "solution": "flashmla_v41",
+      "path": "solutions/mixed_mla/flashmla_v41.json",
+      "scope": "B300 current captured workloads; selected maintained path after scoped comparisons, not a fastest-for-every-shape or global-optimality claim"
+    },
+    {
+      "definition": "moe_router_gemm_topk_deepseek41_d5120_e384_topk6",
+      "solution": "fused_router",
+      "path": "solutions/moe_router/fused_router.json",
+      "scope": "B300 current captured workloads; selected maintained path after scoped comparisons, not a fastest-for-every-shape or global-optimality claim"
+    },
+    {
+      "definition": "neighborhood_attention_3d_h16_d64_kt3_ky7_kx7",
+      "solution": "natten_blackwell_h16_3x7x7",
+      "path": "solutions/neighborhood_attention/natten_blackwell_h16_3x7x7.json",
+      "scope": "B300 current captured workloads; selected maintained path after scoped comparisons, not a fastest-for-every-shape or global-optimality claim"
+    },
+    {
+      "definition": "neighborhood_attention_3d_h32_d64_kt3_ky7_kx7",
+      "solution": "natten_blackwell_h32_3x7x7",
+      "path": "solutions/neighborhood_attention/natten_blackwell_h32_3x7x7.json",
+      "scope": "B300 current captured workloads; selected maintained path after scoped comparisons, not a fastest-for-every-shape or global-optimality claim"
+    },
+    {
+      "definition": "neighborhood_attention_3d_h4_d64_kt11_ky11_kx11",
+      "solution": "natten_blackwell_h4_11x11x11",
+      "path": "solutions/neighborhood_attention/natten_blackwell_h4_11x11x11.json",
+      "scope": "B300 current captured workloads; selected maintained path after scoped comparisons, not a fastest-for-every-shape or global-optimality claim"
+    },
+    {
+      "definition": "neighborhood_attention_3d_h8_d64_kt3_ky5_kx5",
+      "solution": "natten_blackwell_h8_3x5x5",
+      "path": "solutions/neighborhood_attention/natten_blackwell_h8_3x5x5.json",
+      "scope": "B300 current captured workloads; selected maintained path after scoped comparisons, not a fastest-for-every-shape or global-optimality claim"
+    },
+    {
+      "definition": "qsa_index_topk_decode_qwen38_h4_d128_topk512_c4",
+      "solution": "sglang_tilelang_index",
+      "path": "solutions/qsa_index/sglang_tilelang_index.json",
+      "scope": "B300 current captured workloads; selected maintained path after scoped comparisons, not a fastest-for-every-shape or global-optimality claim"
+    },
+    {
+      "definition": "qsa_sparse_gqa_decode_qwen38_h24_kv2_d256_topk512_c4",
+      "solution": "trtllm_sparse_gqa",
+      "path": "solutions/qsa_attention/trtllm_sparse_gqa.json",
+      "scope": "B300 current captured workloads; selected maintained path after scoped comparisons, not a fastest-for-every-shape or global-optimality claim"
+    },
+    {
+      "definition": "sparse_mla_prefill_h64_d512_k128",
+      "solution": "flashmla_prefill_k128",
+      "path": "solutions/sparse_mla/flashmla_prefill_k128.json",
+      "scope": "B300 current captured workloads; selected maintained path after scoped comparisons, not a fastest-for-every-shape or global-optimality claim"
+    },
+    {
+      "definition": "sparse_mla_prefill_h64_d512_k640",
+      "solution": "flashmla_prefill_k640",
+      "path": "solutions/sparse_mla/flashmla_prefill_k640.json",
+      "scope": "B300 current captured workloads; selected maintained path after scoped comparisons, not a fastest-for-every-shape or global-optimality claim"
+    }
+  ]
+}

docs/interface-audit/qsa-tie-edge-cases.json

@@ -0,0 +1,42 @@
+{
+  "checks": [
+    {
+      "capacity": 32,
+      "lengths": [
+        0,
+        1,
+        32
+      ],
+      "all_scores_equal": true,
+      "lower_ids_exact": true,
+      "status": "passed"
+    },
+    {
+      "capacity": 640,
+      "lengths": [
+        0,
+        511,
+        512,
+        513,
+        640
+      ],
+      "all_scores_equal": true,
+      "lower_ids_exact": true,
+      "status": "passed"
+    },
+    {
+      "capacity": 65536,
+      "lengths": [
+        0,
+        511,
+        512,
+        513,
+        65536
+      ],
+      "all_scores_equal": true,
+      "lower_ids_exact": true,
+      "status": "passed"
+    }
+  ],
+  "status": "passed"
+}

docs/interface-audit/sglang-head-recheck-diff.json

@@ -0,0 +1,21 @@
+{
+  "base": "0025f9394421451aa09ec192a4a6e7928e14736b",
+  "head": "ed0b8f433f887995b1ce361b15aaf9f6ca93483f",
+  "ahead_by": 1,
+  "files": [
+    {
+      "path": "python/sglang/kernels/ops/attention/mla_output_gate.py",
+      "status": "modified"
+    },
+    {
+      "path": "python/sglang/srt/layers/moe/moe_runner/ascend.py",
+      "status": "modified"
+    }
+  ],
+  "commits": [
+    {
+      "sha": "ed0b8f433f887995b1ce361b15aaf9f6ca93483f",
+      "title": "[Fix] [NPU] kimi-k3: skip fused gmm1 for situ activation in Ascend runner (#43837)"
+    }
+  ]
+}

docs/interface-audit/summary.json

@@ -0,0 +1,493 @@
+{
+  "date": "2026-10-19",
+  "status": "passed",
+  "secondary_baseline_cases_remaining": 0,
+  "scope": "One current preferred solution per definition, all captured workloads; not full serving integration or proof of global optimality",
+  "gpu": "NVIDIA B300",
+  "torch": "2.14.1+cu130",
+  "cutlass_dsl": "4.8.0",
+  "flashinfer_release": "0.7.2",
+  "tilelang_current_sglang": "0.1.12",
+  "tilelang_original_declared": "0.1.15",
+  "sglang_current_commit": "0025f9394421451aa09ec192a4a6e7928e14736b",
+  "solutions": 41,
+  "preferred_definitions": 21,
+  "preferred_workloads": 1104,
+  "tolerance_dev_and_timing_unchanged": true,
+  "native_input_check": {
+    "definitions": 21,
+    "workloads": 1104,
+    "tensors": 5493,
+    "missing_capture_definitions": [],
+    "errors": []
+  },
+  "changed_attention_engine_output_replay": {
+    "workloads": 202,
+    "passed": 202
+  },
+  "coverage": [
+    {
+      "definition": "prefix_cached_block_causal_h32_d128",
+      "solution": "fa4_prefix_h32_d128",
+      "workloads": 28,
+      "status": "passed",
+      "main_source_sha256": "ea9b3c887ea916e45144176d5efc9689f67e0f2c358b6550878ef474d534cf6c",
+      "source_bundle_sha256": "1b5b733b6a5f88dacc0f7ccd4c6b1680ae56e811349344778107f9e63ee03c97",
+      "runs": [
+        "attention-final-contracts"
+      ]
+    },
+    {
+      "definition": "prefix_cached_block_causal_h32_d128_prefix0",
+      "solution": "fa4_prefix0_h32_d128",
+      "workloads": 12,
+      "status": "passed",
+      "main_source_sha256": "c5742cde113a0e610300650857ae0221928e7242d8710efbb28d53bab066e9a0",
+      "source_bundle_sha256": "b781309fee9fc3fa9f4e73770754b79465b48f148fc4acaea8668704690fe360",
+      "runs": [
+        "attention-all"
+      ]
+    },
+    {
+      "definition": "noncausal_dense_attention_h32_d128",
+      "solution": "fa4_noncausal_h32_d128",
+      "workloads": 54,
+      "status": "passed",
+      "main_source_sha256": "67ed48f66216ccd570fa047fcf6c46dc2c7113387c972bf35788c5235c327f95",
+      "source_bundle_sha256": "dac275c646d983cc090a1427ddcad9972899893be035e5390d36d540cd87b1d4",
+      "runs": [
+        "attention-all"
+      ]
+    },
+    {
+      "definition": "noncausal_dense_attention_h32_d64",
+      "solution": "fa4_noncausal_h32_d64",
+      "workloads": 108,
+      "status": "passed",
+      "main_source_sha256": "7d5c98b3052f60560e52eb49d5802ac386c1da61009ec7faf723d0b055bfd85f",
+      "source_bundle_sha256": "ab47824774752abebf2fca278f38fd3506cbd76f45e74eb9027b7655f12f3978",
+      "runs": [
+        "attention-final-contracts"
+      ]
+    },
+    {
+      "definition": "gdn_decode_qk4_v8_d128_k_last",
+      "solution": "flashinfer_gdn_decode",
+      "workloads": 54,
+      "status": "passed",
+      "main_source_sha256": "e17286beadf7d1cec3c41cdacc7ab1a0f0f426847d7bfe7ec35369498c6393bf",
+      "source_bundle_sha256": "23a710cfbf848aaedb0f58d5313f9ff8e987342f2a1500a1705adfdc34d93f74",
+      "runs": [
+        "gdn-all-counted"
+      ]
+    },
+    {
+      "definition": "gdn_prefill_qk4_v8_d128_k_last",
+      "solution": "flashinfer_gdn_prefill",
+      "workloads": 100,
+      "status": "passed",
+      "main_source_sha256": "63a37b167c6496eee8519318a73177a1d2df07df3da6a9c0debd3c871f0c7b09",
+      "source_bundle_sha256": "a64843eee16239a2cce37dc1f3bfe4feca66e05f3bf3b2c0f2499105e4182378",
+      "runs": [
+        "gdn-all-counted"
+      ]
+    },
+    {
+      "definition": "dense_gemm_bf16_nt_n12288_k4096",
+      "solution": "deepgemm_bf16_n12288_k4096",
+      "workloads": 31,
+      "status": "passed",
+      "main_source_sha256": "ec62fd82b2cfb65dde71e19b1ffc890dfa90c946de4161fb1fdd1729fc5b33fd",
+      "source_bundle_sha256": "59154b578176ddc58f865e55bfa2e061ae48b3f89b2f44a9ec14b963782374a8",
+      "runs": [
+        "dense-n12288-final-all"
+      ]
+    },
+    {
+      "definition": "dense_gemm_bf16_nt_n4096_k12288",
+      "solution": "deepgemm_bf16_n4096_k12288",
+      "workloads": 31,
+      "status": "passed",
+      "main_source_sha256": "8b190e1905d9f7b4b0b14fa7303d4a08e227cf7760f1de5801b3f890ba9c8081",
+      "source_bundle_sha256": "d4ef0c9bb1a051e3d7f654e14646db349173a970100dedf179acc648d16b0533",
+      "runs": [
+        "gemm-all"
+      ]
+    },
+    {
+      "definition": "dense_gemm_bf16_nt_n4096_k4096",
+      "solution": "hybrid_bf16_n4096_k4096",
+      "workloads": 31,
+      "status": "passed",
+      "main_source_sha256": "8e1358895cda9eaa10258759ae3fe3a57c93731c731f73e7772b46b90c26e6b6",
+      "source_bundle_sha256": "ae030e7438d6664b7f4cad3e3244949c237f08de098a5ff452906edfb1eca3be",
+      "runs": [
+        "gemm-all"
+      ]
+    },
+    {
+      "definition": "grouped_gemm_fp8_fp4_e384_n4608_k5120_g32",
+      "solution": "deepgemm_n4608_k5120",
+      "workloads": 52,
+      "status": "passed",
+      "main_source_sha256": "d9814eacc8b50a38371ca250faf9a2c751bf66ac09b32b487c98117a8106ba21",
+      "source_bundle_sha256": "6b1a58f383b9682ae06b21b4feadc7c1c9ec82ea15a464de1b9f4b72f6fce978",
+      "runs": [
+        "gemm-all"
+      ]
+    },
+    {
+      "definition": "grouped_gemm_fp8_fp4_e384_n5120_k2304_g32",
+      "solution": "deepgemm_n5120_k2304",
+      "workloads": 52,
+      "status": "passed",
+      "main_source_sha256": "d9814eacc8b50a38371ca250faf9a2c751bf66ac09b32b487c98117a8106ba21",
+      "source_bundle_sha256": "6b1a58f383b9682ae06b21b4feadc7c1c9ec82ea15a464de1b9f4b72f6fce978",
+      "runs": [
+        "gemm-all"
+      ]
+    },
+    {
+      "definition": "mixed_mla_decode_deepseek41_h64_d512_k8128_k4512",
+      "solution": "flashmla_v41",
+      "workloads": 42,
+      "status": "passed",
+      "main_source_sha256": "05b199f80930fd87851c1b45d18248bc9a51943ceee9554af3dead121af80cea",
+      "source_bundle_sha256": "354ab160017c821ee197ae5741cb263ecb75fb0ad1d53d8fc427e26c0c63a8a6",
+      "runs": [
+        "mla-cu133-all"
+      ]
+    },
+    {
+      "definition": "moe_router_gemm_topk_deepseek41_d5120_e384_topk6",
+      "solution": "fused_router",
+      "workloads": 50,
+      "status": "passed",
+      "main_source_sha256": "278e9e41c9dd4d35607fbc760fbaaac583c7d4f75cbf0fe1353903b7ddd0d890",
+      "source_bundle_sha256": "41251abb5f27fbb587d28c2dbce5280775b403156f4f04cc1d2e85e1bef0018d",
+      "runs": [
+        "router-latest-all"
+      ]
+    },
+    {
+      "definition": "neighborhood_attention_3d_h16_d64_kt3_ky7_kx7",
+      "solution": "natten_blackwell_h16_3x7x7",
+      "workloads": 9,
+      "status": "passed",
+      "main_source_sha256": "1e37321ed835300fa3550a6fe29506bd28412d019581dbc9fbc10ccc8fff4a4c",
+      "source_bundle_sha256": "a8718b4b8210c509699cf4a17a4158a6f0f569236fa3c26aa3dd81278e71e376",
+      "runs": [
+        "na-all"
+      ]
+    },
+    {
+      "definition": "neighborhood_attention_3d_h32_d64_kt3_ky7_kx7",
+      "solution": "natten_blackwell_h32_3x7x7",
+      "workloads": 9,
+      "status": "passed",
+      "main_source_sha256": "1e37321ed835300fa3550a6fe29506bd28412d019581dbc9fbc10ccc8fff4a4c",
+      "source_bundle_sha256": "a8718b4b8210c509699cf4a17a4158a6f0f569236fa3c26aa3dd81278e71e376",
+      "runs": [
+        "na-all"
+      ]
+    },
+    {
+      "definition": "neighborhood_attention_3d_h4_d64_kt11_ky11_kx11",
+      "solution": "natten_blackwell_h4_11x11x11",
+      "workloads": 9,
+      "status": "passed",
+      "main_source_sha256": "c85ab6b43433432b5371920884c95ae14aeef6ead1354d4e60f7080195d0136f",
+      "source_bundle_sha256": "ee62e513b334c9e6dd2cf33cba16b1a615d52c2a5b619d0cf89c19a047b47a95",
+      "runs": [
+        "na-all"
+      ]
+    },
+    {
+      "definition": "neighborhood_attention_3d_h8_d64_kt3_ky5_kx5",
+      "solution": "natten_blackwell_h8_3x5x5",
+      "workloads": 18,
+      "status": "passed",
+      "main_source_sha256": "21d8e807c408bb8a5027ab6154e83bfb2ba06591f13b3cc8c454cc50000c937c",
+      "source_bundle_sha256": "161df7053b7218c4cadbb657165152edd38a897efa768c64a51332c0ee97c06f",
+      "runs": [
+        "na-all"
+      ]
+    },
+    {
+      "definition": "qsa_index_topk_decode_qwen38_h4_d128_topk512_c4",
+      "solution": "sglang_tilelang_index",
+      "workloads": 192,
+      "status": "passed",
+      "main_source_sha256": "ab3dd97e9595fbcb16e57423b8bac278f46dcb2b30472cdcf0d40f72c3e81561",
+      "source_bundle_sha256": "ab7d4df3cdefdaf1dc506f714ce3146c85927b8f58bbe3e964be15b7af8a6098",
+      "runs": [
+        "qsa-index-final-all"
+      ]
+    },
+    {
+      "definition": "qsa_sparse_gqa_decode_qwen38_h24_kv2_d256_topk512_c4",
+      "solution": "trtllm_sparse_gqa",
+      "workloads": 192,
+      "status": "passed",
+      "main_source_sha256": "517707b2c5fbf0e2eca4d038ff27704187ed97d3ff989e0270c887d8727200fc",
+      "source_bundle_sha256": "94954a8fc35eb4f5afa451ddb19f7eea4666d6d490d2ef43c95798ab12dbeddc",
+      "runs": [
+        "qsa-attention-native-all"
+      ]
+    },
+    {
+      "definition": "sparse_mla_prefill_h64_d512_k128",
+      "solution": "flashmla_prefill_k128",
+      "workloads": 10,
+      "status": "passed",
+      "main_source_sha256": "a4b0d38ef8c7f9c663d42dbb7423252c16052b0ad27ea390edd7c63bb9c71114",
+      "source_bundle_sha256": "bd8060d017ae6f67ab1e8f5ce6537b43b93827c612961fa0345dbfd5d4447904",
+      "runs": [
+        "mla-cu133-all"
+      ]
+    },
+    {
+      "definition": "sparse_mla_prefill_h64_d512_k640",
+      "solution": "flashmla_prefill_k640",
+      "workloads": 20,
+      "status": "passed",
+      "main_source_sha256": "a4b0d38ef8c7f9c663d42dbb7423252c16052b0ad27ea390edd7c63bb9c71114",
+      "source_bundle_sha256": "bd8060d017ae6f67ab1e8f5ce6537b43b93827c612961fa0345dbfd5d4447904",
+      "runs": [
+        "mla-cu133-all"
+      ]
+    }
+  ],
+  "comparisons": [
+    {
+      "comparison": "B300 GEMM large-M native-linear dispatch versus DeepGEMM-only",
+      "new_run": "dense-n12288-final-all",
+      "new_solution": "deepgemm_bf16_n12288_k4096",
+      "old_run": "gemm-all",
+      "old_solution": "deepgemm_bf16_n12288_k4096",
+      "paired_workloads": 31,
+      "method": "prepared launch where available; CUDA graph, iters calls per replay",
+      "geometric_mean_speedup": 0.44233388346472824,
+      "range": [
+        0.41260917322780855,
+        0.5396676753908549
+      ],
+      "faster_workloads": 0
+    },
+    {
+      "comparison": "Audio final versus original FP16-conversion solution",
+      "new_run": "attention-final-contracts",
+      "new_solution": "fa4_noncausal_h32_d64",
+      "old_run": "attention-all",
+      "old_solution": "fa4_noncausal_h32_d64",
+      "paired_workloads": 108,
+      "method": "prepared launch where available; CUDA graph, iters calls per replay",
+      "geometric_mean_speedup": 4.03364484223459,
+      "range": [
+        2.590577260426724,
+        7.552192866046962
+      ],
+      "faster_workloads": 108
+    },
+    {
+      "comparison": "Current fused router versus original CUTLASS/torch solution",
+      "new_run": "router-latest-all",
+      "new_solution": "fused_router",
+      "old_run": "router-alternatives-all",
+      "old_solution": "cutlass_router",
+      "paired_workloads": 50,
+      "method": "prepared launch where available; CUDA graph, iters calls per replay",
+      "geometric_mean_speedup": 4.99596423102129,
+      "range": [
+        2.119331801220748,
+        17.49934384645274
+      ],
+      "faster_workloads": 50
+    },
+    {
+      "comparison": "Cached-prefix FA4 versus serving implementation adapter",
+      "new_run": "attention-final-contracts",
+      "new_solution": "fa4_prefix_h32_d128",
+      "old_run": "attention-all",
+      "old_solution": "sglang_prefix_cached_block_causal_h32_d128",
+      "paired_workloads": 28,
+      "method": "prepared launch where available; CUDA graph, iters calls per replay",
+      "geometric_mean_speedup": 3.80843131648756,
+      "range": [
+        3.659472837569554,
+        4.082322533722384
+      ],
+      "faster_workloads": 28
+    },
+    {
+      "comparison": "QSA index final versus original on its declared TileLang 0.1.15",
+      "new_run": "qsa-index-final-all",
+      "new_solution": "sglang_tilelang_index",
+      "old_run": "qsa-original-declared-015-dev-timing",
+      "old_solution": "main",
+      "paired_workloads": 10,
+      "method": "prepared launch where available; CUDA graph, iters calls per replay",
+      "geometric_mean_speedup": 2.2821630132329918,
+      "range": [
+        1.2873084348823565,
+        11.095388935436509
+      ],
+      "faster_workloads": 10
+    },
+    {
+      "comparison": "Native paged sparse GQA versus FA4 sparse gather",
+      "new_run": "qsa-attention-native-all",
+      "new_solution": "trtllm_sparse_gqa",
+      "old_run": "gemm-qsa-dev",
+      "old_solution": "fa4_sparse_gqa",
+      "paired_workloads": 10,
+      "method": "prepared launch where available; CUDA graph, iters calls per replay",
+      "geometric_mean_speedup": 1.900678441525543,
+      "range": [
+        1.4198588236687533,
+        2.403390206583776
+      ],
+      "faster_workloads": 10
+    },
+    {
+      "comparison": "FlashMLA CUDA 13.3 versus CUDA 13.1 compiler build",
+      "new_run": "mla-cu133-all",
+      "new_solution": "flashmla_prefill_k128",
+      "old_run": "mla-all",
+      "old_solution": "flashmla_prefill_k128",
+      "paired_workloads": 10,
+      "method": "prepared launch where available; CUDA graph, iters calls per replay",
+      "geometric_mean_speedup": 1.005949932930726,
+      "range": [
+        0.9976997846493691,
+        1.012003306272232
+      ],
+      "faster_workloads": 8
+    },
+    {
+      "comparison": "FlashMLA CUDA 13.3 versus CUDA 13.1 compiler build",
+      "new_run": "mla-cu133-all",
+      "new_solution": "flashmla_prefill_k640",
+      "old_run": "mla-all",
+      "old_solution": "flashmla_prefill_k640",
+      "paired_workloads": 20,
+      "method": "prepared launch where available; CUDA graph, iters calls per replay",
+      "geometric_mean_speedup": 1.0059326934459807,
+      "range": [
+        0.9992565830555092,
+        1.0361743300418496
+      ],
+      "faster_workloads": 19
+    },
+    {
+      "comparison": "FlashMLA CUDA 13.3 versus CUDA 13.1 compiler build",
+      "new_run": "mla-cu133-all",
+      "new_solution": "flashmla_v41",
+      "old_run": "mla-all",
+      "old_solution": "flashmla_v41",
+      "paired_workloads": 42,
+      "method": "prepared launch where available; CUDA graph, iters calls per replay",
+      "geometric_mean_speedup": 1.0325320877320159,
+      "range": [
+        1.0117352165524782,
+        1.0690543144366038
+      ],
+      "faster_workloads": 42
+    }
+  ],
+  "strict_gdn_diagnostic": {
+    "reference_unchanged": true,
+    "acceptance_unchanged": true,
+    "modern_six_token_new_state_max_abs_error": 0.0012151896953582764,
+    "modern_six_token_failing_elements": 3909,
+    "elements": 131072,
+    "rtol": 0.0001,
+    "atol": 2e-05,
+    "prefill_dev_strict_failures": 10,
+    "prefill_dev_checked": 10
+  },
+  "known_diagnostic_failures": {
+    "old_qsa_on_undeclared_tilelang_0_1_12": 45,
+    "old_qsa_on_declared_tilelang_0_1_15": 0,
+    "explanation": "The old custom scorer is dependency-sensitive, not proven incorrect in its declared environment. Final current scorer passes all 192 on SGLang-required 0.1.12."
+  },
+  "run_counts": {
+    "dense-n12288-final-all": {
+      "environment": 1,
+      "passed": 31
+    },
+    "gdn-all-counted": {
+      "environment": 1,
+      "passed": 154
+    },
+    "attention-all": {
+      "environment": 1,
+      "passed": 404
+    },
+    "attention-final-contracts": {
+      "environment": 1,
+      "passed": 136
+    },
+    "router-alternatives-all": {
+      "environment": 1,
+      "passed": 150
+    },
+    "router-latest-all": {
+      "environment": 1,
+      "passed": 50
+    },
+    "qsa-index-all": {
+      "environment": 1,
+      "passed": 339,
+      "failed": 45
+    },
+    "qsa-original-declared-015-all": {
+      "environment": 1,
+      "passed": 192
+    },
+    "qsa-original-declared-015-dev-timing": {
+      "environment": 1,
+      "passed": 10
+    },
+    "qsa-index-final-all": {
+      "environment": 1,
+      "passed": 192
+    },
+    "qsa-attention-native-all": {
+      "environment": 1,
+      "passed": 192
+    },
+    "gemm-qsa-dev": {
+      "environment": 1,
+      "passed": 100
+    },
+    "gemm-all": {
+      "environment": 1,
+      "passed": 394
+    },
+    "na-all": {
+      "environment": 1,
+      "passed": 90
+    },
+    "mla-all": {
+      "environment": 1,
+      "passed": 144
+    },
+    "mla-cu133-all": {
+      "environment": 1,
+      "passed": 72
+    },
+    "gdn-stable-dev-timing": {
+      "environment": 1,
+      "passed": 17
+    },
+    "gdn-prefill-current-dev": {
+      "environment": 1,
+      "passed": 20
+    },
+    "native-builder-gdn-first": {
+      "environment": 1,
+      "passed": 2
+    }
+  }
+}

docs/interface-audit/upstream-head-recheck.json

@@ -0,0 +1,41 @@
+{
+  "checked_at": "2026-10-19T11:43:24.213060+00:00",
+  "repositories": [
+    {
+      "repository": "sgl-project/sglang",
+      "audited_commit": "0025f9394421451aa09ec192a4a6e7928e14736b",
+      "current_commit": "ed0b8f433f887995b1ce361b15aaf9f6ca93483f",
+      "unchanged": false
+    },
+    {
+      "repository": "flashinfer-ai/flashinfer",
+      "audited_commit": "f64b4ba8762ded12a4f4b9a2092974c9a395e7ca",
+      "current_commit": "f64b4ba8762ded12a4f4b9a2092974c9a395e7ca",
+      "unchanged": true
+    },
+    {
+      "repository": "Dao-AILab/flash-attention",
+      "audited_commit": "e7a6402a9ff099de5eb628ce207a88a3f0aa5378",
+      "current_commit": "e7a6402a9ff099de5eb628ce207a88a3f0aa5378",
+      "unchanged": true
+    },
+    {
+      "repository": "deepseek-ai/DeepGEMM",
+      "audited_commit": "1fc9c66975ee322d628b3288534ca0e9ce12a64d",
+      "current_commit": "1fc9c66975ee322d628b3288534ca0e9ce12a64d",
+      "unchanged": true
+    },
+    {
+      "repository": "deepseek-ai/FlashMLA",
+      "audited_commit": "0f11e178da1f67becb087a324b400854931ec3e3",
+      "current_commit": "0f11e178da1f67becb087a324b400854931ec3e3",
+      "unchanged": true
+    },
+    {
+      "repository": "SHI-Labs/NATTEN",
+      "audited_commit": "39375ea1d2f3b1bb284315fa5f79f6ecbebb6382",
+      "current_commit": "39375ea1d2f3b1bb284315fa5f79f6ecbebb6382",
+      "unchanged": true
+    }
+  ]
+}

docs/interface-audit/upstreams.json

@@ -0,0 +1,112 @@
+{
+  "repositories": [
+    {
+      "repository": "sgl-project/sglang",
+      "commit": "0025f9394421451aa09ec192a4a6e7928e14736b",
+      "date": "2026-10-19T10:24:17Z",
+      "title": "[Fix] sgl-router: Refuse prefill workers that cannot compute before bootstrap under --decode-dispatch-limit (#45120)",
+      "latest_release": {
+        "tag": "v0.5.22",
+        "date": "2026-10-19T02:55:19Z",
+        "url": "https://github.com/sgl-project/sglang/releases/tag/v0.5.22"
+      }
+    },
+    {
+      "repository": "flashinfer-ai/flashinfer",
+      "commit": "f64b4ba8762ded12a4f4b9a2092974c9a395e7ca",
+      "date": "2026-10-19T10:50:33Z",
+      "title": "perf(cake_all_gather_matmul): SM103a CTA-pair main kernel for two measured gate/up shapes (region table with column ranges) (#6566)",
+      "latest_release": {
+        "tag": "v0.7.2",
+        "date": "2026-10-15T20:36:26Z",
+        "url": "https://github.com/flashinfer-ai/flashinfer/releases/tag/v0.7.2"
+      }
+    },
+    {
+      "repository": "Dao-AILab/flash-attention",
+      "commit": "e7a6402a9ff099de5eb628ce207a88a3f0aa5378",
+      "date": "2026-10-19T02:35:33Z",
+      "title": "[CuTe] Add typed forward configurations (#2732)",
+      "latest_release": {
+        "tag": "v2.8.3.post2",
+        "date": "2026-10-13T05:41:17Z",
+        "url": "https://github.com/Dao-AILab/flash-attention/releases/tag/v2.8.3.post2"
+      }
+    },
+    {
+      "repository": "deepseek-ai/DeepGEMM",
+      "commit": "1fc9c66975ee322d628b3288534ca0e9ce12a64d",
+      "date": "2026-10-14T05:35:55Z",
+      "title": "Update FP8 epilogues and paged sparse MQA alignment (#471)",
+      "latest_release": {
+        "tag": "v2.1.1.post3",
+        "date": "2025-10-15T14:30:54Z",
+        "url": "https://github.com/deepseek-ai/DeepGEMM/releases/tag/v2.1.1.post3"
+      }
+    },
+    {
+      "repository": "deepseek-ai/FlashMLA",
+      "commit": "0f11e178da1f67becb087a324b400854931ec3e3",
+      "date": "2026-10-15T13:47:29Z",
+      "title": "Make FlashMLA CPython and LibTorch ABI stable (#230)"
+    },
+    {
+      "repository": "SHI-Labs/NATTEN",
+      "commit": "39375ea1d2f3b1bb284315fa5f79f6ecbebb6382",
+      "date": "2026-07-26T18:07:00Z",
+      "title": "0.21.7 release (#344)",
+      "latest_release": {
+        "tag": "v0.21.7",
+        "date": "2026-07-26T18:35:17Z",
+        "url": "https://github.com/SHI-Labs/NATTEN/releases/tag/v0.21.7"
+      }
+    }
+  ],
+  "packages": {
+    "flash-attn-4": {
+      "latest": "4.0.0b35",
+      "project_urls": {
+        "Homepage": "https://github.com/Dao-AILab/flash-attention",
+        "Repository": "https://github.com/Dao-AILab/flash-attention"
+      }
+    },
+    "flashinfer-python": {
+      "latest": "0.7.2",
+      "project_urls": {
+        "Homepage": "https://github.com/flashinfer-ai/flashinfer"
+      }
+    },
+    "nvidia-cutlass-dsl": {
+      "latest": "4.8.1",
+      "project_urls": {
+        "Documentation": "https://github.com/NVIDIA/cutlass",
+        "Issues": "https://github.com/NVIDIA/cutlass/issues",
+        "License": "https://docs.nvidia.com/cutlass/latest/media/docs/pythonDSL/license.html",
+        "Repository": "https://github.com/NVIDIA/cutlass"
+      }
+    },
+    "quack-kernels": {
+      "latest": "0.6.5",
+      "project_urls": null
+    },
+    "natten": {
+      "latest": "0.21.7",
+      "project_urls": {
+        "Changelog": "https://github.com/SHI-Labs/NATTEN/blob/main/CHANGELOG.md",
+        "Documentation": "https://natten.org",
+        "Homepage": "https://natten.org",
+        "Repository": "https://github.com/SHI-Labs/NATTEN.git"
+      }
+    },
+    "torch": {
+      "latest": "2.14.1",
+      "project_urls": {
+        "Documentation": "https://pytorch.org/docs",
+        "Forum": "https://discuss.pytorch.org",
+        "Homepage": "https://pytorch.org",
+        "Issue Tracker": "https://github.com/pytorch/pytorch/issues",
+        "Repository": "https://github.com/pytorch/pytorch"
+      }
+    }
+  }
+}

scripts/audit_solutions.py

@@ -0,0 +1,395 @@
+"""Validate and time actual solutions against independent task references."""
+
+import argparse
+import contextlib
+import fcntl
+import hashlib
+import importlib.util
+import json
+import os
+from pathlib import Path
+import statistics
+import sys
+import time
+import traceback
+
+from task_acceptance import compare_output
+
+parser = argparse.ArgumentParser(description=__doc__)
+parser.add_argument("--root", type=Path, default=Path(__file__).resolve().parents[1])
+parser.add_argument(
+    "--data-root", type=Path, help="Optional materialized dataset with the same paths"
+)
+parser.add_argument("--lock-directory", type=Path, required=True)
+parser.add_argument(
+    "--cache-directory", type=Path, help="Writable module and reference cache"
+)
+parser.add_argument("--definition", action="append")
+parser.add_argument("--suite", choices=["first", "dev", "all"], default="first")
+parser.add_argument("--only-default", action="store_true")
+parser.add_argument("--report", required=True, type=Path)
+parser.add_argument("--validation-only", action="store_true")
+parser.add_argument("--scale-probe", action="store_true")
+parser.add_argument("--gpu", required=True)
+parser.add_argument("--workload", action="append")
+parser.add_argument("--solution", action="append")
+parser.add_argument(
+    "--candidate",
+    action="append",
+    default=[],
+    help="Extra run() module for comparing a candidate on one selected definition",
+)
+parser.add_argument("--reference-cache", action="store_true")
+parser.add_argument("--graph-timing", action="store_true")
+parser.add_argument(
+    "--strict-diagnostic",
+    action="store_true",
+    help="Also report the historical FP32 bound for GDN; does not affect task acceptance",
+)
+args = parser.parse_args()
+SOURCE = args.root.resolve()
+DATA = args.data_root.resolve() if args.data_root else SOURCE
+CACHE = (
+    args.cache_directory.resolve()
+    if args.cache_directory
+    else SOURCE / "results/audit-cache"
+)
+GPU = args.gpu
+LOCKS = args.lock_directory
+LOCKS.mkdir(exist_ok=True, parents=True)
+os.environ["CUDA_VISIBLE_DEVICES"] = GPU
+stack = contextlib.ExitStack()
+for suffix in ["", ".lock"]:
+    handle = stack.enter_context((LOCKS / (GPU + suffix)).open("a+"))
+    fcntl.flock(handle.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+
+import torch
+from safetensors.torch import load_file
+
+torch.set_num_threads(8)
+torch.backends.cuda.matmul.allow_tf32 = False
+torch._inductor.config.compile_threads = 1
+
+
+def load_function(name, path):
+    identifier = "_audit_" + hashlib.sha256(name.encode()).hexdigest()[:20]
+    package = path.parent
+    spec = importlib.util.spec_from_file_location(
+        identifier, package / "__init__.py", submodule_search_locations=[str(package)]
+    )
+    if path.name != "main.py":
+        spec = importlib.util.spec_from_file_location(identifier, path)
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[identifier] = module
+    spec.loader.exec_module(module)
+    if path.name == "main.py":
+        spec = importlib.util.spec_from_file_location(identifier + ".main", path)
+        child = importlib.util.module_from_spec(spec)
+        sys.modules[spec.name] = child
+        spec.loader.exec_module(child)
+        module = child
+    return module.run, getattr(module, "prepare", None)
+
+
+def normalize(result, definition):
+    return (
+        list(result.values())
+        if isinstance(result, dict)
+        else list(result)
+        if isinstance(result, (tuple, list))
+        else [result]
+    )
+
+
+def compare(actual, expected, definition, config):
+    values = normalize(actual, definition)
+    assert len(values) == len(expected)
+    metrics = {}
+    for name, value, reference in zip(definition["outputs"], values, expected):
+        metrics[name] = compare_output(value, reference, config["tolerance"])
+    return metrics
+
+
+def measure(function, inputs, timing):
+    for _ in range(timing["warmup"]):
+        _result = function(*inputs)
+    torch.cuda.synchronize()
+    samples = []
+    for _ in range(timing["iters"] * timing["trials"]):
+        start = torch.cuda.Event(enable_timing=True)
+        end = torch.cuda.Event(enable_timing=True)
+        start.record()
+        _result = function(*inputs)
+        end.record()
+        end.synchronize()
+        samples.append(start.elapsed_time(end) * 1000)
+    return {
+        "median_us": statistics.median(samples),
+        "samples_us": samples,
+        "method": "CUDA events over eager calls",
+    }
+
+
+def measure_graph(function, inputs, timing, definition, config, expected):
+    for _ in range(max(3, timing["warmup"])):
+        result = function(*inputs)
+    torch.cuda.synchronize()
+    graph = torch.cuda.CUDAGraph()
+    with torch.cuda.graph(graph):
+        for _ in range(timing["iters"]):
+            result = function(*inputs)
+    graph.replay()
+    torch.cuda.synchronize()
+    compare(result, expected, definition, config)
+    samples = []
+    for _ in range(timing["trials"]):
+        start = torch.cuda.Event(enable_timing=True)
+        end = torch.cuda.Event(enable_timing=True)
+        start.record()
+        graph.replay()
+        end.record()
+        end.synchronize()
+        samples.append(start.elapsed_time(end) * 1000 / timing["iters"])
+    return {
+        "median_us": statistics.median(samples),
+        "samples_us": samples,
+        "method": "CUDA graph, iters calls per replay",
+        "calls_per_replay": timing["iters"],
+    }
+
+
+definitions = {
+    json.loads(f.read_text())["name"]: json.loads(f.read_text())
+    for f in (SOURCE / "definitions").rglob("*.json")
+}
+solutions = {}
+for f in (SOURCE / "solutions").rglob("*.json"):
+    s = json.loads(f.read_text())
+    solutions.setdefault(s["definition"], []).append(s)
+rows_by_name = {
+    f.stem: [json.loads(l)["workload"] for l in f.read_text().splitlines()]
+    for f in (SOURCE / "workloads").rglob("*.jsonl")
+}
+args.report.parent.mkdir(exist_ok=True, parents=True)
+failures = 0
+with args.report.open("w") as report, torch.inference_mode():
+
+    def emit(row):
+        report.write(json.dumps(row) + "\n")
+        report.flush()
+
+    emit(
+        {
+            "type": "environment",
+            "gpu": torch.cuda.get_device_name(),
+            "torch": torch.__version__,
+            "suite": args.suite,
+            "pythonpath": os.environ.get("PYTHONPATH"),
+            "started_at": time.time(),
+        }
+    )
+    for name, definition in definitions.items():
+        if args.definition and name not in args.definition:
+            continue
+        config = json.loads((SOURCE / "tasks" / f"{name}.json").read_text())
+        rows = rows_by_name[name]
+        if args.suite == "dev":
+            rows = [row for row in rows if row["uuid"] in config["dev"]]
+        if args.suite == "first":
+            rows = rows[:1]
+        if args.workload:
+            rows = [row for row in rows if row["uuid"] in args.workload]
+        candidates = []
+        for solution in solutions[name]:
+            if args.only_default and solution["name"] == "sglang_" + name:
+                continue
+            digest = hashlib.sha256(
+                json.dumps(solution, sort_keys=True).encode()
+            ).hexdigest()
+            package = CACHE / "modules" / digest
+            for source in solution["sources"]:
+                target = package / source["path"]
+                if not target.resolve().is_relative_to(package.resolve()):
+                    raise ValueError("Source path escapes package")
+                target.parent.mkdir(parents=True, exist_ok=True)
+                target.write_text(source["content"])
+            (package / "__init__.py").touch()
+            entry = solution["spec"]["entry_point"].split("::")[0]
+            candidates.append((solution["name"], package / entry))
+        if args.candidate:
+            assert args.definition and len(args.definition) == 1
+            candidates.extend((Path(p).stem, Path(p)) for p in args.candidate)
+        if args.solution:
+            candidates = [(s, p) for s, p in candidates if s in args.solution]
+        ns = {}
+        exec(definition["reference"], ns)
+        reference = ns["run"]
+        for solution, path in candidates:
+            try:
+                function, prepare = load_function(solution, path)
+            except Exception:
+                failures += 1
+                emit(
+                    {
+                        "type": "load",
+                        "definition": name,
+                        "solution": solution,
+                        "status": "failed",
+                        "error": traceback.format_exc(),
+                    }
+                )
+                print("LOAD FAILED", name, solution, flush=True)
+                continue
+            for row in rows:
+                inputs = []
+                saved = []
+                expected = []
+                result = {
+                    "type": "workload",
+                    "definition": name,
+                    "solution": solution,
+                    "uuid": row["uuid"],
+                    "axes": row["axes"],
+                    "solution_sha256": hashlib.sha256(path.read_bytes()).hexdigest(),
+                    "definition_sha256": hashlib.sha256(
+                        json.dumps(definition, sort_keys=True).encode()
+                    ).hexdigest(),
+                    "task_sha256": hashlib.sha256(
+                        json.dumps(config, sort_keys=True).encode()
+                    ).hexdigest(),
+                }
+                try:
+                    for key in definition["inputs"]:
+                        desc = row["inputs"][key]
+                        value = (
+                            desc["value"]
+                            if desc["type"] == "scalar"
+                            else load_file(str(DATA / desc["path"]), device="cuda")[
+                                desc["tensor_key"]
+                            ]
+                        )
+                        inputs.append(value)
+                        saved.append(
+                            value.clone() if isinstance(value, torch.Tensor) else value
+                        )
+                    cache_key = hashlib.sha256(
+                        json.dumps(
+                            {
+                                "reference": definition["reference"],
+                                "row": row,
+                                "torch": torch.__version__,
+                            },
+                            sort_keys=True,
+                        ).encode()
+                    ).hexdigest()
+                    cache = CACHE / "references" / (cache_key + ".pt")
+                    if args.reference_cache and cache.exists():
+                        expected = [
+                            value.to("cuda")
+                            for value in torch.load(cache, weights_only=True)
+                        ]
+                    else:
+                        expected = [
+                            value.clone()
+                            for value in normalize(reference(*inputs), definition)
+                        ]
+                        if args.reference_cache:
+                            cache.parent.mkdir(exist_ok=True, parents=True)
+                            torch.save([value.cpu() for value in expected], cache)
+                    actual_result = function(*inputs)
+                    result["errors"] = compare(
+                        actual_result, expected, definition, config
+                    )
+                    if args.strict_diagnostic and name.startswith("gdn_"):
+                        result["strict_fp32_diagnostic"] = {}
+                        for key, value, target in zip(
+                            definition["outputs"],
+                            normalize(actual_result, definition),
+                            expected,
+                        ):
+                            if value.dtype == torch.float32:
+                                close = torch.isclose(
+                                    value, target, rtol=1e-4, atol=2e-5
+                                )
+                                result["strict_fp32_diagnostic"][key] = {
+                                    "rtol": 1e-4,
+                                    "atol": 2e-5,
+                                    "mismatched_elements": int((~close).sum()),
+                                    "elements": close.numel(),
+                                    "passes": bool(close.all()),
+                                }
+                    for key, value, original in zip(
+                        definition["inputs"], inputs, saved
+                    ):
+                        if isinstance(value, torch.Tensor):
+                            assert torch.equal(
+                                value.contiguous().view(torch.uint8),
+                                original.contiguous().view(torch.uint8),
+                            ), key + " input mutated"
+                    if args.scale_probe and "scale" in definition["inputs"]:
+                        index = list(definition["inputs"]).index("scale")
+                        original = inputs[index]
+                        inputs[index] = (
+                            definition["axes"]["head_size"]["value"] ** -0.5
+                            if original is None or original == 0
+                            else original
+                        ) * 0.5
+                        target = [
+                            value.clone()
+                            for value in normalize(reference(*inputs), definition)
+                        ]
+                        result["scale_probe"] = compare(
+                            function(*inputs), target, definition, config
+                        )
+                        inputs[index] = original
+                    if not args.validation_only:
+                        result["run_timing"] = measure(
+                            function, inputs, config["timing"]
+                        )
+                        if prepare:
+                            launch = prepare(*inputs)
+                            result["prepared_timing"] = measure(
+                                lambda *unused: launch(), inputs, config["timing"]
+                            )
+                        if args.graph_timing:
+                            try:
+                                launch_function = (
+                                    (lambda *unused: launch()) if prepare else function
+                                )
+                                result["graph_timing"] = measure_graph(
+                                    launch_function,
+                                    inputs,
+                                    config["timing"],
+                                    definition,
+                                    config,
+                                    expected,
+                                )
+                            except Exception:
+                                result["graph_error"] = traceback.format_exc()
+                    for key, value, original in zip(
+                        definition["inputs"], inputs, saved
+                    ):
+                        if isinstance(value, torch.Tensor):
+                            assert torch.equal(
+                                value.contiguous().view(torch.uint8),
+                                original.contiguous().view(torch.uint8),
+                            ), key + " input mutated during timing"
+                    result["inputs_unchanged"] = True
+                    result["status"] = "passed"
+                except Exception:
+                    failures += 1
+                    result.update(status="failed", error=traceback.format_exc())
+                emit(result)
+                print(
+                    result["status"],
+                    name,
+                    solution,
+                    row["axes"],
+                    result.get("run_timing", {}).get("median_us"),
+                    flush=True,
+                )
+                inputs = saved = expected = actual_result = None
+            function = prepare = None
+
+if failures:
+    raise SystemExit(f"{failures} failed cases; see {args.report}")

scripts/benchmark_solutions.py

@@ -10,6 +10,8 @@ import statistics
 import time
 import traceback
 
+from task_acceptance import compare_output
+
 
 def main():
     parser = argparse.ArgumentParser(description=__doc__)
@@ -85,30 +87,8 @@ def main():
             return load_file(str(data_root / descriptor["path"]), device="cuda")[descriptor["tensor_key"]]
 
         def compare(actual, expected, definition, output_name):
-            if actual.shape != expected.shape or actual.dtype != expected.dtype:
-                raise AssertionError(f"{output_name}: output shape or dtype differs")
-            if not actual.is_floating_point():
-                torch.testing.assert_close(actual, expected, rtol=0, atol=0)
-                return {"comparison": "exact"}
-            if not torch.isfinite(actual).all() or not torch.isfinite(expected).all():
-                raise AssertionError(f"{output_name}: nonfinite output")
-            difference = actual.float() - expected.float()
-            metrics = {"max_absolute_error": difference.abs().max().item() if actual.numel() else 0.0}
-            if definition.startswith("gated_delta_rule_prefill_") and output_name == "S_final":
-                metrics.update(
-                    relative_rms=(difference.norm() / expected.norm().clamp_min(1e-12)).item(),
-                    relative_max=(difference.abs().max() / expected.abs().max().clamp_min(1e-12)).item(),
-                    max_head_relative_rms=(difference.norm(dim=(-2, -1)) /
-                        expected.norm(dim=(-2, -1)).clamp_min(1e-12)).max().item(),
-                )
-                for key, bound in {"relative_rms": .01, "relative_max": .015,
-                                   "max_head_relative_rms": .02}.items():
-                    if metrics[key] > bound:
-                        raise AssertionError(f"{output_name}: {key}={metrics[key]} > {bound}")
-            else:
-                rtol, atol = (.016, .005) if actual.dtype == torch.bfloat16 else (1e-4, 2e-5)
-                torch.testing.assert_close(actual, expected, rtol=rtol, atol=atol)
-            return metrics
+            config = json.loads((root / 'tasks' / f'{definition}.json').read_text())
+            return compare_output(actual, expected, config['tolerance'])
 
         def measure(function):
             for _ in range(3):
@@ -170,8 +150,10 @@ def main():
                         inputs = [load(workload["inputs"][key]) for key in definition.inputs]
                         actual = runnable(*inputs)
                         outputs = list(actual) if isinstance(actual, (tuple, list)) else [actual]
-                        descriptors = receipts[workload["uuid"]]["expected_output"]
-                        if "type" in descriptors:
+                        descriptors = receipts[workload["uuid"]].get("expected_output")
+                        if reference is None and descriptors is None:
+                            raise ValueError("This imported workload has no saved engine output; compare to reference")
+                        if descriptors is not None and "type" in descriptors:
                             descriptors = {next(iter(definition.outputs)): descriptors}
                         if len(outputs) != len(definition.outputs):
                             raise AssertionError("Output count differs")

scripts/capture_inputs.py

@@ -138,14 +138,13 @@ def _gemm(a, weight, output, operation):
 
 
 def _block_attention(q, k, v, prefix_length, segments, output, context, operation):
-    import math
     import torch
 
     name = "prefix_cached_block_causal_h32_d128"
     if not prefix_length:
         name += "_prefix0"
     provenance = _provenance(context, operation, prefix_segments=segments,
-                            adapter="Preserve post-normalization/RoPE tensors; materialize the engine's segment visibility.")
+                            adapter="Preserve post-normalization/RoPE tensors; specialize fully visible target attention or encode prefix segment visibility.")
     if not _WRITER.wants(name, provenance):
         return
     image_ids = torch.full((k.shape[1],), -1, dtype=torch.int32, device=q.device)
@@ -156,11 +155,15 @@ def _block_attention(q, k, v, prefix_length, segments, output, context, operatio
             next_image += 1
     if prefix_length:
         image_ids[prefix_length:] = next_image
-    inputs = dict(Q=q, K_current=k[:, prefix_length:], V_current=v[:, prefix_length:],
-                  K_prefix=k[:, :prefix_length], V_prefix=v[:, :prefix_length],
-                  image_ids=image_ids,
-                  key_valid=torch.ones((q.shape[0], k.shape[1]), dtype=torch.bool, device=q.device),
-                  sm_scale=1 / math.sqrt(q.shape[-1]))
+    if q.shape[-1] != 128:
+        raise ValueError("The image attention contract fixes head dimension and scale")
+    inputs = dict(Q=q, K_current=k[:, prefix_length:], V_current=v[:, prefix_length:])
+    if prefix_length:
+        if not bool((image_ids[prefix_length:] == next_image).all()):
+            raise ValueError("Target-image attention must expose one fully visible image block")
+        inputs.update(K_prefix=k[:, :prefix_length], V_prefix=v[:, :prefix_length])
+    else:
+        inputs["image_ids"] = image_ids
     _WRITER.write(name, inputs, output, provenance)
 
 
@@ -340,7 +343,7 @@ def install():
         install_deepseek(_WRITER)
 
 
-def replay(dataset_root, device):
+def replay(dataset_root, device, selected_definitions=None):
     """Compare full reference outputs against the captured serving outputs."""
     import time
     import traceback
@@ -374,6 +377,8 @@ def replay(dataset_root, device):
         for line in path.read_text().splitlines():
             trace = json.loads(line)
             name, workload = trace["definition"], trace["workload"]
+            if selected_definitions and name not in selected_definitions:
+                continue
             if "expected_output" not in receipts[workload["uuid"]]:
                 continue  # Imported workloads (the MLSys 2026 GDN) have no engine output.
             started = time.monotonic()
@@ -488,6 +493,7 @@ def main():
     parser.add_argument("--model-path", type=Path)
     parser.add_argument("--output-root", type=Path)
     parser.add_argument("--replay-root", type=Path)
+    parser.add_argument("--replay-definition", action="append", help="Replay only these definitions; repeatable")
     parser.add_argument("--import-capture", type=Path)
     parser.add_argument("--device", default="cuda")
     parser.add_argument("--port", type=int, default=30000)
@@ -501,7 +507,7 @@ def main():
             parser.error("Import requires --output-root")
         return import_capture(args.import_capture, args.output_root)
     if args.replay_root:
-        return replay(args.replay_root, args.device)
+        return replay(args.replay_root, args.device, args.replay_definition)
     if args.model_path is None or args.output_root is None:
         parser.error("Serving capture requires --model-path and --output-root")
     root = args.output_root.resolve()

scripts/capture_ltx.py

@@ -82,7 +82,7 @@ def install(writer):
                         visible = mask == 0 if mask.is_floating_point() else mask.bool()
                         if not bool(visible.all()):
                             raise ValueError("Mask-free attention capture requires an all-visible engine mask")
-                    writer.write(name, dict(Q=q, K=k, V=v, sm_scale=q.shape[-1] ** -0.5),
+                    writer.write(name, dict(Q=q, K=k, V=v),
                                  output.reshape_as(q), provenance)
                 return output
 

scripts/task_acceptance.py

@@ -0,0 +1,41 @@
+"""Evaluate one output using the task's explicit, unchanged acceptance policy."""
+
+
+def compare_output(actual, expected, tolerance):
+    import torch
+
+    if (
+        actual.shape != expected.shape
+        or actual.dtype != expected.dtype
+        or actual.device != expected.device
+    ):
+        raise AssertionError("Output shape, dtype or device differs")
+    if not actual.is_floating_point():
+        if not torch.equal(actual, expected):
+            raise AssertionError("Integer output differs")
+        return {"exact": True}
+    if not bool(torch.isfinite(actual).all()) or not bool(
+        torch.isfinite(expected).all()
+    ):
+        raise AssertionError("Nonfinite output")
+    error = (actual.float() - expected.float()).abs()
+    if tolerance.get("comparison") == "absolute_or_relative":
+        close = (error <= tolerance["atol"]) | (
+            error / (expected.float().abs() + 1e-8) <= tolerance["rtol"]
+        )
+    else:
+        close = error <= tolerance["atol"] + tolerance["rtol"] * expected.float().abs()
+    # Count in integer arithmetic; a floating-point mean can round below 1
+    # even when every element passes.
+    matched = int(close.sum())
+    ratio = matched / close.numel() if close.numel() else 1.0
+    required = tolerance.get("required_matched_ratio")
+    if ratio < (1.0 if required is None else required):
+        raise AssertionError(
+            f"Matched {matched}/{close.numel()} output elements ({ratio})"
+        )
+    return {
+        "max_absolute_error": error.max().item() if error.numel() else 0.0,
+        "matched_ratio": ratio,
+        "mismatched_elements": close.numel() - matched,
+    }

solutions/block_causal_attention/fa4_prefix0_h32_d128.json

@@ -3,6 +3,25 @@
   "definition": "prefix_cached_block_causal_h32_d128_prefix0",
   "author": "inference-kernels",
   "description": "FlashAttention 4 with causal-or-same-image visibility and runtime key validity. Upstream: https://github.com/Dao-AILab/flash-attention (BSD-3-Clause).",
-  "spec": {"language": "python", "target_hardware": ["NVIDIA_B200"], "entry_point": "main.py::run", "dependencies": ["torch>=2.11", "flash-attn-4==4.0.0b35", "nvidia-cutlass-dsl[cu13]==4.7.1", "quack-kernels==0.6.5"], "destination_passing_style": false},
-  "sources": [{"path": "main.py", "content": "import cutlass\nimport cutlass.cute as cute\nfrom flash_attn.cute import utils\nfrom flash_attn.cute.interface import flash_attn_func\n\n@cute.jit\ndef visible(batch, head, m_idx, n_idx, seqlen_info, aux_tensors):\n    m = cutlass.min(m_idx[0], seqlen_info.seqlen_q - 1)\n    n = cutlass.min(n_idx[0], seqlen_info.seqlen_k - 1)\n    image_q = aux_tensors[0][m]\n    image_k = aux_tensors[0][n]\n    same_image = (image_q >= 0) & (image_q == image_k)\n    allowed = ((n_idx[0] <= m_idx[0]) | same_image) & aux_tensors[1][batch[0], n]\n    return utils.scalar_to_ssa(allowed, cutlass.Boolean)\n\ndef run(Q, K_current, V_current, K_prefix, V_prefix, image_ids, key_valid, sm_scale):\n    return flash_attn_func(Q, K_current, V_current, softmax_scale=sm_scale, mask_mod=visible, aux_tensors=[image_ids, key_valid])[0]\n"}]
+  "spec": {
+    "language": "python",
+    "target_hardware": [
+      "NVIDIA_B200",
+      "NVIDIA_B300"
+    ],
+    "entry_point": "main.py::run",
+    "dependencies": [
+      "torch>=2.11",
+      "flash-attn-4==4.0.0b35",
+      "nvidia-cutlass-dsl[cu13]==4.8.0",
+      "quack-kernels==0.6.5"
+    ],
+    "destination_passing_style": false
+  },
+  "sources": [
+    {
+      "path": "main.py",
+      "content": "import cutlass\nimport cutlass.cute as cute\nfrom flash_attn.cute import utils\nfrom flash_attn.cute.interface import flash_attn_func\n\n@cute.jit\ndef visible(batch, head, m_idx, n_idx, seqlen_info, aux_tensors):\n    m = cutlass.min(m_idx[0], seqlen_info.seqlen_q - 1)\n    n = cutlass.min(n_idx[0], seqlen_info.seqlen_k - 1)\n    image_q = aux_tensors[0][m]\n    image_k = aux_tensors[0][n]\n    same_image = (image_q >= 0) & (image_q == image_k)\n    allowed = ((n_idx[0] <= m_idx[0]) | same_image) & (n_idx[0] < seqlen_info.seqlen_k)\n    return utils.scalar_to_ssa(allowed, cutlass.Boolean)\n\ndef run(Q, K_current, V_current, image_ids):\n    return flash_attn_func(Q, K_current, V_current, softmax_scale=128 ** -0.5, mask_mod=visible, aux_tensors=[image_ids])[0]\n"
+    }
+  ]
 }

solutions/block_causal_attention/fa4_prefix_h32_d128.json

@@ -2,7 +2,26 @@
   "name": "fa4_prefix_h32_d128",
   "definition": "prefix_cached_block_causal_h32_d128",
   "author": "inference-kernels",
-  "description": "FlashAttention 4 with causal-or-same-image visibility and runtime key validity. Prefix concatenation is part of the solution call. Upstream: https://github.com/Dao-AILab/flash-attention (BSD-3-Clause).",
-  "spec": {"language": "python", "target_hardware": ["NVIDIA_B200"], "entry_point": "main.py::run", "dependencies": ["torch>=2.11", "flash-attn-4==4.0.0b35", "nvidia-cutlass-dsl[cu13]==4.7.1", "quack-kernels==0.6.5"], "destination_passing_style": false},
-  "sources": [{"path": "main.py", "content": "import torch\nimport cutlass\nimport cutlass.cute as cute\nfrom flash_attn.cute import utils\nfrom flash_attn.cute.interface import flash_attn_func\n\n@cute.jit\ndef visible(batch, head, m_idx, n_idx, seqlen_info, aux_tensors):\n    offset = seqlen_info.seqlen_k - seqlen_info.seqlen_q\n    m = cutlass.min(m_idx[0] + offset, seqlen_info.seqlen_k - 1)\n    n = cutlass.min(n_idx[0], seqlen_info.seqlen_k - 1)\n    image_q = aux_tensors[0][m]\n    image_k = aux_tensors[0][n]\n    same_image = (image_q >= 0) & (image_q == image_k)\n    allowed = ((n_idx[0] <= m_idx[0] + offset) | same_image) & aux_tensors[1][batch[0], n]\n    return utils.scalar_to_ssa(allowed, cutlass.Boolean)\n\ndef run(Q, K_current, V_current, K_prefix, V_prefix, image_ids, key_valid, sm_scale):\n    K = torch.cat((K_prefix, K_current), dim=1) if K_prefix.shape[1] else K_current\n    V = torch.cat((V_prefix, V_current), dim=1) if V_prefix.shape[1] else V_current\n    return flash_attn_func(Q, K, V, softmax_scale=sm_scale, mask_mod=visible, aux_tensors=[image_ids, key_valid])[0]\n"}]
+  "description": "FlashAttention 4 for the engine target-image call, with its replicated KV prefix. All keys are visible; concatenation is included in run. Upstream: https://github.com/Dao-AILab/flash-attention (BSD-3-Clause).",
+  "spec": {
+    "language": "python",
+    "target_hardware": [
+      "NVIDIA_B200",
+      "NVIDIA_B300"
+    ],
+    "entry_point": "main.py::run",
+    "dependencies": [
+      "torch>=2.11",
+      "flash-attn-4==4.0.0b35",
+      "nvidia-cutlass-dsl[cu13]==4.8.0",
+      "quack-kernels==0.6.5"
+    ],
+    "destination_passing_style": false
+  },
+  "sources": [
+    {
+      "path": "main.py",
+      "content": "import torch\nfrom flash_attn.cute.interface import flash_attn_func\n\ndef run(Q, K_prefix, V_prefix, K_current, V_current):\n    keys = torch.cat((K_prefix, K_current), dim=1)\n    values = torch.cat((V_prefix, V_current), dim=1)\n    return flash_attn_func(Q, keys, values, softmax_scale=128 ** -0.5)[0]\n"
+    }
+  ]
 }

solutions/block_causal_attention/sglang_prefix_cached_block_causal_h32_d128.json

@@ -17,7 +17,7 @@
   "sources": [
     {
       "path": "main.py",
-      "content": "# Copyright 2026 Co-developed by KDA (Kernel Design Agents)\n\"\"\"SGLang 684fea8a: Qwen-Image 2.1 ``target_attn`` under ``--attention-backend torch_sdpa``.\n\nCall path (``python/sglang/multimodal_gen/runtime/``):\n``models/dits/qwen_image21.py:703`` ``target_attn.forward_with_replicated_kv_prefix``\n(or ``qwen_image21.py:629-631`` ``attend_target`` -> ``target_attn(q, k, v)`` with the\nsame packed K/V) -> on one rank, ``layers/attention/layer.py:2116-2119``: concatenate\nthe prefix and current K/V, then ``attn_impl.forward`` -> ``SDPAImpl.forward``\n(``layers/attention/backends/sdpa.py:76-114``): torch SDPA, no mask, scale\n``head_dim**-0.5``.\n\nAdapters: ``USPAttention`` needs SGLang's global server args and parallel groups, so\nthe ``SDPAImpl`` it builds (``layer.py:849-850, 874-886``) is built here with the same\narguments. ``image_ids``, ``key_valid`` and ``sm_scale`` are not arguments of SGLang's\ncall: on every captured row each query sees every key and ``sm_scale`` is\n1/sqrt(128). The transposed SDPA output is copied into an owned dense tensor.\n\"\"\"\n\nimport torch\nfrom sglang.multimodal_gen.runtime.layers.attention.backends.sdpa import SDPAImpl\n\nHEADS, HEAD_DIM = 32, 128\nTARGET_IMPL = SDPAImpl(\n    num_heads=HEADS,\n    head_size=HEAD_DIM,\n    causal=False,\n    softmax_scale=HEAD_DIM**-0.5,\n    num_kv_heads=HEADS,\n)\n\n\ndef run(Q, K_current, V_current, K_prefix, V_prefix, image_ids, key_valid, sm_scale):\n    # layer.py:2117-2119\n    k = torch.cat([K_prefix, K_current], dim=1)\n    v = torch.cat([V_prefix, V_current], dim=1)\n    out = TARGET_IMPL.forward(Q, k, v, None)\n    return out.clone(memory_format=torch.contiguous_format)\n"
+      "content": "# Copyright 2026 Co-developed by KDA (Kernel Design Agents)\n\"\"\"SGLang 684fea8a: Qwen-Image 2.1 ``target_attn`` under ``--attention-backend torch_sdpa``.\n\nCall path (``python/sglang/multimodal_gen/runtime/``):\n``models/dits/qwen_image21.py:703`` ``target_attn.forward_with_replicated_kv_prefix``\n(or ``qwen_image21.py:629-631`` ``attend_target`` -> ``target_attn(q, k, v)`` with the\nsame packed K/V) -> on one rank, ``layers/attention/layer.py:2116-2119``: concatenate\nthe prefix and current K/V, then ``attn_impl.forward`` -> ``SDPAImpl.forward``\n(``layers/attention/backends/sdpa.py:76-114``): torch SDPA, no mask, scale\n``head_dim**-0.5``.\n\nAdapters: ``USPAttention`` needs SGLang's global server args and parallel groups, so\nthe ``SDPAImpl`` it builds (``layer.py:849-850, 874-886``) is built here with the same\narguments. Each captured target query sees every prefix/current key. The fixed scale is\n1/sqrt(128); redundant visibility/scale metadata is omitted. The native SDPA\noutput view is returned without an extra layout copy.\n\"\"\"\n\nimport torch\nfrom sglang.multimodal_gen.runtime.layers.attention.backends.sdpa import SDPAImpl\n\nHEADS, HEAD_DIM = 32, 128\nTARGET_IMPL = SDPAImpl(\n    num_heads=HEADS,\n    head_size=HEAD_DIM,\n    causal=False,\n    softmax_scale=HEAD_DIM**-0.5,\n    num_kv_heads=HEADS,\n)\n\n\ndef run(Q, K_prefix, V_prefix, K_current, V_current):\n    # layer.py:2117-2119\n    k = torch.cat([K_prefix, K_current], dim=1)\n    v = torch.cat([V_prefix, V_current], dim=1)\n    out = TARGET_IMPL.forward(Q, k, v, None)\n    return out.detach()\n"
     }
   ]
 }

solutions/block_causal_attention/sglang_prefix_cached_block_causal_h32_d128_prefix0.json

@@ -17,7 +17,7 @@
   "sources": [
     {
       "path": "main.py",
-      "content": "# Copyright 2026 Co-developed by KDA (Kernel Design Agents)\n\"\"\"SGLang 684fea8a: Qwen-Image 2.1 prefix attention under ``--attention-backend torch_sdpa``.\n\nCall path (``python/sglang/multimodal_gen/runtime/``):\n``models/dits/qwen_image21.py:651-667`` ``attend_sample`` without a cache: per prefix\nsegment, ``local_attn(qp[:, start:end], kp[:, :end], vp[:, :end], attn_mask=mask)``\nwith a causal bool mask for text runs and none for image blocks, joined by\n``cat_outputs`` (``qwen_image21.py:253-255``). ``LocalAttention.forward``\n(``layers/attention/layer.py:725-801``): with a mask, the bool mask made additive in\nbf16 and torch SDPA; without, ``SDPAImpl.forward`` (``backends/sdpa.py:76-114``).\n\nAdapters: ``local_attn`` is built as ``QwenImage21Attention.__init__`` builds it\n(``qwen_image21.py:395-398``), with the CLI backend forced through SGLang's selector,\nand run in SGLang's forward context. The engine's segments are the runs of\n``image_ids`` (text = -1); ``prepare`` derives them and their masks on the host.\n``K_prefix``/``V_prefix`` are empty (Np = 0), so ``kp, vp`` are the current K/V.\n``torch.cat`` replaces ``cat_outputs``, whose one-segment shortcut would return the\ntransposed SDPA view, so the output is an owned dense tensor. ``key_valid`` and\n``sm_scale`` are not arguments of SGLang's call: every captured key is valid and\n``sm_scale`` is 1/sqrt(128).\n\"\"\"\n\nimport torch\nfrom sglang.multimodal_gen.runtime.layers.attention import LocalAttention\nfrom sglang.multimodal_gen.runtime.layers.attention.selector import (\n    global_force_attn_backend_context_manager,\n)\nfrom sglang.multimodal_gen.runtime.managers.forward_context import set_forward_context\nfrom sglang.multimodal_gen.runtime.models.dits.qwen_image21 import (\n    QwenImage21Transformer2DModel,\n)\nfrom sglang.multimodal_gen.runtime.platforms import AttentionBackendEnum\n\nHEADS, HEAD_DIM = 32, 128\nwith global_force_attn_backend_context_manager(AttentionBackendEnum.TORCH_SDPA):\n    LOCAL_ATTN = LocalAttention(\n        HEADS,\n        HEAD_DIM,\n        supported_attention_backends=QwenImage21Transformer2DModel._supported_attention_backends,\n    )\n\n\ndef prepare(\n    Q, K_current, V_current, K_prefix, V_prefix, image_ids, key_valid, sm_scale\n):\n    ids = image_ids.cpu()\n    ends = torch.cumsum(torch.unique_consecutive(ids, return_counts=True)[1], 0)\n    segments = []\n    for start, end in zip([0, *ends[:-1].tolist()], ends.tolist()):\n        mask = None\n        if ids[start] < 0:\n            # qwen_image21.py:657-661\n            mask = (\n                torch.arange(end, device=Q.device)[None, :]\n                <= torch.arange(start, end, device=Q.device)[:, None]\n            )\n            mask = mask[None, None]\n        segments.append((start, end, mask))\n\n    def launch():\n        with set_forward_context(current_timestep=0, attn_metadata=None):\n            # qwen_image21.py:654-665\n            outputs = [\n                LOCAL_ATTN(\n                    Q[:, start:end],\n                    K_current[:, :end],\n                    V_current[:, :end],\n                    attn_mask=mask,\n                )\n                for start, end, mask in segments\n            ]\n        return torch.cat(outputs, dim=1)\n\n    return launch\n\n\ndef run(*inputs):\n    return prepare(*inputs)()\n"
+      "content": "# Copyright 2026 Co-developed by KDA (Kernel Design Agents)\n\"\"\"SGLang 684fea8a: Qwen-Image 2.1 prefix attention under ``--attention-backend torch_sdpa``.\n\nCall path (``python/sglang/multimodal_gen/runtime/``):\n``models/dits/qwen_image21.py:651-667`` ``attend_sample`` without a cache: per prefix\nsegment, ``local_attn(qp[:, start:end], kp[:, :end], vp[:, :end], attn_mask=mask)``\nwith a causal bool mask for text runs and none for image blocks, joined by\n``cat_outputs`` (``qwen_image21.py:253-255``). ``LocalAttention.forward``\n(``layers/attention/layer.py:725-801``): with a mask, the bool mask made additive in\nbf16 and torch SDPA; without, ``SDPAImpl.forward`` (``backends/sdpa.py:76-114``).\n\nAdapters: ``local_attn`` is built as ``QwenImage21Attention.__init__`` builds it\n(``qwen_image21.py:395-398``), with the CLI backend forced through SGLang's selector,\nand run in SGLang's forward context. The engine's segments are the runs of\n``image_ids`` (text = -1); ``prepare`` derives them and their masks on the host.\nThe current K/V are the complete uncached prefix; empty prefix inputs are omitted.\nThe one-segment shortcut matches ``cat_outputs`` and preserves the native output view. Every captured key is valid and scale is the engine's fixed 1/sqrt(128).\n\"\"\"\n\nimport torch\nfrom sglang.multimodal_gen.runtime.layers.attention import LocalAttention\nfrom sglang.multimodal_gen.runtime.layers.attention.selector import (\n    global_force_attn_backend_context_manager,\n)\nfrom sglang.multimodal_gen.runtime.managers.forward_context import set_forward_context\nfrom sglang.multimodal_gen.runtime.models.dits.qwen_image21 import (\n    QwenImage21Transformer2DModel,\n)\nfrom sglang.multimodal_gen.runtime.platforms import AttentionBackendEnum\n\nHEADS, HEAD_DIM = 32, 128\nwith global_force_attn_backend_context_manager(AttentionBackendEnum.TORCH_SDPA):\n    LOCAL_ATTN = LocalAttention(\n        HEADS,\n        HEAD_DIM,\n        supported_attention_backends=QwenImage21Transformer2DModel._supported_attention_backends,\n    )\n\n\ndef prepare(\n    Q, K_current, V_current, image_ids\n):\n    ids = image_ids.cpu()\n    ends = torch.cumsum(torch.unique_consecutive(ids, return_counts=True)[1], 0)\n    segments = []\n    for start, end in zip([0, *ends[:-1].tolist()], ends.tolist()):\n        mask = None\n        if ids[start] < 0:\n            # qwen_image21.py:657-661\n            mask = (\n                torch.arange(end, device=Q.device)[None, :]\n                <= torch.arange(start, end, device=Q.device)[:, None]\n            )\n            mask = mask[None, None]\n        segments.append((start, end, mask))\n\n    def launch():\n        with set_forward_context(current_timestep=0, attn_metadata=None):\n            # qwen_image21.py:654-665\n            outputs = [\n                LOCAL_ATTN(\n                    Q[:, start:end],\n                    K_current[:, :end],\n                    V_current[:, :end],\n                    attn_mask=mask,\n                )\n                for start, end, mask in segments\n            ]\n        return outputs[0] if len(outputs) == 1 else torch.cat(outputs, dim=1)\n\n    return launch\n\n\ndef run(Q, K_current, V_current, image_ids):\n    return prepare(Q, K_current, V_current, image_ids)()\n"
     }
   ]
 }

solutions/dense_attention/fa4_noncausal_h32_d128.json

@@ -6,13 +6,14 @@
   "spec": {
     "language": "python",
     "target_hardware": [
-      "NVIDIA_B200"
+      "NVIDIA_B200",
+      "NVIDIA_B300"
     ],
     "entry_point": "main.py::run",
     "dependencies": [
       "torch>=2.11",
       "flash-attn-4==4.0.0b35",
-      "nvidia-cutlass-dsl[cu13]==4.7.1",
+      "nvidia-cutlass-dsl[cu13]==4.8.0",
       "quack-kernels==0.6.5"
     ],
     "destination_passing_style": false
@@ -20,7 +21,7 @@
   "sources": [
     {
       "path": "main.py",
-      "content": "from flash_attn.cute.interface import flash_attn_func\n\ndef run(Q, K, V, sm_scale):\n    return flash_attn_func(Q, K, V, softmax_scale=sm_scale)[0]\n"
+      "content": "from flash_attn.cute.interface import flash_attn_func\n\ndef run(Q, K, V):\n    return flash_attn_func(Q, K, V, softmax_scale=128 ** -0.5)[0]\n"
     }
   ]
 }

solutions/dense_attention/fa4_noncausal_h32_d64.json

@@ -2,17 +2,18 @@
   "name": "fa4_noncausal_h32_d64",
   "definition": "noncausal_dense_attention_h32_d64",
   "author": "inference-kernels",
-  "description": "FlashAttention 4 CuTe DSL without a mask. Converts the captured normalized audio-attention inputs to FP16 to reduce probability-rounding error, and returns BF16. All conversions are included in the call. Upstream: https://github.com/Dao-AILab/flash-attention (BSD-3-Clause).",
+  "description": "BF16 FlashAttention-4 with native SDPA for self-attention tiles of at most 64 tokens. Removes the former FP16 input/output conversions. Every current workload passes the existing 99.99% element acceptance policy on B300; dispatch is based on runtime shape.",
   "spec": {
     "language": "python",
     "target_hardware": [
-      "NVIDIA_B200"
+      "NVIDIA_B200",
+      "NVIDIA_B300"
     ],
     "entry_point": "main.py::run",
     "dependencies": [
       "torch>=2.11",
       "flash-attn-4==4.0.0b35",
-      "nvidia-cutlass-dsl[cu13]==4.7.1",
+      "nvidia-cutlass-dsl[cu13]==4.8.0",
       "quack-kernels==0.6.5"
     ],
     "destination_passing_style": false
@@ -20,7 +21,7 @@
   "sources": [
     {
       "path": "main.py",
-      "content": "import torch\nfrom flash_attn.cute.interface import flash_attn_func\n\ndef run(Q, K, V, sm_scale):\n    output = flash_attn_func(Q.to(torch.float16), K.to(torch.float16), V.to(torch.float16), softmax_scale=sm_scale)[0]\n    return output.to(Q.dtype)\n"
+      "content": "import torch\nfrom torch.nn import functional as F\nfrom torch.nn.attention import SDPBackend, sdpa_kernel\nfrom flash_attn.cute.interface import flash_attn_func\n\n\ndef run(Q, K, V):\n    # B300 measurements favor native SDPA on the tiny self-attention tile.\n    if max(Q.shape[1], K.shape[1]) <= 64:\n        with sdpa_kernel([SDPBackend.CUDNN_ATTENTION, SDPBackend.FLASH_ATTENTION,\n                          SDPBackend.EFFICIENT_ATTENTION, SDPBackend.MATH],\n                         set_priority=True):\n            out = F.scaled_dot_product_attention(\n                Q.transpose(1, 2), K.transpose(1, 2), V.transpose(1, 2),\n                dropout_p=0.0, is_causal=False, scale=64 ** -0.5,\n            )\n        return out.transpose(1, 2)\n    return flash_attn_func(Q, K, V, softmax_scale=64 ** -0.5)[0]\n"
     }
   ]
 }

solutions/dense_attention/sglang_noncausal_dense_attention_h32_d128.json

@@ -17,7 +17,7 @@
   "sources": [
     {
       "path": "main.py",
-      "content": "# Copyright 2026 Co-developed by KDA (Kernel Design Agents)\n\"\"\"SGLang baseline for noncausal_dense_attention_h32_d128: LTX-2.5 video attention.\n\nSGLang diffusion runtime at commit 684fea8a, paths under\npython/sglang/multimodal_gen/runtime/: LTX2Attention.forward\n(models/dits/ltx_2.py:997-1006) calls ``self.attn(q, k, v, attn_mask=mask)``\non [B, N, H, D] Q/K/V for ``attn1`` (USPAttention, :857-871) and ``attn2``\n(LocalAttention, :841-855); every layer has\nsoftmax_scale=None -> head_size**-0.5 and allow_cudnn_sdp=True. On one GPU the\nmask is None, except for ``attn2``'s all-ones prompt mask, whose additive\nmask is exactly zero; the definition has no mask.\n\nUSPAttention.forward (layers/attention/layer.py:1466-1468) or\nLocalAttention.forward (:799) -> SDPAImpl.forward\n(layers/attention/backends/sdpa.py:76-114): one SDPA call under\n``sdpa_kernel(_PYTORCH_DEFAULT_CUDA_SDP_BACKENDS, set_priority=True)``, which\ntries cuDNN, Flash and memory-efficient attention before math.\n\nSDPAImpl returns a [B, Nq, H, D] transpose of the SDPA output;\n``.contiguous().detach()`` hands it over dense, without a copy when the kernel\nwrote it sequence-major.\n\"\"\"\n\nfrom sglang.multimodal_gen.runtime.layers.attention.backends.sdpa import SDPAImpl\n\n\ndef prepare(Q, K, V, sm_scale):\n    impl = SDPAImpl(\n        num_heads=Q.shape[2],\n        head_size=Q.shape[3],\n        causal=False,\n        softmax_scale=sm_scale,\n        num_kv_heads=K.shape[2],\n        allow_cudnn_sdp=True,\n    )\n\n    def launch():\n        return impl.forward(Q, K, V, None).contiguous().detach()\n\n    return launch\n\n\ndef run(Q, K, V, sm_scale):\n    return prepare(Q, K, V, sm_scale)()\n"
+      "content": "# Copyright 2026 Co-developed by KDA (Kernel Design Agents)\n\"\"\"SGLang baseline for noncausal_dense_attention_h32_d128: LTX-2.5 video attention.\n\nSGLang diffusion runtime at commit 684fea8a, paths under\npython/sglang/multimodal_gen/runtime/: LTX2Attention.forward\n(models/dits/ltx_2.py:997-1006) calls ``self.attn(q, k, v, attn_mask=mask)``\non [B, N, H, D] Q/K/V for ``attn1`` (USPAttention, :857-871) and ``attn2``\n(LocalAttention, :841-855); every layer has\nsoftmax_scale=None -> head_size**-0.5 and allow_cudnn_sdp=True. On one GPU the\nmask is None, except for ``attn2``'s all-ones prompt mask, whose additive\nmask is exactly zero; the definition has no mask.\n\nUSPAttention.forward (layers/attention/layer.py:1466-1468) or\nLocalAttention.forward (:799) -> SDPAImpl.forward\n(layers/attention/backends/sdpa.py:76-114): one SDPA call under\n``sdpa_kernel(_PYTORCH_DEFAULT_CUDA_SDP_BACKENDS, set_priority=True)``, which\ntries cuDNN, Flash and memory-efficient attention before math.\n\nSDPAImpl returns a [B, Nq, H, D] transpose of the SDPA output;\n``.detach()`` returns that native output view without adding a layout copy.\n\"\"\"\n\nfrom sglang.multimodal_gen.runtime.layers.attention.backends.sdpa import SDPAImpl\n\n\ndef prepare(Q, K, V):\n    impl = SDPAImpl(\n        num_heads=Q.shape[2],\n        head_size=Q.shape[3],\n        causal=False,\n        softmax_scale=128 ** -0.5,\n        num_kv_heads=K.shape[2],\n        allow_cudnn_sdp=True,\n    )\n\n    def launch():\n        return impl.forward(Q, K, V, None).detach()\n\n    return launch\n\n\ndef run(Q, K, V):\n    return prepare(Q, K, V)()\n"
     }
   ]
 }

solutions/dense_attention/sglang_noncausal_dense_attention_h32_d64.json

@@ -17,7 +17,7 @@
   "sources": [
     {
       "path": "main.py",
-      "content": "# Copyright 2026 Co-developed by KDA (Kernel Design Agents)\n\"\"\"SGLang baseline for noncausal_dense_attention_h32_d64: LTX-2.5 audio attention.\n\nSGLang diffusion runtime at commit 684fea8a, paths under\npython/sglang/multimodal_gen/runtime/: LTX2Attention.forward\n(models/dits/ltx_2.py:997-1006) calls ``self.attn(q, k, v, attn_mask=mask)``\non [B, N, H, D] Q/K/V for ``audio_attn1``, ``audio_to_video_attn`` and\n``video_to_audio_attn`` (USPAttention, :857-871, or LocalAttention) and\n``audio_attn2`` (LocalAttention, :841-855); every layer has\nsoftmax_scale=None -> head_size**-0.5 and allow_cudnn_sdp=True. On one GPU the\nmask is None, except for ``audio_attn2``'s all-ones prompt mask, whose additive\nmask is exactly zero; the definition has no mask.\n\nUSPAttention.forward (layers/attention/layer.py:1466-1468) or\nLocalAttention.forward (:799) -> SDPAImpl.forward\n(layers/attention/backends/sdpa.py:76-114): one SDPA call under\n``sdpa_kernel(_PYTORCH_DEFAULT_CUDA_SDP_BACKENDS, set_priority=True)``, which\ntries cuDNN, Flash and memory-efficient attention before math.\n\nSDPAImpl returns a [B, Nq, H, D] transpose of the SDPA output;\n``.contiguous().detach()`` hands it over dense, without a copy when the kernel\nwrote it sequence-major.\n\"\"\"\n\nfrom sglang.multimodal_gen.runtime.layers.attention.backends.sdpa import SDPAImpl\n\n\ndef prepare(Q, K, V, sm_scale):\n    impl = SDPAImpl(\n        num_heads=Q.shape[2],\n        head_size=Q.shape[3],\n        causal=False,\n        softmax_scale=sm_scale,\n        num_kv_heads=K.shape[2],\n        allow_cudnn_sdp=True,\n    )\n\n    def launch():\n        return impl.forward(Q, K, V, None).contiguous().detach()\n\n    return launch\n\n\ndef run(Q, K, V, sm_scale):\n    return prepare(Q, K, V, sm_scale)()\n"
+      "content": "# Copyright 2026 Co-developed by KDA (Kernel Design Agents)\n\"\"\"SGLang baseline for noncausal_dense_attention_h32_d64: LTX-2.5 audio attention.\n\nSGLang diffusion runtime at commit 684fea8a, paths under\npython/sglang/multimodal_gen/runtime/: LTX2Attention.forward\n(models/dits/ltx_2.py:997-1006) calls ``self.attn(q, k, v, attn_mask=mask)``\non [B, N, H, D] Q/K/V for ``audio_attn1``, ``audio_to_video_attn`` and\n``video_to_audio_attn`` (USPAttention, :857-871, or LocalAttention) and\n``audio_attn2`` (LocalAttention, :841-855); every layer has\nsoftmax_scale=None -> head_size**-0.5 and allow_cudnn_sdp=True. On one GPU the\nmask is None, except for ``audio_attn2``'s all-ones prompt mask, whose additive\nmask is exactly zero; the definition has no mask.\n\nUSPAttention.forward (layers/attention/layer.py:1466-1468) or\nLocalAttention.forward (:799) -> SDPAImpl.forward\n(layers/attention/backends/sdpa.py:76-114): one SDPA call under\n``sdpa_kernel(_PYTORCH_DEFAULT_CUDA_SDP_BACKENDS, set_priority=True)``, which\ntries cuDNN, Flash and memory-efficient attention before math.\n\nSDPAImpl returns a [B, Nq, H, D] transpose of the SDPA output;\n``.detach()`` returns that native output view without adding a layout copy.\n\"\"\"\n\nfrom sglang.multimodal_gen.runtime.layers.attention.backends.sdpa import SDPAImpl\n\n\ndef prepare(Q, K, V):\n    impl = SDPAImpl(\n        num_heads=Q.shape[2],\n        head_size=Q.shape[3],\n        causal=False,\n        softmax_scale=64 ** -0.5,\n        num_kv_heads=K.shape[2],\n        allow_cudnn_sdp=True,\n    )\n\n    def launch():\n        return impl.forward(Q, K, V, None).detach()\n\n    return launch\n\n\ndef run(Q, K, V):\n    return prepare(Q, K, V)()\n"
     }
   ]
 }

solutions/gdn/flashinfer_gdn_decode.json

@@ -0,0 +1,26 @@
+{
+  "name": "flashinfer_gdn_decode",
+  "definition": "gdn_decode_qk4_v8_d128_k_last",
+  "author": "inference-kernels",
+  "spec": {
+    "language": "python",
+    "target_hardware": [
+      "NVIDIA_B200",
+      "NVIDIA_B300"
+    ],
+    "entry_point": "main.py::run",
+    "dependencies": [
+      "torch>=2.14.1",
+      "flashinfer-python==0.7.2",
+      "nvidia-cutlass-dsl[cu13]==4.8.0"
+    ],
+    "destination_passing_style": false
+  },
+  "sources": [
+    {
+      "path": "main.py",
+      "content": "# SPDX-License-Identifier: Apache-2.0\nfrom flashinfer.gdn_decode import gated_delta_rule_decode_pretranspose\n\n\ndef run(q, k, v, state, A_log, a, dt_bias, b, scale):\n    effective_scale = q.shape[-1] ** -0.5 if scale is None or scale == 0 else scale\n    return gated_delta_rule_decode_pretranspose(\n        q=q, k=k, v=v, state=state.clone(), A_log=A_log, a=a,\n        dt_bias=dt_bias, b=b, scale=effective_scale, use_qk_l2norm=False,\n    )\n"
+    }
+  ],
+  "description": "FlashInfer 0.7.2 maintained GDN decode implementation. Honors the task scale and preserves input state. The contest task keeps its Q/K normalization and per-batch-state boundary; this is not the full SGLang state-pool interface. Upstream: https://github.com/flashinfer-ai/flashinfer/tree/d84335d8c54e0c8f9f7e22faa15c7e34a58abf94 (Apache-2.0)."
+}

solutions/gdn/flashinfer_gdn_prefill.json

@@ -0,0 +1,26 @@
+{
+  "name": "flashinfer_gdn_prefill",
+  "definition": "gdn_prefill_qk4_v8_d128_k_last",
+  "author": "inference-kernels",
+  "spec": {
+    "language": "python",
+    "target_hardware": [
+      "NVIDIA_B200",
+      "NVIDIA_B300"
+    ],
+    "entry_point": "main.py::run",
+    "dependencies": [
+      "torch>=2.14.1",
+      "flashinfer-python==0.7.2",
+      "nvidia-cutlass-dsl[cu13]==4.8.0"
+    ],
+    "destination_passing_style": false
+  },
+  "sources": [
+    {
+      "path": "main.py",
+      "content": "# SPDX-License-Identifier: Apache-2.0\nimport torch\nimport torch.nn.functional as F\nfrom flashinfer.gdn_prefill import chunk_gated_delta_rule\n\n\ndef run(q, k, v, state, A_log, a, dt_bias, b, cu_seqlens, scale):\n    alpha = torch.exp(-torch.exp(A_log.float()) * F.softplus(a.float() + dt_bias.float()))\n    beta = torch.sigmoid(b.float())\n    effective_scale = q.shape[-1] ** -0.5 if scale is None or scale == 0 else scale\n    return chunk_gated_delta_rule(\n        q=q, k=k, v=v, g=alpha, beta=beta, scale=effective_scale,\n        initial_state=state, output_final_state=True, cu_seqlens=cu_seqlens,\n        use_qk_l2norm_in_kernel=False,\n    )\n"
+    }
+  ],
+  "description": "FlashInfer 0.7.2 maintained GDN prefill implementation. Honors the task scale and preserves input state. The contest task keeps its Q/K normalization and per-batch-state boundary; this is not the full SGLang state-pool interface. Upstream: https://github.com/flashinfer-ai/flashinfer/tree/d84335d8c54e0c8f9f7e22faa15c7e34a58abf94 (Apache-2.0)."
+}

solutions/gdn/flashinfer_wrapper_9b7f1e.json

@@ -1,25 +0,0 @@
-{
-  "name": "flashinfer_wrapper_9b7f1e",
-  "definition": "gdn_decode_qk4_v8_d128_k_last",
-  "author": "flashinfer",
-  "spec": {
-    "language": "python",
-    "target_hardware": [
-      "NVIDIA H20",
-      "NVIDIA H100",
-      "NVIDIA H200"
-    ],
-    "entry_point": "main.py::run",
-    "dependencies": [
-      "flashinfer"
-    ],
-    "destination_passing_style": false
-  },
-  "sources": [
-    {
-      "path": "main.py",
-      "content": "import math\nimport torch\nfrom flashinfer.gdn_decode import gated_delta_rule_decode_pretranspose\n\n\ndef run(q, k, v, state, A_log, a, dt_bias, b, scale):\n    if isinstance(scale, torch.Tensor):\n        scale = float(scale.item())\n    else:\n        scale = float(scale)\n    if scale == 0.0:\n        scale = 1.0 / math.sqrt(q.shape[-1])\n\n    B, T, num_v_heads, head_size = v.shape\n    output = torch.empty(B, T, num_v_heads, head_size, dtype=q.dtype, device=q.device)\n\n    out, new_state = gated_delta_rule_decode_pretranspose(\n        q=q,\n        k=k,\n        v=v,\n        state=state,\n        A_log=A_log,\n        a=a,\n        dt_bias=dt_bias,\n        b=b,\n        scale=scale,\n        output=output,\n        use_qk_l2norm=False,\n    )\n\n    return out, new_state\n"
-    }
-  ],
-  "description": "Solution using FlashInfer gated_delta_rule_decode_pretranspose for GDN single-token decode (qk4_v8_d128, k-last state layout)."
-}

solutions/gemm/deepgemm_bf16_n12288_k4096.json

@@ -2,7 +2,24 @@
   "name": "deepgemm_bf16_n12288_k4096",
   "definition": "dense_gemm_bf16_nt_n12288_k4096",
   "author": "inference-kernels",
-  "description": "DeepGEMM Blackwell BF16 GEMM with FP32 accumulation. Selected by local B200 comparison against FlashInfer CUTLASS, cuTile, and small-row CuTe DSL. Upstream: https://github.com/deepseek-ai/DeepGEMM/tree/1fc9c66975ee322d628b3288534ca0e9ce12a64d (MIT).",
-  "spec": {"language": "python", "target_hardware": ["NVIDIA_B200"], "entry_point": "main.py::run", "dependencies": ["torch>=2.11", "deep-gemm @ git+https://github.com/deepseek-ai/DeepGEMM.git@1fc9c66975ee322d628b3288534ca0e9ce12a64d"], "destination_passing_style": false},
-  "sources": [{"path": "main.py", "content": "import torch\nimport deep_gemm\n\ndef run(A, W):\n    output = torch.empty((A.shape[0], W.shape[0]), dtype=torch.bfloat16, device=A.device)\n    deep_gemm.bf16_gemm_nt(A, W, output)\n    return output\n"}]
+  "description": "DeepGEMM BF16 NT GEMM with native linear on the B300 large-row shapes M=12288/16384/24576 that won the current paired comparisons. Other shapes and B200 retain DeepGEMM. All captured workloads are validated against the unchanged reference; no tolerance change.",
+  "spec": {
+    "language": "python",
+    "target_hardware": [
+      "NVIDIA_B200",
+      "NVIDIA_B300"
+    ],
+    "entry_point": "main.py::run",
+    "dependencies": [
+      "torch>=2.11",
+      "deep-gemm @ git+https://github.com/deepseek-ai/DeepGEMM.git@1fc9c66975ee322d628b3288534ca0e9ce12a64d"
+    ],
+    "destination_passing_style": false
+  },
+  "sources": [
+    {
+      "path": "main.py",
+      "content": "import torch\nimport deep_gemm\nfrom torch.nn import functional as F\n\n\ndef run(A, W):\n    # B300 comparisons favor native linear on these retained large-row shapes.\n    if (torch.cuda.get_device_capability(A.device) == (10, 3)\n            and A.shape[0] in (12288, 16384, 24576)):\n        return F.linear(A, W)\n    output = torch.empty((A.shape[0], W.shape[0]), dtype=torch.bfloat16, device=A.device)\n    deep_gemm.bf16_gemm_nt(A, W, output)\n    return output\n"
+    }
+  ]
 }

solutions/gemm/deepgemm_bf16_n4096_k12288.json

@@ -3,6 +3,23 @@
   "definition": "dense_gemm_bf16_nt_n4096_k12288",
   "author": "inference-kernels",
   "description": "DeepGEMM Blackwell BF16 GEMM with FP32 accumulation. Selected by local B200 comparison against FlashInfer CUTLASS, cuTile, and small-row CuTe DSL. Upstream: https://github.com/deepseek-ai/DeepGEMM/tree/1fc9c66975ee322d628b3288534ca0e9ce12a64d (MIT).",
-  "spec": {"language": "python", "target_hardware": ["NVIDIA_B200"], "entry_point": "main.py::run", "dependencies": ["torch>=2.11", "deep-gemm @ git+https://github.com/deepseek-ai/DeepGEMM.git@1fc9c66975ee322d628b3288534ca0e9ce12a64d"], "destination_passing_style": false},
-  "sources": [{"path": "main.py", "content": "import torch\nimport deep_gemm\n\ndef run(A, W):\n    output = torch.empty((A.shape[0], W.shape[0]), dtype=torch.bfloat16, device=A.device)\n    deep_gemm.bf16_gemm_nt(A, W, output)\n    return output\n"}]
+  "spec": {
+    "language": "python",
+    "target_hardware": [
+      "NVIDIA_B200",
+      "NVIDIA_B300"
+    ],
+    "entry_point": "main.py::run",
+    "dependencies": [
+      "torch>=2.11",
+      "deep-gemm @ git+https://github.com/deepseek-ai/DeepGEMM.git@1fc9c66975ee322d628b3288534ca0e9ce12a64d"
+    ],
+    "destination_passing_style": false
+  },
+  "sources": [
+    {
+      "path": "main.py",
+      "content": "import torch\nimport deep_gemm\n\ndef run(A, W):\n    output = torch.empty((A.shape[0], W.shape[0]), dtype=torch.bfloat16, device=A.device)\n    deep_gemm.bf16_gemm_nt(A, W, output)\n    return output\n"
+    }
+  ]
 }

solutions/gemm/hybrid_bf16_n4096_k4096.json

@@ -2,7 +2,24 @@
   "name": "hybrid_bf16_n4096_k4096",
   "definition": "dense_gemm_bf16_nt_n4096_k4096",
   "author": "inference-kernels",
-  "description": "Shape-based B200 dispatch between FlashInfer CuTe DSL for 1-4 or 32 rows and DeepGEMM otherwise. Selected by local comparisons on actual captured shapes. Upstreams: https://github.com/flashinfer-ai/flashinfer (Apache-2.0), https://github.com/deepseek-ai/DeepGEMM/tree/1fc9c66975ee322d628b3288534ca0e9ce12a64d (MIT).",
-  "spec": {"language": "python", "target_hardware": ["NVIDIA_B200"], "entry_point": "main.py::run", "dependencies": ["torch>=2.11", "flashinfer-python==0.7.2", "nvidia-cutlass-dsl[cu13]==4.7.1", "deep-gemm @ git+https://github.com/deepseek-ai/DeepGEMM.git@1fc9c66975ee322d628b3288534ca0e9ce12a64d"], "destination_passing_style": false},
-  "sources": [{"path": "main.py", "content": "import torch\nimport deep_gemm\nfrom flashinfer.gemm import mm_bf16\n\ndef run(A, W):\n    rows = A.shape[0]\n    if rows <= 4 or rows == 32:\n        return mm_bf16(A, W.T, backend='cute-dsl')\n    output = torch.empty((rows, W.shape[0]), dtype=torch.bfloat16, device=A.device)\n    deep_gemm.bf16_gemm_nt(A, W, output)\n    return output\n"}]
+  "description": "DeepGEMM BF16 NT GEMM for the retained M >= 4096 workloads. Removed the unreachable small-M FlashInfer branch and its conflicting CUTLASS dependency. Upstream: https://github.com/deepseek-ai/DeepGEMM/tree/1fc9c66975ee322d628b3288534ca0e9ce12a64d (MIT).",
+  "spec": {
+    "language": "python",
+    "target_hardware": [
+      "NVIDIA_B200",
+      "NVIDIA_B300"
+    ],
+    "entry_point": "main.py::run",
+    "dependencies": [
+      "torch>=2.11",
+      "deep-gemm @ git+https://github.com/deepseek-ai/DeepGEMM.git@1fc9c66975ee322d628b3288534ca0e9ce12a64d"
+    ],
+    "destination_passing_style": false
+  },
+  "sources": [
+    {
+      "path": "main.py",
+      "content": "import torch\nimport deep_gemm\n\n\ndef run(A, W):\n    output = torch.empty((A.shape[0], W.shape[0]), dtype=torch.bfloat16, device=A.device)\n    deep_gemm.bf16_gemm_nt(A, W, output)\n    return output\n"
+    }
+  ]
 }