initial upload: 7 problem definitions

01_fp8_gemm/PROMPT.txt

@@ -0,0 +1,7 @@
+I need you to optimize an FP8 GEMM for the RTX PRO 6000 (SM120 Blackwell, GDDR7, 1.8 TB/s). The reference implementation is in reference.py and your kernel goes in solution.py. You can make whatever mess you want in this directory — scratch files, intermediate kernels, build artifacts, profiling traces — but the final answer has to be in solution.py with the same Model, get_inputs, and get_init_inputs interface as reference.py.
+
+The input is an fp8_e4m3 activation tensor (M, K) and an fp8_e4m3 weight (N, K), and you return y = x @ w.T as bf16 (M, N). Correctness tolerance on the bf16 output is 0.15 abs/rel — fp8 multiply has real noise so the bar is loose, but it has to match the reference within that. The shapes you have to handle are M=4096 N=4096 K=4096 (square aligned, the easy case), M=4096 N=4096 K=4127 (K not a multiple of 128, which forces predicated tails on tile-quantized kernels), M=32 N=8192 K=8192 (skinny M, decode-style), and M=4096 N=14336 K=4096 (Llama-3 up-proj).
+
+This needs to be a real custom kernel. Don't reach for torch._scaled_mm or torch.ops.aten._scaled_mm — they're off-limits and using them fails correctness. Try CUDA C++ via torch.utils.cpp_extension.load_inline, inline PTX, or CUTLASS — whatever fits. Anything you're uncertain about, look up PTX docs, clone CUTLASS or other reference repos, read library headers, and investigate.
+
+Your flywheel is implement, profile (ncu, nsys, torch.profiler — whatever's useful) and time it with benchmark.py, verify correctness by running `python check.py` and reading the output, then iterate. Don't substitute your own one-off correctness snippets for check.py — it iterates over every shape, your spot-check almost certainly won't. If `python check.py` hasn't printed PASS, you're not done. Take as long as you need to actually push the number up.

01_fp8_gemm/benchmark.py

@@ -0,0 +1,128 @@
+"""Roofline benchmark for FP8 GEMM.
+
+For each shape: times eager reference, compiled reference, SOTA (if available),
+and the agent's solution. Reports achieved TFLOPS, GB/s, and peak_fraction.
+
+Output lines the harness picks up:
+  shape=<idx> variant=<name> tflops=<N> gbps=<N> ms=<N>
+  peak_fraction: <N>  (geomean over shapes of solution's peak_fraction)
+"""
+import sys
+from math import exp, log
+from pathlib import Path
+
+import torch
+import yaml
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(REPO_ROOT))
+
+from src.eval.roofline import compute_gbps, compute_tflops, peak_fraction  # noqa: E402
+from src.eval.timing import time_fn  # noqa: E402
+from src.hardware import get as get_hw  # noqa: E402
+
+
+def _eval_formula(expr: str, vars: dict) -> float:
+    # Very small eval: only names from `vars` are valid.
+    return float(eval(expr, {"__builtins__": {}}, vars))
+
+
+def main():
+    import reference
+    import shapes
+    import solution
+
+    meta = yaml.safe_load(Path("problem.yaml").read_text())
+    hw = get_hw(meta["hardware"][0])
+    peak_tflops = hw.peak_tflops_dense.get(meta["peak_tflops_key"], 0.0)
+    peak_gbps = hw.peak_bandwidth_gb_s
+    regime = meta.get("regime", "compute")
+    flops_formula = meta["flops_formula"]
+    bytes_formula = meta["bytes_formula"]
+    num_perf_trials = int(meta.get("num_perf_trials", 30))
+
+    device = torch.device("cuda:0")
+
+    # Optional SOTA
+    try:
+        import sota as sota_mod
+        has_sota = sota_mod.is_available()
+    except Exception:
+        has_sota = False
+
+    sol_fractions: list[float] = []
+
+    for shape_idx, shape in enumerate(shapes.SHAPES):
+        reference.M = shape["M"]
+        reference.N = shape["N"]
+        reference.K = shape["K"]
+
+        init_args = reference.get_init_inputs()
+        ref_model = reference.Model(*init_args).to(device).eval()
+        sol_model = solution.Model(*init_args).to(device).eval()
+        sd = ref_model.state_dict()
+        try:
+            sol_model.load_state_dict(sd, strict=True)
+        except RuntimeError:
+            pass
+
+        torch.manual_seed(2026)
+        inputs = [t.to(device) for t in reference.get_inputs()]
+
+        # Theoretical work per call
+        flops = _eval_formula(flops_formula, shape)
+        bytes_moved = _eval_formula(bytes_formula, shape)
+
+        # Eager
+        ms_eager = time_fn(ref_model, inputs, iters=num_perf_trials)
+
+        # Compiled (best-effort)
+        try:
+            comp = torch.compile(ref_model, mode="reduce-overhead")
+            ms_comp = time_fn(comp, inputs, iters=num_perf_trials)
+        except Exception as e:
+            print(f"  [compile fallback] {type(e).__name__}: {e}")
+            ms_comp = None
+
+        # SOTA
+        ms_sota = None
+        if has_sota:
+            try:
+                def sota_fn(x, _w=ref_model.weight):
+                    return sota_mod.sota_forward(x, _w)
+                ms_sota = time_fn(sota_fn, inputs, iters=num_perf_trials)
+            except Exception as e:
+                print(f"  [sota unavailable] {type(e).__name__}: {e}")
+
+        # Solution
+        ms_sol = time_fn(sol_model, inputs, iters=num_perf_trials)
+
+        for variant, ms in [
+            ("eager", ms_eager),
+            ("compiled", ms_comp),
+            ("sota", ms_sota),
+            ("solution", ms_sol),
+        ]:
+            if ms is None:
+                continue
+            tflops = compute_tflops(flops, ms)
+            gbps = compute_gbps(bytes_moved, ms)
+            print(f"shape={shape_idx} variant={variant} tflops={tflops:.3f} gbps={gbps:.3f} ms={ms:.3f}")
+
+        # Score: peak_fraction depends on regime
+        sol_tflops = compute_tflops(flops, ms_sol)
+        sol_gbps = compute_gbps(bytes_moved, ms_sol)
+        if regime == "compute":
+            frac = peak_fraction(sol_tflops, peak_tflops)
+        else:
+            frac = peak_fraction(sol_gbps, peak_gbps)
+        sol_fractions.append(frac)
+        print(f"shape={shape_idx} solution_peak_fraction={frac:.4f}")
+
+    gmean = exp(sum(log(max(f, 1e-9)) for f in sol_fractions) / len(sol_fractions))
+    print(f"peak_fraction: {gmean:.4f}")
+    print(f"RESULT: {'OK' if gmean >= 0.1 else 'LOW'}")
+
+
+if __name__ == "__main__":
+    main()

01_fp8_gemm/check.py

@@ -0,0 +1,112 @@
+"""Correctness runner for FP8 GEMM.
+
+Runs solution.Model vs reference.Model across all shapes in shapes.py, 3 seeds
+each, with per-dtype atol/rtol. Also rejects forbidden ops by grep.
+"""
+import re
+import sys
+from pathlib import Path
+
+import torch
+import yaml
+
+# Make the repo's src/ importable
+REPO_ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(REPO_ROOT))
+
+from src.eval.correctness import check_correctness  # noqa: E402
+
+
+def main():
+    try:
+        import reference
+        import shapes
+        import solution
+    except Exception as e:
+        print(f"FAIL: import error: {e}")
+        sys.exit(1)
+
+    problem_yaml = Path("problem.yaml")
+    meta = yaml.safe_load(problem_yaml.read_text()) if problem_yaml.exists() else {}
+
+    # --- Forbidden-op check ------------------------------------------------
+    sol_src = Path("solution.py").read_text() if Path("solution.py").exists() else ""
+    for forbidden in meta.get("forbidden", []):
+        pat = re.escape(forbidden)
+        if re.search(pat, sol_src):
+            print(f"FAIL: forbidden op used: {forbidden}")
+            sys.exit(1)
+
+    device = torch.device("cuda:0")
+    tol_override = meta.get("tolerance") or None
+
+    # --- Per-shape correctness --------------------------------------------
+    all_shapes = shapes.SHAPES
+    for shape_idx, shape in enumerate(all_shapes):
+        # Rebuild reference module's module-level M/N/K shims so get_inputs /
+        # get_init_inputs match this shape.
+        reference.M = shape["M"]
+        reference.N = shape["N"]
+        reference.K = shape["K"]
+
+        init_args = reference.get_init_inputs()
+        ref_model = reference.Model(*init_args).to(device).eval()
+        sol_model = solution.Model(*init_args).to(device).eval()
+
+        # Share weights. strict=True — if sol_model doesn't declare the same
+        # parameters, correctness fails (this closes the "identity kernel"
+        # cheat class).
+        sd = ref_model.state_dict()
+        try:
+            sol_model.load_state_dict(sd, strict=True)
+        except RuntimeError as e:
+            print(f"FAIL: state_dict mismatch at shape {shape_idx} ({shape}): {e}")
+            sys.exit(1)
+
+        for seed in (42, 123, 456):
+            torch.manual_seed(seed)
+            torch.cuda.manual_seed_all(seed)
+            inputs = [t.to(device) for t in reference.get_inputs()]
+
+            with torch.no_grad():
+                ref_out = ref_model(*inputs)
+                sol_out = sol_model(*inputs)
+
+            ok, msg = check_correctness(
+                ref_out, sol_out,
+                dtype=ref_out.dtype,
+                override=tol_override,
+            )
+            if not ok:
+                print(f"FAIL: shape {shape_idx} {shape} seed {seed}: {msg}")
+                sys.exit(1)
+
+    # --- Framework label (for stats) --------------------------------------
+    _emit_framework_label()
+    print("PASS")
+
+
+def _emit_framework_label():
+    """Write framework.txt with the detected kernel framework."""
+    patterns = [
+        ("ptx",       r"asm\s+volatile|asm\s*\(|mma\.sync|tcgen05\."),
+        ("cutlass3",  r"\bcute::|cutlass/gemm/collective|cutlass::arch::Sm(9|10|12)"),
+        ("cutlass2",  r"cutlass/gemm/device/gemm|cutlass::gemm::device"),
+        ("cuda_wmma", r"\bnvcuda::wmma\b|wmma::fragment"),
+        ("triton",    r"import\s+triton\b|@triton\.jit|\btl\.dot\b"),
+        ("cuda_raw",  r"torch\.utils\.cpp_extension\.load_inline|__global__\s+void"),
+    ]
+    sol = Path("solution.py")
+    if not sol.exists():
+        return
+    code = sol.read_text()
+    label = "unknown"
+    for name, pat in patterns:
+        if re.search(pat, code):
+            label = name
+            break
+    Path("framework.txt").write_text(label + "\n")
+
+
+if __name__ == "__main__":
+    main()

01_fp8_gemm/problem.yaml

@@ -0,0 +1,37 @@
+name: 01_fp8_gemm
+display_name: "FP8 e4m3 GEMM"
+precision: fp8_e4m3
+regime: compute
+
+# Dense-equivalent FLOPs per invocation. Evaluated per-shape; the benchmark
+# substitutes M/N/K from each shapes.py entry.
+flops_formula: "2 * M * N * K"
+
+# Bytes moved (approximate): fp8 inputs in, bf16 output.
+bytes_formula: "M*K + K*N + M*N*2"
+
+hardware: [RTX_PRO_6000]
+peak_tflops_key: fp8  # index into src/hardware/rtx_pro_6000.py peak_tflops_dense
+peak_bandwidth_key: dram
+
+# Per-dtype tolerance override (optional). Defaults are in src/eval/correctness.py.
+tolerance:
+  fp8_e4m3fn: 0.15
+
+# Forbidden ops — using any of these in solution.py fails correctness post-hoc.
+# torch._scaled_mm is Stanford-style cheating (just call the vendor library).
+forbidden:
+  - "torch._scaled_mm"
+  - "torch.ops.aten._scaled_mm"
+
+sota:
+  name: "FlashInfer FP8 GEMM"
+  url: "https://github.com/flashinfer-ai/flashinfer"
+  function: "flashinfer.gemm.fp8_gemm"
+  deps:
+    - "flashinfer>=0.6.8"
+  # Documented H100 throughput for this shape (informational, not graded):
+  reference_throughput_tflops_h100: 550
+
+num_correct_trials: 3
+num_perf_trials: 30

01_fp8_gemm/reference.py

@@ -0,0 +1,45 @@
+"""Naive FP8 e4m3 GEMM reference (correctness only, NOT the SOTA baseline).
+
+We cast inputs to bf16 and use torch.matmul. The agent's solution must match
+this numerically within the fp8 tolerance declared in problem.yaml.
+"""
+import torch
+import torch.nn as nn
+
+OP_TYPE = "gemm"
+SUPPORTED_PRECISIONS = ["fp8_e4m3"]
+HARDWARE_REQUIRED = ["RTX_PRO_6000", "H100", "B200"]
+
+
+class Model(nn.Module):
+    """y = (x @ w.T).to(bf16), where x is fp8_e4m3 (M, K), w is fp8_e4m3 (N, K)."""
+
+    def __init__(self, M: int, N: int, K: int):
+        super().__init__()
+        self.M, self.N, self.K = M, N, K
+        # Weights stored as parameters so state_dict is well-defined.
+        # We initialize in bf16 then cast; the fp8 dtype is set by get_inputs.
+        self.weight = nn.Parameter(torch.empty(N, K, dtype=torch.bfloat16))
+        nn.init.normal_(self.weight, std=0.02)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        # Upcast to bf16 for the naive reference; the kernel equivalent would
+        # use mma.sync f8f6f4 kind directly.
+        x_bf = x.to(torch.bfloat16)
+        w_bf = self.weight.to(torch.bfloat16)
+        return x_bf @ w_bf.T  # (M, N) bf16
+
+
+M = 4096
+N = 4096
+K = 4096
+
+
+def get_inputs():
+    # fp8_e4m3 input; random uniform in [-4, 4] then cast.
+    x = (torch.rand(M, K) * 8 - 4).to(torch.float8_e4m3fn)
+    return [x]
+
+
+def get_init_inputs():
+    return [M, N, K]

01_fp8_gemm/shapes.py

@@ -0,0 +1,15 @@
+"""Canonical shape sweep for FP8 GEMM.
+
+Mix of:
+  - square aligned (the easy case)
+  - off-alignment K (common real-world failure mode for tile-quantized kernels)
+  - skinny (decode-like, memory-bound)
+  - rectangular (prefill with grouped attention)
+"""
+
+SHAPES = [
+    {"M": 4096, "N": 4096, "K": 4096},        # square aligned
+    {"M": 4096, "N": 4096, "K": 4127},        # K not multiple of 128 -> forces predicated tails
+    {"M": 32,   "N": 8192, "K": 8192},        # skinny M (decode)
+    {"M": 4096, "N": 14336, "K": 4096},       # Llama3 up-proj shape
+]

01_fp8_gemm/sota.py

@@ -0,0 +1,53 @@
+"""SOTA reference for FP8 GEMM: flashinfer.gemm.fp8_gemm.
+
+If flashinfer is not installed or the SM120 path isn't supported, this falls
+back to torch._scaled_mm which is the cuBLAS FP8 path. The benchmark treats
+whichever succeeds as the SOTA reference line.
+
+Agents are FORBIDDEN from using torch._scaled_mm in their solution (see
+problem.yaml.forbidden). This file is only for the benchmark's reference line.
+"""
+from __future__ import annotations
+
+import torch
+
+
+def _try_flashinfer(x: torch.Tensor, w: torch.Tensor) -> torch.Tensor | None:
+    try:
+        import flashinfer  # noqa: F401
+        # Note: flashinfer's FP8 GEMM API surface may differ; adapt if needed.
+        # Placeholder call — replace with the actual flashinfer entry point
+        # once validated on SM120.
+        return None
+    except ImportError:
+        return None
+
+
+def _scaled_mm(x: torch.Tensor, w: torch.Tensor) -> torch.Tensor:
+    # torch._scaled_mm wants per-tensor scales. Use unit scales for the reference.
+    scale_a = torch.tensor(1.0, device=x.device)
+    scale_b = torch.tensor(1.0, device=x.device)
+    out = torch._scaled_mm(
+        x,
+        w.T,
+        scale_a=scale_a,
+        scale_b=scale_b,
+        out_dtype=torch.bfloat16,
+    )
+    return out if not isinstance(out, tuple) else out[0]
+
+
+def sota_forward(x: torch.Tensor, w: torch.Tensor) -> torch.Tensor:
+    """Best-available FP8 GEMM reference. x: (M, K) fp8, w: (N, K) fp8."""
+    out = _try_flashinfer(x, w)
+    if out is not None:
+        return out
+    return _scaled_mm(x, w)
+
+
+def is_available() -> bool:
+    try:
+        # Verify torch._scaled_mm is callable (smoke)
+        return hasattr(torch, "_scaled_mm")
+    except Exception:
+        return False

02_kda_cutlass/PROMPT.txt

