NVIDIA just open-sourced NOOA — a Python agent framework built on one premise: an agent is a Python class. Methods are actions. Fields are state. Docstrings are prompts. Type annotations are runtime contracts. If you’ve spent any time fighting YAML configs, decorator chains, and workflow graph DSLs just to get a basic agent working, NOOA’s pitch is worth your attention.
One Class to Rule Your Agent #
Most agent frameworks make you manage four separate things: prompt templates, tool schemas, callback code, and orchestration graphs. NOOA collapses all of that into a standard Python class. The framework ships as pip install nooa
(v0.0.8, Apache 2.0, Python 3.12–3.13), and the GitHub repo already crossed 1,300 stars within a few days of launch.
Here’s what an agent actually looks like:
class ResearchAgent(Agent):
topic: str
findings: list[str] = []
def search_web(self, query: str) -> list[str]: ...
def summarize(self, sources: list[str]) -> str: ...
def run(self):
results = self.search_web(self.topic)
self.findings.append(self.summarize(results))
The ellipsis (...
) bodies on search_web
and summarize
are the key detail. NOOA sees those and hands execution to the language model at runtime. The run
method is plain Python — it always executes the same way. You control which parts are deterministic and which parts the model fills in, within the same class, without switching contexts.
Type annotations enforce contracts at the interpreter level. Docstrings become prompt instructions automatically. The result is agent code you can test with pytest, lint with ruff, and version-control like any other module — which is something no previous framework has managed cleanly.
Two Ways to Execute #
NOOA offers two execution strategies depending on what your agent needs to do:
PredictStrategy runs a single typed LLM call with a local retry loop on validation failure. Use this for structured output tasks where you need a typed response and don’t require multi-step reasoning.CodeActStrategy opens a Python REPL loop where the model callsexecute_python()
iteratively until it submitsreturn_result()
. This is the path for complex, multi-step tasks that need real tool use.
Both strategies benefit from NOOA’s pass-by-reference design: large data structures stay live in the REPL while the model sees a bounded preview. A hundred-element list renders in around thirty tokens while the full variable remains accessible. That’s not a minor optimization — it’s the reason NOOA’s token numbers look the way they do.
The Benchmark Story #
NVIDIA reports 82.2% on SWE-bench Verified using GPT-5.5 — compared to 78.6% for OpenCode on the same benchmark. The more interesting number is efficiency: roughly 1.1 million tokens and 28 model calls per task, versus about 2.2 million tokens and 66 calls for comparable open frameworks. That’s roughly half the inference cost for better results. Independent verification of these figures hasn’t landed yet, so treat them as directionally accurate rather than gospel, but the methodology is grounded in the arXiv paper.
NOOA also scores 86.8% on CyberGym L1 and 85.1% mean RHAE on ARC-AGI-3. The paper claims NOOA is the first framework to combine typed I/O, pass-by-reference over live objects, code as action, programmable loop engineering, explicit object state, and model-callable harness APIs on a single surface.
When to Use NOOA vs. Alternatives #
NOOA isn’t a LangChain killer and it’s not trying to be. The honest comparison:
NOOA: best if you want testable, refactorable agent code and can accept alpha-stage API instability. The OO model genuinely wins on developer experience.LangGraph: better for long-running stateful agents with durable execution, streaming, and human-in-the-loop control. NOOA doesn’t replace this use case.OpenAI Agents SDK: smaller surface area, more production-ready. Pick it if you need stability guarantees NOOA can’t offer at v0.0.8.
The pattern to watch: NOOA excels on greenfield agent code where the team values testability and maintainability. It’s a worse fit for anything requiring durable execution or battle-tested production guarantees.
The Security Caveat You Cannot Skip #
NVIDIA is refreshingly direct in the documentation: AST checks and module deny-lists are defense-in-depth controls, not a containment boundary. Python’s capabilities — file I/O, importlib, reflection — mean static analysis cannot prevent all escapes. Model-generated code can transmit private data, delete files, or modify its own environment.
The required posture is OS-level isolation: containers, VMs, or NVIDIA’s own OpenShell. If you’re running NOOA on raw host infrastructure because the framework feels sandboxed, you’re making a mistake the documentation already warned you about. This isn’t unique to NOOA — it’s the reality of any framework that executes LLM-generated code — but it bears repeating because developers consistently underestimate it.
Getting Started #
Installation is one line:
pip install nooa # requires Python 3.12 or 3.13
Models route through LiteLLM, so you can point NOOA at OpenAI, Anthropic, a local Ollama instance, or any vLLM endpoint without changing agent code. The PyPI page has the latest release notes. The API is unstable at v0.0.8 — pin your version, watch the changelog, and expect breaking changes before 1.0.
The object-oriented framing is the right way to think about agents. That’s not a hot take — it’s just programming. NVIDIA figured out how to make Python itself the interface, and that’s worth experimenting with even in alpha.