NVIDIA Open-Sources NOOA: AI Agents as Python Classes (No Tool Schemas Required)
Your agent is just a Python class. No tool schemas. No prompt templates. No separate workflow graph.
It's called NVIDIA Object Oriented Agents. 100% Open Source, model agnostic.
Every framework today makes you define the same agent in four places. The prompt sits in a string.
The tool sits in a JSON schema. The state sits in a dict. The orchestration sits in a graph you wire up somewhere else. Change one and the other three quietly go stale.
NOOA maps all four onto things Python already has.
Fields are the agent's state. Methods are its capabilities. Docstrings are the prompts. Type annotations are the output contract.
Then comes the part that makes this actually work: a method with an empty body becomes an LLM-driven agentic loop. Write a real body and it stays deterministic Python. You choose method by method what the model decides and what your code decides, inside the same class.
When the model does act, it writes Python in a Jupyter-style REPL with access to self. Your methods are already the callable interface, so there are no tool schemas to maintain.
Everything you would normally wire up around that call is already handled:
• Typed inputs and outputs with auto-retry when the model returns wrong shape
• Live objects passed by reference instead of serialized copies
• Every LLM call, code execution, and method invocation traced by default
• Runs on Anthropic, OpenAI, Ollama, or vLLM through LiteLLM
• SWE-bench Verified and Terminal-Bench 2.0 results published in the paper
Agents execute generated code here, so NVIDIA is direct about running them sandboxed.
NVIDIA has open-sourced NOOA (NVIDIA Object-Oriented Agents) — a research framework that represents an AI agent as a single Python class instead of splitting it across prompt strings, JSON tool schemas, state dicts, and orchestration graphs.
How it maps: class fields = state, methods = capabilities, docstrings = prompts, type annotations = the output contract. A method with an empty (...) body is executed at runtime by an LLM-driven agent loop; give it a real body and it stays plain deterministic Python — chosen per method, in the same class.
When the model acts, it writes Python in a Jupyter-style REPL with direct access to self, so your methods double as the tool interface — reducing (not fully eliminating) the need for separate tool schemas.
Built-in: typed I/O with auto-retry on malformed output, objects passed live by reference rather than serialized, and full tracing of every LLM call, code execution, and method call by default. It's model-agnostic via LiteLLM (Anthropic, OpenAI, Ollama, vLLM), and reports strong SWE-bench Verified and Terminal-Bench 2.0 results in the accompanying paper.
Important caveat: this is labeled research/alpha software, and NVIDIA is explicit that since agents can execute LLM-generated code, you must run it in an isolated sandbox (container/VM) — not on your primary filesystem.
🔗 github.com/NVIDIA-NeMo/labs-OO-Agents