What Happens When You Give an AI Agent a Blackwell GPU and Seven Days

When AI Agents Start Optimizing GPUs Themselves: Lessons from NVIDIA's AVO Paper

Last week, NVIDIA quietly posted a paper on arXiv. The title was unremarkable, the methodology not entirely novel. But the experimental results pointed to something genuinely interesting: an LLM-powered AI agent, running autonomously on a Blackwell B200 GPU for seven consecutive days, produced attention kernels that outperformed NVIDIA's own closed-source cuDNN library — by 3.5%. Against the current state-of-the-art open-source implementation, FlashAttention-4, the margin was 10.5%.

3.5% doesn't sound like much. But to understand what that number means, you need to understand what the denominator is.

Attention Kernels: A Domain Already Pushed to Its Limits

Attention computation is the core operation of the Transformer architecture, and one of the most heavily optimized GPU kernels in existence. Since Tri Dao introduced FlashAttention in 2022, this domain has gone through multiple rounds of iteration — FlashAttention-2, 3, and finally FlashAttention-4, specifically optimized for the Blackwell architecture. NVIDIA's own cuDNN library integrates deeply customized optimizations for each generation of hardware.

In other words, this is a domain where human engineers have squeezed performance nearly to the physical limits of the hardware. Pushing even 1% further requires extraordinarily deep understanding of GPU microarchitecture — warp scheduling, register allocation, memory barrier semantics — and extraordinarily patient iterative tuning.

AVO delivered its results against that backdrop.

From "LLM Generates Code" to "Agent Evolves Autonomously"

The framework proposed in this paper is called Agentic Variation Operators (AVO). To understand why it matters, you need to place it within the research lineage of evolutionary search.

In my earlier analysis of Google's AlphaEvolve-class methods, I noted that the combination of LLMs and search algorithms had already demonstrated the potential to surpass human experts in scientific discovery and software optimization. But in those approaches, the LLM's role was fundamentally that of a "candidate generator" — embedded within a predefined pipeline where the framework decided when to invoke it, what inputs to feed it, and how to evaluate its outputs. The LLM generated. It did not think.

EVO vs. AVO comparison

source: NVIDIA, "AVO: Agentic Variation Operators for Autonomous Evolutionary Search", arXiv:2603.24517

AVO inverts that relationship. The LLM is no longer a component within the pipeline — it becomes the pipeline itself. Specifically, AVO replaces the "variation operator" in traditional evolutionary search — the mechanism that generates new candidate solutions from existing ones — with a fully autonomous AI agent. This agent independently decides which documentation to consult, which historical versions' performance bottlenecks to analyze, what code modifications to implement, what tests to run, and how to diagnose and correct failures when tests don't pass.

This is not a subtle distinction. In FunSearch and AlphaEvolve, search strategy, population management, and evaluation protocols are all controlled by human-designed algorithms; the LLM simply generates a piece of code when asked. In AVO, the agent has complete autonomy over the entire optimization loop — it sets its own strategy, executes, evaluates, and adapts.

AVO agent loop

source: NVIDIA, arXiv:2603.24517

7 Days, 40 Versions, 500 Directions

The experimental setup for AVO on the Blackwell B200 was straightforward: starting from a seed kernel, let the agent run continuously for seven days with the goal of maximizing multi-head attention (MHA) forward-pass TFLOPS throughput. The agent had access to the CUDA programming guide, PTX ISA documentation, Blackwell architecture specifications, and FlashAttention-4 source code.

After seven days, the agent submitted 40 kernel versions that passed correctness verification. But those 40 were just the tip of the iceberg — internally, the agent explored over 500 candidate optimization directions, the majority abandoned due to correctness failures or performance regressions. This scale of systematic exploration — each direction involving reading documentation, implementing changes, compiling, testing, and profiling — far exceeds what any human engineer could accomplish in the same timeframe.

Evolution trajectory of AVO on causal attention

source: NVIDIA, arXiv:2603.24517

The evolution trajectory itself is telling. Performance improvements were not linear and gradual but followed a staircase pattern of plateaus punctuated by discrete jumps. The five largest performance leaps corresponded to architectural breakthroughs: introducing QK-PV interleaving with bitmask causal masking, restructured single-pass softmax computation, branchless accumulator rescaling with lighter memory barriers for unmasked iterations, correction/MMA pipeline overlap, and register rebalancing across warp groups. Earlier versions (v1 through v20) captured the major coarse-grained gains, while later versions continued to extract marginal improvements through increasingly fine-grained microarchitectural tuning.

