Best AI Agents for GPU Optimization in 2026: AKO, KernelAgent, AutoKernel, Apex, and CUDA Agent (Compared)

A reported 232x GPU-kernel speedup can still cut the full workload by less than 5%. The best AI agent for GPU optimization is therefore the one with the right hardware path, a hostile correctness harness, and an end-to-end payback gate, not the biggest benchmark headline.

The short answer: AKO is the best overall, but hardware flips the ranking

AKO is the best AI agent harness for a serious NVIDIA GPU optimization campaign. It has the strongest combination of broad expert-baseline evidence, repeatable campaign infrastructure, and independent auditing. It is not a new model. It gives Claude Code a disciplined environment in which to propose kernels, benchmark them, preserve good trajectories, and catch candidates that only appear correct.

That verdict changes immediately on AMD hardware. Apex is the dedicated ROCm choice, while AutoKernel is the more general alternative for selected AMD Instinct targets. KernelAgent is the better fit for a PyTorch team that wants an NVIDIA or Intel XPU loop driven by hardware counters. CUDA Agent shows the highest research ceiling here, but it is not a product a team can provision today.

Pricing and availability below were verified on 16 August 2026. These are self-hosted open-source systems, so a $0 starting price means no software subscription fee. The model plan, API usage, engineer time, and GPU compute are separate.

The table deliberately does not repeat benchmark multipliers. AKO's expert baselines, KernelAgent's torch.compile comparison, Apex's seven-kernel validation, CUDA Agent's KernelBench result, and the reported 232x contest result use different denominators. Sorting those numbers from largest to smallest would look precise and tell you almost nothing.

The decision rule is simple: pick the harness that can profile, verify, and deploy on your actual accelerator; then compare evidence within that route. A theoretically stronger optimizer on unsupported hardware has a business value of zero.

What the 232x result actually means for a GPU bill

The current excitement has a real source. In a firsthand account that reached Hacker News on 15 August 2026, Sankalp reported improving one NVIDIA B200 QR-decomposition benchmark from a rough 419,000 microseconds to 1,805 microseconds. That is the reported 232x result. The campaign ran for 14 days, produced more than 1,500 submissions, and finished 12th among 183 participants. The author tracked 103 successive best submissions from 108,803 to 1,805 microseconds, a 98.34% reduction. Read the experiment with its full setup and caveats.

That is impressive evidence for the workflow. It is not evidence that a production model becomes 232x cheaper. The starting point was a rough implementation on a particular benchmark. The final number came after human steering, domain knowledge, and repeated escapes from local optima. The author describes the difficult move from roughly 3,000 to 1,800 microseconds and suggests exploring three to five candidates at once rather than trusting a single optimization path.

The missing variable is the hot-kernel share, meaning the fraction of total workload time spent inside the kernel being optimized. Amdahl's law says the untouched portion of the system sets a hard ceiling on the total improvement.

If the kernel consumes 25% of workload time and becomes 232x faster, the theoretical total speedup is only 1.3314x. The corresponding theoretical cost reduction is 24.8922%. If that same kernel consumes 5% of workload time, the total speedup falls to 1.0524x and the theoretical cost reduction to 4.9784%.

This is also why a verifier matters more than a charismatic model demo. A candidate can exploit repeated inputs, cache behavior, a weak tolerance, or a narrow shape and still earn a spectacular local score. The production question is harsher: does it stay correct on fresh values, across the shapes you serve, inside the real framework, while moving the end-to-end latency or cost?

The reported campaign's own cost is instructive. The author had ChatGPT Pro at $200 per month, Claude Pro at $20 per month, and Modal's $30 monthly Starter credit available at the time. Those subscriptions made experimentation accessible, but the useful operating unit was still a long campaign of benchmark, inspect, edit, and verify. The agent reduced the cost of searching the space; it did not eliminate the need to define the right space.

1. AKO: best overall for verified NVIDIA optimization campaigns

AKO is the best overall choice when the job is an NVIDIA kernel campaign and the team can use Claude Code. Its defining advantage is not a magic model. AKO turns an existing coding agent into a recorded optimization process with a benchmark harness, campaign memory, profiling, and an adversarial audit.

