If you’ve ever tried to build an AI agent from scratch, you know the drill. You write a prompt template in one file, define tool schemas in another, wire up callback functions somewhere else, and then stitch it all together with a workflow graph that only you fully understand. It works, but it doesn’t feel like writing software — it feels like assembling a machine from mismatched parts. NVIDIA NOOA Python framework

NVIDIA’s research team thinks this fragmentation is the actual bottleneck holding agent development back, and they’ve built something to prove it. Enter the NVIDIA NOOA Python framework — short for NVIDIA Object-Oriented Agents — a new open-source library that compresses the entire agent-building process into a single, ordinary Python class.

No separate prompt files. No YAML tool schemas. No sprawling workflow graphs. Just a class, the way you’d write any other piece of Python code. It sounds almost too simple, but the results NVIDIA is reporting suggest this simplicity is exactly what makes it work.

In this post, we’ll unpack what the NVIDIA NOOA Python framework actually does, how it’s structured under the hood, the benchmark numbers behind the hype, and who should (and shouldn’t) be reaching for it right now.

What Exactly Is NOOA?

NOOA stands for NVIDIA Object-Oriented Agents, and the name is a fairly literal description of what it does. Instead of scattering an agent’s logic across prompts, tool definitions, and orchestration code, NOOA maps every piece of an agent onto a familiar Python construct:

• Methods become actions. Whatever the model is allowed to do — call an API, run a calculation, fetch a file — is written as a method on the class.
• Fields hold state. The agent’s memory of what it has seen and done so far lives in ordinary class attributes.
• Docstrings function as prompts. Instead of maintaining prompt text in a separate template, you write it directly into the method’s docstring.
• Type annotations become enforceable contracts. The runtime actually checks that inputs and outputs match the types you declared, instead of hoping the model returns something sensible.

The clever part is how NOOA handles a method whose body is just an ellipsis (...). When a method is left unimplemented like this, NOOA treats it as an “agentic” method — one that gets completed at runtime by a loop driven by a large language model. But if you give the method a real, working body, it stays completely deterministic Python code, and the model can call it like any other tool. This means a single class can mix genuinely intelligent, model-driven behavior with plain, predictable logic, without needing two different systems to manage them.

Because everything lives in one class, developers and the underlying model are effectively working from the same interface. That has a practical payoff: agent behavior built this way can be unit tested, traced, refactored, and version-controlled using the same habits and tools that Python developers already use for regular software. You’re not maintaining a parallel universe of prompt files that drift out of sync with your code — the prompt is the code.

Two Execution Strategies Under the Hood

The NVIDIA NOOA Python framework ships with two distinct strategies for how an agentic method actually gets executed:

1. PredictStrategy — This is the simpler of the two. It makes a single, typed LLM call and, if the output fails validation against the declared return type, retries locally until it gets something that fits. Good for straightforward, single-shot tasks where you know roughly what shape the answer should take.
2. CodeActStrategy — This is the more powerful option, and it’s where a lot of NOOA’s benchmark performance comes from. It runs an iterative Python REPL loop: the model repeatedly calls an execute_python(...) function to run code, inspect results, and adjust its approach, until it’s ready to call return_result(...). That final result is then checked against the method’s declared return type before it’s accepted.

This REPL-based loop is what gives NOOA agents the ability to work with large, messy, or evolving data without constantly re-describing it to the model in plain text — which brings us to one of the framework’s more interesting design choices.

Pass By Reference: Why NOOA Doesn’t Choke on Large Data

Most agent frameworks have a very literal-minded relationship with data: if the model needs to “see” a variable, that variable gets serialized into text and stuffed into the prompt. Do that with a 10,000-row dataset, and you’ll burn through your context window before the agent gets anything useful done.

The NVIDIA NOOA Python framework takes a different approach, borrowed straight from how object-oriented programming already works: pass by reference. Arguments are handed to the model as live Python objects, not as flattened text. The model only ever sees a bounded preview — the object’s type, its true length, and a small sample from the beginning and end of it. NVIDIA notes that a hundred-element list can be represented in roughly thirty tokens this way, while the full, untouched variable remains available in the REPL for the agent to actually operate on.

On top of this, NOOA splits the agent’s context into three distinct zones: a cacheable static prefix that rarely changes, an append-only typed event history that grows as the agent works, and dynamic blocks that sit at the very end of the context. This structure preserves KV-cache reuse across turns, which is a fancy way of saying the framework avoids redoing expensive computation on parts of the context that haven’t actually changed.

There’s also an optional memory subsystem that can be bolted onto an agent without modifying its code. It exposes seven model-callable tools for writing and recalling information, ranks memories using an activation-based scoring approach borrowed from cognitive science (ACT-R), and stores everything in a single SQLite file that a human can actually open and inspect — no black-box vector database required.

Six Ideas, Combined for the First Time

NVIDIA’s research team argues that no single existing framework combines all six of these capabilities the way NOOA does:

• Typed input and output
• Pass by reference over live objects
• Code as the primary action space
• Programmable loop engineering
• Explicit, inspectable object state
• Model-callable harness APIs

