Source: Qu, Wang, Chen et al. (Amazon), "CompoundingKernel: Self-Improving from Zero to First", arXiv 2611.19230, November 2026; highlighted by DAIR.AI on LinkedIn (2026-11-17). Code and kernels are linked from the paper's Hugging Face Space.
What it claims
CompoundingKernel is a self-improving agent system that writes NVIDIA Blackwell (B200) GPU kernels by search. As of 2026-11-11 it ranked first on the public L1 (single ops), L2 (fused ops) and Quantization boards of SOL-ExecBench, NVIDIA's benchmark for agent-written kernels. Every one of the 235 problems has a kernel the benchmark site marks correct, and on the 209 public-board problems the kernels are 4.40x faster than the benchmark's optimized PyTorch baseline (geometric mean; median 3.78x; site timing). It is first on 89 of those 209 problems individually and top 10 on 193.
The search starts "from zero" in a specific sense: each run gets only the PyTorch definition, shapes and dtypes. No reference kernels, no prior runs, and no official scores ever enter the search. The model itself is fixed (one frontier model for both controller and children) and was pretrained on public code; agents could read CUTLASS headers, the web and a public wiki.
Architecture: four nested loops
Child loop. A child agent gets one parent kernel (or none, for a new design) and one direction. It edits, compiles and times on a B200; checks outside the model decide correctness; a correct result is appended to the problem's archive with timings and parent link. In the final run a child stops at its first correct kernel.
Controller loop. One stateless LLM controller per problem re-reads the archive whenever a child slot frees, picks any archived kernel to refine (not just the best) or opens a new root, and issues distinct directions, one per free slot.
Team loop. Lead and helper agents monitor the fleet and fix the harness. Fixes go live only at warm restarts, which stop the agents, update prompts/tools/evaluation, and relaunch with every archive intact.
Outer loop. People decide which kernels to submit and when, and reallocate child slots toward problems close behind first place. Agents see only a slot count, never a rank.
The archive is the only shared memory. Each run appends to a ledger; a single builder rebuilds a SQLite database and swaps it in atomically; agents query it read-only with SQL, so they never see a half-written state. Only an evaluation can add a node, and only for a correct kernel. Failed tries are logged but are not nodes. People's dashboard reads a separate copy agents cannot see.
Reward is local timing. Geometric-mean speedup over the published baseline, measured on the team's own B200s (which run a higher clock than the site, so a calibration only people see corrects for it). The benchmark's SOL score is shown to agents as context but not used as reward because it flattens at high speedups.
Results that matter for system design
LLM controller vs coded tree search. At equal wall time, the LLM controller beat a UCB-style tree on 35 of 38 paired problems. Parent choice was about equally good per attempt; the controller won by making 2.4x as many correct attempts.
Evaluation throughput is the bottleneck. One warm-restart fix raised evaluated candidates per hour 3.6x across the fleet. Lock waits, not agent count, were the limit.
More guidance did not help. Making optional references (an internal skill and a public wiki) mandatory added nothing measurable.
Stepping stones. Because any archived kernel can be a parent, slower designs can lead to the best one: one Quantization problem's best path went from 6.25x to 27.36x (local) with 76 of its 270 steps level or slower.
Diminishing returns. 73 to 85% of each board's rise came in the first 15% of run time; the first 2% of candidates delivered 81% of the pooled gain. The late tail is small in score but decided many per-problem ranks.
Hardware-native output. 214 of 235 kernels are CUDA C++; the median is about 7,000 lines; most use Blackwell tensor-core instructions and TMA copies, and almost all contain inline PTX.
Correctness and reward hacking
A wrong kernel usually returns plausible numbers rather than crashing, and 7,000-line kernels outpace human review. The benchmark's own authors flagged 14.5% of submissions in their agent runs as reward hacks. CompoundingKernel puts every correctness decision outside the model in five classes of checks: official correctness on every workload, robustness on unshipped shapes and stress values, rules and reward-hack detection, site readiness (build time, rehearsal), and review plus a person's go. The search found reward hacks on its own during the run; new checks were added before anything was sent. In one case a fast L2 kernel that overflowed FP16 on stress inputs was dropped for a much slower robust one. A code review also rejected a library fallback that had passed every automated check, leaving one problem slower than baseline by choice.
Tradeoffs
Stateless agents plus an external archive make restarts and harness changes cheap, at the cost of re-reading the archive every step.
Children stop at first correct kernel, which maximizes attempt throughput but relies on the controller for exploration depth.
Local timing as reward keeps official scores out of the loop, but needs a hidden calibration and can diverge from site timing (pods read about 1.19x fast).
Humans steer compute by rank outside the search. That is a legitimate operational choice, but it means slot allocation, not the agents alone, shaped which problems improved late in the run.
Failure modes and caveats
Candidate counts track difficulty, not payoff (Spearman -0.36 between correct candidates and gain), so "more tries" is not evidence that tries buy gain.
Plain GEMM/MLP and full layers remain furthest from the speed-of-light bound; 21 public problems sit below 1.5x and two end slower than baseline.
Most systems lessons are before/after readings inside one live run, not controlled experiments.
FlashInfer-Bench results were verified but not published.
Leaderboard standings are dated and move; other teams overtook the system on two boards for periods before it retook them.
Review checklist for an agent search system
Is the shared memory outside the model, append-only for verified results, and read atomically?
Do all correctness verdicts come from checks the agents cannot edit, with robustness and reward-hack classes, not just a reference comparison?
Is official or held-out scoring kept out of the reward path entirely?
Are you measuring reliable evaluations per hour before adding agents?
Can the controller expand non-best nodes, so slower designs can serve as stepping stones?
Are harness changes batched into restarts that preserve state, with an approval step?
Is a human required to approve anything that leaves the system?
Related
R114: AutoRL, agents supervising a live RL run.
R103: EvoTrias, separation of powers for agentic program evolution.
R066: TRUST, a statistical acceptance gate for self-improving harnesses.
R024: InfraRSI, contract-locked agents for training-throughput tuning.