@@ -0,0 +1,7 @@
+I need you to implement Kimi Delta Attention forward (chunk form) for the RTX PRO 6000 (SM120 Blackwell, GDDR7, 1.8 TB/s). The reference implementation is in reference.py and your kernel goes in solution.py. You can make whatever mess you want in this directory — scratch files, intermediate kernels, build artifacts, profiling traces — but the final answer has to be in solution.py with the same Model, get_inputs, and get_init_inputs interface as reference.py.
+
+The op is the chunk-parallel KDA forward from the FLA library: q and k of shape (B, T, H, K) in bf16, v of shape (B, T, H, V) in bf16, g of shape (B, T, H, K) in fp32 (per-channel log-decay with in-chunk cumsum already applied), beta of shape (B, T, H) in bf16, scale a python float, chunk_size 64, no initial state, no final state. You return o of shape (B, T, H, V) in bf16. Correctness tolerance is 0.05 abs/rel — the long recurrence accumulates more error than a single GEMM so the bar's a bit looser than default bf16. The shapes you have to handle are B=2 T=1024 H=8 K=128 V=128 (short-context training step), B=2 T=2048 H=8 K=128 V=128 (the headline shape from the Kimi Linear paper), B=1 T=4096 H=8 K=128 V=128 (long context that stresses the inter-chunk recurrence), and B=1 T=2048 H=4 K=128 V=128 (thin batch decode).
+
+This needs to be a real custom kernel — the whole point of the problem is to write the chunk-parallel attention yourself, not call FLA's existing implementation. Don't import or call fla.ops.kda, fla.ops.chunk_kda, chunk_kda, fused_recurrent_kda, naive_chunk_kda, or naive_recurrent_kda. The intended path is CUTLASS CuTe on SM120 but Triton, CUDA C++ via load_inline, or inline PTX are also fine if you prefer. Anything you're uncertain about, look up PTX docs, clone CUTLASS or FLA or other reference repos, read library headers, and investigate.
+
+Your flywheel is implement, profile (ncu, nsys, torch.profiler — whatever's useful) and time it with benchmark.py, verify correctness by running `python check.py` and reading the output, then iterate. Don't substitute your own one-off correctness snippets for check.py — it iterates over every shape, your spot-check almost certainly won't. If `python check.py` hasn't printed PASS, you're not done. Take as long as you need to actually push the number up.

02_kda_cutlass/benchmark.py

@@ -0,0 +1,133 @@
+"""Roofline benchmark for KDA forward (chunk form).
+
+For each shape: times eager reference, compiled reference, SOTA (FLA's Triton
+chunk_kda, if available on this GPU), and the agent's solution. Reports
+achieved TFLOPS, GB/s, and peak_fraction.
+
+Output lines the harness picks up:
+  shape=<idx> variant=<name> tflops=<N> gbps=<N> ms=<N>
+  peak_fraction: <N>  (geomean over shapes of solution's peak_fraction)
+"""
+import sys
+from math import exp, log
+from pathlib import Path
+
+import torch
+import yaml
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(REPO_ROOT))
+
+from src.eval.roofline import compute_gbps, compute_tflops, peak_fraction  # noqa: E402
+from src.eval.timing import time_fn  # noqa: E402
+from src.hardware import get as get_hw  # noqa: E402
+
+
+def _eval_formula(expr: str, vars: dict) -> float:
+    return float(eval(expr, {"__builtins__": {}}, vars))
+
+
+def _apply_shape(reference, shape):
+    for k, v in shape.items():
+        setattr(reference, k, v)
+
+
+def main():
+    import reference
+    import shapes
+    import solution
+
+    meta = yaml.safe_load(Path("problem.yaml").read_text())
+    hw = get_hw(meta["hardware"][0])
+    peak_tflops = hw.peak_tflops_dense.get(meta["peak_tflops_key"], 0.0)
+    peak_gbps = hw.peak_bandwidth_gb_s
+    regime = meta.get("regime", "compute")
+    flops_formula = meta["flops_formula"]
+    bytes_formula = meta["bytes_formula"]
+    num_perf_trials = int(meta.get("num_perf_trials", 20))
+
+    device = torch.device("cuda:0")
+
+    # Optional SOTA
+    try:
+        import sota as sota_mod
+        has_sota = sota_mod.is_available()
+    except Exception:
+        has_sota = False
+
+    sol_fractions: list[float] = []
+
+    for shape_idx, shape in enumerate(shapes.SHAPES):
+        _apply_shape(reference, shape)
+
+        init_args = reference.get_init_inputs()
+        ref_model = reference.Model(*init_args).to(device).eval()
+        sol_model = solution.Model(*init_args).to(device).eval()
+        sd = ref_model.state_dict()
+        try:
+            sol_model.load_state_dict(sd, strict=True)
+        except RuntimeError:
+            pass
+
+        torch.manual_seed(2026)
+        inputs = [t.to(device) if hasattr(t, "to") else t for t in reference.get_inputs()]
+
+        # Theoretical work per call
+        flops = _eval_formula(flops_formula, shape)
+        bytes_moved = _eval_formula(bytes_formula, shape)
+
+        # Eager
+        ms_eager = time_fn(ref_model, inputs, iters=num_perf_trials)
+
+        # Compiled (best-effort -- the chunk-form recurrence often defeats inductor)
+        try:
+            comp = torch.compile(ref_model, mode="reduce-overhead")
+            ms_comp = time_fn(comp, inputs, iters=num_perf_trials)
+        except Exception as e:
+            print(f"  [compile fallback] {type(e).__name__}: {e}")
+            ms_comp = None
+
+        # SOTA
+        ms_sota = None
+        if has_sota:
+            try:
+                scale = float(shape["K"]) ** -0.5
+
+                def sota_fn(q, k, v, g, beta, _scale=scale):
+                    return sota_mod.sota_forward(q, k, v, g, beta, scale=_scale)
+
+                ms_sota = time_fn(sota_fn, inputs, iters=num_perf_trials)
+            except Exception as e:
+                print(f"  [sota unavailable] {type(e).__name__}: {e}")
+
+        # Solution
+        ms_sol = time_fn(sol_model, inputs, iters=num_perf_trials)
+
+        for variant, ms in [
+            ("eager", ms_eager),
+            ("compiled", ms_comp),
+            ("sota", ms_sota),
+            ("solution", ms_sol),
+        ]:
+            if ms is None:
+                continue
+            tflops = compute_tflops(flops, ms)
+            gbps = compute_gbps(bytes_moved, ms)
+            print(f"shape={shape_idx} variant={variant} tflops={tflops:.3f} gbps={gbps:.3f} ms={ms:.3f}")
+
+        sol_tflops = compute_tflops(flops, ms_sol)
+        sol_gbps = compute_gbps(bytes_moved, ms_sol)
+        if regime == "compute":
+            frac = peak_fraction(sol_tflops, peak_tflops)
+        else:
+            frac = peak_fraction(sol_gbps, peak_gbps)
+        sol_fractions.append(frac)
+        print(f"shape={shape_idx} solution_peak_fraction={frac:.4f}")
+
+    gmean = exp(sum(log(max(f, 1e-9)) for f in sol_fractions) / len(sol_fractions))
+    print(f"peak_fraction: {gmean:.4f}")
+    print(f"RESULT: {'OK' if gmean >= 0.1 else 'LOW'}")
+
+
+if __name__ == "__main__":
+    main()

02_kda_cutlass/check.py

@@ -0,0 +1,113 @@
+"""Correctness runner for KDA forward (chunk form).
+
+Runs solution.Model vs reference.Model across all shapes in shapes.py, 3 seeds
+each, with per-dtype atol/rtol (bf16 default 1e-2 plus a 5e-2 override for
+this problem). Also rejects forbidden ops by grep.
+"""
+import re
+import sys
+from pathlib import Path
+
+import torch
+import yaml
+
+# Make the repo's src/ importable
+REPO_ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(REPO_ROOT))
+
+from src.eval.correctness import check_correctness  # noqa: E402
+
+
+def _apply_shape(reference, shape):
+    """Override reference's module-level shape shims so get_inputs/get_init_inputs match."""
+    for k, v in shape.items():
+        setattr(reference, k, v)
+
+
+def main():
+    try:
+        import reference
+        import shapes
+        import solution
+    except Exception as e:
+        print(f"FAIL: import error: {e}")
+        sys.exit(1)
+
+    problem_yaml = Path("problem.yaml")
+    meta = yaml.safe_load(problem_yaml.read_text()) if problem_yaml.exists() else {}
+
+    # --- Forbidden-op check ------------------------------------------------
+    sol_src = Path("solution.py").read_text() if Path("solution.py").exists() else ""
+    for forbidden in meta.get("forbidden", []):
+        pat = re.escape(forbidden)
+        if re.search(pat, sol_src):
+            print(f"FAIL: forbidden op used: {forbidden}")
+            sys.exit(1)
+
+    device = torch.device("cuda:0")
+    tol_override = meta.get("tolerance") or None
+
+    # --- Per-shape correctness --------------------------------------------
+    all_shapes = shapes.SHAPES
+    for shape_idx, shape in enumerate(all_shapes):
+        _apply_shape(reference, shape)
+
+        init_args = reference.get_init_inputs()
+        ref_model = reference.Model(*init_args).to(device).eval()
+        sol_model = solution.Model(*init_args).to(device).eval()
+
+        # Share weights/buffers. strict=True closes the "identity kernel" cheat.
+        sd = ref_model.state_dict()
+        try:
+            sol_model.load_state_dict(sd, strict=True)
+        except RuntimeError as e:
+            print(f"FAIL: state_dict mismatch at shape {shape_idx} ({shape}): {e}")
+            sys.exit(1)
+
+        for seed in (42, 123, 456):
+            torch.manual_seed(seed)
+            torch.cuda.manual_seed_all(seed)
+            inputs = [t.to(device) if hasattr(t, "to") else t for t in reference.get_inputs()]
+
+            with torch.no_grad():
+                ref_out = ref_model(*inputs)
+                sol_out = sol_model(*inputs)
+
+            ok, msg = check_correctness(
+                ref_out, sol_out,
+                dtype=ref_out.dtype,
+                override=tol_override,
+            )
+            if not ok:
+                print(f"FAIL: shape {shape_idx} {shape} seed {seed}: {msg}")
+                sys.exit(1)
+
+    # --- Framework label (for stats) --------------------------------------
+    _emit_framework_label()
+    print("PASS")
+
+
+def _emit_framework_label():
+    """Write framework.txt with the detected kernel framework."""
+    patterns = [
+        ("ptx",       r"asm\s+volatile|asm\s*\(|mma\.sync|tcgen05\."),
+        ("cutlass3",  r"\bcute::|cutlass/gemm/collective|cutlass::arch::Sm(9|10|12)"),
+        ("cutlass2",  r"cutlass/gemm/device/gemm|cutlass::gemm::device"),
+        ("cuda_wmma", r"\bnvcuda::wmma\b|wmma::fragment"),
+        ("triton",    r"import\s+triton\b|@triton\.jit|\btl\.dot\b"),
+        ("cuda_raw",  r"torch\.utils\.cpp_extension\.load_inline|__global__\s+void"),
+    ]
+    sol = Path("solution.py")
+    if not sol.exists():
+        return
+    code = sol.read_text()
+    label = "unknown"
+    for name, pat in patterns:
+        if re.search(pat, code):
+            label = name
+            break
+    Path("framework.txt").write_text(label + "\n")
+
+
+if __name__ == "__main__":
+    main()

02_kda_cutlass/problem.yaml

@@ -0,0 +1,54 @@
+name: 02_kda_cutlass
+display_name: "Kimi Delta Attention (chunk forward) via CUTLASS CuTe"
+precision: bf16
+regime: compute
+
+# Approximate FLOPs per forward call. KDA forward (chunk form) breakdown per
+# token across all heads:
+#   - intra-chunk Aqk (q @ k.T with decay): 2*BT*K
+#   - intra-chunk Akk + cumulative invert : ~3*BT*K + BT^2
+#   - w = A @ (g.exp()*k):                  2*BT*K
+#   - u = A @ v:                            2*BT*V
+#   - inter-chunk q @ S:                    2*K*V
+#   - inter-chunk (Aqk @ v_i):              2*BT*V
+#   - state update S += k.T @ v_i:          2*K*V
+# Aggregating with a constant of 4 (typical for chunked linear attention) gives
+# the formula below. Used only for roofline reporting -- not graded directly.
+flops_formula: "4 * B * T * H * (K*V + CHUNK_SIZE*K + CHUNK_SIZE*V)"
+
+# Bytes moved (lower bound): one read of q,k,v,g,beta and one write of o.
+bytes_formula: "B*T*H*K*2 + B*T*H*K*2 + B*T*H*V*2 + B*T*H*K*4 + B*T*H*2 + B*T*H*V*2"
+
+hardware: [RTX_PRO_6000]
+peak_tflops_key: bf16  # KDA's heavy work is bf16 @ bf16 -> fp32 GEMM-equivalent
+peak_bandwidth_key: dram
+
+# bf16 default tolerance from src/eval/correctness.py is 1e-2 atol/rtol; KDA's
+# long recurrence accumulates more error than a single GEMM, so we relax slightly.
+tolerance:
+  torch.bfloat16: 0.05  # was "5e-2" -- PyYAML parses un-dotted sci-notation as string
+
+# Forbidden ops -- using any in solution.py fails correctness post-hoc.
+# The whole point of the problem is to write the kernel; calling FLA's existing
+# Triton chunk_kda is the canonical reward-hack to block.
+forbidden:
+  - "fla.ops.kda"
+  - "fla.ops.chunk_kda"
+  - "chunk_kda"
+  - "fused_recurrent_kda"
+  - "naive_chunk_kda"
+  - "naive_recurrent_kda"
+
+sota:
+  name: "FLA chunk_kda (Triton)"
+  url: "https://github.com/fla-org/flash-linear-attention/tree/main/fla/ops/kda"
+  function: "fla.ops.kda.chunk_kda"
+  deps:
+    - "flash-linear-attention>=0.3"
+  # Documented H100 throughput (informational, not graded). FLA's KDA Triton
+  # kernel hits roughly 0.6-0.8x of FlashAttention-2 wall-clock on H100 at the
+  # B=2,T=2048,H=8,K=V=128 shape (per the Kimi Linear blog / FLA benchmarks).
+  reference_throughput_tflops_h100: null
+
+num_correct_trials: 3
+num_perf_trials: 20

02_kda_cutlass/reference.py

@@ -0,0 +1,143 @@
+"""Naive PyTorch reference for Kimi Delta Attention (KDA) forward, chunk form.
+
+This is the correctness oracle, NOT the SOTA baseline. It mirrors the
+chunk-parallel formulation in fla/ops/kda/naive.py (Songlin Yang et al.)
+without any Triton or CUDA optimization.
+
+Inputs (per the FLA convention):
+  q, k : (B, T, H, K)   bf16   -- queries / keys
+  v    : (B, T, H, V)   bf16   -- values
+  g    : (B, T, H, K)   fp32   -- per-channel log-decay (in-chunk cumsum applied)
+  beta : (B, T, H)      bf16   -- write strength
+
+Output:
+  o    : (B, T, H, V)   bf16
+
+The agent must reproduce this output (within bf16 tolerance) using a CUTLASS
+CuTe kernel on SM120 -- NOT by calling fla.ops.chunk_kda directly.
+"""
+from __future__ import annotations
+
+import torch
+import torch.nn as nn
+from einops import rearrange
+
+OP_TYPE = "linear_attention"
+SUPPORTED_PRECISIONS = ["bf16"]
+HARDWARE_REQUIRED = ["RTX_PRO_6000", "H100", "B200"]
+
+
+def _naive_chunk_kda(
+    q: torch.Tensor,
+    k: torch.Tensor,
+    v: torch.Tensor,
+    g: torch.Tensor,
+    beta: torch.Tensor,
+    scale: float,
+    chunk_size: int = 64,
+) -> torch.Tensor:
+    """KDA forward, no initial state, no final state. Returns o with v's dtype."""
+    dtype = v.dtype
+    B, T, H, K = q.shape
+    V = v.shape[-1]
+    BT = chunk_size
+    assert T % BT == 0, f"T={T} must be a multiple of chunk_size={BT}"
+    NT = T // BT
+
+    q, k, v, g, beta = (x.to(torch.float32) for x in (q, k, v, g, beta))
+    q = q * scale
+
+    q = rearrange(q, "b (n c) h d -> b h n c d", c=BT)
+    k = rearrange(k, "b (n c) h d -> b h n c d", c=BT)
+    v = rearrange(v, "b (n c) h d -> b h n c d", c=BT)
+    g = rearrange(g, "b (n c) h d -> b h n c d", c=BT)
+    beta = rearrange(beta, "b (n c) h -> b h n c", c=BT)
+
+    g = g.cumsum(-2)
+
+    # ---- Build A_kk (intra-chunk K-K interaction, lower-triangular w/ diag masked) ----
+    mask_diag_upper = torch.triu(torch.ones(BT, BT, dtype=torch.bool, device=q.device), diagonal=0)
+    A = torch.zeros(*q.shape[:-1], BT, dtype=torch.float32, device=q.device)
+    for i in range(BT):
+        k_i = k[..., i, :]
+        g_i = g[..., i:i + 1, :]
+        A[..., i] = torch.einsum("... c d, ... d -> ... c", k * (g - g_i).exp(), k_i)
+    A = A * beta[..., None]
+    A = -A.masked_fill(mask_diag_upper, 0)
+
+    for i in range(1, BT):
+        A[..., i, :i] = A[..., i, :i].clone() + (A[..., i, :, None].clone() * A[..., :, :i].clone()).sum(-2)
+    A = (A + torch.eye(BT, dtype=torch.float32, device=q.device)) * beta[..., None, :]
+
+    w = A @ (g.exp() * k)
+    u = A @ v
+
+    # ---- Recurrent inter-chunk pass ----
+    S = q.new_zeros(B, H, K, V)
+    o = torch.zeros_like(v)
+    mask_strict_upper = torch.triu(torch.ones(BT, BT, dtype=torch.bool, device=q.device), diagonal=1)
+    for i in range(NT):
+        q_i, k_i, u_i, g_i, w_i = q[:, :, i], k[:, :, i], u[:, :, i], g[:, :, i], w[:, :, i]
+        Aqk = torch.zeros(B, H, BT, BT, dtype=torch.float32, device=q.device)
+        for j in range(BT):
+            k_j = k[:, :, i, j]
+            g_j = g[:, :, i, j:j + 1, :]
+            Aqk[..., j] = torch.einsum("... c d, ... d -> ... c", q_i * (g_i - g_j).exp(), k_j)
+        Aqk = Aqk.masked_fill(mask_strict_upper, 0)
+        v_i = u_i - w_i @ S
+        o[:, :, i] = (q_i * g_i.exp()) @ S + Aqk @ v_i
+        S = S * rearrange(g_i[:, :, -1].exp(), "b h k -> b h k 1")
+        S = S + rearrange((g_i[:, :, -1:] - g_i).exp() * k_i, "b h c k -> b h k c") @ v_i
+
+    o = rearrange(o, "b h n c d -> b (n c) h d")
+    return o.to(dtype)
+
+
+class Model(nn.Module):
+    """KDA forward (chunk form). No learned parameters; all inputs are activations."""
+
+    def __init__(self, B: int, T: int, H: int, K: int, V: int, chunk_size: int = 64):
+        super().__init__()
+        self.B, self.T, self.H, self.K, self.V = B, T, H, K, V
+        self.chunk_size = chunk_size
+        self.scale = float(K) ** -0.5
+        # No learned params; declare a dummy buffer so state_dict is well-defined.
+        self.register_buffer("_dummy", torch.zeros(1), persistent=False)
+
+    def forward(
+        self,
+        q: torch.Tensor,
+        k: torch.Tensor,
+        v: torch.Tensor,
+        g: torch.Tensor,
+        beta: torch.Tensor,
+    ) -> torch.Tensor:
+        return _naive_chunk_kda(q, k, v, g, beta, scale=self.scale, chunk_size=self.chunk_size)
+
+
+# Module-level shape shims (overridden by check.py / benchmark.py per shape).
+B = 2
+T = 1024
+H = 8
+K = 128
+V = 128
+CHUNK_SIZE = 64
+
+
+def get_inputs():
+    """Return a list of activations for one forward call.
+
+    bf16 for q/k/v/beta; fp32 for the log-decay g (per FLA convention).
+    """
+    torch.manual_seed(0)
+    q = torch.randn(B, T, H, K, dtype=torch.bfloat16) * 0.1
+    k = torch.randn(B, T, H, K, dtype=torch.bfloat16) * 0.1
+    v = torch.randn(B, T, H, V, dtype=torch.bfloat16) * 0.1
+    # log-decay: small negative numbers so exp(g) is in (0, 1).
+    g = (torch.randn(B, T, H, K, dtype=torch.float32) * 0.1 - 0.05)
+    beta = torch.sigmoid(torch.randn(B, T, H, dtype=torch.bfloat16))
+    return [q, k, v, g, beta]
+
+
+def get_init_inputs():
+    return [B, T, H, K, V, CHUNK_SIZE]

02_kda_cutlass/shapes.py

@@ -0,0 +1,19 @@
+"""Canonical shape sweep for KDA forward (chunk form).
+
+Mix of:
+  - short-context training-step scale (T=1024)
+  - mid-context (T=2048) which is the headline benchmark
+  - long-context that stresses the inter-chunk recurrence (T=4096)
+  - thin-batch decode-style (B=1, T=2048, fewer heads)
+
+Constraints:
+  - T % chunk_size == 0 (chunk_size = 64)
+  - K, V are the per-head channel dims; KDA in Kimi Linear uses K=V=128
+"""
+
+SHAPES = [
+    {"B": 2, "T": 1024, "H": 8, "K": 128, "V": 128, "CHUNK_SIZE": 64},
+    {"B": 2, "T": 2048, "H": 8, "K": 128, "V": 128, "CHUNK_SIZE": 64},
+    {"B": 1, "T": 4096, "H": 8, "K": 128, "V": 128, "CHUNK_SIZE": 64},
+    {"B": 1, "T": 2048, "H": 4, "K": 128, "V": 128, "CHUNK_SIZE": 64},
+]

