By ByteBot
If you’ve built an AI agent in the last year, you know the pattern: one file for prompt templates, another for tool schemas, a callback system you barely understand, and a workflow graph that looks like a subway map. Debugging means chasing state across five separate abstractions. Testing means mocking half the framework. It doesn’t feel like software engineering — it feels like archaeology.
NVIDIA quietly released a different answer on July 30, 2026. NOOA (NVIDIA Object-Oriented Agents) is a Python framework with one central claim: an agent is a Python class. Methods are the actions the model takes. Fields are state. Docstrings are prompts. Type annotations are enforced contracts.
Install it: pip install nooa. It’s Apache 2.0, requires Python 3.12–3.13, and is currently a research preview backed by a paper on arXiv.
The Core Idea: The ... Body Pattern
The most elegant thing in NOOA is how it handles the boundary between deterministic code and LLM-driven behavior. Write a method body as ... and the agent loop fills it in at runtime, with the return type annotation enforced as a contract. Write normal Python and it runs as regular code. Same class, same interface, two execution modes.
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."""
...Calling await agent.analyze_feedback("Great product, but shipping was slow") routes to the LLM. The str return type is validated — not trusted.
A more complete example shows why this matters for real applications:
class SupportAgent(Agent):
"""You are a support agent for a customer service system."""
order_db: OrderDB # typed field: visible to the model, passed by reference
def is_refund_eligible(self, order: Order) -> bool:
"""Return whether an order is eligible for a refund."""
return order.delivered and order.days_since_delivery TicketKind:
"""Classify the customer message into the best ticket kind."""
...
async def triage(self, message: str, order: Order | None) -> Ticket:
"""Triage a customer message and create a support ticket."""
...is_refund_eligible runs as deterministic Python — no LLM involved. classify makes a single typed LLM call via PredictStrategy. triage runs through an iterative reasoning loop. The developer doesn’t have to wire these together through a separate graph layer; they’re just methods on a class.
Why Token Costs Drop by Half
NOOA introduces pass-by-reference for Python objects. Instead of serializing a 100-element list to JSON and dumping it into a context window, the framework passes a bounded 30-token preview. The model operates on live Python objects, not serialized blobs.
The effect on benchmark costs is measurable. NOOA reaches 82.2% on SWE-bench Verified using approximately 1.1 million tokens per task. Competing frameworks hit similar scores using 2.2 million tokens — roughly double the cost. For teams running agents at scale, this isn’t a footnote; it’s a line item on the infrastructure bill.
Benchmark Numbers Worth Knowing
NVIDIA ran NOOA across three benchmark domains with GPT-5.5 and GPT-5.6-sol:
- SWE-bench Verified: 82.2% — competitive with current state-of-the-art, at half the token cost
- ARC-AGI-3: 85.1% mean RHAE — the optional memory subsystem contributed +11.8 points over file-based notes
- CyberGym L1: 86.8% — top open-source result in this category
The memory system result is particularly notable: NOOA uses SQLite-backed long-term memory where the agent itself writes and corrects its own records, rather than relying on automatic context summarization. That design choice matters — auto-summarization loses precision at exactly the moments an agent needs it most.
The Security Caveat You Cannot Ignore
NOOA executes LLM-generated Python code. That sentence should make you pause before shipping anything to production.
NVIDIA is admirably honest about the risk: AST checks and module deny-lists are “defense-in-depth guardrails, not a containment boundary.” The containment boundary you actually need is a container, a VM, or NVIDIA’s OpenShell environment. NOOA is not designed to be secure by default — it’s designed to be used inside something that is.
This is the right trade-off for a research framework, but it means NOOA isn’t a drop-in replacement for a production agent system without infrastructure around it. Keep that in mind before your team’s agent starts executing customer-provided inputs.
How to Try It
NOOA is available on PyPI and GitHub under Apache 2.0.
pip install nooa # core framework
pip install nooa-cli # CLI tools and trace viewer
pip install nooa-memory # long-term memory subsystemPython 3.12 or 3.13 is required. Models connect through LiteLLM, which means you can point NOOA at OpenAI, Anthropic, Ollama, or any vLLM endpoint without changing your agent code.
Is OOP Actually the Right Abstraction?
The case for NOOA is compelling: agents that look like software, behave like software, and can be debugged, tested, and version-controlled like software. That’s not nothing. The current state of agent development — prompts and graphs and callbacks living in separate files, loosely coupled by a framework’s internal conventions — is not sustainable at scale.
But OOP has known limits. Single-agent tasks map cleanly to a class. Multi-agent coordination — where agents spawn sub-agents, share state, and negotiate — is where the abstraction starts to strain. NOOA is still alpha. It has 1,100 GitHub stars after 10 days and 19 open issues. The community hasn’t stress-tested it on the complex orchestration patterns that LangGraph and AutoGen were designed for.
That said: if you’re building a focused agent — one that does one class of work well — NOOA’s approach is cleaner than anything else available right now. The code is on GitHub. It’s worth an afternoon to try.