There are two useful entry points. AKO4ALL is the drop-in skill for optimizing a kernel through Triton, CUDA, C++, TileLang, CuTe DSL, Python, or HIP. It records the trajectory and Git history, so the result is more inspectable than a disappearing chat transcript. AKO4X is the larger campaign system: it can run single or multiple rounds, preserve a cross-run archive, use local or Modal execution, collect NCU profiles, evolve the harness when explicitly allowed, and perform an independent audit.

That last feature is the reason AKO ranks first. The published material shows a cached candidate that appeared successful until an independent check changed input values while reusing pointers. It then failed all 38 checks. This is exactly the sort of reward hacking that a permissive benchmark misses and a production incident discovers too late.

The evidence is unusually well disclosed. AKO's published evaluation used an NVIDIA B200 with CUDA 13.2, PyTorch 2.12, Triton 3.6, and Claude Opus 4.7 or 4.8. Across 10 kernel families and 471 workloads, the authors report beating the expert implementation in nine families, with geometric-mean improvements from 1.14x to 1.43x. The standout cases include 30.71x for DSA sparse attention with 23 of 23 workloads passing and 2.30x for GDN prefill with 100 of 100 passing. AKO publishes the workload ranges and environment, which makes the more modest results just as valuable as the big ones.

Those modest results are the buying signal. GQA decode includes a 0.85x to 1.81x range, MLA decode a 0.84x to 1.98x range, MLA prefill a 0.82x to 2.37x range, and RMSNorm a 0.96x to 1.67x range. GEMM stayed at 1.00x because cuBLAS remained unbeaten. In other words, AKO sometimes loses on individual workloads and sometimes cannot improve a mature expert library. That is more credible than a page where every arrow points up.

Best for: NVIDIA teams running repeatable, audited kernel campaigns

Standout: Independent audit plus cross-run campaign memory

Pricing: $0 software for self-hosted AKO4X under the MIT license; Claude Code and GPU usage are separate, verified 16 August 2026

Free trial: Not applicable

AKO reports a typical AKO4ALL run at roughly 55 minutes, about 15,000 input tokens, 253,000 output tokens, 17.6 million cache-read tokens, and 752,000 cache-write tokens. That profile makes caching economics and model-plan limits part of the real budget. The open-source harness may cost $0, but the campaign does not.

1. 1

   Profile one production workload

   Measure the full request and identify the kernel's share of runtime before opening an agent session. Record representative shapes, dtypes, batch sizes, warm-up behavior, and the current end-to-end cost. If the kernel is not hot, stop.

2. 2

   Choose AKO4ALL or AKO4X

   Use AKO4ALL for one bounded kernel and AKO4X when the work needs multiple rounds, an archive, NCU profiling, or independent campaign audits. Do not start with the larger system merely because it has more controls.

3. 3

   Lock the reference and inputs

   Treat the existing implementation as the reference. Build correctness checks over the actual production shapes and add fresh values that defeat cached-output shortcuts. Keep the harness protected from agent edits unless harness evolution is an explicit experiment.

4. 4

   Run a capped search

   For a first pass, cap compute at 32 B200 hours and pair it with a $100 agent plan. At current Modal pricing that is a $299.99 pilot before engineer time. Preserve every accepted candidate and its exact environment.

5. 5

   Audit independently

   Re-run the winner outside the agent's working context with changed values, reused pointers where relevant, boundary shapes, and repeated trials. A candidate that only wins inside its training loop is rejected.

6. 6

   Demand end-to-end payback

   Integrate the kernel into the actual model or service, then measure full-workload latency and accelerator cost. Ship only if the observed monthly saving clears the payback window set before the campaign.

2. KernelAgent: best PyTorch-native hardware-guided loop

KernelAgent is the best fit for a PyTorch team that wants the optimizer to reason from hardware counters rather than repeatedly guess at code. The open-source project combines kernel generation, profiling, verification, benchmarking, and optimization in a multi-agent loop.

Its strongest distinction is the profiler feedback. The system gathers 28 NVIDIA Nsight Compute metrics, uses a roofline model to classify a candidate as memory-bound, compute-bound, or underutilized, and routes the next optimization accordingly. A roofline model is simply a way to ask whether the kernel is limited by arithmetic capacity, memory movement, or poor occupancy. That diagnosis makes the next edit more purposeful.