02_kda_cutlass/sota.py

@@ -0,0 +1,71 @@
+"""SOTA reference for KDA forward: fla.ops.kda.chunk_kda (Triton).
+
+The agent's solution is forbidden from importing this module path (see
+problem.yaml.forbidden). This file is only used by benchmark.py to draw
+the SOTA reference line.
+
+If FLA's Triton kernel does not run on SM120 (Blackwell consumer-lineage --
+some Triton kernels in FLA target Hopper TMA), is_available() returns False
+and benchmark.py omits the SOTA variant. The H100 reference is documented
+in problem.yaml for context.
+"""
+from __future__ import annotations
+
+import torch
+
+
+def _import_fla():
+    try:
+        from fla.ops.kda import chunk_kda  # noqa: F401
+        return chunk_kda
+    except Exception:
+        return None
+
+
+def sota_forward(
+    q: torch.Tensor,
+    k: torch.Tensor,
+    v: torch.Tensor,
+    g: torch.Tensor,
+    beta: torch.Tensor,
+    scale: float | None = None,
+) -> torch.Tensor:
+    """Run FLA's Triton chunk_kda. Returns o (B, T, H, V) in v's dtype."""
+    chunk_kda = _import_fla()
+    if chunk_kda is None:
+        raise RuntimeError("fla.ops.kda.chunk_kda unavailable")
+    # FLA's chunk_kda has a richer signature (A_log, dt_bias, l2norm, gates, ...).
+    # We need the bare forward: pass A_log/dt_bias as None, gates off, no l2norm.
+    # The wrapper expects fp32 g; q/k/v/beta in bf16/fp16.
+    out = chunk_kda(
+        q=q,
+        k=k,
+        v=v,
+        g=g,
+        beta=beta,
+        scale=scale,
+        initial_state=None,
+        output_final_state=False,
+        use_qk_l2norm_in_kernel=False,
+        use_gate_in_kernel=False,
+    )
+    # chunk_kda returns (o, final_state) or just o depending on flags.
+    return out[0] if isinstance(out, tuple) else out
+
+
+def is_available() -> bool:
+    if _import_fla() is None:
+        return False
+    # Probe a tiny call to confirm the kernel compiles on the current SM.
+    try:
+        device = torch.device("cuda:0")
+        B, T, H, K, V = 1, 64, 1, 64, 64
+        q = torch.randn(B, T, H, K, dtype=torch.bfloat16, device=device)
+        k = torch.randn(B, T, H, K, dtype=torch.bfloat16, device=device)
+        v = torch.randn(B, T, H, V, dtype=torch.bfloat16, device=device)
+        g = torch.randn(B, T, H, K, dtype=torch.float32, device=device) * 0.01
+        beta = torch.sigmoid(torch.randn(B, T, H, dtype=torch.bfloat16, device=device))
+        sota_forward(q, k, v, g, beta, scale=K ** -0.5)
+        return True
+    except Exception:
+        return False

03_paged_attention/PROMPT.txt

@@ -0,0 +1,7 @@
+I need you to write a paged attention decode kernel for the RTX PRO 6000 (SM120 Blackwell, GDDR7, 1.8 TB/s). The reference implementation is in reference.py and your kernel goes in solution.py. You can make whatever mess you want in this directory — scratch files, intermediate kernels, build artifacts, profiling traces — but the final answer has to be in solution.py with the same Model, get_inputs, and get_init_inputs interface as reference.py.
+
+This is single-query decode: each batch element has a query of shape (num_heads, head_dim) and attends over a KV cache of seq_len[b] tokens stored as fixed-size pages in a global pool, with block_table[b] listing which pages belong to batch element b. The KV cache is laid out as (num_blocks, page_size, num_kv_heads, head_dim * 2) where the last dim packs [K | V] so a single gather pulls both. You return the bf16 output of shape (batch, num_heads, head_dim). Correctness tolerance is 0.02 abs/rel on bf16/fp16. The shapes you have to handle are batch=8 num_heads=32 num_kv_heads=8 head_dim=128 seq_len=1024 page_size=16 (Llama-3 8B-style decode), batch=32 num_heads=32 num_kv_heads=8 head_dim=128 seq_len=2048 page_size=16 (server-batched decode), batch=4 num_heads=64 num_kv_heads=8 head_dim=128 seq_len=4096 page_size=16 (Llama-3 70B GQA wide ratio with long context), batch=16 num_heads=32 num_kv_heads=8 head_dim=128 seq_len=1535 page_size=16 (non-power-of-two seq_len that forces predicated tails), and batch=8 num_heads=16 num_kv_heads=4 head_dim=64 seq_len=2000 page_size=16 (small head_dim, non-pow2).
+
+This needs to be a real custom kernel. Don't import or call vllm.attention, flashinfer.batch_decode_with_paged_kv_cache, flashinfer.decode, torch.nn.functional.scaled_dot_product_attention, or F.scaled_dot_product_attention — they're off-limits, including the trick of gathering pages first and then dispatching to SDPA. Try CUDA C++ via load_inline, Triton, inline PTX, or CUTLASS — whatever fits. Anything you're uncertain about, look up PTX docs, clone CUTLASS or vLLM or FlashInfer or other reference repos, read library headers, and investigate.
+
+Your flywheel is implement, profile (ncu, nsys, torch.profiler — whatever's useful) and time it with benchmark.py, verify correctness by running `python check.py` and reading the output, then iterate. Don't substitute your own one-off correctness snippets for check.py — it iterates over every shape, your spot-check almost certainly won't. If `python check.py` hasn't printed PASS, you're not done. Take as long as you need to actually push the number up.

03_paged_attention/benchmark.py

@@ -0,0 +1,131 @@
+"""Roofline benchmark for paged-attention decode.
+
+For each shape: times eager reference, compiled reference, SOTA (if available),
+and the agent's solution. Reports achieved TFLOPS, GB/s, and peak_fraction.
+
+Decode is memory-bound, so peak_fraction is computed from achieved GB/s vs
+the GPU's peak DRAM bandwidth.
+"""
+import sys
+from math import exp, log
+from pathlib import Path
+
+import torch
+import yaml
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(REPO_ROOT))
+
+from src.eval.roofline import compute_gbps, compute_tflops, peak_fraction  # noqa: E402
+from src.eval.timing import time_fn  # noqa: E402
+from src.hardware import get as get_hw  # noqa: E402
+
+
+def _eval_formula(expr: str, vars: dict) -> float:
+    return float(eval(expr, {"__builtins__": {}}, vars))
+
+
+def _apply_shape(reference, shape: dict) -> None:
+    reference.BATCH = shape["batch"]
+    reference.NUM_HEADS = shape["num_heads"]
+    reference.NUM_KV_HEADS = shape["num_kv_heads"]
+    reference.HEAD_DIM = shape["head_dim"]
+    reference.SEQ_LEN = shape["seq_len"]
+    reference.PAGE_SIZE = shape["page_size"]
+
+
+def main():
+    import reference
+    import shapes
+    import solution
+
+    meta = yaml.safe_load(Path("problem.yaml").read_text())
+    hw = get_hw(meta["hardware"][0])
+    peak_tflops = hw.peak_tflops_dense.get(meta["peak_tflops_key"], 0.0)
+    peak_gbps = hw.peak_bandwidth_gb_s
+    regime = meta.get("regime", "memory")
+    flops_formula = meta["flops_formula"]
+    bytes_formula = meta["bytes_formula"]
+    num_perf_trials = int(meta.get("num_perf_trials", 30))
+
+    device = torch.device("cuda:0")
+
+    try:
+        import sota as sota_mod
+        has_sota = sota_mod.is_available()
+    except Exception:
+        has_sota = False
+
+    sol_fractions: list[float] = []
+
+    for shape_idx, shape in enumerate(shapes.SHAPES):
+        _apply_shape(reference, shape)
+
+        init_args = reference.get_init_inputs()
+        ref_model = reference.Model(*init_args).to(device).eval()
+        sol_model = solution.Model(*init_args).to(device).eval()
+        sd = ref_model.state_dict()
+        try:
+            sol_model.load_state_dict(sd, strict=True)
+        except RuntimeError:
+            pass
+
+        torch.manual_seed(2026)
+        inputs = [t.to(device) for t in reference.get_inputs()]
+
+        flops = _eval_formula(flops_formula, shape)
+        bytes_moved = _eval_formula(bytes_formula, shape)
+
+        ms_eager = time_fn(ref_model, inputs, iters=num_perf_trials)
+
+        try:
+            comp = torch.compile(ref_model, mode="reduce-overhead")
+            ms_comp = time_fn(comp, inputs, iters=num_perf_trials)
+        except Exception as e:
+            print(f"  [compile fallback] {type(e).__name__}: {e}")
+            ms_comp = None
+
+        ms_sota = None
+        if has_sota:
+            try:
+                Hkv = shape["num_kv_heads"]
+                D = shape["head_dim"]
+                P = shape["page_size"]
+
+                def sota_fn(q, kvc, bt, sl, _Hkv=Hkv, _D=D, _P=P):
+                    return sota_mod.sota_forward(q, kvc, bt, sl, _Hkv, _D, _P)
+
+                ms_sota = time_fn(sota_fn, inputs, iters=num_perf_trials)
+            except Exception as e:
+                print(f"  [sota unavailable] {type(e).__name__}: {e}")
+
+        ms_sol = time_fn(sol_model, inputs, iters=num_perf_trials)
+
+        for variant, ms in [
+            ("eager", ms_eager),
+            ("compiled", ms_comp),
+            ("sota", ms_sota),
+            ("solution", ms_sol),
+        ]:
+            if ms is None:
+                continue
+            tflops = compute_tflops(flops, ms)
+            gbps = compute_gbps(bytes_moved, ms)
+            print(f"shape={shape_idx} variant={variant} tflops={tflops:.3f} gbps={gbps:.3f} ms={ms:.3f}")
+
+        sol_tflops = compute_tflops(flops, ms_sol)
+        sol_gbps = compute_gbps(bytes_moved, ms_sol)
+        if regime == "compute":
+            frac = peak_fraction(sol_tflops, peak_tflops)
+        else:
+            frac = peak_fraction(sol_gbps, peak_gbps)
+        sol_fractions.append(frac)
+        print(f"shape={shape_idx} solution_peak_fraction={frac:.4f}")
+
+    gmean = exp(sum(log(max(f, 1e-9)) for f in sol_fractions) / len(sol_fractions))
+    print(f"peak_fraction: {gmean:.4f}")
+    print(f"RESULT: {'OK' if gmean >= 0.1 else 'LOW'}")
+
+
+if __name__ == "__main__":
+    main()

03_paged_attention/check.py

@@ -0,0 +1,109 @@
+"""Correctness runner for paged-attention decode.
+
+Runs solution.Model vs reference.Model across all shapes in shapes.py, 3 seeds
+each, with per-dtype atol/rtol. Also rejects forbidden ops by grep.
+"""
+import re
+import sys
+from pathlib import Path
+
+import torch
+import yaml
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(REPO_ROOT))
+
+from src.eval.correctness import check_correctness  # noqa: E402
+
+
+def _apply_shape(reference, shape: dict) -> None:
+    reference.BATCH = shape["batch"]
+    reference.NUM_HEADS = shape["num_heads"]
+    reference.NUM_KV_HEADS = shape["num_kv_heads"]
+    reference.HEAD_DIM = shape["head_dim"]
+    reference.SEQ_LEN = shape["seq_len"]
+    reference.PAGE_SIZE = shape["page_size"]
+
+
+def main():
+    try:
+        import reference
+        import shapes
+        import solution
+    except Exception as e:
+        print(f"FAIL: import error: {e}")
+        sys.exit(1)
+
+    problem_yaml = Path("problem.yaml")
+    meta = yaml.safe_load(problem_yaml.read_text()) if problem_yaml.exists() else {}
+
+    sol_src = Path("solution.py").read_text() if Path("solution.py").exists() else ""
+    for forbidden in meta.get("forbidden", []):
+        pat = re.escape(forbidden)
+        if re.search(pat, sol_src):
+            print(f"FAIL: forbidden op used: {forbidden}")
+            sys.exit(1)
+
+    device = torch.device("cuda:0")
+    tol_override = meta.get("tolerance") or None
+
+    all_shapes = shapes.SHAPES
+    for shape_idx, shape in enumerate(all_shapes):
+        _apply_shape(reference, shape)
+
+        init_args = reference.get_init_inputs()
+        ref_model = reference.Model(*init_args).to(device).eval()
+        sol_model = solution.Model(*init_args).to(device).eval()
+
+        sd = ref_model.state_dict()
+        try:
+            sol_model.load_state_dict(sd, strict=True)
+        except RuntimeError as e:
+            print(f"FAIL: state_dict mismatch at shape {shape_idx} ({shape}): {e}")
+            sys.exit(1)
+
+        for seed in (42, 123, 456):
+            torch.manual_seed(seed)
+            torch.cuda.manual_seed_all(seed)
+            inputs = [t.to(device) for t in reference.get_inputs()]
+
+            with torch.no_grad():
+                ref_out = ref_model(*inputs)
+                sol_out = sol_model(*inputs)
+
+            ok, msg = check_correctness(
+                ref_out, sol_out,
+                dtype=ref_out.dtype,
+                override=tol_override,
+            )
+            if not ok:
+                print(f"FAIL: shape {shape_idx} {shape} seed {seed}: {msg}")
+                sys.exit(1)
+
+    _emit_framework_label()
+    print("PASS")
+
+
+def _emit_framework_label():
+    patterns = [
+        ("ptx",       r"asm\s+volatile|asm\s*\(|mma\.sync|tcgen05\."),
+        ("cutlass3",  r"\bcute::|cutlass/gemm/collective|cutlass::arch::Sm(9|10|12)"),
+        ("cutlass2",  r"cutlass/gemm/device/gemm|cutlass::gemm::device"),
+        ("cuda_wmma", r"\bnvcuda::wmma\b|wmma::fragment"),
+        ("triton",    r"import\s+triton\b|@triton\.jit|\btl\.dot\b"),
+        ("cuda_raw",  r"torch\.utils\.cpp_extension\.load_inline|__global__\s+void"),
+    ]
+    sol = Path("solution.py")
+    if not sol.exists():
+        return
+    code = sol.read_text()
+    label = "unknown"
+    for name, pat in patterns:
+        if re.search(pat, code):
+            label = name
+            break
+    Path("framework.txt").write_text(label + "\n")
+
+
+if __name__ == "__main__":
+    main()

03_paged_attention/problem.yaml

@@ -0,0 +1,48 @@
+name: 03_paged_attention
+display_name: "Paged Attention Decode"
+precision: bf16
+regime: memory  # decode is bandwidth-bound (KV cache streamed once per token)
+
+# Effective FLOPs per call: QK^T + softmax*V across all batches/heads/seq.
+# Sum-formula evaluated per-shape; the benchmark substitutes batch/num_heads/etc.
+# 2 * B * H * L * D for QK^T plus 2 * B * H * L * D for AV  =>  4 * B * H * L * D
+flops_formula: "4 * batch * num_heads * seq_len * head_dim"
+
+# Bytes moved (the real bottleneck): the KV cache must be streamed end-to-end.
+#   K and V each:  batch * seq_len * num_kv_heads * head_dim * 2 bytes (bf16)
+#   Q: batch * num_heads * head_dim * 2  (negligible vs KV)
+#   Out: same as Q
+# So total ~ 2 * (B * L * Hkv * D * 2) + small.
+bytes_formula: "2 * batch * seq_len * num_kv_heads * head_dim * 2 + batch * num_heads * head_dim * 2 * 2"
+
+hardware: [RTX_PRO_6000]
+peak_tflops_key: bf16          # informational; regime=memory uses bandwidth
+peak_bandwidth_key: dram        # 1.8 TB/s GDDR7 on RTX PRO 6000 Blackwell
+
+tolerance:
+  bfloat16: 0.02
+  float16: 0.02
+
+# Forbidden ops -- using any of these in solution.py fails correctness post-hoc.
+# vllm.attention / flashinfer.batch_decode_with_paged_kv_cache: dispatching to
+# the SOTA library is the trivial cheat. SDPA is also banned because the agent
+# could gather pages then call SDPA and inherit FlashAttention "for free".
+forbidden:
+  - "vllm.attention"
+  - "flashinfer.batch_decode_with_paged_kv_cache"
+  - "flashinfer.decode"
+  - "torch.nn.functional.scaled_dot_product_attention"
+  - "F.scaled_dot_product_attention"
+
+sota:
+  name: "vLLM PagedAttention v2 / FlashInfer batch_decode_with_paged_kv_cache"
+  url: "https://github.com/vllm-project/vllm/blob/main/csrc/attention/paged_attention_v2.cu"
+  function: "vllm._C.ops.paged_attention_v2"
+  deps:
+    - "vllm>=0.6.0"
+    - "flashinfer>=0.2.0"
+  # Decode is memory-bound; reference reaches ~70-85% of peak HBM bandwidth on H100.
+  reference_bandwidth_gbps_h100: 2400
+
+num_correct_trials: 3
+num_perf_trials: 30

03_paged_attention/reference.py

