NVIDIA NOOA

NVIDIA NOOA (NVIDIA Object-Oriented Agents) is an open-source Python framework from NVIDIA Labs that collapses agent development into a single class. In most frameworks an agent is spread across prompt templates, tool schemas, callback code, and workflow graphs. NOOA puts all of that inside one Python object: methods are the actions the model can take, fields are agent state, docstrings are the prompts, and type annotations are contracts the runtime enforces. A method whose body is an ellipsis is completed at runtime by an LLM loop, while a method with a real body stays deterministic Python, so developers and models share one interface and agent behavior can be tested, traced, refactored, and version-controlled like ordinary software.

Key Features

• One class, one agent: the whole agent lives in a Python class rather than scattered config, so agent code reads like normal code.
• Model-agnostic: any model works through LiteLLM, including hosted APIs, Ollama, and vLLM.
• Token efficiency by design: arguments arrive as live Python objects and the model sees only a bounded preview, so a hundred-element list renders in about thirty tokens while the full variable stays in the REPL.
• Pass by reference: large data stays live in the REPL, which NVIDIA says removed the need for context compaction on SWE-bench.
• Apache 2.0 and pip-installable: pip install nooa for Python 3.12-3.13, released July 30, 2026 as v0.0.8 alpha.

Benchmarks

NVIDIA reports 82.2% on SWE-bench Verified, 86.8% on CyberGym L1, and 85.1% mean RHAE on ARC-AGI-3, at roughly half the tokens of the open harnesses it was compared against. With GPT-5.5 it reported about 1.1M tokens and 28 model calls per task versus 2.2M and 66 for peers. Treat these as vendor numbers: no independent head-to-head against LangGraph or AutoGen on matched tasks exists yet.

Use Cases

• Teams burning frontier inference bills on multi-agent scaffolding they only half understand: NOOA's token-efficiency claim is the draw.
• Developers who think in classes and methods and want an agent that is unit-testable and refactorable.
• Prototyping a coding agent where repo context must stay live instead of being compacted away.
• Security-sensitive labs that want to run generated code inside a container, VM, or NVIDIA OpenShell.

Problems It Solves

1. Sprawl: no more juggling prompt files, tool schemas, callbacks, and workflow graphs.
2. Token cost: bounded argument previews and pass-by-reference keep context small.
3. Testability: agent logic is plain Python, so standard tooling works.

Pricing

NOOA is free and open source.

Important Caveat

NOOA is v0.0.8 and PyPI labels it alpha, a research preview from NVIDIA Labs rather than a production framework. More critically, the AST checks and module deny-lists are defense-in-depth, not a containment boundary. The boundary is a container, a VM, or NVIDIA OpenShell, so never run generated code directly on your host.

Getting Started

1. pip install nooa in a Python 3.12-3.13 environment.
2. Define your agent as a class: methods for actions, fields for state, docstrings as prompts.
3. Point LiteLLM at your model of choice.
4. Run it inside a container or VM before letting it touch anything you care about.

Frequently Asked Questions

What language?

Python 3.12 to 3.13 only.

Is it production ready?

No. Alpha research preview. Keep it out of regulated production workloads for now.

Is it safe to run generated code?

Not on your host. NOOA's AST checks are not a boundary; use a container or VM.

Alternatives

• LangGraph: durable graph runtime with a larger ecosystem.
• OpenAI Agents SDK: OpenAI's official primitives.
• Google ADK: multi-language agent SDK.

Tips

1. Run a controlled benchmark on your own tasks before committing to it, because the strong numbers are vendor-reported.
2. Always isolate execution: the containment warning is the most important sentence in the docs.
3. Treat API stability as pending; it is an alpha and the interface can change.

Conclusion

NOOA is NVIDIA's bet that an agent should be ordinary Python. It is fast, cheap on tokens, and nicely testable, at the cost of being an alpha from NVIDIA Labs with a serious containment caveat. For a weekend proof-of-concept against your current framework cost it is worth the benchmark. Start at the GitHub repo or the technical blog.