Most agent frameworks force you to juggle four separate things: a prompt template, a tool schema, a callback function, and a workflow graph. Change one and you have to remember to update the other three. NVIDIA just open-sourced a framework that collapses all of it into a single Python class — and early benchmark numbers suggest the simplification isn't costing anything in capability.
The framework is called NOOA (NVIDIA-labs Object-Oriented Agents), released under Apache 2.0 as part of NVIDIA's contribution to the Open Secure AI Alliance. It's a genuinely different way to think about building agents, and it's worth understanding even if you're not planning to switch frameworks this quarter.
In NOOA, an agent is a Python class. That's the whole pitch, and it's more radical than it sounds:
... body is agentic. The runtime hands that method to an LLM at call time. The method's type-annotated signature becomes the contract the model has to satisfy, and the docstring becomes the prompt.Here's the shape of it:
from nooa import Agent
class SupportAgent(Agent):
"""You are a support agent."""
order_db: OrderDB
def is_refund_eligible(self, order: Order) -> bool:
return order.delivered and order.days_since_delivery <= 30
async def triage(self, message: str, order: Order) -> Ticket:
"""Create a typed support ticket."""
...
is_refund_eligible runs like any Python method. triage gets executed by an LLM-driven loop, constrained by the Ticket return type. Both live on the same object, can call each other, and can be tested, traced, and version-controlled the same way.
The pitch isn't just aesthetic. Splitting an agent across prompt files, JSON tool schemas, and orchestration YAML makes agents hard to refactor and even harder to reason about as a team scales past one or two engineers. Anyone who's tried to onboard a new developer onto a LangGraph or CrewAI codebase has felt this — you're teaching them a bespoke DSL on top of Python, not just Python.
NOOA's answer is to let the model act by writing and executing Python in a Jupyter-style REPL, with access to self, imports, and helper functions. Type annotations do double duty as the callable interface the model uses — which means less hand-written tool-schema boilerplate to keep in sync with your actual code.
Practically, that also means standard software engineering habits transfer directly: unit tests around the deterministic methods, tracing on every LLM call and code execution by default (with a built-in trace viewer), and normal Python refactoring tools instead of framework-specific tooling.
NVIDIA didn't just publish a framework — it published a paper with results. A NOOA-based agent reached 82.2% on SWE-bench Verified using GPT-5.5, and the framework posts state-of-the-art or near-state-of-the-art results across SWE-bench Verified, CyberGym (a cybersecurity capability benchmark), and ARC-AGI-3 reasoning tasks. The full methodology and evaluation numbers are in the accompanying research paper on arXiv.
It's also explicitly model-agnostic. NOOA ships with LiteLLM-backed support for Anthropic, OpenAI, local Ollama models, and self-hosted vLLM endpoints — so teams aren't locked into a single model vendor to use it.
NVIDIA's own documentation is blunt about this: NOOA is research software, and agents built with it can execute LLM-generated code. The framework runs static checks and module deny-lists, but explicitly says these are "defense-in-depth guardrails, not a containment boundary." Anything that lets a model write and run arbitrary Python needs to sit inside a sandboxed environment — a container, a VM, or NVIDIA's own OpenShell project — not directly on a machine with access to real credentials or a production filesystem. If you're evaluating this for client work, that sandboxing requirement isn't optional.
If your team is building or maintaining agent workflows — whether that's an internal automation, a client-facing AI feature, or an agency-built solution on top of Claude, GPT, or an open-weight model — NOOA is worth a look for two reasons. First, the object-oriented model is a genuinely simpler mental model than graph-based orchestration once you're past a trivial single-tool agent. Second, it's coming from NVIDIA with real benchmark backing, not just a weekend side project, which usually means it'll keep getting maintained.
It won't replace every framework overnight, and picking it up mid-project isn't a small lift. But for new agent builds where the team already thinks in Python classes, it's a serious contender worth prototyping against whatever you're using today.
... body are handed to an LLM, constrained by their type signature.
Our cutting-edge features simplify collaboration and creativity, making your workflow intuitive and efficient. Transform your vision into reality effortlessly with Hadidiz Flow.