To back this claim, NVIDIA benchmarked NOOA against fourteen other frameworks and harnesses — including well-known names like LangGraph, Google’s ADK, PydanticAI, smolagents, the Claude Agent SDK, OpenAI Codex, and OpenHands — across these same six axes. According to their published comparison, every other framework covers only some of these capabilities, while NOOA is the only one that checks all six boxes at once.

How Well Does NOOA Actually Perform?

Benchmarks are easy to publish and hard to trust, so it’s worth looking at how NVIDIA tested NOOA before getting to the headline numbers.

The team ran 88 capability tests, five times each, across ten different models — 4,400 test runs in total. Of those, 4,309 passed, a 97.9% success rate. A tougher subset focused specifically on batching, error recovery, and task decomposition came in lower at 84.7%, and this subset is where the gap between smaller and frontier-scale models widened considerably — from roughly a 3-point difference to a 23-point difference.

On real-world benchmarks, the numbers get more interesting:

• SWE-bench Verified: A general-purpose, 253-line NOOA agent reached 82.2% using GPT-5.5 at extra-high reasoning effort. For comparison, OpenCode reached 78.6% and PI reached 78.2% on the same benchmark. Using Opus 4.6 instead, NOOA reached 79.8%.
• Terminal-Bench 2.0: NOOA hit 73.0% at high reasoning effort, ahead of the 60.7% and 68.5% scored by comparison harnesses — though PI edged ahead at extra-high effort with 75.3%.
• CyberGym L1: With network access deliberately blocked, NOOA solved 86.8% of tasks, which NVIDIA describes as the strongest open-source result reported on this benchmark.
• ARC-AGI-3: A single NOOA agent equipped with just a one-page world-model skill reached a mean relative human-adjusted efficiency (RHAE) of 50.2% using GPT-5.5, and 85.1% using GPT-5.6-sol — all for under $20 per game played.

What stands out more than the raw accuracy numbers, though, is efficiency. NOOA hit 82.2% on SWE-bench Verified using roughly 1.1 million tokens and about 28 model calls per task. PI, by comparison, needed about 2.2 million tokens and 66 calls to reach a lower 78.2%. NVIDIA’s trace analysis attributes part of this gap to how each system decides a task is finished: OpenCode stops as soon as the model replies without making a tool call, while NOOA requires the agent to submit a typed TaskResult object that includes supporting evidence and a verification command — a small design choice that appears to prevent a lot of wasted, wandering turns.

Is NOOA Actually Safe to Deploy?

Here’s where some healthy caution is warranted. NOOA is released under the Apache 2.0 license and installs easily with pip install nooa — the current version, 0.0.8, was released on July 30, 2026, and requires Python 3.12 or 3.13. But PyPI classifies it as alpha software, and NVIDIA itself describes it as a research preview rather than a production-ready tool.

Because NOOA agents can execute LLM-generated code directly, this matters. NVIDIA is upfront that its AST-based checks and module deny-lists are defense-in-depth measures, not a real containment boundary. If you’re going to run a NOOA agent on anything that matters, the actual safety boundary needs to be a container, a virtual machine, or NVIDIA’s own OpenShell sandbox — not the framework’s built-in guardrails alone.

On the flexibility side, NOOA is model-agnostic thanks to LiteLLM integration, so it works with hosted APIs, locally-run Ollama models, and vLLM endpoints without much friction.

Who Should Actually Try This?

Based on where the project stands today, NOOA looks like the strongest fit for:

• AI-native startups and mid-market platform teams experimenting with internal agent tooling.
• Enterprise AI research and applied research groups running structured evaluations or early pilots.
• Developer tooling, cybersecurity, DevOps, data analytics, financial operations, and customer-support use cases specifically — repository issue triage, terminal automation, vulnerability validation, large-batch data extraction, and multi-agent orchestration are all called out as strong applications.

If you’re running anything regulated or genuinely production-critical, it’s probably worth waiting for a stable release before committing to it — alpha software plus code execution is not a combination you want sitting behind a compliance-sensitive workload.

The Bigger Picture

What makes the NVIDIA NOOA Python framework worth paying attention to isn’t just the benchmark scores — plenty of agent frameworks claim state-of-the-art numbers on one leaderboard or another. It’s the underlying bet: that agent development doesn’t need a new paradigm at all. It needs the same object-oriented discipline that’s shaped software engineering for decades, applied honestly to how we build agents.

Whether that bet pays off at scale remains to be seen — the project is only a few weeks old, and alpha software has a way of surprising you in production. But for developers who’ve felt the friction of juggling prompt templates, tool schemas, and workflow graphs just to get a simple agent running, NOOA’s pitch — write a class, not a pipeline — is hard to ignore.

You can explore the project directly on GitHub under NVIDIA-NeMo/labs-OO-Agents, read the accompanying research paper on arXiv, or check NVIDIA’s technical blog for a deeper walkthrough of the six capabilities discussed above. For anyone building agent systems in Python, it’s worth at least a weekend of experimentation to see whether the single-class approach fits the way you already think about code.