By NVIDIA just released a Python agent framework where an agent is a class, its methods are what it can do, and an ellipsis tells the model to take over. That sounds like a trick until you see what it eliminates: separate prompt templates, JSON tool schemas, callback handlers, and workflow graphs — all gone, folded into one Python object. NOOA (NVIDIA Object-Oriented Agents) dropped v0.0.8 on July 30 under Apache 2.0, and it benchmarks better than most of what came before it.
One Class, No Scaffolding
Every major agent framework today fragments agent logic across multiple files. LangChain gives you chains, tools, prompts, and memory as separate objects that you wire together. LangGraph layers workflow graphs on top. AutoGen introduces conversation threads between agents. That abstraction accumulates fast.
NOOA collapses it. An agent is a Python class. Methods are its capabilities. Fields hold its state. Docstrings are its prompts. Type annotations are enforced contracts. Any method whose body is an ellipsis gets implemented by the LLM at runtime:
from nooa import Agent
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."""
...That ... is the whole mechanism. At runtime, NOOA’s strategy loop sends the method signature, the docstring, and relevant context to the model, which returns a typed result. If the return type doesn’t match, it retries automatically. If the method body is ordinary Python, it runs without touching the model at all.
The practical outcome: agents can be unit-tested like any Python class. Mock the LLM, run pytest, catch regressions in CI. Two years into the LangChain era, that’s still not straightforward with most frameworks. NOOA makes it the default.
Mixed Execution in Practice
A more complete agent shows how NOOA mixes deterministic and LLM-driven methods in the same class:
class RefundAgent(Agent, llm=llm):
orders: OrderStore
def eligible(self, order: Order) -> bool:
return order.age_days RefundDecision:
"""Return a reviewed refund decision with evidence."""
... # LLM-driveneligible() is pure Python — fast, deterministic, testable in isolation. decide() is where judgment goes, handled by the model at runtime. The boundary between code and model is explicit and visible in the method signatures. This is not a subtle difference from how most frameworks handle this.
Two Execution Strategies
NOOA provides two strategies for LLM-driven method execution. PredictStrategy makes a single typed LLM call and retries locally until the return type validates. Use this for structured output tasks: classification, extraction, scoring — fast and cheap. CodeActStrategy opens an iterative Python REPL where the model writes code, calls execute_python(), inspects results, and loops until it’s ready to return. This is where the SWE-bench numbers come from, and where you want it for multi-step reasoning, codebase manipulation, or terminal tasks.
The Benchmark Numbers
On SWE-bench Verified — the standard test for resolving real GitHub issues — NOOA with GPT-5.5 scores 82.2% using approximately 1.1 million tokens and 28 model calls per task. A comparable harness at 78.2% required 2.2 million tokens and 66 calls. NOOA reaches a higher score at roughly half the cost.
CyberGym L1 (cybersecurity tasks with network access blocked): 86.8%. ARC-AGI-3 (abstract reasoning): 85.1% mean. These are vendor-reported numbers, so reproduce them before betting a production pipeline on them — but the token efficiency methodology is documented in the accompanying paper and hard to dispute at face value.
Read NVIDIA’s Security Warning
NVIDIA is explicit in the README: “AST checks and module deny-lists are defense-in-depth guardrails, not a containment boundary.” Model-written Python executes in the agent process. A misconfigured agent can read files, make network calls, or delete data — the AST validator cannot stop all of it.
The recommendation is OS-level isolation: containers, VMs, or NVIDIA’s own OpenShell. This is the right posture and uncommon for a framework README. Most agent frameworks don’t say this clearly enough. The practical consequence: NOOA adds deployment overhead, and regulated industries should wait for the security story to mature.
Where NOOA Fits in the Field
LangGraph wins for complex durable workflows where you need explicit checkpoints and human-in-the-loop gates. OpenAI Agents SDK wins for teams that want production maturity and built-in tracing today and don’t mind the vendor lock-in. AutoGen wins for multi-agent dialogue-heavy applications.
NOOA wins when you want your agents to behave like software: testable, inspectable, versionable. The NVIDIA developer blog positions the framework as the intersection of familiar Python tooling and LLM-driven execution — and that positioning is accurate.
Who Should Try It Now
Pilot NOOA if your team is fluent in Python testing practices, your agents work over in-memory data or codebases, and you can deploy inside a container or VM. AI-native startups and internal DevOps or security tooling teams are the obvious fit.
Wait if you’re in a regulated environment, your infrastructure can’t own OS-level sandboxing, or you need a production SLA. The framework is v0.0.8 alpha — NVIDIA describes it as a research preview, which means public APIs can change and ecosystem support is thin compared to LangChain or the OpenAI Agents SDK.
Install it with pip install nooa. Run the dev server with nooa start-dev to get traces on every method call. Give it three hours before deciding anything.
The Bottom Line
NOOA has the cleanest Python API in the agent framework space right now. The OOP design eliminates the accidental complexity that has made LangChain unwieldy for many teams. The benchmark numbers are strong and the token efficiency lead is real. The alpha status and security constraints are genuine limitations — NVIDIA says so plainly — but they don’t change what the design gets right. If you build Python agents, this is worth your time.