The loop verifies outputs, benchmarks with CUDA events, and can stop at the configured round limit, convergence, or at least 95% of speed-of-light efficiency. The repository lists full NVIDIA CUDA support and Intel XPU support, but no AMD ROCm support. It runs on Linux and macOS with Python 3.8 through 3.12 and requires Triton, PyTorch, and an OpenAI, Anthropic, or custom model provider. The KernelAgent repository has the current support matrix.

The published benchmark covers 100 KernelBench Level 1 tasks. The authors report 2.02x over an earlier set of generated kernels, 1.56x over default torch.compile, wins over torch.compile on 65 of 100 tasks, and 89% of the H100 roofline. An earlier generation system is credited with 100% correctness across 250 Level 1, Level 2, and Level 3 tasks; that correctness number should not be casually reassigned to every optimized KernelAgent result.

One worked case captures the honest value better than the aggregate. A matrix-vector implementation fell from 9.52 milliseconds to 1.95 milliseconds, while torch.compile reached 2.09 milliseconds. The agent made the raw implementation dramatically faster, but the final margin over the readily available compiler was much smaller. That is precisely why your economic baseline should be the best system you would otherwise deploy, not the slowest code an agent can replace.

Best for: PyTorch teams on NVIDIA CUDA or Intel XPU that want profiler-guided iteration

Standout: Roofline routing from 28 NCU metrics

Pricing: $0 software under Apache 2.0; model-provider and GPU usage are separate, verified 16 August 2026

Free trial: Not applicable

KernelAgent should be your second choice when you value a clean PyTorch-native architecture and provider flexibility. It should be your first choice when the target already sits in its supported stack and the team wants to inspect why a kernel is slow. It is a weaker fit for a broad autonomous campaign that needs cross-run archives and adversarial audit machinery out of the box.

3. AutoKernel: best simple overnight experiment loop

AutoKernel is the best practical starting point when a team wants Claude, Codex, or another coding agent to run a straightforward profile-edit-benchmark loop overnight. It profiles the model, extracts bottlenecks, edits Triton or CUDA C++, keeps or reverts each candidate, and verifies the final model end to end.

The project documents a fixed benchmark with five stages of correctness checking and a roofline report. That fixed harness is important because an open-ended coding agent is otherwise free to improve the score by changing the test instead of the kernel. AutoKernel's loop gives each candidate the same trial and retains only measured improvements.

The planning rate is easy to budget. The documentation estimates about 90 seconds for an experiment, about 40 experiments per hour, and about 320 overnight. Those are planning numbers, not guaranteed throughput. The repository also describes 50 to more than 300 experiments per KernelBench problem across a set of more than 250 problems. AutoKernel documents the current loop and requirements.

Hardware breadth is a genuine advantage. Tested NVIDIA targets include H100, A100, and RTX 4090. Version 1.3 added AMD ROCm support for MI300X, MI325X, MI350X, and MI355X. The tool requires Python 3.10 or newer and uv, and it documents nine kernel types.

The evidence limit is just as important: the public README describes the harness, workflow, and campaign scale, but it does not publish a current independent aggregate benchmark across all supported targets. That does not make AutoKernel weak. It means the honest buying case is deployability and experiment design, not a leaderboard victory.

Best for: Teams that want a legible overnight loop with broad agent compatibility

Standout: Simple keep-or-revert experiments plus final end-to-end verification

Pricing: $0 software under the MIT license; coding-agent and GPU usage are separate, verified 16 August 2026

Free trial: Not applicable

AutoKernel is the sensible first pilot for a team that already trusts its coding agent and needs the missing experimental discipline. Choose it over KernelAgent when overnight throughput and agent choice matter more than an NCU-driven multi-agent design. Choose it over AKO when the team wants a lighter loop or needs the listed ROCm targets. Do not choose it because 320 experiments sounds automatically better than 40; search quality depends on the harness, candidate diversity, and baseline.

4. Apex: best dedicated AMD ROCm route

