agent/README.md

# The KBench kernel agent

A Claude Code skill and four subagents for writing and optimizing GPU kernels. Built for the KBench
tasks in this repo, but nothing here is KBench-specific — it works on any kernel with a correctness
check and a timer.

The premise it is built around: **the score is an absolute metric and it is uncapped.** There is no
"good enough", so the agent is told to keep attacking the largest remaining component rather than to
stop at a percentage of roofline.

## Install

Copy into a project so Claude Code can find it:

```bash
mkdir -p .claude/skills/kernel-optimization .claude/agents
cp -r agent/*.md agent/ref agent/tools .claude/skills/kernel-optimization/
cp agent/agents/kernel-*.md .claude/agents/
rm .claude/skills/kernel-optimization/README.md          # this file; not part of the skill
chmod +x .claude/skills/kernel-optimization/tools/*.sh   # exec bits do not survive the download
```

Paths inside `SKILL.md` assume that layout. The skill triggers on requests like "make this kernel
faster", "implement a fused attention kernel", or "solve this KBench task".

## What is in it

| file | purpose |
|---|---|
| `SKILL.md` | the 7-step loop: harness → roofline → algorithm → toolchain → implement → profile → specialize → iterate |
| `profiling.md` | nsys before ncu, the metric→conclusion tree, and the permission wall |
| `toolchain.md` | CUDA vs Triton vs CUTLASS vs CuTe — where Triton wins and where it loses |
| `algorithms.md` | the restructuring catalog: online softmax, chunked recurrences, recompute-in-backward |
| `hardware.md` | the sm_80/90/100 capability ladder |
| `pitfalls.md` | measurement lies, correctness traps, and how to read a profile without chasing a healthy-looking counter |
| `references.md` | which open-source kernel demonstrates which technique |

### Language references (`ref/`)

| file | covers |
|---|---|
| `ref/ptx.md` | inline PTX: constraints, cache hints, `cp.async`, TMA, `mbarrier`, `mma`/`wgmma`, `ldmatrix`/`stmatrix`, `setmaxnreg`, fast-math opcodes |
| `ref/cuda-cpp.md` | CUDA C++: opt-in shared memory, `cuda::pipeline`, cooperative groups, clusters/DSMEM, host-side TMA descriptors, build and debug flags |
| `ref/triton.md` | the Triton 3.6 API surface, launch knobs, idioms, and where it caps out |
| `ref/cute-cutlass.md` | CuTe layout algebra, swizzles, atoms, and where CUTLASS lives in the image |
| `ref/official-docs.md` | a working guide to NVIDIA's own documentation: what each guide contains, chapter by chapter, which one answers which question, version matching, and the licence position |

**These are verified, not recalled.** Every instruction and API was compiled with the container's own
`nvcc` on `sm_90a` / CUDA 12.8: 39/41 PTX instructions assemble (the two that do not are recorded —
`tcgen05` is Blackwell-only), 24/24 CUDA C++ constructs compile, and the Triton tables come from
introspecting the installed 3.6.0.

Two examples of what that buys you. `wgmma.m64nNk16.f32` needs exactly **N/2 accumulator registers per
thread** — measured across five shapes — so an `m64n256k16` tile spends 128 registers on the accumulator
alone, which is what forces warp specialisation. And Triton 3.6 *accepts* `cache_modifier=".cg"`
together with `eviction_policy="evict_first"` but ptxas rejects the pair; the full combination matrix is
in `ref/triton.md`.

### Tools (`tools/`)

- **`roofline.py`** — measures the device rather than quoting a datasheet, then gives the floor and
  whether you are compute- or memory-bound.
- **`bench.py`** — CUDA events, fresh inputs per rep, min-of-N, warmup excluded, and a warning when the
  measurement is host-bound.
- **`profile.sh`** — `nsys` mode answers "is the time even in a kernel?"; `ncu` mode emits a
  *diagnosis*, not a metric dump.
- **`dump_ir.sh`** — Triton PTX/TTGIR/cubin, Inductor's generated Triton, and SASS. Reading the SASS is
  how you confirm the MMA you intended actually issued and that nothing spilled.
- **`occupancy.py`** — finds the occupancy limiter and checks a persistent grid for the co-residency
  deadlock.
- **`check_toolchain.py`** — re-derives every table in `ref/` by compiling on the machine you are
  actually on; `--matrix` compares sm_89 (Ada), sm_90a (Hopper) and sm_100a/sm_120a (Blackwell) side by
  side, which works even for architectures you do not own. The docs were verified on sm_90a / CUDA 12.8; on a different GPU or toolkit some rows
  change, and this tool wins over the docs.
- **`fetch_nvidia_docs.sh`** / **`search_docs.sh`** — downloads NVIDIA's official CUDA/PTX guides as
  **greppable text** (~11 MB) and searches them offline. The documents are **not bundled here**:
  NVIDIA's documentation is copyrighted and the CUDA EULA distributes only the runtime libraries listed
  in its Attachment A, which does not include documentation — so you fetch your own copy under NVIDIA's
  terms. Task containers have network at image-build time and none at run time, so a Dockerfile `RUN`
  step puts the guides inside an offline container. It auto-matches your CUDA version, which matters:
  the live docs always serve the newest CUDA, and 12.8 wants PTX ISA 8.7, not the 9.3 now published.
  PDFs are deliberately not fetched — a 700-page reference you cannot grep is not useful offline.
- **`ledger.md`** — one row per variant. The column that matters records whether an abandoned variant
  was *slower* or merely *broken*; dropping a good optimization over a fixable bug is the most common
  way to leave 2x on the table.

### Subagents (`agents/`)

`kernel-algorithmist` restructures the maths, `kernel-implementer` writes it, `kernel-profiler`
diagnoses the bottleneck, `kernel-verifier` builds the harness and measures the tolerance. The split
exists mostly to keep the profiler's output out of the implementer's context.

## Two things that will bite you

**`ncu` needs GPU performance counters.** Without them it exits with `ERR_NVGPUCTRPERM`. Run the
container with `--cap-add SYS_ADMIN`, or set `NVreg_RestrictProfilingToAdminUsers=0` on the host.
`ncu --version` succeeding proves nothing — it never touches a counter. `nsys` needs no extra
capability, and it is the right first tool anyway.

**Counters are hints, not verdicts.** Measured here on an H200: cuBLAS's own bf16 GEMM profiles at
SM 90.5%, DRAM 16.5%, **occupancy 14.6%**, 168 registers/thread and 136k shared-memory bank conflicts —
and it is essentially the fastest thing on the device. Three of those numbers look like defects.
Establish which resource is saturated first, then look for a specific mechanism explaining the gap.