tools/factory/AGENT_GUIDE.md

# How to add a kernel-generation task

Read this fully before writing anything. Everything here is a hard requirement learned from building
the existing 153 tasks; the pitfalls at the bottom are all things that actually went wrong.

## What a task is

An agent is given a slow-but-correct `reference.py` and an empty stub, and must write a fast GPU kernel.

    reward = 0                        if the submission is incorrect
    reward = achieved TFLOP/s or GB/s otherwise, UNCAPPED

Correctness is the **gate**. Speed is the **reward**. There is no oracle and no gold solution: the
score is an absolute hardware metric, so it is hardware-portable and nothing needs re-benchmarking.

## Workflow

```bash
cd /home/zhuominc/MLE-Bench/mle_tasks/kernel-generation/kernels
$EDITOR _factory/specs/my_task.py                 # write the spec (see below)
python3 _factory/build.py _factory/specs/my_task.py   # generates the whole task directory
bash _factory/validate.sh <YOUR_GPU> my-task-name     # stub must be 0, reference must be > 0
python3 _factory/audit_sizes.py my-task-name          # roofline must be >= 250 us
```

**Write the spec file to disk the moment you have it drafted, before validating.** Agents have been
lost mid-run; anything not on disk is gone.

`validate.sh` must print:

    my-task-name    stub[0.0 <metric> | correct: 0.0] ref[<positive> <metric> | correct: 1.0]

If the stub scores non-zero or the reference scores zero, the task is broken. Do not move on.

## The spec

Every field is in `_factory/spec.py`. The ones that matter most:

| field | notes |
|---|---|
| `reference_src` | correct + simple. NOT a performance target. Must be numerically *tractable*, not fair. |
| `make_inputs_src` | `def _mk(*shape, seed)` returning the arg tuple, on `cuda`, seeded |
| `flops_src` | `def canonical_work(*shape)` — FLOPs or BYTES from **shape alone**, never from the data |
| `flops_formula` | set this explicitly whenever `canonical_work` uses helpers or multiple statements |
| `metric` | `"TFLOP/s"` for compute-bound, `"GB/s"` for bandwidth-bound. Pick honestly. |
| `compare` | `"tensor"` \| `"tuple"` (needs `tuple_names`) \| `"rowwise"` (needs `row_pass`) |
| `tol` | **measure it**, do not guess. See Precision below. |
| `grader_shapes` / `correct_shapes` / `measure_shapes` | see Sizing below |

`canonical_work` depending on the *data* (e.g. counting actual non-zeros) breaks the leaderboard —
two submissions would be credited differently for the same work. Shape only.

## Sizing — the most common failure

The kernel must dominate, not launch overhead. **At the largest graded shape the roofline time must be
>= 250 us**, where roofline is `FLOPs / 700e12` (bf16 H200) or `bytes / 4.8e12`.

`python3 _factory/audit_sizes.py <task>` checks this. If it reports under 250 us, make the tensors
bigger — and then update `regime_md` so the prose matches the new numbers.

Keep `correct_shapes` **small** (they run many times) and `grader_shapes` **large**. They are separate
lists precisely so correctness can be cheap while timing is at scale.

## Precision

Prefer **bf16 / fp8** — that is what LLM and diffusion inference actually use. fp32 references are fine
as the numerical *spec*, but the graded dtype should be realistic.

**Measure the tolerance, do not guess it.** Write the reference, write a second independent-but-correct
implementation (different reduction order, different chunking), compare them, and set `tol` at roughly
**2x** the observed difference. State the reasoning in `precision_md`.

If a task ships pre-quantised inputs (fp8/int4/nvfp4), the reference must dequantise **those exact
bytes**. Making the agent quantise and then charging them the quantisation error is a bug — it cost the
megakernel fp8 task a 10x tolerance error before it was caught.

## Quantisation tasks: constrain the input span

Quantised tasks have a failure mode the rest of the lane does not — the measured error depends on the
input span, so a tolerance measured on a few seeds can be a lottery.

