NVIDIA has open-sourced NOOA (NVIDIA Labs Object-Oriented Agents), a model-agnostic Python framework that turns an AI agent into an ordinary Python object. The first public releases (v0.0.7 and v0.0.8) landed on July 30, 2026, and the framework arrived as NVIDIA's core code contribution to the newly formed Open Secure AI Alliance. The idea is deceptively simple: an agent is a class, its methods are the actions the model can take, its fields hold state, its docstrings are the prompts, and its type annotations are contracts. NVIDIA lays out the design in a companion technical blog post.
If you have ever wired an agent together from prompt templates, JSON tool schemas, and a graph of nodes and edges, NOOA is a bet that you already know a better abstraction: the programming language itself. This deep dive walks through what shipped, how the object model actually works, how it compares to graph and DSL frameworks, the benchmark numbers, and how to build your first NOOA agent this afternoon.
What NVIDIA Just Open-Sourced
NOOA is published under the Apache 2.0 license on GitHub and to PyPI as the package nooa. NVIDIA Labs announced the release on the NVIDIA Developer Forums and paired the code with a research paper. The framework is deliberately small at its core: you install one package, subclass one base class, and mark the methods you want the model to implement.
The release is part of a bigger move. The Open Secure AI Alliance launched the same week with dozens of founding members, including Microsoft, Dell, The Linux Foundation, Adobe, Cisco, Databricks, and Snowflake. NOOA is positioned as the reference framework for building agent harnesses whose behavior can be tested, traced, audited, and governed, rather than yet another black-box orchestrator. That framing matters for builders who need to ship agents into environments where "we cannot explain what the agent did" is not an acceptable answer.
NOOA vs Traditional Agent Frameworks
Most agent frameworks ask you to describe an agent in a format that is not your application code: a graph, a YAML file, a chain of prompt templates, or a registry of tool schemas. NOOA collapses all of that back into a single Python class. Here is how the two approaches line up.
| Dimension | NOOA (agents as Python objects) | Graph / DSL frameworks |
|---|---|---|
| Agent definition | A plain Python class | Graph nodes and edges, or config files |
| Tools | Regular typed methods on the class | Separately declared tool schemas |
| Model-generated steps | A method whose body is ..., completed by an LLM loop at runtime | Prompt templates plus output parsers |
| State | Object fields, passed by reference | External state dicts or context objects |
| Memory | Typed, relational, human-readable SQLite store | Vector store plus summarization pipelines |
| Testing and debugging | Standard Python tests, tracing, refactoring | Framework-specific tooling |
| Model support | Model-agnostic via LiteLLM | Varies by framework |
| License | Apache 2.0, open source | Varies |
How to Build an Agent with NOOA
The whole point of NOOA is that there is very little new syntax to learn. If you can write a Python class, you can write an agent. Here is the minimal workflow.
- Install the package. Add NOOA to a project with
pip install nooa, oruv add nooaif you use uv. - Pick a model. NOOA routes through LiteLLM, so the same code runs against Claude, GPT, a local Ollama model, or a self-hosted vLLM endpoint. You pass the model identifier when you construct the agent.
- Define the class. Subclass the base
Agentand write a class docstring that acts as the system prompt. - Mark generation methods. Any method whose body is
...is implemented by the model at runtime through a validated agent loop. Its signature and docstring become the contract. - Keep deterministic logic as normal methods. Methods with real bodies run as ordinary Python, so your database calls, math, and validation stay exact and testable.
- Run and trace. Every model call and code execution is traced automatically, so you can inspect exactly what happened without bolting on a separate observability layer.
A minimal agent looks like this:
class FeedbackAgent(Agent, llm=llm):
"""You are an agent specializing in analyzing customer feedback."""
async def analyze_feedback(self, text: str) -> str:
"""Analyze customer feedback for sentiment and key topics."""
...
The analyze_feedback method has no body. At runtime, NOOA hands the model the docstring, the typed signature, and the object state, then runs a loop until the method returns a value that satisfies the -> str contract. Because the method is typed, you do not hand-write a separate tool schema, and because it is a normal method, you can unit-test the agent the same way you test any other class.
The Six Harness Capabilities Behind the Numbers
The NOOA paper argues that agent quality is bottlenecked less by the model and more by the harness around it. It combines six model-facing ideas on a single surface:
- Typed input and output. Signatures act as contracts the model must satisfy, cutting parsing failures.
- Pass-by-reference over live objects. The model manipulates real objects instead of copying large blobs of text into context.
- Code as action. The agent executes generated Python inside the environment rather than emitting tool-call JSON.
- Programmable loop engineering. You control the generate, test, and reflect loop in plain Python.
- Explicit object state. State lives in fields, so it is inspectable and serializable.
- Model-callable harness APIs. The agent can query its own context, memory, and event history through typed calls.
The memory system is worth calling out on its own. NOOA agents curate long-term, typed, relational memory in a human-readable SQLite store. Combined with pass-by-reference, NVIDIA says this removes the need for the context-compaction and summarization pipelines that most agent stacks rely on to stay under the context window.
Benchmarks and Token Efficiency
NVIDIA reports that across SWE-bench Verified, CyberGym L1, and ARC-AGI-3, NOOA reaches state-of-the-art accuracy while spending fewer tokens than prior harnesses. The paper page on Hugging Face collects the results and discussion. The claim is not that a new model is smarter, but that the same models do more with a better interface, which is the entire thesis of the object-oriented approach. Lower token cost at equal accuracy is the number most teams shipping agents in production actually care about, because it maps directly to per-run cost and latency.
Why NVIDIA Framed It as a Security Tool
NOOA is not marketed only as a productivity framework. It is the flagship contribution to the Open Secure AI Alliance, and the security angle is baked into the design. Because agents are plain objects with explicit state and full tracing, you can audit exactly what an agent read, wrote, and executed. NVIDIA points to a real incident as motivation: during a security event at a major AI platform, closed tools could not distinguish attackers from defenders, so the team ran an open-weight model on its own infrastructure and analyzed more than 17,000 actions to contain the intrusion. NOOA aims to make that kind of forensic visibility the default rather than a scramble.
There is a sharp caveat here for anyone building on it. NOOA agents execute model-generated code. The framework ships guardrails such as abstract-syntax-tree validation and module deny-lists, but NVIDIA is explicit that you must run agents inside an operating-system-level sandbox like a container, not rely on in-process protection alone. Treat generated code as untrusted input, because that is exactly what it is.
What This Enables for Builders
For creators and developers building on top of AI, NOOA changes the day-to-day workflow in three concrete ways. First, your agent is testable: you can write a normal unit test that asserts an agent method returns the right shape, and run it in CI like any other code. Second, it is model-portable: because everything routes through LiteLLM, you can prototype against a small local Ollama model and swap in Claude or GPT for production by changing one identifier, with no rewrite. Third, it is debuggable: built-in tracing plus explicit object state means "why did the agent do that" is answered by reading a trace and the object fields, not by re-running and hoping.
Practically, that lowers the cost of moving an agent from a notebook demo to something you would put in front of users. The parts you already trust (your Python) stay deterministic, and only the genuinely fuzzy steps get delegated to the model.
What to Do Next
Start small. Spin up a fresh virtual environment, install the package, and port one existing prompt-plus-parser workflow into a single NOOA class with one generation method. Run it against a local model first so iteration is free, then point it at a hosted model once the shape is right. The GitHub repository ships runnable examples in its examples directory, which is the fastest way to see the object model in action before you commit to it.
Frequently Asked Questions
What is NVIDIA NOOA?
NOOA (NVIDIA Labs Object-Oriented Agents) is an open-source Python framework where an AI agent is defined as a single Python class. Methods are the agent's actions, fields are its state, docstrings are its prompts, and type annotations act as contracts. It was open-sourced on July 30, 2026 under the Apache 2.0 license.
How is NOOA different from LangGraph or CrewAI?
Those frameworks typically model an agent as a graph of nodes or a configuration of roles and prompt templates. NOOA models the agent as ordinary application code, so you use standard Python tooling for testing, tracing, and refactoring instead of framework-specific abstractions. Tools are just typed methods rather than separately declared schemas.
Which models does NOOA support?
NOOA is model-agnostic and routes through LiteLLM, so it works with Anthropic Claude, OpenAI GPT, local Ollama models, and self-hosted vLLM endpoints. You choose the model by passing its identifier when you construct the agent, which makes swapping models a one-line change.
How do I install NOOA?
Install it from PyPI with pip install nooa, or uv add nooa if you use uv. The core framework is a single package, and the GitHub repository includes runnable examples.
Is it safe to run agents that execute generated code?
NOOA includes guardrails such as abstract-syntax-tree validation and module deny-lists, but NVIDIA explicitly recommends running agents inside an operating-system-level sandbox like a container. Do not rely on in-process protection alone, because agents execute model-generated code that should be treated as untrusted.
What benchmarks has NOOA been tested on?
NVIDIA reports state-of-the-art accuracy with lower token cost across SWE-bench Verified, CyberGym L1, and ARC-AGI-3. The emphasis is on getting more out of existing models through a better harness, rather than on a new model.
