NOOA — NVIDIA Object-Oriented Agents Documentation
by NVIDIA
An agent is one Python class: methods are capabilities, fields are state, docstrings are prompts, type hints are the contract.
Overview
NOOA (NVIDIA Object-Oriented Agents) is a model-agnostic, Apache-2.0 Python framework published by NVIDIA in mid-2026, sitting at roughly 2,000 GitHub stars and 275 forks. Its thesis is that the usual agent stack fragments one idea across four artifacts — a prompt template, a JSON tool schema, a state dict and a graph config — and that Python already has the primitives: an agent is a class, its methods are its capabilities, its fields are its typed persistent state, its docstrings are its prompts, and its type annotations are the enforced I/O contract. Methods whose body is `...` are implemented at runtime by LLM-driven strategies; ordinary methods stay deterministic Python, so hybrid agents mix generated and hand-written behaviour in one object. The repository is the documentation: `docs/tour.md` is a 10-minute conceptual pass, `docs/architecture.md` covers runtime mechanics and how a method call actually executes, `docs/local-models.md` covers self-hosted backends, and `docs/concepts/` answers agents, strategies, tools, prompts, orchestration, tracing and safety. Four notebook tutorials — `01_your_first_agent`, `02_choosing_a_strategy`, `03_codeact_tools_and_live_objects`, `04_composing_subagents` — are the hands-on path, backed by an examples catalog covering structured output, tools, strategies, tracing, context blocks and MCP. Install with `uv add nooa` or `pip install nooa`, with optional `nooa-cli`, `nooa-acp`, `nooa-memory` and `nooa-bench` packages. Every LLM call, code execution and method invocation is traced by default with parent-child spans, viewable via `uv run nooa start-dev`. Model backends go through LiteLLM, so Claude, OpenAI, Ollama and vLLM all work.
At a Glance
- Topic
- Frameworks
- Level
- Intermediate
- Format
- Documentation
- Cost
- Free
- Duration
- ~10 minute framework tour, then ~3-4 hours across the four notebook tutorials and examples catalog
- Provider
- NVIDIA
- Hands-on
- Yes — code/exercises
- Certificate
- None
What You’ll Learn
- ✓Model an agent as a single Python class where fields hold typed, durable state
- ✓Write LLM-implemented methods with `...` bodies alongside ordinary deterministic Python methods
- ✓Use docstrings as prompts and type annotations as enforced input/output contracts
- ✓Choose between generation strategies and understand when CodeAct beats plain tool calling
- ✓Compose subagents as objects instead of wiring a separate orchestration graph
- ✓Read the built-in parent-child trace spans in the local viewer to debug a failing run
- ✓Apply NVIDIA's stated safety posture: AST checks and deny-lists are guardrails, OS-level isolation is the boundary
Highlights
- •Agents are debuggable with ordinary `pdb` and testable with `pytest` — no framework-specific harness
- •Tracing is on by default with parent-child spans and a local viewer, rather than a bolt-on integration
- •Documentation is explicit that AST validation and module deny-lists are defense-in-depth, not a containment boundary — rare honesty in agent framework docs
- •Model-agnostic through LiteLLM, so Claude, OpenAI, Ollama and vLLM backends are interchangeable
- •A community deep dive reports substantially fewer LLM calls and tokens than JSON-schema-driven frameworks on coding benchmarks — treat as a claim to reproduce, not a settled result
- •Caveat: it is research-grade and Python-only, with no JavaScript or TypeScript path
Who It’s For
Best For
- ✓Python engineers who find prompt/tool/graph config sprawl harder to maintain than code
- ✓Teams comparing agent frameworks and wanting a genuinely different design point next to LangGraph and CrewAI
- ✓Engineers who need per-call tracing and reproducible debugging in their agent loop
- ✓Researchers prototyping multi-agent systems where subagents are just composed objects
Prerequisites
- •Solid Python: classes, type annotations, decorators and dataclass-style state
- •Prior exposure to at least one agent framework or hand-rolled tool-calling loop
- •A container, VM or other OS-level sandbox available, since generated code execution requires real isolation
FAQ
What is NOOA — NVIDIA Object-Oriented Agents Documentation?
NVIDIA's documentation for NOOA, an Apache-2.0 Python framework published in 2026 that collapses prompts, tools, state and orchestration into a single Python class. For engineers tired of maintaining prompt templates, JSON tool schemas and graph configs as three separate artifacts that drift apart, the docs walk from a 10-minute tour through four notebook tutorials to multi-agent composition, tracing and sandboxing.
Is NOOA — NVIDIA Object-Oriented Agents Documentation free?
NOOA — NVIDIA Object-Oriented Agents Documentation is free to access.
What level is NOOA — NVIDIA Object-Oriented Agents Documentation for?
NOOA — NVIDIA Object-Oriented Agents Documentation is aimed at a intermediate audience. Recommended background: Solid Python: classes, type annotations, decorators and dataclass-style state, Prior exposure to at least one agent framework or hand-rolled tool-calling loop, A container, VM or other OS-level sandbox available, since generated code execution requires real isolation.
How long does NOOA — NVIDIA Object-Oriented Agents Documentation take?
Expect roughly ~10 minute framework tour, then ~3-4 hours across the four notebook tutorials and examples catalog. Most learners work through it at their own pace.
What will I learn from NOOA — NVIDIA Object-Oriented Agents Documentation?
You'll learn: Model an agent as a single Python class where fields hold typed, durable state; Write LLM-implemented methods with `...` bodies alongside ordinary deterministic Python methods; Use docstrings as prompts and type annotations as enforced input/output contracts; Choose between generation strategies and understand when CodeAct beats plain tool calling; Compose subagents as objects instead of wiring a separate orchestration graph; Read the built-in parent-child trace spans in the local viewer to debug a failing run; Apply NVIDIA's stated safety posture: AST checks and deny-lists are guardrails, OS-level isolation is the boundary.
Topics
Sources
This page was written from 4 sources, 1 on domains other than github.com.