@@ -0,0 +1,144 @@
+"""Naive PyTorch paged-attention decode reference (correctness oracle, not SOTA).
+
+Single-query decode: each batch element has a query of shape (num_heads, head_dim)
+and attends over a KV cache of `seq_len[b]` tokens stored as fixed-size pages in
+a global pool. Pages for batch element b are listed in `block_table[b]`.
+
+The reference performs the slow path:
+  1. Gather pages -> contiguous (seq_len, num_kv_heads, head_dim) per batch element.
+  2. Repeat KV heads for grouped-query (broadcast num_kv_heads -> num_heads).
+  3. Manual softmax(QK^T / sqrt(d)) @ V in fp32, cast back to bf16.
+
+This avoids torch.nn.functional.scaled_dot_product_attention (which is on the
+forbidden list) so the agent cannot dispatch through SDPA either.
+"""
+import math
+
+import torch
+import torch.nn as nn
+
+OP_TYPE = "attention"
+SUPPORTED_PRECISIONS = ["bf16"]
+HARDWARE_REQUIRED = ["RTX_PRO_6000", "H100", "B200"]
+
+
+# --- Shape knobs (overridden by check.py / benchmark.py from shapes.py) ----
+BATCH = 8
+NUM_HEADS = 32
+NUM_KV_HEADS = 8
+HEAD_DIM = 128
+SEQ_LEN = 1024
+PAGE_SIZE = 16
+
+
+class Model(nn.Module):
+    """Single-query paged attention decode.
+
+    Forward inputs (all on device):
+      query:       (batch, num_heads, head_dim)               bf16
+      kv_cache:    (num_blocks, page_size, num_kv_heads, head_dim * 2)
+                   Layout: last dim packs [K | V] so a single gather pulls both.
+                   Stored as bf16.
+      block_table: (batch, max_blocks)                        int32
+      seq_lens:    (batch,)                                   int32
+
+    Output:
+      attn_out:    (batch, num_heads, head_dim)               bf16
+    """
+
+    def __init__(
+        self,
+        batch: int,
+        num_heads: int,
+        num_kv_heads: int,
+        head_dim: int,
+        seq_len: int,
+        page_size: int,
+    ):
+        super().__init__()
+        assert num_heads % num_kv_heads == 0, "num_heads must be a multiple of num_kv_heads (GQA)"
+        self.batch = batch
+        self.num_heads = num_heads
+        self.num_kv_heads = num_kv_heads
+        self.head_dim = head_dim
+        self.seq_len = seq_len
+        self.page_size = page_size
+        self.group_size = num_heads // num_kv_heads
+        self.scale = 1.0 / math.sqrt(head_dim)
+
+        # No learned parameters: everything flows through get_inputs(). We keep
+        # an empty buffer so state_dict() round-trips trivially between reference
+        # and solution.
+        self.register_buffer("_dummy", torch.zeros(1, dtype=torch.bfloat16), persistent=False)
+
+    def forward(
+        self,
+        query: torch.Tensor,
+        kv_cache: torch.Tensor,
+        block_table: torch.Tensor,
+        seq_lens: torch.Tensor,
+    ) -> torch.Tensor:
+        B, H, D = query.shape
+        Hkv = self.num_kv_heads
+        G = self.group_size
+        P = self.page_size
+
+        out = torch.empty(B, H, D, dtype=query.dtype, device=query.device)
+
+        for b in range(B):
+            L = int(seq_lens[b].item())
+            num_pages = (L + P - 1) // P
+            pages = block_table[b, :num_pages].long()
+            # Gather: (num_pages, page_size, num_kv_heads, 2*head_dim)
+            kv = kv_cache.index_select(0, pages)
+            kv = kv.reshape(num_pages * P, Hkv, 2 * D)
+            kv = kv[:L]                          # mask trailing padded slots
+            k = kv[..., :D]                      # (L, Hkv, D)
+            v = kv[..., D:]                      # (L, Hkv, D)
+
+            # Broadcast KV heads to query heads (GQA): (L, H, D)
+            k = k.repeat_interleave(G, dim=1)
+            v = v.repeat_interleave(G, dim=1)
+
+            q = query[b]                          # (H, D)
+            # Attention in fp32 for the oracle.
+            qf = q.float()
+            kf = k.float()
+            vf = v.float()
+            # scores: (H, L) = (H, D) @ (L, H, D) -> per-head dot
+            scores = torch.einsum("hd,lhd->hl", qf, kf) * self.scale
+            probs = torch.softmax(scores, dim=-1)
+            # out: (H, D) = sum_l probs[h, l] * v[l, h, :]
+            o = torch.einsum("hl,lhd->hd", probs, vf)
+            out[b] = o.to(query.dtype)
+
+        return out
+
+
+def get_inputs():
+    """Build random paged inputs for the current module-level shape knobs."""
+    B = BATCH
+    H = NUM_HEADS
+    Hkv = NUM_KV_HEADS
+    D = HEAD_DIM
+    L = SEQ_LEN
+    P = PAGE_SIZE
+
+    pages_per_seq = (L + P - 1) // P
+    # Keep the global pool larger than strictly needed and shuffle assignments
+    # so the block_table actually exercises non-contiguous gather.
+    total_pages = max(B * pages_per_seq + 8, 64)
+
+    query = torch.randn(B, H, D, dtype=torch.bfloat16) * 0.1
+    kv_cache = torch.randn(total_pages, P, Hkv, 2 * D, dtype=torch.bfloat16) * 0.1
+
+    perm = torch.randperm(total_pages)[: B * pages_per_seq].reshape(B, pages_per_seq).int()
+    # Pad to pages_per_seq columns; for fixed-seq-len shapes this is exact.
+    block_table = perm.contiguous()
+    seq_lens = torch.full((B,), L, dtype=torch.int32)
+
+    return [query, kv_cache, block_table, seq_lens]
+
+
+def get_init_inputs():
+    return [BATCH, NUM_HEADS, NUM_KV_HEADS, HEAD_DIM, SEQ_LEN, PAGE_SIZE]

03_paged_attention/shapes.py

@@ -0,0 +1,18 @@
+"""Shape sweep for paged attention decode.
+
+Mix targets:
+  - small batch / long context (Llama-3 8B-style decode)
+  - large batch / medium context (server batched decode)
+  - GQA wide ratio (Llama-3 70B: 64 heads / 8 kv-heads)
+  - non-power-of-2 seq_len (forces predicated tail handling)
+  - head_dim=64 small-head case
+"""
+
+SHAPES = [
+    # (B, H, Hkv, D, L, P)
+    {"batch": 8,  "num_heads": 32, "num_kv_heads": 8,  "head_dim": 128, "seq_len": 1024, "page_size": 16},
+    {"batch": 32, "num_heads": 32, "num_kv_heads": 8,  "head_dim": 128, "seq_len": 2048, "page_size": 16},
+    {"batch": 4,  "num_heads": 64, "num_kv_heads": 8,  "head_dim": 128, "seq_len": 4096, "page_size": 16},
+    {"batch": 16, "num_heads": 32, "num_kv_heads": 8,  "head_dim": 128, "seq_len": 1535, "page_size": 16},  # non-pow2
+    {"batch": 8,  "num_heads": 16, "num_kv_heads": 4,  "head_dim": 64,  "seq_len": 2000, "page_size": 16},  # small-D, non-pow2
+]

03_paged_attention/sota.py

@@ -0,0 +1,84 @@
+"""SOTA reference for paged-attention decode.
+
+Tries, in order:
+  1. FlashInfer's BatchDecodeWithPagedKVCacheWrapper (preferred -- portable,
+     supports SM120, GQA, arbitrary head_dim).
+  2. vLLM's paged_attention_v2 CUDA op (requires its KV-cache layout, more
+     finicky; we adapt the layout on the fly when possible).
+
+If neither is importable, is_available() returns False and the benchmark just
+reports eager + compiled + solution.
+
+Agents are FORBIDDEN from importing these in solution.py (see problem.yaml).
+This file is only for the benchmark's reference line.
+"""
+from __future__ import annotations
+
+import torch
+
+
+def _try_flashinfer(
+    query: torch.Tensor,
+    kv_cache: torch.Tensor,
+    block_table: torch.Tensor,
+    seq_lens: torch.Tensor,
+    num_kv_heads: int,
+    head_dim: int,
+    page_size: int,
+) -> torch.Tensor | None:
+    try:
+        import flashinfer  # noqa: F401
+        from flashinfer.decode import BatchDecodeWithPagedKVCacheWrapper
+    except Exception:
+        return None
+
+    B, H, D = query.shape
+    # FlashInfer expects K and V as separate (num_blocks, page_size, num_kv_heads, head_dim) tensors.
+    # Our reference packs [K|V] on the last dim -- split here.
+    k_cache = kv_cache[..., :D].contiguous()
+    v_cache = kv_cache[..., D:].contiguous()
+
+    workspace = torch.empty(128 * 1024 * 1024, dtype=torch.uint8, device=query.device)
+    wrapper = BatchDecodeWithPagedKVCacheWrapper(workspace, kv_layout="NHD")
+
+    # Build the indptr / indices / last_page_len schedule.
+    pages_per_seq = ((seq_lens + page_size - 1) // page_size).int()
+    indptr = torch.zeros(B + 1, dtype=torch.int32, device=query.device)
+    indptr[1:] = torch.cumsum(pages_per_seq, dim=0)
+    indices_list = [block_table[b, : int(pages_per_seq[b].item())] for b in range(B)]
+    indices = torch.cat(indices_list).int()
+    last_page_len = ((seq_lens - 1) % page_size + 1).int()
+
+    wrapper.plan(
+        indptr, indices, last_page_len,
+        num_qo_heads=H,
+        num_kv_heads=num_kv_heads,
+        head_dim=D,
+        page_size=page_size,
+        data_type=query.dtype,
+    )
+    return wrapper.run(query, (k_cache, v_cache))
+
+
+def sota_forward(
+    query: torch.Tensor,
+    kv_cache: torch.Tensor,
+    block_table: torch.Tensor,
+    seq_lens: torch.Tensor,
+    num_kv_heads: int,
+    head_dim: int,
+    page_size: int,
+) -> torch.Tensor:
+    out = _try_flashinfer(query, kv_cache, block_table, seq_lens, num_kv_heads, head_dim, page_size)
+    if out is not None:
+        return out
+    raise RuntimeError("No SOTA backend available (flashinfer not installed)")
+
+
+def is_available() -> bool:
+    try:
+        import flashinfer  # noqa: F401
+        from flashinfer.decode import BatchDecodeWithPagedKVCacheWrapper  # noqa: F401
+        return True
+    except Exception:
+        return False

04_kahan_softmax/PROMPT.txt

@@ -0,0 +1,7 @@
+I need you to write a numerically tight softmax for the RTX PRO 6000 (SM120 Blackwell, GDDR7, 1.8 TB/s). The reference implementation is in reference.py and your kernel goes in solution.py. You can make whatever mess you want in this directory — scratch files, intermediate kernels, build artifacts, profiling traces — but the final answer has to be in solution.py with the same Model, get_inputs, and get_init_inputs interface as reference.py.
+
+The op is softmax along the last dim of a 2D fp32 tensor. The reference computes ground truth in fp64 and casts back to fp32, and you have to match it within atol=rtol=1e-5 — that's a tighter bar than default fp32 (1e-4) on purpose. With long reductions naive fp16 accumulation drifts past this; fp32 accumulation with subtract-max stability is enough on most shapes; on the largest vocabs you may need compensated (Kahan-style) summation to stay under the bar. The shapes you have to handle are batch=32 vocab=4096 (sanity), batch=16 vocab=32768 (GPT-2 class), batch=8 vocab=131072 (Llama-3 vocab), batch=4 vocab=262144 (256K, DeepSeek-V3 / Gemma-3 class — naive fp16 sum drifts past 1e-5 here), and batch=8 vocab=131072 with extreme logits (a few very large positives per row to stress max-subtract — exping before subtracting overflows). The check and benchmark scripts handle the extreme-flag input generation; you just need to read x and return y.
+
+This needs to be a real custom kernel. Don't import or call torch.nn.functional.softmax, torch.softmax, F.softmax, liger_kernel.softmax, liger_kernel.transformers.softmax, or any .softmax( method on a tensor. Try Triton, CUDA C++ via load_inline, or inline PTX — whatever fits. Anything you're uncertain about, look up PTX docs, clone Liger-Kernel or other reference repos, read library headers, and investigate.
+
+Your flywheel is implement, profile (ncu, nsys, torch.profiler — whatever's useful) and time it with benchmark.py, verify correctness by running `python check.py` and reading the output, then iterate. Don't substitute your own one-off correctness snippets for check.py — it iterates over every shape, your spot-check almost certainly won't. If `python check.py` hasn't printed PASS, you're not done. Take as long as you need to actually push the number up.

04_kahan_softmax/benchmark.py

@@ -0,0 +1,135 @@
+"""Roofline benchmark for Kahan-corrected softmax.
+
+For each shape: times eager reference, compiled reference, SOTA (if
+available), and the agent's solution. Reports achieved TFLOPS, GB/s, and
+peak_fraction. Softmax is memory-bound, so the score is GB/s / peak_dram.
+
+Output lines the harness picks up:
+  shape=<idx> variant=<name> tflops=<N> gbps=<N> ms=<N>
+  peak_fraction: <N>  (geomean over shapes of solution's peak_fraction)
+"""
+import sys
+from math import exp, log
+from pathlib import Path
+
+import torch
+import yaml
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(REPO_ROOT))
+
+from src.eval.roofline import compute_gbps, compute_tflops, peak_fraction  # noqa: E402
+from src.eval.timing import time_fn  # noqa: E402
+from src.hardware import get as get_hw  # noqa: E402
+
+
+def _eval_formula(expr: str, vars: dict) -> float:
+    return float(eval(expr, {"__builtins__": {}}, vars))
+
+
+def _make_inputs(batch: int, vocab: int, extreme: bool) -> torch.Tensor:
+    if extreme:
+        x = torch.randn(batch, vocab) * 2.0
+        idx = torch.randint(0, vocab, (batch, 4))
+        x.scatter_(1, idx, 30.0)
+    else:
+        x = torch.randn(batch, vocab) * 4.0
+    return x.to(torch.float32)
+
+
+def main():
+    import reference
+    import shapes
+    import solution
+
+    meta = yaml.safe_load(Path("problem.yaml").read_text())
+    hw = get_hw(meta["hardware"][0])
+    peak_tflops = hw.peak_tflops_dense.get(meta["peak_tflops_key"], 0.0)
+    peak_gbps = hw.peak_bandwidth_gb_s
+    regime = meta.get("regime", "memory")
+    flops_formula = meta["flops_formula"]
+    bytes_formula = meta["bytes_formula"]
+    num_perf_trials = int(meta.get("num_perf_trials", 30))
+
+    device = torch.device("cuda:0")
+
+    try:
+        import sota as sota_mod
+        has_sota = sota_mod.is_available()
+    except Exception:
+        has_sota = False
+
+    sol_fractions: list[float] = []
+
+    for shape_idx, shape in enumerate(shapes.SHAPES):
+        batch = shape["batch"]
+        vocab = shape["vocab"]
+        extreme = shape.get("extreme", False)
+
+        reference.BATCH = batch
+        reference.VOCAB = vocab
+
+        init_args = reference.get_init_inputs()
+        ref_model = reference.Model(*init_args).to(device).eval()
+        sol_model = solution.Model(*init_args).to(device).eval()
+        sd = ref_model.state_dict()
+        try:
+            sol_model.load_state_dict(sd, strict=True)
+        except RuntimeError:
+            pass
+
+        torch.manual_seed(2026)
+        x = _make_inputs(batch, vocab, extreme).to(device)
+        inputs = [x]
+
+        flops = _eval_formula(flops_formula, {"batch": batch, "vocab": vocab})
+        bytes_moved = _eval_formula(bytes_formula, {"batch": batch, "vocab": vocab})
+
+        ms_eager = time_fn(ref_model, inputs, iters=num_perf_trials)
+
+        try:
+            comp = torch.compile(ref_model, mode="reduce-overhead")
+            ms_comp = time_fn(comp, inputs, iters=num_perf_trials)
+        except Exception as e:
+            print(f"  [compile fallback] {type(e).__name__}: {e}")
+            ms_comp = None
+
+        ms_sota = None
+        if has_sota:
+            try:
+                def sota_fn(t):
+                    return sota_mod.sota_forward(t)
+                ms_sota = time_fn(sota_fn, inputs, iters=num_perf_trials)
+            except Exception as e:
+                print(f"  [sota unavailable] {type(e).__name__}: {e}")
+
+        ms_sol = time_fn(sol_model, inputs, iters=num_perf_trials)
+
+        for variant, ms in [
+            ("eager", ms_eager),
+            ("compiled", ms_comp),
+            ("sota", ms_sota),
+            ("solution", ms_sol),
+        ]:
+            if ms is None:
+                continue
+            tflops = compute_tflops(flops, ms)
+            gbps = compute_gbps(bytes_moved, ms)
+            print(f"shape={shape_idx} variant={variant} tflops={tflops:.3f} gbps={gbps:.3f} ms={ms:.3f}")
+
+        sol_tflops = compute_tflops(flops, ms_sol)
+        sol_gbps = compute_gbps(bytes_moved, ms_sol)
+        if regime == "compute":
+            frac = peak_fraction(sol_tflops, peak_tflops)
+        else:
+            frac = peak_fraction(sol_gbps, peak_gbps)
+        sol_fractions.append(frac)
+        print(f"shape={shape_idx} solution_peak_fraction={frac:.4f}")
+
+    gmean = exp(sum(log(max(f, 1e-9)) for f in sol_fractions) / len(sol_fractions))
+    print(f"peak_fraction: {gmean:.4f}")
+    print(f"RESULT: {'OK' if gmean >= 0.1 else 'LOW'}")
+
+
+if __name__ == "__main__":
+    main()

04_kahan_softmax/check.py

@@ -0,0 +1,126 @@
+"""Correctness runner for Kahan-corrected softmax.
+
+Runs solution.Model vs reference.Model across all shapes in shapes.py, 3
+seeds each, with the tight (1e-5) fp32 tolerance from problem.yaml. Also
+rejects forbidden ops via grep.
+"""
+import re
+import sys
+from pathlib import Path
+
+import torch
+import yaml
+
+# Make the repo's src/ importable
+REPO_ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(REPO_ROOT))
+
+from src.eval.correctness import check_correctness  # noqa: E402
+
+
+def _make_inputs(batch: int, vocab: int, extreme: bool, seed: int) -> torch.Tensor:
+    g = torch.Generator().manual_seed(seed)
+    if extreme:
+        # Adversarial: most logits are mild but a handful per row are huge.
+        # If the kernel forgets to subtract the row-max before exp, this
+        # row overflows fp32 and produces NaN/Inf. If it accumulates in
+        # fp16, the long tail of small exp() values is lost beneath the
+        # tolerance threshold.
+        x = torch.randn(batch, vocab, generator=g) * 2.0
+        # Spike: 4 very large positive logits per row.
+        idx = torch.randint(0, vocab, (batch, 4), generator=g)
+        x.scatter_(1, idx, 30.0)
+    else:
+        x = torch.randn(batch, vocab, generator=g) * 4.0
+    return x.to(torch.float32)
+
+
+def main():
+    try:
+        import reference
+        import shapes
+        import solution
+    except Exception as e:
+        print(f"FAIL: import error: {e}")
+        sys.exit(1)
+
+    problem_yaml = Path("problem.yaml")
+    meta = yaml.safe_load(problem_yaml.read_text()) if problem_yaml.exists() else {}
+
+    # --- Forbidden-op check ------------------------------------------------
+    sol_src = Path("solution.py").read_text() if Path("solution.py").exists() else ""
+    for forbidden in meta.get("forbidden", []):
+        pat = re.escape(forbidden)
+        if re.search(pat, sol_src):
+            print(f"FAIL: forbidden op used: {forbidden}")
+            sys.exit(1)
+
+    device = torch.device("cuda:0")
+    tol_override = meta.get("tolerance") or None
+
+    # --- Per-shape correctness --------------------------------------------
+    for shape_idx, shape in enumerate(shapes.SHAPES):
+        batch = shape["batch"]
+        vocab = shape["vocab"]
+        extreme = shape.get("extreme", False)
+
+        reference.BATCH = batch
+        reference.VOCAB = vocab
+
+        init_args = reference.get_init_inputs()
+        ref_model = reference.Model(*init_args).to(device).eval()
+        sol_model = solution.Model(*init_args).to(device).eval()
+
+        sd = ref_model.state_dict()
+        try:
+            sol_model.load_state_dict(sd, strict=True)
+        except RuntimeError as e:
+            print(f"FAIL: state_dict mismatch at shape {shape_idx} ({shape}): {e}")
+            sys.exit(1)
+
+        for seed in (42, 123, 456):
+            torch.manual_seed(seed)
+            torch.cuda.manual_seed_all(seed)
+            x = _make_inputs(batch, vocab, extreme, seed).to(device)
+
+            with torch.no_grad():
+                ref_out = ref_model(x)
+                sol_out = sol_model(x)
+
+            ok, msg = check_correctness(
+                ref_out, sol_out,
+                dtype=torch.float32,
+                override=tol_override,
+            )
+            if not ok:
+                print(f"FAIL: shape {shape_idx} {shape} seed {seed}: {msg}")
+                sys.exit(1)
+
+    _emit_framework_label()
+    print("PASS")
+
+
+def _emit_framework_label():
+    """Write framework.txt with the detected kernel framework."""
+    patterns = [
+        ("ptx",       r"asm\s+volatile|asm\s*\(|mma\.sync|tcgen05\."),
+        ("cutlass3",  r"\bcute::|cutlass/gemm/collective|cutlass::arch::Sm(9|10|12)"),
+        ("cutlass2",  r"cutlass/gemm/device/gemm|cutlass::gemm::device"),
+        ("cuda_wmma", r"\bnvcuda::wmma\b|wmma::fragment"),
+        ("triton",    r"import\s+triton\b|@triton\.jit|\btl\.dot\b"),
+        ("cuda_raw",  r"torch\.utils\.cpp_extension\.load_inline|__global__\s+void"),
+    ]
+    sol = Path("solution.py")
+    if not sol.exists():
+        return
+    code = sol.read_text()
+    label = "unknown"
+    for name, pat in patterns:
+        if re.search(pat, code):
+            label = name
+            break
+    Path("framework.txt").write_text(label + "\n")
+
+
+if __name__ == "__main__":
+    main()