This pattern — capturing structural optimizations first, then polishing details — is precisely how senior GPU kernel engineers work.

The Final Scorecard

Under the standard configuration of BF16 precision, head dimension 128, and 16 heads, AVO's evolved MHA kernel reached a peak throughput of 1,668 TFLOPS on causal attention — 3.5% above cuDNN and 10.5% above FA4.

MHA forward-pass throughput on B200

source: NVIDIA, arXiv:2603.24517

The transferability test was perhaps even more interesting. When prompted to adapt its MHA optimizations to grouped-query attention (GQA) — the attention variant actually used by mainstream models like Qwen3 — the agent completed the autonomous adaptation in just 30 minutes. The resulting GQA kernel achieved a 7.0% improvement over cuDNN and 9.3% over FA4. This suggests the agent's discovered optimizations were not configuration-specific overfitting, but reflected genuine understanding of the underlying hardware.

What the Agent Actually Found

The paper's dissection of three key optimizations is the most compelling section, because it demonstrates the agent was performing deep optimization requiring joint reasoning across multiple hardware subsystems — not superficial code transformations.

The first was branchless accumulator rescaling. In the online softmax algorithm, when the running row maximum changes, the output accumulator must be rescaled. The prior implementation used a conditional branch to skip unnecessary rescaling, but the branch itself introduced warp synchronization overhead and prevented the use of lighter-weight memory barriers. The agent replaced the conditional branch with a branchless speculative path — always computing the rescaling factor but substituting 1.0 when rescaling wasn't needed. This eliminated warp divergence and enabled the substitution of blocking memory barriers with non-blocking ones. This single optimization alone delivered a +8.1% throughput improvement on non-causal attention.

The second was correction/MMA pipeline overlap. In FlashAttention-4's dual Q-stage pipeline, the correction warp had to wait for both PV GEMMs to complete before beginning its work. The agent restructured the pipeline so the correction warp could begin immediately after the first GEMM, running in parallel with the second.

The third was register rebalancing across warp groups. Through profiling, the agent discovered the correction warp group was spilling values to slower local memory due to insufficient registers, while the softmax group had register headroom to spare. It reallocated 8 registers from the softmax group to the correction group (increasing from 80 to 88), eliminating register-spill stalls on the critical path.

Each optimization looks straightforward in isolation. But arriving at them required simultaneous reasoning about the interplay between synchronization mechanisms, memory ordering semantics, pipeline scheduling, and register allocation. That cross-subsystem joint reasoning is what makes this paper worth taking seriously.

What It Means for Investors

Zooming out, this paper sits along a research trajectory that is advancing at a measurable pace. From Google's FunSearch to AlphaEvolve to NVIDIA's AVO, the capability frontier of agentic coding keeps pushing forward. The difference is this: FunSearch and AlphaEvolve demonstrated that LLMs can generate useful candidates within a search loop; AVO demonstrates that when you give an agent sufficient autonomy, tools, and time, it can continue to find valuable improvements in domains where human experts have already optimized deeply.

For NVIDIA itself, this creates a positive feedback loop. If AI agents can autonomously optimize GPU kernels, then better GPUs → stronger agents → better kernel optimization → the effective performance ceiling of existing hardware gets pushed higher still. In my earlier analysis of NVIDIA's system-level architecture, I discussed how the Vera Rubin platform achieves compute leaps through hardware co-design. AVO reveals a complementary path: extracting additional performance from existing hardware through agentic software optimization.

This also echoes the trend I identified in my analysis of Cadence's ChipStack — agentic AI is entering engineering domains that have traditionally demanded deep expertise, extensive iteration, and sustained human effort. Chip design is one such domain. Kernel optimization is another.

That said, calibrated expectations are warranted. AVO currently operates in a single-lineage setup, without population-level branching or archive management. The paper is candid that the agent encounters stalls and unproductive cycles, requiring self-supervision mechanisms to intervene. And while the 3.5% advantage over cuDNN has been ablation-verified, reproducibility across different system configurations (driver versions, thermal conditions, clock frequencies) would benefit from additional data.

The question worth tracking going forward: as AVO scales from single-lineage evolution to population-level parallel search, as the underlying LLM capabilities continue to improve, and as this approach is applied to GPU workloads beyond attention kernels — how large could the compounding improvement space be?

This paper doesn't offer a definitive answer. What it offers is a directional signal: AI autonomously optimizing AI infrastructure is no longer a hypothetical proposition.