NVIDIA NOOA: Why Your Next AI Agent Should Just Be a Python Object

TL;DR

NVIDIA-labs has released NOOA (Object-Oriented Agents), a framework that abandons complex Domain Specific Languages (DSLs) in favor of a radical idea: an agent is just a Python class. By using methods as actions and fields as state, NOOA has shattered benchmarks, achieving 82.2% on SWE-bench Verified and 85.1% on ARC-AGI-3. It proves that when we stop treating agents like prompt-wrappers and start treating them like software, they become significantly more reliable and efficient.

The Problem: The "Framework Tax" on Intelligence

Building AI agents today feels like assembly-line work: you manage prompt templates, JSON schemas for tools, callback code for transitions, and a messy graph for workflows. This "Framework Tax" creates two major issues:

1. Impedance Mismatch: LLMs are trained on vast amounts of clean Python code, yet we force them to communicate via brittle JSON-tool schemas.
2. Context Bloat: Most frameworks serialize every tool output back into the prompt. If your agent queries a 10MB database, the prompt dies.

Methodology: The Architecture of Native Python Agents

NOOA’s brilliance lies in its simplicity. Instead of a "black box" loop, you define a class. Methods with a standard body are deterministic Python; methods with an ellipsis (...) become LLM-driven loops.

1. Code as Action (CodeAct)

Instead of selecting a tool from a JSON list, the agent writes a Python script. It can import libraries, write loops, and call other methods. This allows the model to use its logic to process data before returning a result.

2. Pass-by-Reference & Bounded Previews

This is the "killer feature." If a method receives a list of 1 million items, NOOA doesn't paste them all into the prompt. Instead, it provides a Bounded Preview: records = list(len=1000000, [:5]=[...], [-5:]=[...]) The agent knows the variable records exists in the local namespace and can iterate over it in code without ever seeing the full text.

The NOOA Agent combines state, deterministic code, and agentic loops into one cohesive class.

Experiments: Breaking the SOTA

NOOA was tested across four grueling benchmarks:

• SWE-bench Verified: 82.2% pass rate. It consistently defined the "Accuracy-Cost Pareto Frontier," delivering higher accuracy than OpenCode and PI while using significantly fewer tokens.
• ARC-AGI-3: On this interactive reasoning task, NOOA advanced human-baseline scores to 85.1%.
• CyberGym L1: It became the top-scoring open-source agent for vulnerability discovery and repair.

The Strategy Loop ensures that every LLM turn is validated against a Python type contract.

Deep Insight: Memory as Active Curation

Unlike "Auto-RAG" systems that dump everything into a vector DB, NOOA agents curate their own memory. Using the MemoryManager, agents decide what is "critical" or "trivial." The system uses ACT-R activation (a concept from cognitive science) to rank relevance, recency, and importance.

Our analysis showed that successful agents performed 1.63 deliberate recalls per decision. When agents were restricted to plain markdown files instead of this structured memory, their performance in ARC-AGI-3 dropped by 11.8 points.

Critical Analysis & Conclusion

NOOA represents a maturation of the agent field. By moving away from "prompt engineering" and toward "software engineering with types and objects," NVIDIA has provided a roadmap for building production-grade AI.

Limitations: Currently, NOOA executes code in-process for speed and reference-passing. While this is efficient, it requires robust external sandboxing (like Landlock or seccomp) to ensure the agent doesn't escape its host environment.

The Takeaway: Stop building "Prompt-Chains." Start writing "Agentic Classes." When an agent understands its own state as a Python object, it doesn't just act—it reasons with the precision of a software engineer.