04_kahan_softmax/problem.yaml

@@ -0,0 +1,43 @@
+name: 04_kahan_softmax
+display_name: "Kahan-corrected Softmax"
+precision: fp32
+regime: memory  # softmax is bandwidth-bound: 2 passes over the input tensor
+
+# Softmax FLOPs: per-element exp + 2 reductions + divide. Roughly 5 flops/elt.
+flops_formula: "5 * batch * vocab"
+
+# Bytes moved: read x once, write y once. Both fp32.
+bytes_formula: "batch * vocab * 4 + batch * vocab * 4"
+
+hardware: [RTX_PRO_6000]
+peak_tflops_key: fp32
+peak_bandwidth_key: dram
+
+# TIGHTER than default (fp32 default is 1e-4). This problem exists
+# specifically to test whether the agent uses compensated summation, so
+# we squeeze the tolerance to 1e-5 — naive fp16 sum across 256K elements
+# drifts past this; fp32 accumulation passes; Kahan/fp32 always passes.
+tolerance:
+  "torch.float32": {"atol": 1.0e-5, "rtol": 1.0e-5}
+
+# Forbidden ops — block the obvious "just call the library" cheats. The
+# agent must implement softmax themselves with explicit (compensated)
+# summation logic.
+forbidden:
+  - "torch.nn.functional.softmax"
+  - "torch.softmax"
+  - "F.softmax"
+  - "liger_kernel.softmax"
+  - "liger_kernel.transformers.softmax"
+  - ".softmax("
+
+sota:
+  name: "Liger-Kernel Softmax (Triton)"
+  url: "https://github.com/linkedin/Liger-Kernel"
+  function: "liger_kernel.ops.softmax.LigerSoftmaxFunction"
+  deps:
+    - "liger-kernel>=0.5.0"
+  reference_throughput_gbps_h100: 2800
+
+num_correct_trials: 3
+num_perf_trials: 30

04_kahan_softmax/reference.py

@@ -0,0 +1,52 @@
+"""Naive softmax over the last dim, computed in fp64 for ground-truth.
+
+The reference deliberately runs in float64 so that fp16 / fp32 accumulation
+drift in agent solutions is exposed by the tight tolerance in problem.yaml.
+The agent's job is to produce an fp32 softmax whose values match this
+double-precision reference within atol=rtol=1e-5 — this requires either
+fp32 accumulation or compensated (Kahan) summation when vocab is large.
+"""
+import torch
+import torch.nn as nn
+
+OP_TYPE = "softmax"
+SUPPORTED_PRECISIONS = ["fp32"]
+HARDWARE_REQUIRED = ["RTX_PRO_6000", "H100", "B200"]
+
+
+class Model(nn.Module):
+    """y = softmax(x, dim=-1) computed in fp64 then returned as fp32.
+
+    No learned parameters — softmax is parameter-free. We still expose an
+    empty state_dict so the harness's strict load_state_dict matches.
+    """
+
+    def __init__(self, batch: int, vocab: int):
+        super().__init__()
+        self.batch = batch
+        self.vocab = vocab
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        # Promote to fp64 for the ground-truth pathway. Even with double
+        # precision we still subtract the row-max for stability.
+        x64 = x.to(torch.float64)
+        m = x64.amax(dim=-1, keepdim=True)
+        e = torch.exp(x64 - m)
+        s = e.sum(dim=-1, keepdim=True)
+        return (e / s).to(torch.float32)
+
+
+# Default shape; overridden per-iteration by check.py / benchmark.py.
+BATCH = 8
+VOCAB = 32768
+
+
+def get_inputs():
+    # Mix of moderate-magnitude logits. The shapes module supplies an
+    # extreme-magnitude variant separately to stress numerical stability.
+    x = torch.randn(BATCH, VOCAB, dtype=torch.float32) * 4.0
+    return [x]
+
+
+def get_init_inputs():
+    return [BATCH, VOCAB]

04_kahan_softmax/shapes.py

@@ -0,0 +1,24 @@
+"""Shape sweep for Kahan-corrected softmax.
+
+The point of this problem is numerical accuracy on long reductions. Shapes
+mix typical LLM vocab sizes with deliberately adversarial regimes:
+
+  - small vocab (sanity check; naive fp32 should pass)
+  - Llama3 vocab 128K (real-world, where fp16 accumulation starts to drift)
+  - 256K (DeepSeek-V3 / Gemma-3 class vocab; naive fp16 sum DOES drift past
+    the 1e-5 tolerance — this row is what proves Kahan was needed)
+  - extreme-logit edge case (large positive logits stress max-subtract +
+    summation; if the implementation accidentally exps before subtracting
+    max, this row overflows)
+
+The 'extreme' flag is read by check.py to switch input generation to a
+distribution that produces a few very large logits per row.
+"""
+
+SHAPES = [
+    {"batch": 32, "vocab": 4096, "extreme": False},      # sanity
+    {"batch": 16, "vocab": 32768, "extreme": False},     # GPT-2 class
+    {"batch": 8,  "vocab": 131072, "extreme": False},    # Llama3 vocab
+    {"batch": 4,  "vocab": 262144, "extreme": False},    # 256K — Kahan needed
+    {"batch": 8,  "vocab": 131072, "extreme": True},     # extreme logits edge
+]

04_kahan_softmax/sota.py

@@ -0,0 +1,45 @@
+"""SOTA reference for last-dim softmax.
+
+Preference order:
+  1. liger-kernel's Triton softmax (LigerSoftmaxFunction) — fused, fp32-acc
+  2. torch.compile(torch.softmax) — Inductor generates a Triton kernel that
+     is competitive on bandwidth-bound reductions
+
+Agents are FORBIDDEN from importing either of these in solution.py (see
+problem.yaml.forbidden). This file is only the benchmark's reference line.
+"""
+from __future__ import annotations
+
+import torch
+
+_compiled_softmax = None
+
+
+def _liger_softmax(x: torch.Tensor) -> torch.Tensor | None:
+    try:
+        from liger_kernel.ops.softmax import LigerSoftmaxFunction
+        return LigerSoftmaxFunction.apply(x)
+    except Exception:
+        return None
+
+
+def _compiled(x: torch.Tensor) -> torch.Tensor:
+    global _compiled_softmax
+    if _compiled_softmax is None:
+        _compiled_softmax = torch.compile(
+            lambda t: torch.softmax(t, dim=-1),
+            mode="reduce-overhead",
+        )
+    return _compiled_softmax(x)
+
+
+def sota_forward(x: torch.Tensor) -> torch.Tensor:
+    """Best-available softmax reference. x: (batch, vocab) fp32."""
+    out = _liger_softmax(x)
+    if out is not None:
+        return out
+    return _compiled(x)
+
+
+def is_available() -> bool:
+    return True  # torch.compile fallback is always available

05_topk_bitonic/PROMPT.txt

@@ -0,0 +1,7 @@
+I need you to optimize a top-k kernel for the RTX PRO 6000 (SM120 Blackwell, GDDR7, 1.8 TB/s). The reference implementation is in reference.py and your kernel goes in solution.py. You can make whatever mess you want in this directory — scratch files, intermediate kernels, build artifacts, profiling traces — but the final answer has to be in solution.py with the same Model, get_inputs, and get_init_inputs interface as reference.py.
+
+The input is a 2D fp32 tensor and you return the top-k values and their int64 indices along the last dim, sorted descending, same contract as torch.topk(largest=True, sorted=True). Correctness tolerance is 1e-4 abs/rel on the values; index ties are handled leniently — what matters is the returned values match the reference to tolerance, not that the index sets are bitwise identical. The shapes you have to handle are batch=1 n=131072 k=64 (decoder vocab top-k over a Llama-size vocabulary), batch=64 n=8192 k=8 (prefill / attention top-k), batch=32 n=16384 k=32 (mid-size batched), batch=16 n=12000 k=16 (non-power-of-two n, which bitonic networks don't naturally want), and batch=128 n=4096 k=1 (batched argmax).
+
+This needs to be a real custom kernel — CUDA C++ via torch.utils.cpp_extension.load_inline, Triton, inline PTX, or CUTLASS, whatever you think fits. Don't reach for torch.topk, torch.kthvalue, torch.sort, or torch.argsort, or any of their Tensor.* / torch.ops.aten.* variants; they're off-limits and using them fails correctness. Anything you're uncertain about, look up PTX docs, clone CUTLASS or other reference repos, read library headers, and investigate.
+
+Your flywheel is implement, profile (ncu, nsys, torch.profiler — whatever's useful) and time it with benchmark.py, verify correctness by running `python check.py` and reading the output, then iterate. Don't substitute your own one-off correctness snippets for check.py — it iterates over every shape, your spot-check almost certainly won't. If `python check.py` hasn't printed PASS, you're not done. Take as long as you need to actually push the number up.

05_topk_bitonic/benchmark.py

@@ -0,0 +1,122 @@
+"""Roofline benchmark for TopK.
+
+For each shape: times eager reference (torch.topk), compiled reference, SOTA
+(also torch.topk — see sota.py), and the agent's solution. Reports achieved
+TFLOPS, GB/s, and peak_fraction (vs DRAM bandwidth, since this is memory-bound).
+
+Output lines the harness picks up:
+  shape=<idx> variant=<name> tflops=<N> gbps=<N> ms=<N>
+  peak_fraction: <N>  (geomean over shapes of solution's peak_fraction)
+"""
+import sys
+from math import exp, log
+from pathlib import Path
+
+import torch
+import yaml
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(REPO_ROOT))
+
+from src.eval.roofline import compute_gbps, compute_tflops, peak_fraction  # noqa: E402
+from src.eval.timing import time_fn  # noqa: E402
+from src.hardware import get as get_hw  # noqa: E402
+
+
+def _eval_formula(expr: str, vars: dict) -> float:
+    return float(eval(expr, {"__builtins__": {}}, vars))
+
+
+def main():
+    import reference
+    import shapes
+    import solution
+
+    meta = yaml.safe_load(Path("problem.yaml").read_text())
+    hw = get_hw(meta["hardware"][0])
+    peak_tflops = hw.peak_tflops_dense.get(meta["peak_tflops_key"], 0.0)
+    peak_gbps = hw.peak_bandwidth_gb_s
+    regime = meta.get("regime", "memory")
+    flops_formula = meta["flops_formula"]
+    bytes_formula = meta["bytes_formula"]
+    num_perf_trials = int(meta.get("num_perf_trials", 50))
+
+    device = torch.device("cuda:0")
+
+    try:
+        import sota as sota_mod
+        has_sota = sota_mod.is_available()
+    except Exception:
+        has_sota = False
+
+    sol_fractions: list[float] = []
+
+    for shape_idx, shape in enumerate(shapes.SHAPES):
+        reference.batch = shape["batch"]
+        reference.n = shape["n"]
+        reference.k = shape["k"]
+
+        init_args = reference.get_init_inputs()
+        ref_model = reference.Model(*init_args).to(device).eval()
+        sol_model = solution.Model(*init_args).to(device).eval()
+        sd = ref_model.state_dict()
+        try:
+            sol_model.load_state_dict(sd, strict=True)
+        except RuntimeError:
+            pass
+
+        torch.manual_seed(2026)
+        inputs = [t.to(device) for t in reference.get_inputs()]
+
+        flops = _eval_formula(flops_formula, shape)
+        bytes_moved = _eval_formula(bytes_formula, shape)
+
+        ms_eager = time_fn(ref_model, inputs, iters=num_perf_trials)
+
+        try:
+            comp = torch.compile(ref_model, mode="reduce-overhead")
+            ms_comp = time_fn(comp, inputs, iters=num_perf_trials)
+        except Exception as e:
+            print(f"  [compile fallback] {type(e).__name__}: {e}")
+            ms_comp = None
+
+        ms_sota = None
+        if has_sota:
+            try:
+                k_val = shape["k"]
+                def sota_fn(x, _k=k_val):
+                    return sota_mod.sota_forward(x, _k)
+                ms_sota = time_fn(sota_fn, inputs, iters=num_perf_trials)
+            except Exception as e:
+                print(f"  [sota unavailable] {type(e).__name__}: {e}")
+
+        ms_sol = time_fn(sol_model, inputs, iters=num_perf_trials)
+
+        for variant, ms in [
+            ("eager", ms_eager),
+            ("compiled", ms_comp),
+            ("sota", ms_sota),
+            ("solution", ms_sol),
+        ]:
+            if ms is None:
+                continue
+            tflops = compute_tflops(flops, ms)
+            gbps = compute_gbps(bytes_moved, ms)
+            print(f"shape={shape_idx} variant={variant} tflops={tflops:.3f} gbps={gbps:.3f} ms={ms:.3f}")
+
+        sol_tflops = compute_tflops(flops, ms_sol)
+        sol_gbps = compute_gbps(bytes_moved, ms_sol)
+        if regime == "compute":
+            frac = peak_fraction(sol_tflops, peak_tflops)
+        else:
+            frac = peak_fraction(sol_gbps, peak_gbps)
+        sol_fractions.append(frac)
+        print(f"shape={shape_idx} solution_peak_fraction={frac:.4f}")
+
+    gmean = exp(sum(log(max(f, 1e-9)) for f in sol_fractions) / len(sol_fractions))
+    print(f"peak_fraction: {gmean:.4f}")
+    print(f"RESULT: {'OK' if gmean >= 0.1 else 'LOW'}")
+
+
+if __name__ == "__main__":
+    main()

05_topk_bitonic/check.py

@@ -0,0 +1,149 @@
+"""Correctness runner for TopK.
+
+Runs solution.Model vs reference.Model across all shapes in shapes.py, 3 seeds
+each. Top-k correctness has two parts:
+
+  1. VALUES: sol_values must match ref_values within fp32 tol. Both are
+     returned sorted descending, so positional comparison is well-defined.
+  2. INDICES: lenient — we do NOT require sol_indices == ref_indices because
+     ties in x can yield multiple valid index sets. Instead we gather x at
+     sol_indices and check those values match ref_values within tol. This
+     catches "wrong indices" without false-failing on legitimate tie-breaks.
+
+Also rejects forbidden ops by grep.
+"""
+import re
+import sys
+from pathlib import Path
+
+import torch
+import yaml
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(REPO_ROOT))
+
+from src.eval.correctness import check_correctness  # noqa: E402
+
+
+def main():
+    try:
+        import reference
+        import shapes
+        import solution
+    except Exception as e:
+        print(f"FAIL: import error: {e}")
+        sys.exit(1)
+
+    problem_yaml = Path("problem.yaml")
+    meta = yaml.safe_load(problem_yaml.read_text()) if problem_yaml.exists() else {}
+
+    # --- Forbidden-op check ------------------------------------------------
+    sol_src = Path("solution.py").read_text() if Path("solution.py").exists() else ""
+    for forbidden in meta.get("forbidden", []):
+        pat = re.escape(forbidden)
+        if re.search(pat, sol_src):
+            print(f"FAIL: forbidden op used: {forbidden}")
+            sys.exit(1)
+
+    device = torch.device("cuda:0")
+    tol_override = meta.get("tolerance") or None
+
+    all_shapes = shapes.SHAPES
+    for shape_idx, shape in enumerate(all_shapes):
+        reference.batch = shape["batch"]
+        reference.n = shape["n"]
+        reference.k = shape["k"]
+
+        init_args = reference.get_init_inputs()
+        ref_model = reference.Model(*init_args).to(device).eval()
+        sol_model = solution.Model(*init_args).to(device).eval()
+
+        sd = ref_model.state_dict()
+        try:
+            sol_model.load_state_dict(sd, strict=True)
+        except RuntimeError as e:
+            print(f"FAIL: state_dict mismatch at shape {shape_idx} ({shape}): {e}")
+            sys.exit(1)
+
+        for seed in (42, 123, 456):
+            torch.manual_seed(seed)
+            torch.cuda.manual_seed_all(seed)
+            inputs = [t.to(device) for t in reference.get_inputs()]
+
+            with torch.no_grad():
+                ref_values, ref_indices = ref_model(*inputs)
+                sol_out = sol_model(*inputs)
+
+            if not (isinstance(sol_out, (tuple, list)) and len(sol_out) == 2):
+                print(f"FAIL: shape {shape_idx} {shape} seed {seed}: "
+                      f"solution must return (values, indices); got {type(sol_out)}")
+                sys.exit(1)
+            sol_values, sol_indices = sol_out
+
+            # Shape checks
+            expected_shape = (shape["batch"], shape["k"])
+            if tuple(sol_values.shape) != expected_shape:
+                print(f"FAIL: shape {shape_idx} values shape {tuple(sol_values.shape)} "
+                      f"!= expected {expected_shape}")
+                sys.exit(1)
+            if tuple(sol_indices.shape) != expected_shape:
+                print(f"FAIL: shape {shape_idx} indices shape {tuple(sol_indices.shape)} "
+                      f"!= expected {expected_shape}")
+                sys.exit(1)
+
+            # 1. Strict-ish values check (positional, both are sorted desc)
+            ok, msg = check_correctness(
+                ref_values.float(), sol_values.float(),
+                dtype=torch.float32,
+                override=tol_override,
+            )
+            if not ok:
+                print(f"FAIL: shape {shape_idx} {shape} seed {seed} values: {msg}")
+                sys.exit(1)
+
+            # 2. Lenient indices check: gather x at sol_indices, compare to ref_values.
+            # This handles ties without false negatives.
+            x = inputs[0]
+            sol_idx_long = sol_indices.to(torch.int64)
+            if sol_idx_long.min() < 0 or sol_idx_long.max() >= shape["n"]:
+                print(f"FAIL: shape {shape_idx} indices out of range "
+                      f"[{int(sol_idx_long.min())}, {int(sol_idx_long.max())}]")
+                sys.exit(1)
+            gathered = torch.gather(x, dim=-1, index=sol_idx_long)
+            ok, msg = check_correctness(
+                ref_values.float(), gathered.float(),
+                dtype=torch.float32,
+                override=tol_override,
+            )
+            if not ok:
+                print(f"FAIL: shape {shape_idx} {shape} seed {seed} indices "
+                      f"(gather mismatch): {msg}")
+                sys.exit(1)
+
+    _emit_framework_label()
+    print("PASS")
+
+
+def _emit_framework_label():
+    patterns = [
+        ("ptx",       r"asm\s+volatile|asm\s*\(|mma\.sync|tcgen05\."),
+        ("cutlass3",  r"\bcute::|cutlass/gemm/collective|cutlass::arch::Sm(9|10|12)"),
+        ("cutlass2",  r"cutlass/gemm/device/gemm|cutlass::gemm::device"),
+        ("cuda_wmma", r"\bnvcuda::wmma\b|wmma::fragment"),
+        ("triton",    r"import\s+triton\b|@triton\.jit|\btl\.dot\b"),
+        ("cuda_raw",  r"torch\.utils\.cpp_extension\.load_inline|__global__\s+void"),
+    ]
+    sol = Path("solution.py")
+    if not sol.exists():
+        return
+    code = sol.read_text()
+    label = "unknown"
+    for name, pat in patterns:
+        if re.search(pat, code):
+            label = name
+            break
+    Path("framework.txt").write_text(label + "\n")
+
+
+if __name__ == "__main__":
+    main()