Apex is the best dedicated choice for optimizing supported AMD ROCm workloads. This is AMD-AGI's agentic optimizer, not NVIDIA Apex, and its operating assumptions are explicitly tied to AMD Instinct hardware.

The default target is MI355X, with stated support for MI300X, MI300A, and MI250X. The environment requires Ubuntu 22.04 or newer, Python 3.10 or newer, Node.js 18, and ROCm 6.x or newer for grading. The current setup installs a ROCm 7.2 PyTorch wheel. Apex can orchestrate Claude Code, Codex, or Cursor, but it does not bundle model access. The Apex repository lists the current target and setup boundaries.

The workflow is production-minded. Apex benchmarks the workload, identifies a bottleneck, asks the agent for an optimization, grades it with Magpie, integrates candidates above 1.05x, and finishes with an end-to-end benchmark. It can hotpatch Python or Triton paths in aiter, vLLM, and SGLang, as well as aiter HIP. It cannot hotpatch system C++ libraries or monolithic _C.so extensions. That wall matters more than its agent list: if the bottleneck lives behind an integration surface Apex cannot replace, the campaign cannot reach it.

The vendor validation contains seven kernels. It reports 36.35x for all_reduce, 1.14x for fused_moe, 1.05x for rms_norm, and 1.00x for the remaining four. Treat the 36.35x case as a useful result on one kernel, not as the expected portfolio return. The four unchanged kernels show that the acceptance threshold can correctly leave code alone.

Best for: AMD Instinct teams whose bottleneck is reachable through a supported ROCm hotpatch path

Standout: Agentic optimization and end-to-end grading designed around ROCm

Pricing: $0 software under the MIT license; model access and AMD GPU compute are separate, verified 16 August 2026

Free trial: Not applicable

Apex becomes the top recommendation as soon as the production target is a supported AMD accelerator and the hot code is inside its patchable surface. AutoKernel version 1.3 is the alternative when broader campaign mechanics or its listed MI300X through MI355X route fit better. Neither choice should be made from the word "AMD" alone; check the exact accelerator, ROCm stack, and integration point.

5. CUDA Agent: best research ceiling, not the buying choice

CUDA Agent is the most interesting research system in this comparison and the weakest procurement choice. The ByteDance Seed and Tsinghua University project trains a system with reinforcement learning for CUDA work and releases a 6,000-example dataset, a coding-agent skill, and an agent work directory.

The authors describe it as the first reinforcement-learning-trained system for CUDA development. Their KernelBench evaluation reports a 98.8% overall pass rate, 96.8% of problems faster than torch.compile, and a 2.11x geometric-mean speedup versus torch.compile. On Level 3, they report a 94% pass rate, 90% faster than torch.compile, and a 1.52x geometric-mean speedup. The CUDA Agent project page provides the benchmark setup.

The setup is substantial: up to 128,000 context tokens, 150 training turns, and 200 evaluation turns. A candidate needed to beat torch.compile by more than 5%, pass five-input correctness, leave protected scripts alone, and operate without web retrieval. Those controls make the published result more informative than an unguarded coding-agent demo.

The buying wall is concrete. The project site and public repository do not list downloadable model weights or a managed endpoint. A dataset and skill can inform your own system, but they are not the trained product described by the headline result. Until the actual model or service is available, CUDA Agent is a research reference rather than a deployable optimization vendor.

Best for: Researchers studying agent training, CUDA trajectories, and KernelBench evaluation

Standout: Published reinforcement-learning setup and strong author-reported KernelBench result

Pricing: Not sold; public research artifacts are available, with no commercial tier listed as of 16 August 2026

Free trial: Not applicable

Keep CUDA Agent on the technical watchlist and use its evaluation discipline as a standard for other claims. Do not put it into a procurement comparison as if a team can buy the reported model today. That distinction is the difference between citing a research ceiling and inventing a product.

Who should pick what

Choose AKO if you run NVIDIA, can use Claude Code, and want the strongest disclosed campaign and audit machinery. It is especially compelling when you have a family of important kernels, repeated optimization rounds, and enough potential savings to justify preserving trajectories across runs.

