Most AI agent frameworks are built from a tangle of prompt templates, tool schemas, callback functions, and workflow graphs, each piece maintained separately and rarely playing well with the others. Nvidia researchers Ricardo Silveira Cabral and Paul Furgale published a technical report on July 27, 2026, proposing something considerably simpler: build an agent as a single Python class, and let ordinary software engineering tools handle the rest.

They called the result NOOA, short for Nvidia Object-Oriented Agents, and released it as a free, open-source package under an Apache 2.0 license. The installable version, v0.0.8, shipped on July 30. Anyone running Python 3.12 or 3.13 can install it with a single pip command.

An Agent Is Now Just One Class

The core idea collapses agent development into a format every working developer already understands. In NOOA, a method represents an action the agent can take. A field holds the agent's state. A docstring functions as the prompt guiding that specific action. Type annotations become contracts the runtime actually enforces rather than suggestions a model might ignore. A method whose body is written as an ellipsis gets completed at runtime by an LLM-driven reasoning loop, while a method with ordinary code inside stays fully deterministic, no model involved at all. Developers and the AI model itself end up sharing one interface, which means agent behavior can be tested, version-controlled, and refactored using the same tools teams already use for regular software, rather than a separate, harder-to-inspect layer built specifically for AI.

Nvidia's technical report identifies six specific interface capabilities it claims to be the first framework to combine on a single surface: typed input and output, passing live objects by reference instead of copying data into a context window, treating code itself as an action the model can take, programmable control over how the reasoning loop runs, explicit object state the model can read and modify directly, and model-callable APIs for handling context and events.

The Benchmark Numbers Behind the Design

Nvidia backed the architecture with real benchmark comparisons. On SWE-bench Verified, a widely used software engineering benchmark, a 253-line general-purpose NOOA agent running GPT-5.5 reached 82.2% accuracy, ahead of the previous published state of the art at 79.2%, and ahead of comparison harnesses OpenCode at 78.6% and PI at 78.2%. Running the same framework with Anthropic's Opus 4.6 reached 79.8%, a useful data point for anyone comparing agent harnesses across different underlying models rather than assuming performance comes from the model alone. That comparison matters more now that Anthropic's own Claude Opus 5 has specifically targeted agentic coding performance as its core selling point, since it shows how much of an agent's real-world score depends on the harness wrapped around a model, not just the model's raw capability.

On Terminal-Bench 2.0, a command-line focused benchmark, NOOA reached 73.0% at high effort, though a competing harness called PI edged ahead at its maximum effort setting with 75.3%. In cybersecurity specifically, NOOA solved 86.8% of tasks on CyberGym L1, a vulnerability discovery benchmark, running with network access deliberately blocked so results reflect genuine reasoning over code rather than looking up already-known, disclosed vulnerabilities. Nvidia describes that CyberGym result as the top open-source score recorded, ahead of most closed-source competitors on the same benchmark.

Where NOOA Actually Wins: Cost, Not Just Accuracy

The more consequential number sits underneath the accuracy figures. NOOA reached its SWE-bench Verified score using roughly 1.1 million tokens and about 29 model calls per task, compared to 2.2 million tokens and 66 calls for the PI harness to reach a lower score. That's not a marginal efficiency gain. It's close to half the operating cost for a better result, achieved specifically because NOOA's design lets agents pass references to live objects rather than repeatedly copying large chunks of data back into the model's context window, and because it avoids the context compaction techniques other harnesses need to manage that repeated copying. For any organization running agents at real production scale, where token costs compound across thousands of daily tasks, that efficiency gap is arguably a bigger practical story than the accuracy numbers themselves.

Why Nvidia Gave This Away for Free

NOOA didn't launch in isolation. Nvidia specifically contributed the framework to the Open Secure AI Alliance, the industry coalition it formed in late July alongside Microsoft, SpaceX, and more than thirty other companies in direct response to a wave of AI containment failures that month. Paul Furgale explained the reasoning on LinkedIn, writing that the future of open AI depends on more than open models. Nvidia's stated position is that studying how models actually interact with computers, not just what the underlying model can theoretically do, deserves the same open, community-driven scrutiny that open-weight models themselves have gotten.

The Review That Wasn't All Praise

Independent evaluation of NOOA, published August 9 by the developer publication Wavect, offered a useful counterweight to Nvidia's own framing. The review found NOOA genuinely worth piloting for Python teams needing direct live-object access and explicit state control, but was blunt about a specific limitation: NOOA is not a production security boundary. Because model-written Python code runs directly inside the agent's own process, any real deployment still needs separate operating-system-level isolation, tightly scoped credentials, ongoing evaluation, and human approval steps layered on top, the same containment discipline Cloudflare built into its own newly launched agent wallet system to keep autonomous spending decisions from running unchecked. Wavect also noted its own review was based on public documentation and Nvidia's published results rather than independently reproducing every benchmark run, a fair methodological caveat for any vendor-authored performance claim, including Nvidia's own.

What This Says About the Next Phase of the Agent Race

NOOA's real significance isn't really about winning a specific benchmark leaderboard, since Nvidia's own data shows a rival harness beating it on at least one test. It's about where the AI industry's competitive attention is shifting. For the past two years, most of the public focus in agentic AI has centered on which underlying model reasons best. NOOA's benchmark results, especially the token-efficiency gap, make a specific and testable claim: the software architecture wrapped around a model, the harness, can matter as much as which model sits inside it. If that claim holds up as more teams adopt or challenge NOOA's approach, the next real battleground in agentic AI may not be the model race everyone's been watching, but a quieter fight over who builds the best scaffolding around whichever model a business happens to choose.