05_topk_bitonic/problem.yaml

@@ -0,0 +1,56 @@
+name: 05_topk_bitonic
+display_name: "TopK via Bitonic Sort"
+precision: fp32
+regime: memory
+
+# Top-k is dominated by the input read (small output, no reduction over k).
+# Comparator-network FLOPs are not the bottleneck on real hardware, so we
+# track them but score on bandwidth.
+flops_formula: "batch * n * 4"            # ~O(n log^2 n) compares total, but the
+                                          # bitonic network is so cheap relative
+                                          # to memory that a coarse 4*n estimate
+                                          # is fine for telemetry only.
+bytes_formula: "batch * n * 4 + batch * k * (4 + 8)"  # fp32 input read + (fp32 value + int64 idx) output
+
+hardware: [RTX_PRO_6000]
+peak_tflops_key: fp32
+peak_bandwidth_key: dram
+
+# Top-k correctness:
+#   - VALUES must match within fp32 atol/rtol (the kth largest value is
+#     well-defined modulo float-equal ties, so we use a loose-ish tol).
+#   - INDICES are checked leniently: for each row, the multiset of returned
+#     indices must select values that match ref values within tol. Direct
+#     index equality is NOT required (ties in x can yield different valid
+#     index sets).
+tolerance:
+  float32: 1.0e-4
+
+# Forbidden ops — using any of these in solution.py fails correctness post-hoc.
+# This problem is about IMPLEMENTING the selection, not dispatching to PyTorch's
+# tuned top-k. torch.sort is also banned because torch.topk falls back to it.
+forbidden:
+  - "torch.topk"
+  - "torch.kthvalue"
+  - "torch.sort"
+  - "torch.argsort"
+  - "Tensor.topk"
+  - "Tensor.kthvalue"
+  - "Tensor.sort"
+  - "Tensor.argsort"
+  - "torch.ops.aten.topk"
+  - "torch.ops.aten.sort"
+  - "torch.ops.aten.kthvalue"
+
+sota:
+  name: "torch.topk (cuTOPK / CUB internals)"
+  url: "https://github.com/pytorch/pytorch/blob/main/aten/src/ATen/native/cuda/TensorTopK.cu"
+  function: "torch.topk"
+  deps: []
+  # Informational: torch.topk dispatches to a radix-select kernel for moderate
+  # k and to a bitonic sort kernel for small n. Beating it on the (1, 131072,
+  # 64) decoder shape requires saturating DRAM bandwidth on the input read.
+  reference_throughput_gbps_h100: 2400
+
+num_correct_trials: 3
+num_perf_trials: 50

05_topk_bitonic/reference.py

@@ -0,0 +1,52 @@
+"""Naive top-k reference: torch.topk over the last dim.
+
+This is the correctness oracle. The agent's solution must produce the same
+top-k values (and equivalent indices modulo ties) within the tolerance
+declared in problem.yaml. Note that solution.py is FORBIDDEN from calling
+torch.topk / torch.sort / torch.kthvalue (see problem.yaml).
+"""
+import torch
+import torch.nn as nn
+
+OP_TYPE = "topk"
+SUPPORTED_PRECISIONS = ["fp32"]
+HARDWARE_REQUIRED = ["RTX_PRO_6000", "H100", "B200"]
+
+
+class Model(nn.Module):
+    """Top-k over the last dim of a 2D tensor.
+
+    Input:
+        x: (batch, n) fp32
+    Output:
+        values:  (batch, k) fp32, sorted descending
+        indices: (batch, k) int64, into the last dim of x
+    """
+
+    def __init__(self, batch: int, n: int, k: int):
+        super().__init__()
+        self.batch, self.n, self.k = batch, n, k
+        # No learned parameters, but declare a dummy buffer so state_dict
+        # is non-empty and load_state_dict(strict=True) is meaningful.
+        self.register_buffer("_dummy", torch.zeros(1))
+
+    def forward(self, x: torch.Tensor):
+        values, indices = torch.topk(x, k=self.k, dim=-1, largest=True, sorted=True)
+        return values, indices
+
+
+# Module-level shims rebuilt by check.py / benchmark.py per shape.
+batch = 64
+n = 8192
+k = 8
+
+
+def get_inputs():
+    # fp32 input drawn from a roughly Gaussian distribution; ties unlikely
+    # but possible. Seed is set by the caller.
+    x = torch.randn(batch, n, dtype=torch.float32)
+    return [x]
+
+
+def get_init_inputs():
+    return [batch, n, k]

05_topk_bitonic/shapes.py

@@ -0,0 +1,19 @@
+"""Canonical shape sweep for TopK.
+
+Mix of:
+  - decoder vocab top-k (single sequence, very large n, moderate k) — pure
+    bandwidth test; the input read dominates everything.
+  - prefill / batched attention top-k (many rows, moderate n, small k) — tests
+    per-row parallelism and shared-memory bitonic networks.
+  - non-power-of-2 n stress case — bitonic sort networks naturally want
+    powers of two; this forces the agent to handle padding or partial sorts.
+  - small-k limit — k=1 (argmax) is a degenerate but useful sanity case.
+"""
+
+SHAPES = [
+    {"batch": 1,   "n": 131072, "k": 64},   # decoder vocab top-k (Llama vocab ~128k)
+    {"batch": 64,  "n": 8192,   "k": 8},    # prefill / attention top-k
+    {"batch": 32,  "n": 16384,  "k": 32},   # mid-size batched
+    {"batch": 16,  "n": 12000,  "k": 16},   # non-power-of-2 n stress
+    {"batch": 128, "n": 4096,   "k": 1},    # batched argmax (k=1 corner case)
+]

05_topk_bitonic/sota.py

@@ -0,0 +1,25 @@
+"""SOTA reference for TopK: torch.topk itself.
+
+torch.topk dispatches to a CUB-backed kernel that uses radix-select for
+moderate k and a tuned bitonic sort for small n. It is the bar the agent's
+hand-rolled bitonic kernel must beat. There is no obvious vendor library that
+does better on the (batch, n, k) shape mix we evaluate — Faiss BlockSelect is
+specialized for k>=32 with much larger n, and CUB's DeviceSegmentedRadixSort
+sorts the full row (overkill for top-k).
+
+This file is INTENTIONALLY allowed to call torch.topk because it is the SOTA
+oracle, not the agent's submission. The agent's solution.py is forbidden from
+using torch.topk (see problem.yaml.forbidden).
+"""
+from __future__ import annotations
+
+import torch
+
+
+def sota_forward(x: torch.Tensor, k: int):
+    """Best-available top-k reference. x: (batch, n) fp32."""
+    return torch.topk(x, k=k, dim=-1, largest=True, sorted=True)
+
+
+def is_available() -> bool:
+    return True

06_sonic_moe_swiglu/PROMPT.txt

