NVIDIA NOOA: AI Agents as Native Python Objects

The Problem With Most Agent Frameworks

Ask any developer who has shipped an AI agent to production what they hate most about the process, and you'll usually get the same answer: everything lives in a different place. The prompt is a string template buried in a .txt file. The tools are JSON schemas hand-written to mirror Python functions that already have type hints. The workflow is a graph object built with a DSL that only exists inside the framework. The state is scattered across a message history that keeps growing until you're forced to bolt on a summarization pipeline just to keep the context window from exploding.

NVIDIA Labs just shipped an open-source framework that throws most of that apparatus out. It's called NOOA — NVIDIA Object-Oriented Agents — and its core idea is almost stubbornly simple: an agent is a Python class. Nothing more exotic than that.

An Agent Is Just a Class

In NOOA, you define an agent the way you'd define any other Python object. Fields hold state. Methods hold capabilities. Docstrings double as prompts. Type annotations become enforced contracts instead of decoration.

1from nooa import Agent
2
3class SupportAgent(Agent):
4    """You are a support agent."""
5
6    order_db: OrderDB
7
8    def is_refund_eligible(self, order: Order) -> bool:
9        return order.delivered and order.days_since_delivery <= 30
10
11    async def triage(self, message: str, order: Order) -> Ticket:
12        """Create a typed support ticket."""
13        ...

The trick is in that final method. A method with a normal body — like is_refund_eligible — runs as ordinary, deterministic Python, exactly as you'd expect. But a method whose body is just an ellipsis (...) is handed off to an LLM-driven agent loop at runtime. The signature defines the contract. The docstring is the prompt. Everything else about how the model gets there is the framework's problem, not yours.

That distinction matters more than it looks. It means developers can mix deterministic business logic and LLM-driven reasoning inside the same object, using the same tooling — pytest, git diffs, code review, static type checkers — that they already use for the rest of their codebase. An agent stops being a fragile prompt-engineering artifact and becomes something you can unit test.

Six Ideas Doing the Heavy Lifting

NOOA's design paper (released alongside the framework on arXiv) breaks the approach down into six interface ideas that the NVIDIA Labs team argues account for most of the performance gains:

• Typed input/output — agentic calls take typed arguments and return validated values, not loose free text.
• Pass by reference — the model works on live Python objects and sees bounded previews instead of giant serialized JSON dumps.
• Code as action — the model acts by writing real Python in a Jupyter-style REPL, with actual control flow, not a fixed menu of tool calls.
• Programmable loop engineering — the orchestration loop itself is ordinary Python that both developers and the model can inspect or modify.
• Explicit object state — durable, typed state lives on the agent object itself, not smeared across conversation history.
• Model-callable harness APIs — context blocks and event history are APIs the model can query and manage directly.

The pass-by-reference piece is arguably the most consequential. Instead of round-tripping every tool result through the context window as serialized text, NOOA keeps the full value live in the execution environment and only shows the model a typed, bounded preview. That single design choice is why NOOA reportedly doesn't need a context-compaction or summarization pipeline at all — sessions on SWE-bench Verified peak at 22–72k prompt tokens against 200–400k context windows, and because nothing gets re-serialized, the transcript stays append-only and cache-valid for the whole task.

Memory the Agent Curates Itself

Rather than bolting on an automatic background summarizer, NOOA ships a long-term memory subsystem that the agent actively curates through its own tool calls. Records carry types, importance scores, and tags, and typed relationships — "supports," "contradicts," "derived-from" — link them into something closer to a knowledge graph than a flat log. A background reflection pass merges duplicates, links related records, distills episodes into insights, and prunes what's no longer useful.

Everything lands in a single human-readable SQLite file, so teams can inspect, back up, and audit it with tools they already know. Multiple agents can share one store while keeping separate ownership boundaries — a detail that matters once you're running fleets of agents rather than one chatbot.

The Numbers That Made People Pay Attention

Benchmarks are where NOOA's pitch gets tested, and NVIDIA published the full evaluation trail rather than a highlight reel.

On SWE-bench Verified, NOOA hits 82.2% using GPT-5.5 — above the published leaderboard SOTA at time of submission (79.2%) — and 79.8% with Claude Opus 4.6, using what the team describes as a general-purpose, 253-line agent with no benchmark-specific prompting. Comparison harnesses needed 66 LLM calls and roughly 2.2M tokens per task to reach 78.2%; NOOA got to 82.2% in 29 calls and about 1.1M tokens. Same or better accuracy, roughly half the cost.

On CyberGym L1, a real-world vulnerability rediscovery benchmark, NOOA solved 86.8% of tasks with GPT-5.5 — the top score among open-source agents, ahead of most closed-source systems, with network access blocked and no cybersecurity-specific steering.

On ARC-AGI-3, a benchmark where an agent has to reverse-engineer the rules of an unknown grid game purely by acting and observing, a single NOOA agent reached 50.2% mean RHAE with GPT-5.5, and 85.1% with GPT-5.6-sol at around $13.30 per game — under the $20/game mark across the board. The memory subsystem alone contributed +11.8 points over file-based notes.

A Warning Worth Repeating

NOOA's own documentation is unusually blunt for a framework release: this is research software, and agents can be configured to execute LLM-generated code. The framework validates generated code with AST checks and module deny-lists before execution, but the maintainers are explicit that these are defense-in-depth guardrails, not a containment boundary — open() still gives arbitrary file access, and importlib can load modules from any path. The actual containment boundary has to be OS-level isolation: a container, a VM, or NVIDIA's own OpenShell secure runtime. If you're experimenting with NOOA, don't skip that part.

Getting Started

NOOA installs like any modern Python package, with uv as the recommended path:

1uv init my-agent-project
2cd my-agent-project
3uv add nooa

Optional extras — nooa-cli for a trace viewer and eval runner, nooa-memory for the long-term memory subsystem, and nooa-bench for benchmark tooling — install the same way. Every LLM call, code execution, and method invocation is traced by default, and pointing uv run nooa start-dev at a local port opens a full trace viewer in the browser.

Why It Matters

NOOA arrives at a moment when the agent framework space is crowded with orchestration DSLs, graph builders, and prompt-chaining libraries that each invent their own abstractions. NVIDIA's bet is that developers don't want another DSL — they want their agents to look and behave like the rest of their software. Whether that bet pays off at scale is still an open question; this is a research preview, not a 1.0 release, and the team is explicit about rough edges. But the benchmark numbers, the released code, and the willingness to publish the evaluation methodology alongside the framework make NOOA one of the more substantive open-source agent releases of the summer — worth a serious look for anyone building agents that need to survive contact with a real codebase.

The project is Apache 2.0 licensed and available now on GitHub under the NVIDIA-NeMo organization, alongside the full research paper detailing the design principles and evaluation results.

Related reading

• Nemotron 3.5 Lightning: NVIDIA’s Fast Agent Model
• Qwen3.8-Max: Alibaba’s 2.4T Model for Agentic Coding
• Grok 4.6: Frontier Agents, API Pricing & Benchmarks