Choose KernelAgent if your team lives in PyTorch and wants the optimizer's next move grounded in NCU metrics and roofline classification. It is the most natural choice for supported NVIDIA or Intel XPU work where engineers want to understand the hardware bottleneck, not merely accept a faster candidate.

Choose AutoKernel if you need a smaller operational step: connect an existing coding agent, profile the model, and run a fixed sequence of experiments overnight. It is also the flexible middle route when Codex matters or a listed AMD Instinct target makes AKO or KernelAgent a poor fit.

Choose Apex if the workload is on supported AMD Instinct hardware and the bottleneck lives in a patchable aiter, vLLM, SGLang, or HIP path. On AMD, this hardware match outweighs AKO's broader published campaign evidence.

Choose CUDA Agent only for research, replication planning, or evaluation design until trained weights or a managed endpoint become available.

The explicit flip is hardware first, integration surface second, verifier third, benchmark fourth. The model name comes later. If two systems survive those filters, prefer the one that exposes the denominator, failure ranges, and end-to-end result. A lower but comparable improvement is more valuable than a spectacular number attached to the wrong baseline.

For the broader question of selecting the orchestration layer around a specialist harness, the AI agent platform comparison covers the surrounding tradeoffs. Keep that decision separate from the kernel loop itself.

The real cost: use a $299.99 pilot, then demand payback

The open-source price tag is the least important cost line. A real campaign combines accelerator time, agent access, compilation and profiling overhead, and expert review.

Modal's live price for an NVIDIA B200 was $0.001736 per second, or $6.2496 per hour, when checked on 16 August 2026. Its Starter tier is $0 per month plus compute, includes a $30 monthly compute credit, and has three seats. Team is $250 per month plus compute, includes a $100 monthly compute credit, and has unlimited seats. Enterprise lists custom compute pricing. Modal publishes the current rates.

That makes 32 B200 hours $199.99. Add a $100 agent plan and the first campaign budget is $299.99 before engineer time. The cap is intentionally small enough to kill a weak idea and large enough to run more than a token demo.

Current agent access offers several planning anchors. ChatGPT Plus is $20 per month. ChatGPT Pro offers a $100 option at 5x Plus usage and a $200 option at 20x Plus usage; both include Codex. Claude has a $0 Free tier, Claude Pro at $17 per month with annual billing paid as $200 upfront or $20 with monthly billing, and Max at $100 for 5x or $200 for 20x. Claude Pro includes Claude Code. These were verified 16 August 2026 from OpenAI's Plus information, OpenAI's Pro information, Anthropic's pricing page, and Anthropic's plan guide. API billing can differ, so keep model-token cost separate from GPU compute; the cheapest AI API guide explains that layer.

Now put the pilot against a production bill. One B200 running 720 hours at the current list rate costs $4,499.71. If the target kernel consumes 25% of the workload and becomes 2x faster, the whole workload saves 12.5%, or $562.46 per month. The $299.99 pilot pays back in about 16 days.

If the kernel consumes only 5%, the same 2x kernel improvement saves 2.5%, or $112.49 per month. Payback stretches to about 80 days. The optimization result is identical; the business result is not.

The calculation is deliberately conservative in one way and incomplete in another. It treats list-price accelerator time as the saving base, but it does not include engineer time, model-token variability, compilation overhead, reserved-capacity discounts, or utilization changes. Replace every input with your actual bill before approving a longer campaign.

How these AI GPU optimizers were picked

This is a live documentation and evidence comparison, not a claim that all five systems were installed and exercised on identical hardware. That is why the title says Compared, not Tested. Each included system had to provide a concrete agent or harness path for GPU-kernel work, a public first-party description, and enough implementation detail to identify who should use it and where it stops.

The ranking uses six criteria:

• Deployability: Can a builder obtain and run the relevant system now?
• Hardware fit: Does it explicitly support the target accelerator and software stack?
• Correctness hostility: Does the harness resist cached answers, edited tests, narrow shapes, and weak tolerances?
• Benchmark denominator: Is the baseline named, and are failures or unchanged cases visible?
• End-to-end validation: Does the workflow return to the actual model or service after the isolated kernel improves?
• Cost legibility: Can a team put a bounded GPU and agent budget around the first campaign?