@@ -0,0 +1,7 @@
+I need you to write the up-projection of a top-K MoE FFN with grouped GEMM and fused SwiGLU for the RTX PRO 6000 (SM120 Blackwell, GDDR7, 1.8 TB/s). The reference implementation is in reference.py and your kernel goes in solution.py. You can make whatever mess you want in this directory — scratch files, intermediate kernels, build artifacts, profiling traces — but the final answer has to be in solution.py with the same Model, get_inputs, and get_init_inputs interface as reference.py.
+
+The op is: per expert e, compute h_e = silu(x_e @ W_gate[e]) * (x_e @ W_up[e]) where x_e is the slice of permuted hidden states routed to expert e. Inputs are hidden_states of shape (T_perm, H) bf16 (already permuted into expert order, T_perm = T_total * K), expert_offsets of shape (E+1,) int32 (prefix sums of token counts per expert, so expert e owns rows [offsets[e]:offsets[e+1]]), and per-expert weights W_gate and W_up each of shape (E, H, I) bf16. You return gated_up of shape (T_perm, I) bf16. Correctness tolerance is 0.02 abs/rel on bf16. The shapes you have to handle are T_total=32768 H=4096 I=1536 E=128 K=8 (the headline sonic-moe configuration, 32K tokens, 128 experts, top-8), T_total=4096 H=2048 I=1024 E=64 K=4 (smaller / faster iteration), and T_total=16384 H=2048 I=4096 E=64 K=8 (intermediate-heavy aspect ratio that forces larger N tiles).
+
+This needs to be a real custom kernel — the whole point is to implement the variable-length grouped GEMM and fuse SwiGLU into the epilogue, not to dispatch to a vendor library. Don't import or call torch.matmul, torch.bmm, torch.nn.functional.linear, F.linear, or anything from sonic_moe. Try CUTLASS grouped GEMM (the intended path), Triton with a grouped-GEMM autotune, CUDA C++ via load_inline, or inline PTX — your call. Anything you're uncertain about, look up PTX docs, clone CUTLASS or sonic-moe or quack-kernels or other reference repos, read library headers, and investigate.
+
+Your flywheel is implement, profile (ncu, nsys, torch.profiler — whatever's useful) and time it with benchmark.py, verify correctness by running `python check.py` and reading the output, then iterate. Don't substitute your own one-off correctness snippets for check.py — it iterates over every shape, your spot-check almost certainly won't. If `python check.py` hasn't printed PASS, you're not done. Take as long as you need to actually push the number up.

06_sonic_moe_swiglu/benchmark.py

@@ -0,0 +1,131 @@
+"""Roofline benchmark for Sonic-MoE up-projection (grouped GEMM + fused SwiGLU).
+
+For each shape: times eager reference, compiled reference, SOTA (if available),
+and the agent's solution. Reports achieved TFLOPS, GB/s, and peak_fraction.
+
+Output lines the harness picks up:
+  shape=<idx> variant=<name> tflops=<N> gbps=<N> ms=<N>
+  peak_fraction: <N>  (geomean over shapes of solution's peak_fraction)
+"""
+import sys
+from math import exp, log
+from pathlib import Path
+
+import torch
+import yaml
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(REPO_ROOT))
+
+from src.eval.roofline import compute_gbps, compute_tflops, peak_fraction  # noqa: E402
+from src.eval.timing import time_fn  # noqa: E402
+from src.hardware import get as get_hw  # noqa: E402
+
+
+def _eval_formula(expr: str, vars: dict) -> float:
+    return float(eval(expr, {"__builtins__": {}}, vars))
+
+
+def main():
+    import reference
+    import shapes
+    import solution
+
+    meta = yaml.safe_load(Path("problem.yaml").read_text())
+    hw = get_hw(meta["hardware"][0])
+    peak_tflops = hw.peak_tflops_dense.get(meta["peak_tflops_key"], 0.0)
+    peak_gbps = hw.peak_bandwidth_gb_s
+    regime = meta.get("regime", "compute")
+    flops_formula = meta["flops_formula"]
+    bytes_formula = meta["bytes_formula"]
+    num_perf_trials = int(meta.get("num_perf_trials", 20))
+
+    device = torch.device("cuda:0")
+
+    # Optional SOTA
+    try:
+        import sota as sota_mod
+        has_sota = sota_mod.is_available()
+    except Exception:
+        has_sota = False
+
+    sol_fractions: list[float] = []
+
+    for shape_idx, shape in enumerate(shapes.SHAPES):
+        reference.T_total = shape["T_total"]
+        reference.H = shape["H"]
+        reference.I = shape["I"]
+        reference.E = shape["E"]
+        reference.K = shape["K"]
+
+        init_args = reference.get_init_inputs()
+        ref_model = reference.Model(*init_args).to(device).eval()
+        sol_model = solution.Model(*init_args).to(device).eval()
+        sd = ref_model.state_dict()
+        try:
+            sol_model.load_state_dict(sd, strict=True)
+        except RuntimeError:
+            pass
+
+        torch.manual_seed(2026)
+        inputs = [t.to(device) for t in reference.get_inputs()]
+
+        flops = _eval_formula(flops_formula, shape)
+        bytes_moved = _eval_formula(bytes_formula, shape)
+
+        # Eager (slow Python loop in reference)
+        ms_eager = time_fn(ref_model, inputs, iters=max(3, num_perf_trials // 4))
+
+        # Compiled (best-effort)
+        try:
+            comp = torch.compile(ref_model, mode="reduce-overhead")
+            ms_comp = time_fn(comp, inputs, iters=max(3, num_perf_trials // 4))
+        except Exception as e:
+            print(f"  [compile fallback] {type(e).__name__}: {e}")
+            ms_comp = None
+
+        # SOTA (sonic-moe). Wrap in try/except: SM120 path may be unavailable.
+        ms_sota = None
+        if has_sota:
+            try:
+                hidden_states, expert_offsets = inputs
+                W_gate, W_up = ref_model.W_gate, ref_model.W_up
+
+                def sota_fn(_x=hidden_states, _o=expert_offsets, _g=W_gate, _u=W_up):
+                    return sota_mod.sota_forward(_x, _g, _u, _o)
+
+                ms_sota = time_fn(sota_fn, [], iters=num_perf_trials)
+            except Exception as e:
+                print(f"  [sota unavailable] {type(e).__name__}: {e}")
+
+        # Solution
+        ms_sol = time_fn(sol_model, inputs, iters=num_perf_trials)
+
+        for variant, ms in [
+            ("eager", ms_eager),
+            ("compiled", ms_comp),
+            ("sota", ms_sota),
+            ("solution", ms_sol),
+        ]:
+            if ms is None:
+                continue
+            tflops = compute_tflops(flops, ms)
+            gbps = compute_gbps(bytes_moved, ms)
+            print(f"shape={shape_idx} variant={variant} tflops={tflops:.3f} gbps={gbps:.3f} ms={ms:.3f}")
+
+        sol_tflops = compute_tflops(flops, ms_sol)
+        sol_gbps = compute_gbps(bytes_moved, ms_sol)
+        if regime == "compute":
+            frac = peak_fraction(sol_tflops, peak_tflops)
+        else:
+            frac = peak_fraction(sol_gbps, peak_gbps)
+        sol_fractions.append(frac)
+        print(f"shape={shape_idx} solution_peak_fraction={frac:.4f}")
+
+    gmean = exp(sum(log(max(f, 1e-9)) for f in sol_fractions) / len(sol_fractions))
+    print(f"peak_fraction: {gmean:.4f}")
+    print(f"RESULT: {'OK' if gmean >= 0.1 else 'LOW'}")
+
+
+if __name__ == "__main__":
+    main()

06_sonic_moe_swiglu/check.py

@@ -0,0 +1,110 @@
+"""Correctness runner for Sonic-MoE up-projection (grouped GEMM + fused SwiGLU).
+
+Runs solution.Model vs reference.Model across all shapes in shapes.py, 3 seeds
+each, with per-dtype atol/rtol. Also rejects forbidden ops by grep.
+"""
+import re
+import sys
+from pathlib import Path
+
+import torch
+import yaml
+
+# Make the repo's src/ importable
+REPO_ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(REPO_ROOT))
+
+from src.eval.correctness import check_correctness  # noqa: E402
+
+
+def main():
+    try:
+        import reference
+        import shapes
+        import solution
+    except Exception as e:
+        print(f"FAIL: import error: {e}")
+        sys.exit(1)
+
+    problem_yaml = Path("problem.yaml")
+    meta = yaml.safe_load(problem_yaml.read_text()) if problem_yaml.exists() else {}
+
+    # --- Forbidden-op check ------------------------------------------------
+    sol_src = Path("solution.py").read_text() if Path("solution.py").exists() else ""
+    for forbidden in meta.get("forbidden", []):
+        pat = re.escape(forbidden)
+        if re.search(pat, sol_src):
+            print(f"FAIL: forbidden op used: {forbidden}")
+            sys.exit(1)
+
+    device = torch.device("cuda:0")
+    tol_override = meta.get("tolerance") or None
+
+    # --- Per-shape correctness --------------------------------------------
+    all_shapes = shapes.SHAPES
+    for shape_idx, shape in enumerate(all_shapes):
+        # Rebuild reference module's module-level shape shims.
+        reference.T_total = shape["T_total"]
+        reference.H = shape["H"]
+        reference.I = shape["I"]
+        reference.E = shape["E"]
+        reference.K = shape["K"]
+
+        init_args = reference.get_init_inputs()
+        ref_model = reference.Model(*init_args).to(device).eval()
+        sol_model = solution.Model(*init_args).to(device).eval()
+
+        sd = ref_model.state_dict()
+        try:
+            sol_model.load_state_dict(sd, strict=True)
+        except RuntimeError as e:
+            print(f"FAIL: state_dict mismatch at shape {shape_idx} ({shape}): {e}")
+            sys.exit(1)
+
+        for seed in (42, 123, 456):
+            torch.manual_seed(seed)
+            torch.cuda.manual_seed_all(seed)
+            inputs = [t.to(device) for t in reference.get_inputs()]
+
+            with torch.no_grad():
+                ref_out = ref_model(*inputs)
+                sol_out = sol_model(*inputs)
+
+            ok, msg = check_correctness(
+                ref_out, sol_out,
+                dtype=ref_out.dtype,
+                override=tol_override,
+            )
+            if not ok:
+                print(f"FAIL: shape {shape_idx} {shape} seed {seed}: {msg}")
+                sys.exit(1)
+
+    # --- Framework label (for stats) --------------------------------------
+    _emit_framework_label()
+    print("PASS")
+
+
+def _emit_framework_label():
+    """Write framework.txt with the detected kernel framework."""
+    patterns = [
+        ("ptx",       r"asm\s+volatile|asm\s*\(|mma\.sync|tcgen05\."),
+        ("cutlass3",  r"\bcute::|cutlass/gemm/collective|cutlass::arch::Sm(9|10|12)"),
+        ("cutlass2",  r"cutlass/gemm/device/gemm|cutlass::gemm::device"),
+        ("cuda_wmma", r"\bnvcuda::wmma\b|wmma::fragment"),
+        ("triton",    r"import\s+triton\b|@triton\.jit|\btl\.dot\b"),
+        ("cuda_raw",  r"torch\.utils\.cpp_extension\.load_inline|__global__\s+void"),
+    ]
+    sol = Path("solution.py")
+    if not sol.exists():
+        return
+    code = sol.read_text()
+    label = "unknown"
+    for name, pat in patterns:
+        if re.search(pat, code):
+            label = name
+            break
+    Path("framework.txt").write_text(label + "\n")
+
+
+if __name__ == "__main__":
+    main()

06_sonic_moe_swiglu/problem.yaml

@@ -0,0 +1,47 @@
+name: 06_sonic_moe_swiglu
+display_name: "Sonic-MoE up-projection (Grouped GEMM + SwiGLU)"
+precision: bf16
+regime: compute
+hardware: [RTX_PRO_6000]
+peak_tflops_key: bf16
+peak_bandwidth_key: dram
+
+# Dense-equivalent FLOPs: gate GEMM + up GEMM + SwiGLU (negligible elementwise).
+# Per token: 2*H*I FMAs for gate, 2*H*I for up => 2 * T_total * H * (2*I).
+# (Each of T_total tokens visits K experts, but total work = T_total * K * (2*H*I*2)
+# only if you count routing. The standard MoE FLOPs convention counts only the
+# active per-token compute: T_total tokens * 2 * (2*I) * H. We follow that.)
+flops_formula: "2 * T_total * H * (2 * I)"
+
+# Bytes moved (approximate, lower bound):
+#   read hidden (T_perm = T_total*K rows of H bf16) + read 2 weight matrices per
+#   expert (E * H * 2*I bf16) + write output (T_perm rows of I bf16).
+bytes_formula: "T_total*K*H*2 + E*H*(2*I)*2 + T_total*K*I*2"
+
+tolerance:
+  bfloat16: 0.02
+
+# Forbidden ops -- agent must write the grouped GEMM + fused SwiGLU themselves.
+# - torch.matmul / torch.bmm / F.linear: cuBLAS dispatch, defeats the point.
+# - sonic_moe imports: vendor-call cheating; the SOTA is graded separately.
+forbidden:
+  - "torch.matmul"
+  - "torch.bmm"
+  - "torch.nn.functional.linear"
+  - "F.linear"
+  - "from sonic_moe"
+  - "import sonic_moe"
+
+sota:
+  name: "Sonic-MoE up-projection (Tri Dao)"
+  url: "https://github.com/Dao-AILab/sonic-moe"
+  function: "sonic_moe.fused_moe_up"
+  deps:
+    - "sonic-moe>=0.1.2"   # requires Python>=3.12, sm_120 support in-progress
+    - "quack-kernels"      # CuTeDSL grouped GEMM that sonic-moe dispatches to
+  # Documented H100 paper number for this configuration (informational, not graded
+  # live on SM120). Sonic-MoE reports 1.87-4.04x over ScatterMoE/MoMoE on H100.
+  reference_throughput_tflops_h100: 480
+
+num_correct_trials: 3
+num_perf_trials: 20

06_sonic_moe_swiglu/reference.py

@@ -0,0 +1,102 @@
+"""Naive grouped GEMM + fused SwiGLU reference (correctness only, NOT the SOTA).
+
+This is the up-projection of an MoE FFN. Each token i is assigned to K experts;
+expert_indices[i*K + j] tells you which expert. Tokens are dispatched to experts
+according to routing metadata; we compute, per expert e:
+
+    h_e = silu(x_e @ W_gate[e])  *  (x_e @ W_up[e])
+
+where x_e is the slice of permuted hidden states routed to expert e, with
+expert_offsets[e]:expert_offsets[e+1] giving its row range in the permuted layout.
+
+The reference loops over experts in Python. Slow, but pedagogically clear and
+correct. Forbidden ops (torch.matmul, torch.bmm, F.linear, sonic_moe imports)
+are NOT used here, but the reference is exempt — only solution.py is checked.
+"""
+from __future__ import annotations
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+OP_TYPE = "grouped_gemm_swiglu"
+SUPPORTED_PRECISIONS = ["bf16"]
+HARDWARE_REQUIRED = ["RTX_PRO_6000", "H100", "B200"]
+
+
+class Model(nn.Module):
+    """Up-projection of a top-K MoE FFN with fused SwiGLU.
+
+    Inputs at call time:
+      hidden_states:    (T_perm, H)  bf16, already permuted to expert order
+      expert_offsets:   (E+1,)       int32, prefix sums of token counts per expert
+                                     so expert e owns rows [offsets[e]:offsets[e+1]]
+                                     T_perm = T_total * K (each token visits K experts)
+
+    Output:
+      gated_up:         (T_perm, I)  bf16
+    """
+
+    def __init__(self, T_total: int, H: int, I: int, E: int, K: int):  # noqa: E741
+        super().__init__()
+        self.T_total = T_total
+        self.H = H
+        self.I = I
+        self.E = E
+        self.K = K
+        # Two weight tensors per expert: gate (E, H, I) and up (E, H, I).
+        self.W_gate = nn.Parameter(torch.empty(E, H, I, dtype=torch.bfloat16))
+        self.W_up = nn.Parameter(torch.empty(E, H, I, dtype=torch.bfloat16))
+        nn.init.normal_(self.W_gate, std=0.02)
+        nn.init.normal_(self.W_up, std=0.02)
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,   # (T_perm, H) bf16
+        expert_offsets: torch.Tensor,  # (E+1,) int32
+    ) -> torch.Tensor:
+        T_perm, H = hidden_states.shape
+        out = torch.empty(T_perm, self.I, dtype=torch.bfloat16, device=hidden_states.device)
+        # Loop over experts. Each expert is a small dense GEMM on its slice.
+        for e in range(self.E):
+            start = int(expert_offsets[e].item())
+            end = int(expert_offsets[e + 1].item())
+            if end == start:
+                continue
+            x_e = hidden_states[start:end]                 # (n_e, H)
+            gate = x_e @ self.W_gate[e]                    # (n_e, I)
+            up = x_e @ self.W_up[e]                        # (n_e, I)
+            out[start:end] = F.silu(gate) * up
+        return out
+
+
+# Module-level shape shims rewritten by check.py / benchmark.py per shape.
+T_total = 32768
+H = 4096
+I = 1536  # noqa: E741
+E = 128
+K = 8
+
+
+def _build_routing(T_total: int, E: int, K: int, device: str = "cpu") -> torch.Tensor:
+    """Round-robin-ish routing metadata: balanced offsets summing to T_total*K."""
+    T_perm = T_total * K
+    # Even split with remainder distributed to first experts.
+    base = T_perm // E
+    rem = T_perm - base * E
+    counts = torch.full((E,), base, dtype=torch.int32, device=device)
+    counts[:rem] += 1
+    offsets = torch.zeros(E + 1, dtype=torch.int32, device=device)
+    offsets[1:] = torch.cumsum(counts, dim=0)
+    return offsets
+
+
+def get_inputs():
+    T_perm = T_total * K
+    hidden_states = torch.randn(T_perm, H, dtype=torch.bfloat16) * 0.1
+    expert_offsets = _build_routing(T_total, E, K)
+    return [hidden_states, expert_offsets]
+
+
+def get_init_inputs():
+    return [T_total, H, I, E, K]

06_sonic_moe_swiglu/shapes.py

@@ -0,0 +1,19 @@
+"""Shape sweep for Sonic-MoE up-projection (grouped GEMM + fused SwiGLU).
+
+Defaults match the sonic-moe paper's headline configuration. We add:
+  - a smaller shape for fast iteration during agent development
+  - a wider intermediate (different aspect ratio) to stress N-tile selection
+"""
+
+SHAPES = [
+    # Headline sonic-moe shape: 32K tokens, 128 experts, top-8.
+    {"T_total": 32768, "H": 4096, "I": 1536, "E": 128, "K": 8},
+
+    # Fast-iteration shape (~16x cheaper). Same expert count to keep the
+    # variable-length grouped layout meaningful, but smaller token / hidden dims.
+    {"T_total": 4096, "H": 2048, "I": 1024, "E": 64, "K": 4},
+
+    # Different aspect ratio: smaller H, wider I (intermediate-heavy FFN).
+    # Forces tiles to handle larger N relative to K.
+    {"T_total": 16384, "H": 2048, "I": 4096, "E": 64, "K": 8},
+]

06_sonic_moe_swiglu/sota.py

@@ -0,0 +1,71 @@
+"""SOTA reference for Sonic-MoE up-projection: Tri Dao's sonic-moe.
+
+Status (2026-04): sonic-moe ships on PyPI as `sonic-moe` (>=0.1.2.post1) and
+requires Python>=3.12. It dispatches to QuACK CuTeDSL grouped GEMM kernels.
+SM120 (RTX PRO 6000 Blackwell Workstation) support is in-progress upstream --
+the package installs cleanly but kernels may fail at launch on SM120 (the
+QuACK grouped-GEMM path targets Sm90/Sm100 in the public release).
+
+If the live call fails, `is_available()` returns False and the benchmark scores
+the agent against PyTorch eager + the documented H100 paper ceiling (see
+problem.yaml.sota.reference_throughput_tflops_h100). Agents are FORBIDDEN from
+importing sonic_moe in solution.py (see problem.yaml.forbidden).
+"""
+from __future__ import annotations
+
+import torch
+
+
+def _try_sonic_moe(
+    hidden_states: torch.Tensor,
+    W_gate: torch.Tensor,
+    W_up: torch.Tensor,
+    expert_offsets: torch.Tensor,
+) -> torch.Tensor | None:
+    try:
+        import sonic_moe  # type: ignore  # noqa: F401
+    except Exception:
+        return None
+    try:
+        # Public sonic-moe API surface is still stabilizing. The expected entry
+        # point bundles gate+up weights as a single (E, H, 2*I) tensor and fuses
+        # SwiGLU. Adapt to the actual signature once SM120 lands.
+        W = torch.cat([W_gate, W_up], dim=-1).contiguous()  # (E, H, 2*I)
+        from sonic_moe import fused_moe_up  # type: ignore
+        return fused_moe_up(hidden_states, W, expert_offsets)
+    except Exception:
+        return None
+
+
+def sota_forward(
+    hidden_states: torch.Tensor,
+    W_gate: torch.Tensor,
+    W_up: torch.Tensor,
+    expert_offsets: torch.Tensor,
+) -> torch.Tensor:
+    """Best-available grouped-GEMM + SwiGLU reference."""
+    out = _try_sonic_moe(hidden_states, W_gate, W_up, expert_offsets)
+    if out is not None:
+        return out
+    raise RuntimeError("sonic-moe SOTA path unavailable on this hardware")
+
+
+def is_available() -> bool:
+    # On SM120 with the current public sonic-moe, this is expected to return
+    # False until upstream lands SM120 kernels. Detect by attempting a tiny
+    # smoke call on import; any failure -> not available.
+    try:
+        import sonic_moe  # type: ignore  # noqa: F401
+    except Exception:
+        return False
+    if not torch.cuda.is_available():
+        return False
+    # Cheap capability gate: sonic-moe public release targets sm_90/sm_100.
+    major, _ = torch.cuda.get_device_capability(0)
+    if major < 9:
+        return False
+    # We do not run a live smoke here (would require allocating real weights);
+    # benchmark.py wraps sota_forward in try/except and treats failures as
+    # "SOTA unavailable" -- see problem.yaml.sota.reference_throughput_tflops_h100
+    # for the documented paper ceiling used in that case.
+    return True

07_w4a16_gemm/PROMPT.txt

@@ -0,0 +1,7 @@
+I need you to write a weight-only int4 quantized GEMM (W4A16) for the RTX PRO 6000 (SM120 Blackwell, GDDR7, 1.8 TB/s). The reference implementation is in reference.py and your kernel goes in solution.py. You can make whatever mess you want in this directory — scratch files, intermediate kernels, build artifacts, profiling traces — but the final answer has to be in solution.py with the same Model, get_inputs, and get_init_inputs interface as reference.py.
+
+The scheme is AWQ/GPTQ-style asymmetric int4 with explicit zero-points and per-group bf16 scales. Inputs are x of shape (M, K) bf16, w_q of shape (K // 2, N) uint8 (two int4 weights packed per byte, low nibble = even-K row, high nibble = odd-K row), scales of shape (K // 128, N) bf16, and zeros of shape (K // 128, N) bf16. Group size is 128 along K. Dequant per group is w_bf[k, n] = (unpack(w_q)[k, n] - zeros[k // 128, n]) * scales[k // 128, n], and the output is (M, N) bf16. Correctness tolerance is 0.10 abs/rel — group-quant adds noise on top of bf16 accumulator slop. The shapes you have to handle are M=1 N=12288 K=4096 (decode, memory-bound on the int4 weight read), M=32 N=12288 K=4096 (small prefill, mixed regime), M=256 N=12288 K=4096 (larger prefill, approaching compute-bound), M=1 N=4096 K=4096 (decode, square), and M=16 N=14336 K=4096 (speculative-decode-ish).
+
+This needs to be a real custom kernel that fuses unpack and GEMM in the same pass — a separate dequant-then-matmul wastes the entire bandwidth advantage of int4. Don't import or call bitsandbytes.functional.dequantize_4bit, bitsandbytes.functional.gemv_4bit, marlin_kernel.gemm, or torch.nn.functional.linear. Try CUTLASS mixed-input GEMM (the intended path), Triton with a fused dequant epilogue, CUDA C++ via load_inline, or inline PTX — your call. Anything you're uncertain about, look up PTX docs, clone CUTLASS or Marlin or bitsandbytes or other reference repos, read library headers, and investigate.
+
+Your flywheel is implement, profile (ncu, nsys, torch.profiler — whatever's useful) and time it with benchmark.py, verify correctness by running `python check.py` and reading the output, then iterate. Don't substitute your own one-off correctness snippets for check.py — it iterates over every shape, your spot-check almost certainly won't. If `python check.py` hasn't printed PASS, you're not done. Take as long as you need to actually push the number up.

07_w4a16_gemm/benchmark.py

@@ -0,0 +1,128 @@
+"""Roofline benchmark for FP8 GEMM.
+
+For each shape: times eager reference, compiled reference, SOTA (if available),
+and the agent's solution. Reports achieved TFLOPS, GB/s, and peak_fraction.
+
+Output lines the harness picks up:
+  shape=<idx> variant=<name> tflops=<N> gbps=<N> ms=<N>
+  peak_fraction: <N>  (geomean over shapes of solution's peak_fraction)
+"""
+import sys
+from math import exp, log
+from pathlib import Path
+
+import torch
+import yaml
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(REPO_ROOT))
+
+from src.eval.roofline import compute_gbps, compute_tflops, peak_fraction  # noqa: E402
+from src.eval.timing import time_fn  # noqa: E402
+from src.hardware import get as get_hw  # noqa: E402
+
+
+def _eval_formula(expr: str, vars: dict) -> float:
+    # Very small eval: only names from `vars` are valid.
+    return float(eval(expr, {"__builtins__": {}}, vars))
+
+
+def main():
+    import reference
+    import shapes
+    import solution
+
+    meta = yaml.safe_load(Path("problem.yaml").read_text())
+    hw = get_hw(meta["hardware"][0])
+    peak_tflops = hw.peak_tflops_dense.get(meta["peak_tflops_key"], 0.0)
+    peak_gbps = hw.peak_bandwidth_gb_s
+    regime = meta.get("regime", "compute")
+    flops_formula = meta["flops_formula"]
+    bytes_formula = meta["bytes_formula"]
+    num_perf_trials = int(meta.get("num_perf_trials", 30))
+
+    device = torch.device("cuda:0")
+
+    # Optional SOTA
+    try:
+        import sota as sota_mod
+        has_sota = sota_mod.is_available()
+    except Exception:
+        has_sota = False
+
+    sol_fractions: list[float] = []
+
+    for shape_idx, shape in enumerate(shapes.SHAPES):
+        reference.M = shape["M"]
+        reference.N = shape["N"]
+        reference.K = shape["K"]
+
+        init_args = reference.get_init_inputs()
+        ref_model = reference.Model(*init_args).to(device).eval()
+        sol_model = solution.Model(*init_args).to(device).eval()
+        sd = ref_model.state_dict()
+        try:
+            sol_model.load_state_dict(sd, strict=True)
+        except RuntimeError:
+            pass
+
+        torch.manual_seed(2026)
+        inputs = [t.to(device) for t in reference.get_inputs()]
+
+        # Theoretical work per call
+        flops = _eval_formula(flops_formula, shape)
+        bytes_moved = _eval_formula(bytes_formula, shape)
+
+        # Eager
+        ms_eager = time_fn(ref_model, inputs, iters=num_perf_trials)
+
+        # Compiled (best-effort)
+        try:
+            comp = torch.compile(ref_model, mode="reduce-overhead")
+            ms_comp = time_fn(comp, inputs, iters=num_perf_trials)
+        except Exception as e:
+            print(f"  [compile fallback] {type(e).__name__}: {e}")
+            ms_comp = None
+
+        # SOTA
+        ms_sota = None
+        if has_sota:
+            try:
+                def sota_fn(x, _ref=ref_model):
+                    return sota_mod.sota_forward(x, _ref)
+                ms_sota = time_fn(sota_fn, inputs, iters=num_perf_trials)
+            except Exception as e:
+                print(f"  [sota unavailable] {type(e).__name__}: {e}")
+
+        # Solution
+        ms_sol = time_fn(sol_model, inputs, iters=num_perf_trials)
+
+        for variant, ms in [
+            ("eager", ms_eager),
+            ("compiled", ms_comp),
+            ("sota", ms_sota),
+            ("solution", ms_sol),
+        ]:
+            if ms is None:
+                continue
+            tflops = compute_tflops(flops, ms)
+            gbps = compute_gbps(bytes_moved, ms)
+            print(f"shape={shape_idx} variant={variant} tflops={tflops:.3f} gbps={gbps:.3f} ms={ms:.3f}")
+
+        # Score: peak_fraction depends on regime
+        sol_tflops = compute_tflops(flops, ms_sol)
+        sol_gbps = compute_gbps(bytes_moved, ms_sol)
+        if regime == "compute":
+            frac = peak_fraction(sol_tflops, peak_tflops)
+        else:
+            frac = peak_fraction(sol_gbps, peak_gbps)
+        sol_fractions.append(frac)
+        print(f"shape={shape_idx} solution_peak_fraction={frac:.4f}")
+
+    gmean = exp(sum(log(max(f, 1e-9)) for f in sol_fractions) / len(sol_fractions))
+    print(f"peak_fraction: {gmean:.4f}")
+    print(f"RESULT: {'OK' if gmean >= 0.1 else 'LOW'}")
+
+
+if __name__ == "__main__":
+    main()

07_w4a16_gemm/check.py

@@ -0,0 +1,112 @@
+"""Correctness runner for FP8 GEMM.
+
+Runs solution.Model vs reference.Model across all shapes in shapes.py, 3 seeds
+each, with per-dtype atol/rtol. Also rejects forbidden ops by grep.
+"""
+import re
+import sys
+from pathlib import Path
+
+import torch
+import yaml
+
+# Make the repo's src/ importable
+REPO_ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(REPO_ROOT))
+
+from src.eval.correctness import check_correctness  # noqa: E402
+
+
+def main():
+    try:
+        import reference
+        import shapes
+        import solution
+    except Exception as e:
+        print(f"FAIL: import error: {e}")
+        sys.exit(1)
+
+    problem_yaml = Path("problem.yaml")
+    meta = yaml.safe_load(problem_yaml.read_text()) if problem_yaml.exists() else {}
+
+    # --- Forbidden-op check ------------------------------------------------
+    sol_src = Path("solution.py").read_text() if Path("solution.py").exists() else ""
+    for forbidden in meta.get("forbidden", []):
+        pat = re.escape(forbidden)
+        if re.search(pat, sol_src):
+            print(f"FAIL: forbidden op used: {forbidden}")
+            sys.exit(1)
+
+    device = torch.device("cuda:0")
+    tol_override = meta.get("tolerance") or None
+
+    # --- Per-shape correctness --------------------------------------------
+    all_shapes = shapes.SHAPES
+    for shape_idx, shape in enumerate(all_shapes):
+        # Rebuild reference module's module-level M/N/K shims so get_inputs /
+        # get_init_inputs match this shape.
+        reference.M = shape["M"]
+        reference.N = shape["N"]
+        reference.K = shape["K"]
+
+        init_args = reference.get_init_inputs()
+        ref_model = reference.Model(*init_args).to(device).eval()
+        sol_model = solution.Model(*init_args).to(device).eval()
+
+        # Share weights. strict=True — if sol_model doesn't declare the same
+        # parameters, correctness fails (this closes the "identity kernel"
+        # cheat class).
+        sd = ref_model.state_dict()
+        try:
+            sol_model.load_state_dict(sd, strict=True)
+        except RuntimeError as e:
+            print(f"FAIL: state_dict mismatch at shape {shape_idx} ({shape}): {e}")
+            sys.exit(1)
+
+        for seed in (42, 123, 456):
+            torch.manual_seed(seed)
+            torch.cuda.manual_seed_all(seed)
+            inputs = [t.to(device) for t in reference.get_inputs()]
+
+            with torch.no_grad():
+                ref_out = ref_model(*inputs)
+                sol_out = sol_model(*inputs)
+
+            ok, msg = check_correctness(
+                ref_out, sol_out,
+                dtype=ref_out.dtype,
+                override=tol_override,
+            )
+            if not ok:
+                print(f"FAIL: shape {shape_idx} {shape} seed {seed}: {msg}")
+                sys.exit(1)
+
+    # --- Framework label (for stats) --------------------------------------
+    _emit_framework_label()
+    print("PASS")
+
+
+def _emit_framework_label():
+    """Write framework.txt with the detected kernel framework."""
+    patterns = [
+        ("ptx",       r"asm\s+volatile|asm\s*\(|mma\.sync|tcgen05\."),
+        ("cutlass3",  r"\bcute::|cutlass/gemm/collective|cutlass::arch::Sm(9|10|12)"),
+        ("cutlass2",  r"cutlass/gemm/device/gemm|cutlass::gemm::device"),
+        ("cuda_wmma", r"\bnvcuda::wmma\b|wmma::fragment"),
+        ("triton",    r"import\s+triton\b|@triton\.jit|\btl\.dot\b"),
+        ("cuda_raw",  r"torch\.utils\.cpp_extension\.load_inline|__global__\s+void"),
+    ]
+    sol = Path("solution.py")
+    if not sol.exists():
+        return
+    code = sol.read_text()
+    label = "unknown"
+    for name, pat in patterns:
+        if re.search(pat, code):
+            label = name
+            break
+    Path("framework.txt").write_text(label + "\n")
+
+
+if __name__ == "__main__":
+    main()

07_w4a16_gemm/problem.yaml

@@ -0,0 +1,49 @@
+name: 07_w4a16_gemm
+display_name: "W4A16 Weight-only Quantized GEMM"
+precision: int4_bf16
+regime: memory  # decode-dominant; M=1 is bandwidth-bound on the int4 weight stream
+
+# Dense-equivalent FLOPs (matmul work, ignoring dequant arithmetic).
+flops_formula: "2 * M * N * K"
+
+# Bytes moved per call (memory roofline):
+#   x:      M*K*2          (bf16 activations, streamed in once)
+#   w_q:    (K/2)*N        (packed int4, 0.5 B/elem)
+#   scales: (K/128)*N*2    (bf16 scales)
+#   zeros:  (K/128)*N*2    (bf16 zero-points)
+#   out:    M*N*2          (bf16 store)
+bytes_formula: "M*K*2 + (K/2)*N + (K/128)*N*2 + (K/128)*N*2 + M*N*2"
+
+hardware: [RTX_PRO_6000]
+peak_tflops_key: bf16
+peak_bandwidth_key: dram
+
+tolerance:
+  bfloat16: 0.10  # group-quant adds noise on top of bf16 accumulator slop
+
+# Forbidden ops -- agent must write the unpack + GEMM themselves, not call a
+# vendor library that does both.
+forbidden:
+  - "bitsandbytes.functional.dequantize_4bit"
+  - "bitsandbytes.functional.gemv_4bit"
+  - "marlin_kernel.gemm"
+  - "torch.nn.functional.linear"
+
+sota:
+  name: "bitsandbytes NF4 (gemv_4bit / dequantize_4bit + matmul)"
+  url: "https://github.com/TimDettmers/bitsandbytes"
+  function: "bitsandbytes.functional.gemv_4bit"
+  notes: |
+    Marlin (IST-DASLab) is the W4A16 SOTA on Ampere/Hopper but does not have
+    SM120 (Blackwell consumer) kernels yet. GPTQ-Triton is unmaintained and
+    does not target SM120. bitsandbytes 0.49.2 *does* run on SM120 -- it
+    autotunes its CUDA kernels for compute capability 12.0 -- so we use its
+    NF4 path (different quant scheme but same regime) as the SOTA reference
+    line. Note that bnb's NF4 is symmetric/non-uniform; our reference uses
+    AWQ-style asymmetric int4 with explicit zero-points, which is what the
+    agent must implement. The SOTA line is informational only.
+  deps:
+    - "bitsandbytes>=0.49.2"
+
+num_correct_trials: 3
+num_perf_trials: 50

07_w4a16_gemm/reference.py

@@ -0,0 +1,112 @@
+"""Naive W4A16 weight-only quantized GEMM reference (correctness only).
+
+AWQ/GPTQ-style scheme:
+  x:      (M, K)               bf16
+  w_q:    (K // 2, N)          uint8   -- two int4 weights packed per byte (low nibble = even-K, high = odd-K)
+  scales: (K // group, N)      bf16
+  zeros:  (K // group, N)      bf16    -- asymmetric (stored already as float zero-point)
+  out:    (M, N)                bf16
+
+Dequant (per group along K):
+  w_bf[k, n] = (w_q[k, n] - zeros[k // group, n]) * scales[k // group, n]
+where w_q[k, n] is the unpacked 4-bit value (0..15).
+
+This reference unpacks to a full bf16 matrix and then runs torch.matmul. Slow and
+memory-heavy on the dequant; the agent's solution must fuse unpack+GEMM.
+"""
+from __future__ import annotations
+
+import torch
+import torch.nn as nn
+
+OP_TYPE = "gemm_w4a16"
+SUPPORTED_PRECISIONS = ["int4_bf16"]
+HARDWARE_REQUIRED = ["RTX_PRO_6000", "H100", "B200"]
+
+GROUP_SIZE = 128
+
+
+def _pack_int4(w_q: torch.Tensor) -> torch.Tensor:
+    """Pack (K, N) uint8 in [0,15] into (K//2, N) uint8.
+
+    Even rows go in the low nibble, odd rows in the high nibble.
+    """
+    K, N = w_q.shape
+    assert K % 2 == 0
+    lo = w_q[0::2].to(torch.uint8) & 0xF
+    hi = w_q[1::2].to(torch.uint8) & 0xF
+    return (lo | (hi << 4)).contiguous()
+
+
+def _unpack_int4(w_packed: torch.Tensor, K: int) -> torch.Tensor:
+    """Unpack (K//2, N) uint8 -> (K, N) uint8 in [0,15]."""
+    Kh, N = w_packed.shape
+    assert Kh * 2 == K
+    out = torch.empty((K, N), dtype=torch.uint8, device=w_packed.device)
+    out[0::2] = w_packed & 0xF
+    out[1::2] = (w_packed >> 4) & 0xF
+    return out
+
+
+class Model(nn.Module):
+    """W4A16 GEMM: y = x @ dequant(w_q, scales, zeros).
+
+    Buffers are registered (not Parameters) so state_dict carries them across to
+    the agent's solution. Initialization picks scales/zeros from a normal weight,
+    then quantizes deterministically.
+    """
+
+    def __init__(self, M: int, N: int, K: int, group_size: int = GROUP_SIZE):
+        super().__init__()
+        assert K % group_size == 0, "K must be divisible by group_size"
+        assert K % 2 == 0, "K must be even (int4 packing)"
+        self.M, self.N, self.K = M, N, K
+        self.group_size = group_size
+        n_groups = K // group_size
+
+        # Synthetic quant: take a random bf16 weight, compute per-group asym
+        # quant params, then pack. This produces a *correct* set of (w_q, s, z)
+        # triples that round-trip cleanly under the dequant formula.
+        torch.manual_seed(0xC0DE ^ (M * 1315423911 + N * 2654435761 + K))
+        w_full = torch.randn(K, N, dtype=torch.float32) * 0.02
+
+        w_g = w_full.view(n_groups, group_size, N)
+        w_min = w_g.min(dim=1, keepdim=True).values  # (n_groups, 1, N)
+        w_max = w_g.max(dim=1, keepdim=True).values
+        scales = (w_max - w_min).clamp_min(1e-8) / 15.0  # (n_groups, 1, N)
+        zeros = (-w_min / scales).round().clamp(0, 15)   # (n_groups, 1, N)
+        # Quantize
+        w_q = ((w_g / scales) + zeros).round().clamp(0, 15).to(torch.uint8)
+        w_q = w_q.view(K, N)
+
+        scales_2d = scales.squeeze(1).to(torch.bfloat16)         # (n_groups, N)
+        zeros_2d = zeros.squeeze(1).to(torch.bfloat16)            # (n_groups, N)
+        w_packed = _pack_int4(w_q)                                # (K//2, N)
+
+        self.register_buffer("w_q", w_packed)        # uint8
+        self.register_buffer("scales", scales_2d)    # bf16
+        self.register_buffer("zeros", zeros_2d)      # bf16
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        # Naive: unpack -> dequant -> matmul.
+        K = self.K
+        w_unpacked = _unpack_int4(self.w_q, K).to(torch.bfloat16)  # (K, N) in [0,15]
+        # Broadcast scales/zeros along the group axis.
+        scales = self.scales.repeat_interleave(self.group_size, dim=0)  # (K, N) bf16
+        zeros = self.zeros.repeat_interleave(self.group_size, dim=0)    # (K, N) bf16
+        w_bf = (w_unpacked - zeros) * scales  # (K, N) bf16
+        return x.to(torch.bfloat16) @ w_bf  # (M, N) bf16
+
+
+M = 1
+N = 12288
+K = 4096
+
+
+def get_inputs():
+    x = torch.randn(M, K, dtype=torch.bfloat16)
+    return [x]
+
+
+def get_init_inputs():
+    return [M, N, K]

07_w4a16_gemm/shapes.py

@@ -0,0 +1,13 @@
+"""Shape sweep for W4A16 GEMM.
+
+Llama-style up_proj / qkv_proj shapes. Decode (M=1) is the bandwidth-bound
+case every inference engine optimizes -- it's the bar to beat.
+"""
+
+SHAPES = [
+    {"M": 1,   "N": 12288, "K": 4096},   # decode: memory-bound on int4 weight read
+    {"M": 32,  "N": 12288, "K": 4096},   # small prefill: mixed regime
+    {"M": 256, "N": 12288, "K": 4096},   # larger prefill: approaching compute
+    {"M": 1,   "N": 4096,  "K": 4096},   # decode: square shape
+    {"M": 16,  "N": 14336, "K": 4096},   # speculative-decode-ish
+]

07_w4a16_gemm/sota.py

@@ -0,0 +1,87 @@
+"""SOTA reference for W4A16 GEMM.
+
+Library survey on RTX PRO 6000 Blackwell (SM120, CC 12.0):
+
+  - Marlin (IST-DASLab):         no SM120 kernels (Ampere/Hopper only). Skip.
+  - GPTQ-Triton (fpgaminer):     unmaintained; pure Triton path works on SM120
+                                 but is not faster than Marlin on its target HW
+                                 and has no Blackwell tuning. Skip as primary.
+  - AWQ (mit-han-lab/llm-awq):   CUDA kernels not built for SM120 in the wheel.
+                                 Skip.
+  - bitsandbytes >= 0.49.2:      CUDA kernels compile and run on SM120 (verified
+                                 on this machine). Different quant scheme (NF4,
+                                 symmetric, blocksize 64) than our reference's
+                                 AWQ-style asymmetric INT4 with group_size 128,
+                                 but it occupies the same memory regime and is
+                                 the only tuned W4A16-class kernel that runs on
+                                 SM120 today. Used here as an *informational*
+                                 SOTA line, not as a numerical reference.
+
+The benchmark calls `sota_forward(x, ref_model)` and times it; correctness is
+NOT checked against this path (the quant scheme differs).
+"""
+from __future__ import annotations
+
+import torch
+
+_BNB_OK: bool | None = None
+
+
+def is_available() -> bool:
+    global _BNB_OK
+    if _BNB_OK is not None:
+        return _BNB_OK
+    try:
+        import bitsandbytes  # noqa: F401
+        from bitsandbytes.functional import quantize_4bit  # noqa: F401
+        _BNB_OK = torch.cuda.is_available()
+    except Exception:
+        _BNB_OK = False
+    return _BNB_OK
+
+
+_CACHE: dict[tuple[int, int, int], tuple] = {}
+
+
+def _prepare(ref_model) -> tuple:
+    """Quantize the reference's bf16-equivalent weight with bnb NF4 once."""
+    key = (ref_model.M, ref_model.N, ref_model.K)
+    if key in _CACHE:
+        return _CACHE[key]
+    from bitsandbytes.functional import quantize_4bit
+    # Reconstruct the bf16 weight that the reference effectively uses.
+    # We dequantize the int4 packed weights via the reference's own formula
+    # so the SOTA line operates on the *same* underlying matrix.
+    # (Numerics will still differ slightly because bnb re-quantizes to NF4.)
+    K, N = ref_model.K, ref_model.N
+    w_packed = ref_model.w_q  # (K//2, N) uint8
+    scales = ref_model.scales  # (K/group, N) bf16
+    zeros = ref_model.zeros    # (K/group, N) bf16
+    g = ref_model.group_size
+
+    w_unpacked = torch.empty((K, N), dtype=torch.uint8, device=w_packed.device)
+    w_unpacked[0::2] = w_packed & 0xF
+    w_unpacked[1::2] = (w_packed >> 4) & 0xF
+    s_full = scales.repeat_interleave(g, dim=0)  # (K, N)
+    z_full = zeros.repeat_interleave(g, dim=0)
+    w_bf = (w_unpacked.to(torch.bfloat16) - z_full) * s_full  # (K, N) bf16
+
+    # bnb expects (out_features, in_features) = (N, K)
+    w_for_bnb = w_bf.t().contiguous()
+    qw, qstate = quantize_4bit(w_for_bnb, blocksize=64, quant_type="nf4")
+    _CACHE[key] = (qw, qstate, w_bf)
+    return _CACHE[key]
+
+
+def sota_forward(x: torch.Tensor, ref_model) -> torch.Tensor:
+    """W4A16 GEMM via bitsandbytes NF4. x: (M, K) bf16, returns (M, N) bf16."""
+    from bitsandbytes.functional import dequantize_4bit, gemv_4bit
+    qw, qstate, _ = _prepare(ref_model)
+    M = x.shape[0]
+    if M == 1:
+        # Decode path: bnb gemv_4bit. Wants (1, 1, K).
+        out = gemv_4bit(x.view(1, 1, -1).contiguous(), qw.t(), state=qstate)
+        return out.view(1, -1)
+    # Prefill: dequant then matmul (bnb has no batched W4A16 GEMM kernel).
+    w_deq = dequantize_4bit(qw, qstate, blocksize=64, quant_type="nf4")  # (N, K)
+    return x @ w_deq.t()

README.md

@@ -0,0 +1,114 @@
+---
+license: mit
+language:
+- en
+tags:
+- gpu
+- cuda
+- kernels
+- benchmarks
+- code-generation
+- agents
+size_categories:
+- n<1K
+pretty_name: KernelBench-Hard Problems
+---
+
+# KernelBench-Hard — Problem Definitions
+
+The 7 problem definitions for **KernelBench-Hard**, a benchmark for autonomous LLM coding agents writing GPU kernels on a single Blackwell GPU (RTX PRO 6000, sm_120, CUDA 13.2).
+
+Companion datasets:
+- [`Infatoshi/kernelbench-hard-runs`](https://huggingface.co/datasets/Infatoshi/kernelbench-hard-runs) — 84 agent transcripts, winning solutions, leaderboard, reward-hack annotations
+- Live site: https://kernelbench.com/hard
+- Methodology blog: https://kernelbench.com/blog/hard
+- Source repo: https://github.com/Infatoshi/kernelbench.com (monorepo)
+
+## Problems
+
+| id | task | shapes | regime |
+| --- | --- | --- | --- |
+| `01_fp8_gemm` | FP8 (E4M3) GEMM with bf16 accumulation | 8 | compute-bound |
+| `02_kda_cutlass` | Kimi Delta Attention forward (CUTLASS) | 4 | compute-bound |
+| `03_paged_attention` | Paged-attention decode (vLLM-style) | 6 | memory-bound |
+| `04_kahan_softmax` | Numerically stable softmax with Kahan compensation | 5 | memory-bound |
+| `05_topk_bitonic` | Top-k via bitonic select | 6 | memory-bound |
+| `06_sonic_moe_swiglu` | Sonic-MoE forward with SwiGLU | 4 | compute-bound |
+| `07_w4a16_gemm` | W4A16 weight-only quantized GEMM | 8 | compute-bound |
+
+## File layout per problem
+
+Each `0X_<name>/` directory contains:
+
+| file | purpose |
+| --- | --- |
+| `reference.py` | The PyTorch reference implementation. The agent must match its output. |
+| `check.py` | Correctness harness — reference vs. submission with `torch.allclose` tolerances |
+| `benchmark.py` | Timing harness — L2-flush + 30-trial median, prints `shape= variant= tflops= gbps= ms=` lines |
+| `problem.yaml` | Metadata: regime (compute/memory bound), tolerance, dtype, shapes |
+| `shapes.py` | Iterable of input shapes the benchmark runs |
+| `sota.py` | Hand-written SOTA reference (when available) for the upper-bound row in the leaderboard |
+| `PROMPT.txt` | The exact prompt fed to the agent harness |
+
+## Scoring (peak_fraction)
+
+For each (model, problem) cell, we compute `peak_fraction` ∈ [0, 1] as:
+
+```
+peak_fraction = geomean over shapes of (achieved_throughput / hardware_peak)
+```
+
+where `achieved_throughput` is TFLOPS for compute-bound or GB/s for memory-bound, and `hardware_peak` is the sm_120 spec (peak fp8 TFLOPS or peak HBM bandwidth). This rewards approaching the hardware ceiling rather than the easier-to-game "speedup over PyTorch."
+
+A solution must first pass `check.py` (correctness) before it gets a `peak_fraction`.
+
+## Hardware
+
+- **GPU**: NVIDIA RTX PRO 6000 Blackwell Workstation
+- **SM**: sm_120a (Blackwell)
+- **VRAM**: 96 GB GDDR7
+- **Peak HBM bandwidth**: ~1800 GB/s
+- **CUDA**: 13.2 / NVCC 12.8 / Driver 595.58.03
+- **Host**: Ryzen 9950X3D, 92 GB DDR5
+
+## Rubric leaks (known issues)
+
+Two of the seven problems leak the rubric — meaning the easiest path to a high score involves something other than writing a fast correct kernel. We publish anyway with these documented inline in `benchmarks/hard/SPEC.md` and per-cell in the runs dataset's annotation files:
+
+- **`01_fp8_gemm`** — agents that downcast to bf16 + tensor cores get ~80–90% peak without doing the actual fp8 quantization. The judge model catches some of these but not all. See annotations with `verdict: rubric_leak`.
+- **`04_kahan_softmax`** — agents that skip Kahan compensation pass `check.py`'s atol within float32 limits and get a free ~2× speedup. The numerical instability only shows up at extreme magnitudes that the test inputs don't probe.
+
+These are documented honestly because (a) we want the community to fix them, and (b) the rubric leaks themselves are interesting reward-hacking examples.
+
+## How to use
+
+```python
+from datasets import load_dataset
+# Or just clone the repo
+# git clone https://huggingface.co/datasets/Infatoshi/kernelbench-hard-problems
+```
+
+To run a problem locally with your own kernel:
+
+```bash
+cd 01_fp8_gemm
+# Drop your solution at solution.py
+uv run python check.py        # verifies correctness
+uv run python benchmark.py    # measures throughput
+```
+
+## License
+
+MIT. Cite as:
+
+```
+@misc{kernelbench-hard-2026,
+  author = {Arledge, Elliot},
+  title = {KernelBench-Hard: A GPU Kernel Engineering Benchmark for Autonomous Coding Agents},
+  year = {2026},
+  url = {https://kernelbench.com/hard},
+  note = {Built on top of KernelBench (Ouyang et al., 2025).}
+}
+```
+
+Original KernelBench: Ouyang et al., https://github.com/ScalingIntelligence/KernelBench