ako4all

News

• 🔌 [2026.08.17] dsh-kernel-opt is open-source — a DeepSeek Harness (DSH) plugin that makes a kernel-optimization run watchable and steerable live; AKO4ALL's evaluator ships inside it as the built-in default.
• 📄 [2026.05.31] The AKO tech report is now available.
• 🚀 [2026.05.31] AKO4X is now open-source — the closed-loop, campaign-based system behind our MLSys 2026 competition entry.
• ✨ [2026.05.31] AKO4ALL is now a single drop-in Claude Code skill — invoke it in any working directory.
• 🚀 [2026.03.24] AKO4ALL is released.

Table of Contents

• What is AKO4ALL?
• What You Provide
• Install
• How to Use
• Requirements
• How It Works
• Results
• Agent Behavior
• Permissions
• Repo Layout
• Example: SOL-ExecBench
• Anti-Cheat
• FAQ
• Tech Report
• Acknowledgments

What is AKO4ALL?

AKO4ALL is automated GPU kernel optimization, packaged as a single Claude Code skill. Drop a kernel into your working directory, invoke the skill, and the agent bootstraps a workspace in place and iteratively rewrites the kernel for maximum performance — profile, edit, benchmark, repeat, until the kernel stops getting faster. The skill is a single SKILL.md protocol document; other coding agents can drive the same loop by following it directly.

AKO4ALL vs AKO4X — two sibling projects with different framings.

• Form: AKO4ALL is a single Claude Code skill that runs in place in your working directory. AKO4X is a template repository that builds a fresh isolated child environment for each run.
• Unit of work: AKO4ALL is one continuous optimization run on one kernel — resumable across chat sessions, but with no memory carried into the next run on the same kernel. AKO4X is a multi-round campaign on one operator — a persistent master agent spawns rounds back-to-back, and a per-operator archive accumulates each round's results so the Nth round is informed by all earlier rounds.
• Harness evolution: AKO4ALL's protocol is static — you can supply behavior directives, but the skill itself does not change. AKO4X has an opt-in harness co-evolution mode in which the agent, after each round, can propose improvements to its own knowledge and tooling layer that the master gates and applies — no analogue here.

Reach for AKO4ALL when you just want a kernel optimized; reach for AKO4X when you want infrastructure around the optimization.

What You Provide

A kernel and at least one set of test inputs are required. Everything else is optional.

• Kernel (required) — The kernel to optimize. Can be a single file or a directory. Supports Triton, CUDA, C++, TileLang, CuTe DSL, Python, or any language that can be benchmarked.
• Reference implementation (optional) — Used as the correctness golden. If absent, the original kernel is used.
• Inputs (at least one set required) — In any form: hardcoded inside the kernel/reference, defined in your benchmark script, a separate Python file with get_inputs(), or raw data files (.npz, .bin, shape lists, etc.) that the agent wires up itself. The agent assembles whatever is provided into something the bench script can call.
• Benchmark script (optional) — Your own benchmark script; the agent reads it to figure out how to run it. If no benchmark script is provided, the built-in KernelBench evaluator is used automatically (no setup needed beyond PyTorch).
• Knowledge (optional) — Reference materials for the agent: algorithm descriptions, papers, design docs, or any background knowledge that helps inform the optimization.
• Hints (optional) — Directives for the agent: optimization constraints, focus areas, and behavior controls (e.g., whether to allow web search).

Install

Clone the repo directly into Claude Code's skills directory:

git clone https://github.com/TongmingLAIC/AKO4ALL.git ~/.claude/skills/ako4all

Or, if you already have it cloned somewhere else, symlink it:

ln -s /path/to/AKO4ALL ~/.claude/skills/ako4all

How to Use

Mode 1 — Interactive (default)

Open Claude Code in a directory containing your kernel, then ask it to optimize the kernel. Files in the working directory are inspected automatically; you can also point at external paths. Optional constraints — iteration cap, language preference, dependency policy, etc. — included in the prompt will be merged into HINTS.md.

The skill presents a resolved plan, asks if anything is genuinely ambiguous, and starts iterating. You can interrupt at any point to redirect.

If you want the conventional layout the skill recognizes:

<workspace>/
├── source/                      # Kernel + optional reference and inputs
│   ├── kernel.py
│   ├── reference.py             # Optional
│   └── inputs.py / data.npz ... # Optional — input data, any format
├── bench/                       # Your own benchmark script (optional)
│   └── ...
├── knowledge/                   # Reference materials (optional)
└── HINTS.md                     # Agent directives (optional)

These are conventions, not requirements. If your files are organized differently, just point Claude at them.

Mode 2 — Batch via subagents (advanced)

For optimizing several related kernels in parallel, in Claude Code the main agent can spawn one subagent per kernel via the Task tool.

⚠️ Subagents can't ask back. In Claude Code, subagents lack AskUserQuestion. The main agent composes each subagent's prompt from your instructions plus what's in each kernel's directory; any decision you don't pin down there will fall to SKILL.md defaults. So include the things you care about (per-kernel paths, optional reference / inputs locations, language or iteration-cap constraints, custom branch names) — and let the rest default.

Requirements

• A coding agent (e.g., Claude Code)
• NVIDIA GPU with CUDA-enabled PyTorch (only for the built-in evaluator; a remote-execution bench script may not need either locally)
• Python >= 3.10 for the built-in evaluator (or whatever your custom bench script requires)
• NVIDIA Nsight Compute (ncu) — recommended; its version must match your CUDA / PyTorch CUDA build. If unavailable, the loop still proceeds (no profiling — the agent reasons from runtime stats instead).
• Git

Note: During the loop the agent may run pip install / apt install etc. to fill in missing dependencies. A container or virtual environment is recommended for isolation; to forbid installs, add a directive to HINTS.md (see Agent Behavior) or restrict via Permissions.

How It Works

The agent creates an opt/<kernel> branch, copies your kernel to solution/, and generates scripts/bench.sh to wrap your benchmark. After verifying the baseline (and profiling it with ncu if available), it iterates: edit solution/ → benchmark → log → commit. After 3 stagnant iterations it re-profiles, plans the next direction, and continues. Defaults like the stall threshold live in HINTS.md; iteration history lives in ITERATIONS.md. See SKILL.md for the full protocol.

Results

Driven by Claude Opus 4.8 (1M context, max thinking effort), on four FlashInfer-Bench inference operators AKO4ALL rewrote the reference into Triton kernels that all beat FlashInfer's strongest expert kernel — geomean speedup over the FlashInfer expert on NVIDIA B200, all correctness-passing:

Operator	Speedup vs FlashInfer expert	Workloads
GQA paged decode	1.36×	48
MLA paged decode	1.21×	47
MLA paged prefill	1.50×	38
RMSNorm h128	1.12×	14

All four operators we ran are shown here — we time-boxed this round to four kernels, so these are not the best four cherry-picked from a larger sweep.

What one kernel takes to optimize — a typical run, end-to-end from the initial prompt to the agent finishing:

End-to-end	Input	Output	Cache read	Cache write
~55 min	~15k	~253k	~17.6M	~752k

A single drop-in skill — competitive-with-expert kernels in under an hour, from a single prompt.

Agent Behavior

A few defaults worth knowing:

• Language switching — the agent may rewrite your kernel in a different language (e.g., Triton → CUDA) to chase performance.
• Web search — enabled; the agent searches for optimization ideas after consecutive stagnant iterations.
• Profiling — ncu runs on the baseline before iter-1 and again after 3 stagnant iterations.

To adjust any of this — or to add your own directives (optimization constraints, dependency policies, iteration caps, ...) — edit HINTS.md in your workspace. The file is self-documenting.

Permissions

The optimization loop involves running shell commands (compiling, benchmarking, profiling). By default, most coding agents prompt for approval on each command. To run fully unattended, grant the necessary permissions through your agent's configuration.

For Claude Code, the simplest option is to bypass all permission checks:

claude --dangerously-skip-permissions

Create .claude/settings.local.json:

{
  "permissions": {
    "allow": [
      "Bash(*)", "Read(*)", "Write(*)", "Edit(*)",
      "Glob(*)", "Grep(*)", "Agent(*)",
      "WebFetch(*)", "WebSearch(*)"
    ]
  }
}