The ranking does not average vendor multipliers. It rewards evidence quality, operational fit, and the chance of turning a local benchmark into a verified production saving. That is why AKO's 1.14x to 1.43x production-breadth results can matter more than a much larger isolated number, and why CUDA Agent's 2.11x KernelBench result does not overcome the absence of a deployable model.

No partner from the site's active commercial pool belongs naturally in GPU-kernel optimization. Inserting a phone, CRM, training, accounting, or website tool here would make the page less trustworthy. The roundup therefore uses no affiliate placement and ranks only the relevant systems.

The ones to avoid

Avoid KernelAgent for AMD ROCm. Its current support list includes NVIDIA CUDA and Intel XPU, not AMD ROCm. A profiler-guided design cannot compensate for an unsupported runtime.

Avoid AMD-AGI Apex for NVIDIA work. The Apex discussed here is built for ROCm and AMD Instinct. It is also not NVIDIA Apex, the separate mixed-precision and distributed-training project. Resolve the entity before assigning engineering time.

Avoid CUDA Agent as a managed production purchase. Its dataset, skill, and working artifacts are public, but the trained weights and an endpoint are not listed. Study it; do not budget it as a service that exists.

Avoid AKO when Claude Code is not an approved dependency. AKO's current harness is valuable precisely because it constrains an existing agent, but that agent fit is still a procurement and security dependency.

Avoid AutoKernel when the decision requires an independent aggregate benchmark before a pilot. Its public material explains the loop and supported targets well, but it does not supply a current independent aggregate result across those targets. Run the bounded pilot or choose a system with evidence closer to your requirement.

Most of all, avoid bare Claude Code or Codex sessions presented as a complete optimizer. Both can write and revise kernels, and AutoKernel or Apex can orchestrate them, but the product is the surrounding profiler, immutable reference, correctness tests, benchmark timing, keep-or-revert logic, and deployment check. Without that harness, the agent is an enthusiastic kernel author grading its own exam.

Frequently asked questions

Can Codex optimize CUDA and Triton kernels?

Yes. AutoKernel explicitly works with Codex for Triton or CUDA C++ optimization, and Apex can orchestrate Codex on supported AMD ROCm work. Codex alone is not the full optimization system; it needs a profiler, protected correctness harness, benchmark, and keep-or-revert loop.

Is KernelAgent better than AutoKernel?

KernelAgent is better when a PyTorch-native loop, NCU metrics, and roofline-guided NVIDIA or Intel XPU tuning are the priority. AutoKernel is better when you want a simpler overnight loop, broader agent choice, or its listed NVIDIA and AMD Instinct targets.

Does Apex optimize NVIDIA GPUs?

No. AMD-AGI Apex is a ROCm optimizer for supported AMD Instinct hardware. Do not confuse it with NVIDIA Apex, which is a different project and not the agentic optimizer ranked here.

What is the best AI agent for AMD GPU optimization?

Apex is the first dedicated choice for a supported AMD Instinct workload inside its patchable integration surface. AutoKernel version 1.3 is the broader alternative for MI300X, MI325X, MI350X, and MI355X.

How should KernelBench scores be compared?

Attach the hardware, task level, baseline, pass definition, correctness inputs, and geometric-mean method to every score. A result versus torch.compile is not interchangeable with one versus an expert implementation or a rough contest baseline.

Is a GPU kernel agent worth it for a small team?

It can be, if profiling shows one kernel owns enough of a recurring accelerator bill. Use the $299.99 pilot and the hot-kernel payback gate; stop when the measured end-to-end saving cannot repay the work inside your target window.

The Monday move

Do not install all five systems. On Monday morning, profile one representative production workload and write down the hottest kernel's share of total runtime. Then select one path: AKO for an audited NVIDIA campaign, KernelAgent for a PyTorch and hardware-counter loop, AutoKernel for a lighter overnight search, or Apex for supported AMD ROCm.

Cap the first experiment at 32 B200 hours plus a $100 agent plan, or the equivalent on your hardware. Freeze the reference implementation and benchmark. Add fresh-value correctness checks. Require the winning kernel to survive outside the agent's own loop and move the full workload, not merely its microbenchmark.

The shipping rule is one sentence: no measured end-to-end payback, no second campaign.