An Agent Begins Where a Model's Answer Ends
What turns a language model into an autonomous agent? NVIDIA's AVO achieved a 100.00 score on ARC-AGI-3 and explored more than 500 GPU optimization directions over seven days.
An Agent Begins Where a Model’s Answer Ends
There is a temptation to measure artificial intelligence by individual answers. The model writes code, solves a problem, recognizes an image, or produces a plan. Everything looks convincing until the work stretches across several hours or days. Then a simple fact becomes clear: a good answer does not necessarily mean good work.
In a long-running task, the value of a system depends on what happens between its answers. Did it preserve previous decisions? Did it understand why an experiment failed? Can it return to a working state after an error? Can it notice that its twentieth attempt is repeating the first one? This is where the line appears between a model that generates text and an agent that actually moves work forward.
That line is visible in NVIDIA’s Agentic Variation Operators project, or AVO. In a NVIDIA publication dated August 21, 2026, the architecture is described as a system that gives a language model memory, tools, feedback, and a separate supervisory loop.[1] The researchers are testing more than the model’s intelligence. They are testing how that intelligence is organized around a task.
AVO was first applied to GPU-kernel optimization. This is almost a perfect test of autonomy. Source code can be changed in a second, but it is impossible to know in advance whether a small modification will improve speed, break correctness, or behave differently with another set of parameters. The agent therefore has to act like an engineer: inspect the implementation, form a hypothesis, run tests, examine the profile, preserve successful versions, and discard weak ones.
In the described experiment, the system worked continuously for seven days, explored more than 500 optimization directions, and produced 40 committed kernel versions. On NVIDIA DGX B200 systems, the best results were up to 3.5% better than cuDNN and up to 10.5% better than FlashAttention-4 across the evaluated configurations.[1] The acceleration figures matter, but they are not the most interesting part. More important is that the agent continued the engineering loop without a human prescribing every next command.
The same architecture was later connected to ARC-AGI-3, an interactive benchmark built around unfamiliar game-like environments. The agent receives no rules, stated objective, or ready-made instructions. It sees a set of possible actions, tries them, observes the consequences, and gradually develops a working understanding of what is happening. A task like this quickly destroys the illusion that a single long response from a powerful model is enough.
AVO completed all 183 levels across 25 public environments and achieved an RHAE score of 100.00. The system required 6,624 environment actions. In the comparison presented by NVIDIA, another implementation using the same Claude Opus 5 model required 7,542 actions, approximately 12% more.[1] The result is impressive, but it should not be treated as a clean experiment isolating the contribution of AVO’s memory. The systems differed in interface design, context management, internal agent loops, and other implementation details.
That qualification makes the result more interesting, not less. This is not a magical coefficient that suddenly adds 70 percentage points to a model’s capability. A complete agent system changes how existing capabilities are used. Memory reduces repeated exploration. Tools connect reasoning to action. Supervision can detect stagnation. Feedback turns failure into material for the next hypothesis.
A good agent resembles less a genius who only needs to open a door and more a research laboratory. The laboratory has an operator, an experiment log, measurement instruments, and someone who can stop a meaningless sequence of tests. Remove any of these elements and the system may start forgetting, repeating itself, or moving confidently in the wrong direction.
I keep seeing the same effect when working with agents for analysis and development. Even a strong model quickly loses the thread when every new run starts from a blank page. It has to reread files, reconstruct earlier decisions, and guess why the previous approach failed. When the state of the task is preserved separately, the quality of the work changes more noticeably than it does after another attempt to find the perfect prompt.
This leads to an uncomfortable conclusion for the AI market. Comparing models only through single-response tests is becoming less sufficient. Real work depends on recovery speed, the cost of an incorrect action, the ability to use external tools, and stability across a long chain of intermediate decisions. A model may solve one level brilliantly and still fail a twenty-minute session because it forgets what it has already discovered.
AVO demonstrates something important: generality can come from the organization of a process, not only from accumulating more knowledge. GPU optimization and the exploration of an unfamiliar game environment have little in common at the level of subject matter. Yet both tasks rely on the same loop: form a hypothesis, take action, gather evidence, update the model of the problem, preserve the result, and continue.
The model remains the center of an agent, but it is no longer the agent’s complete biography. The model proposes the next step. The architecture decides whether that step will be connected to previous work, tested against reality, and placed inside a longer sequence of actions.
If we want to see genuinely autonomous systems, perhaps we should ask a different question. Instead of asking how intelligent the model is, we should ask what helps it preserve the meaning of a task an hour later.
Source: NVIDIA Technical Blog, “NVIDIA AVO Reaches 100% on ARC-AGI-3,” August 21, 2026.[1]