* **Per-TENSOR scales must be exactly representable.** A scalar scale drawn from a continuous
  distribution is not representable in bf16, and its rounding error multiplies the WHOLE output
  coherently instead of averaging out. `nvfp4-dequant-gemm` measured a **221x spread** in E across 80
  seeds from one such scalar, leaving 1.73x headroom at the worst seed. Round per-tensor scales onto
  the bf16 grid at generation. Per-row and per-block scales average out over the reduction and should
  be left alone — rounding them would misrepresent the real format.
* **Measure E over MANY seeds, not two or three.** The tail grows: that same task measured 2.4e-3 over
  20 seeds and 2.9e-3 over 80. And the grader validates the last TIMED rep on seeds 10000+i, which are
  different from the correctness seeds 100+i, so an unstable E can pass correctness and fail timing.
* **Watch for underflow outliers.** If a fixture lets a dequantised value reach exactly zero where a
  divisor expects it not to, a handful of elements can dominate the relative-Frobenius norm.
  `quantized-optimizer-state` had 8 elements carrying 86% of the output energy for that reason.
* **Relative Frobenius error under-weights what quantisation damages.** It is dominated by the largest
  elements, which are the ones that SET absmax and are best represented. Keep the block dynamic range
  (`absmax/rms`) near what a gaussian gives (~3.2 for a 128-block); if you want real activation
  outliers, inject them at a FIXED count and magnitude rather than relying on the tail of `randn`.
* **If your gate ends up tight enough to forbid bf16 metadata, say so in the prose.** Scales and
  dequantisation maps are tiny and fully reused, so keeping them fp32 costs no bandwidth — but an
  agent will not guess that a 4e-5 gate is enforcing it.

## Contract clarity

Difficulty must come from the kernel, never from ambiguity. `contract_md` must state, for every
argument: shape, dtype, layout, and meaning; and for every output: shape, dtype, and whether it may be
bf16 or must be exact. Say explicitly whether inputs are read-only and whether updates are in-place or
functional. If a dimension is ragged (not a multiple of any tile), say so and include a ragged
`correct_shape`.

`perf_md` must tell the agent where the performance actually comes from, and `instruction.md` must
explicitly push for speed — this is a leaderboard, not a pass/fail.

## Toolchain policy (what agents may use)

Encouraged: **CUDA C++ / CuTe DSL**, then Triton (Gluon ships with it), CUTLASS. `torch` is allowed for
setup and where there is no efficient direct alternative.

Not available, by absence rather than by scanning: no internet at run time, and no flashinfer, vLLM,
flash-attn, TensorRT-LLM, or any pre-fused library kernel installed. **Never add an anti-cheat source
scan** — if agents should not have something, it simply is not installed.

## Novelty

Tasks must be genuinely new, LLM- or video-generation-related, and not duplicate any of the 153
existing directories. `ls -d */ | grep -v '^_'` before you name anything.

## Pitfalls that have actually bitten

* **Integer tensors must compare exactly.** `.float()` is lossy above 2^24, so two distinct page/token
  ids can compare equal and let a wrong kernel pass. The generated grader already handles this — do not
  reintroduce float comparison in a custom check.
* **Top-k / argmax gates are fragile.** Near-tied values flip on ordinary numerical noise, so two
  *correct* implementations disagree. Gate on relative error instead. This killed a MoBA design and a
  megakernel design.
* **`tensor / python_float` is a reciprocal-multiply** and flips ~0.05% of fp8 codes. Use a 0-dim
  tensor divisor.
* **Check the drop-the-feature error.** Measure what a kernel that *ignores* your task's distinguishing
  feature would score. It must be far above `tol`, or the feature is not actually being graded.
* **Do not trust a reference you have not verified.** Validate against a known-correct special case or
  an independent implementation before shipping.
* **Disk.** Reap images as you go: `docker rmi -f mle-v-<task>`. `/` has filled mid-run several times.