There is a detail that a lot of people overlook when talking about artificial intelligence in practice: the model itself is not everything.
What really makes an agent work for real, especially on longer and more complex tasks, is the system built around it. That system, often called a harness, is what determines how the model receives context, how it uses tools, how it maintains state, how it responds to feedback, how it recovers from failures, and how it sustains progress across tasks that take hours or even days. The choice of how to orchestrate decisions, how to maintain context across long runs, and how to explore alternative paths without getting stuck in an endless loop matters just as much as the weights of the model running underneath.
That is exactly what NVIDIA demonstrated in a pretty compelling way with AVO, the Agentic Variation Operators, a general-purpose autonomous agent that just hit the 100% mark on ARC-AGI-3, one of the most challenging benchmarks out there today for measuring interactive and autonomous reasoning. And the most interesting part is that this architecture was not born in abstract reasoning labs. It was tested and proven first in the brutal world of GPU kernel optimization, running for 7 straight days, exploring over 500 optimization directions, and generating 40 kernel versions, ultimately surpassing well-established libraries like FlashAttention-4 by up to 10.5% 🚀
Then, when the same system was pointed at a completely different benchmark — no instructions, no defined rules, no explicit goals — the results followed the same trajectory. Here you will understand how AVO works, what it did on ARC-AGI-3, and why this matters well beyond the numbers.
What is AVO and why it is different
AVO, short for Agentic Variation Operators, is an autonomous agent architecture for coding developed by NVIDIA with a very specific goal in mind: solving long-duration problems that require continuous exploration, hypothesis revision, and constant strategy adaptation. Like modern coding agents, AVO can inspect and edit code, run commands, look up documentation, and validate its own work through execution. But what truly sets it apart is its focus on sustained autonomous operation over very long time horizons.
The core logic of AVO lies in what are called variation operators. In the GPU optimization work, AVO replaces the predefined variation step of conventional evolutionary search systems with an autonomous agent that decides on its own how to generate the next candidate — what to inspect, what to change, what to test, and what to commit. In practical terms, it is like having a researcher who, instead of following a fixed script, is constantly asking: what if I tried something different here? And then actually tests that variation, measures the result, and decides whether to keep going down that path or abandon it. This ability to self-revise in real time is what separates AVO from most agents on the market today.
Receive the best innovation content in your email.
All the news, tips, trends, and resources you're looking for, delivered to your inbox.
By subscribing to the newsletter, you agree to receive communications from Método Viral. We are committed to always protecting and respecting your privacy.
It is also worth noting that AVO was not built for a specific domain. It is described as a general-purpose agent, which means the architecture does not assume what kind of problem it will encounter. When NVIDIA wanted to test it on ARC-AGI-3, they just connected the same agent to a different task interface. The agent underneath remains exactly the same — only the environment-specific tools and the evaluation method change. This is technically hard to achieve, because specialized agents tend to perform much better in their domains precisely because they were tuned for that context. AVO bets on a different approach: instead of optimizing for one type of task, it optimizes for the ability to explore any type of task.
Persistent memory and supervision: the two pillars
Two mechanisms are especially important for AVO to maintain progress beyond a single model context window: persistent memory and supervision.
Persistent memory carries forward previous implementations, evaluation results, compiler and profiler outputs, along with the reasoning accumulated throughout the process. This allows the agent to pick up work from the current state rather than rebuilding the search from scratch over and over. The supervisor, on the other hand, monitors the broader trajectory, keeping an eye out for stagnation or unproductive cycles that repeat, and can redirect the main agent toward alternative strategies when needed. During the 7-day run on attention kernel optimization, the main agent remained responsible for deciding what to inspect, change, test, and evaluate, while the supervisor helped maintain progress when the search hit a plateau.
Seven days optimizing GPU: where AVO was forged
Before talking about ARC-AGI-3, it is important to understand where AVO was first tested under serious conditions. NVIDIA put the agent to work on one of the most technical and demanding tasks in the world of high-performance hardware and software: GPU kernel optimization. This kind of task involves rewriting kernels — the programs that run directly on GPU hardware — to squeeze out the maximum possible performance, typically benchmarking the result against reference libraries that have been highly optimized by engineering teams over the course of years.
The search space here is enormous, the performance landscape is hard to reason about directly, and small implementation changes can affect correctness, memory behavior, scaling, and throughput in ways that are nearly impossible to predict without actually running them. Even so, in the attention kernel study, AVO ran for 7 continuous days, explored over 500 different optimization directions, and produced 40 distinct kernel versions.
The results were impressive. Running on NVIDIA DGX B200 systems, the generated multihead attention kernels outperformed cuDNN by up to 3.5% and FlashAttention-4 by up to 10.5% in the configurations evaluated. After that, the agent adapted the evolved kernel for grouped-query attention in roughly 30 minutes of additional autonomous work. For those who are not familiar with the context, FlashAttention is one of the most optimized libraries in the deep learning community, developed by top-tier researchers with years of refinement behind it. Beating that level of performance autonomously is the kind of thing that catches the attention of anyone working with artificial intelligence systems in production.
This experiment was not just a demonstration of technical capability. It served as an extremely tough validation environment for the AVO architecture, reinforcing a systems-level view of agent design: building a reliable stack requires that performance, reliability, and safety be considered across the entire system, not treated as properties of the model alone. The fact that AVO managed to navigate this space efficiently — without getting lost in infinite exploration and without converging too early on poor solutions — was the first solid evidence that the architecture was working as intended. It was the necessary foundation for the next step.
ARC-AGI-3: the benchmark that measures real reasoning
ARC-AGI-3 is an interactive reasoning benchmark created specifically to be hard for artificial intelligence systems. In it, the agent enters unknown, game-like environments with no instructions, no explicit rules, and no stated objective. It needs to explore through interaction, infer the dynamics and goals of the environment, and plan actions efficiently across progressively harder levels. It is precisely this combination of no clear instructions and the need for generalization that makes the benchmark so relevant as a measure of autonomous reasoning.
The evaluation uses a metric called RHAE (Relative Human Action Efficiency), which combines task completion with per-level action efficiency, compared to the performance of humans encountering the challenge for the first time. This performance is aggregated across levels and environments. In other words, solving a single state is not enough: the agent needs to preserve useful knowledge, learn from previous interactions, recover from mistakes, and spend environment actions economically.
Instead of centering the system on an explicit, programmatic world-model construction, as explored by approaches like Tycho, NVIDIA adopted direct interaction principles inspired by VISTA and reimplemented the task interface independently. There is an important detail worth noting about the setup: the model operated in a purely text-based mode. Each observation was delivered as a text grid of exactly 64 x 64, with no images sent to the model at all. And, consistent with the direct interaction setup, the agent received only the available actions, with no description of the rules or goals of the game — it had to infer the effects of each action through interaction itself.
The numbers AVO delivered
When AVO was put to work on the public set of ARC-AGI-3, it did not receive a prompt crafted for that domain. The agent was pointed at the benchmark with the same architecture used for GPU optimization. The result was an RHAE score of 100.00 across all 25 environments in the public set, completing all 183 levels using the Claude Opus 5 model.
And it was efficient too: AVO finished everything in 6,624 environment actions. For reference, VISTA reports 7,542 actions with the same Claude Opus 5 to complete the same 183 levels. That means AVO used approximately 12% fewer actions in this comparison between systems. It is important to be honest here: this should not be read as a controlled experiment, since the two systems differ in agent backend, observation representation, memory, and context management. One difference that may matter over long horizons is precisely the AVO memory system, designed to carry useful understanding forward and reduce repeated exploration.
To add more context, the ARC Prize itself reports around 30% for Claude Opus 5 running on its own with high reasoning effort. The AVO run used the same model family, but in a substantially different agent system and evaluation setup. These numbers should not be interpreted as a direct measure of what AVO contributes — but they illustrate very well that evaluating a model in isolation does not characterize the performance of a complete agent. NVIDIA also tested AVO with GPT-5.6 Sol on a challenging subset of games, suggesting complementary profiles between models, leaving a more systematic comparison for future work.
What AVO performance means in practice
It is natural for impressive benchmark results to generate skepticism, and rightly so. The history of artificial intelligence is full of moments where a system performed well in a controlled setting and ran into serious difficulties when exposed to the real world. But the AVO case has a characteristic that sets it apart from the typical hype-and-disappointment cycle: the same agent architecture transferred from highly specialized GPU kernel optimization to a completely different interactive reasoning task.
In GPU optimization, feedback comes from compilers, tests, profilers, and performance benchmarks. In ARC-AGI-3, feedback comes from environment transitions and action outcomes. The interfaces change, but the cycle is the same: form a hypothesis, act, observe the evidence, update the state, and continue. This suggests that generality may come not only from domain knowledge, but from the very machinery that allows reasoning and feedback to accumulate over time.
For anyone working with systems that depend on autonomous agents in production, what AVO represents is a new way of thinking about how these systems are designed. Long-horizon capability is a property of the entire system: memory determines what survives, tools determine what actions are possible, feedback anchors progress, and recovery allows work to continue beyond a single model invocation. The idea that an agent can explore massive solution spaces efficiently, adapt continuously without intervention, and still converge on high-quality answers is exactly the behavior many teams are trying to achieve with more complex and expensive architectures.
Another point worth noting is the impact on GPU optimization as a field. Having an agent capable of exploring the kernel space autonomously and surpassing results from libraries built by specialized teams could change the pace of development of high-performance tools for deep learning. Historically, this type of optimization required engineers with very specific knowledge of hardware architecture. If agents like AVO can handle part of that work autonomously, the impact goes well beyond NVIDIA — it affects the entire development chain of AI systems that depend on efficient hardware to operate at scale.
At the end of the day, the most important lesson might be the simplest one to sum up: the model matters, but the model is not the entire agent. And understanding that difference may be what separates AI systems that only work in demos from those that actually sustain progress in the real world. 🔥
