NVIDIA-labs Object-Oriented Agents (OO Agents)
A Pythonic way to build AI agents: state, capabilities, prompts, and typed interfaces in a single Python class.
- Source repo
- NVIDIA-NeMo/labs-OO-Agents
- Stars
- ★ 2.3k
- Last updated
- 3d ago
- License
- NOASSERTION
- Primary language
- Python
- FA score
- 64/100 · Some gaps
At a glance
- How it runs
- Works with
- Universal · cross-platformOpenAI API · Claude API
- Cost
- Free software; you pay for model usage
- Setup effort
- Medium · a few setup steps
- You'll need
- Typical use
- A developer wanting to build a customer-support agent that accesses a database and handles tickets, using Python objects for state and methods for tools.
- Not a fit if
- Teams unwilling to sandbox LLM-generated code execution
- Non-Python stacks or users wanting no-code setup
- Source review
- 64/100 · Some gaps
What does this agent do, and when should you use it?
NVIDIA-labs OO Agents (NOOA) is a model-agnostic Python framework for reliable AI agent development. It merges prompts, tools, callbacks, and workflows into a single Python class, where fields define state, methods define capabilities, docstrings serve as prompts, and type annotations define contracts. Methods with '...' bodies are LLM-driven; method name, parameters, and docstring effectively form the prompt. NOOA executes model-generated Python in a Jupyter-style REPL, reducing the need for separate tool-schema definitions. It supports typed I/O with auto-retry, live-object references, and model-callable context and event APIs. The framework ships with a CLI, memory subsystem, and benchmark utilities, and provides tracing and a trace viewer for observability. As research software, it warns that LLM-generated code may be unsafe and should be run in a sandboxed environment.
NOOA lets developers define Python classes that inherit from Agent; fields act as state, methods as capabilities, docstrings as prompts, and type annotations as contracts. Methods with '...' bodies are implemented at runtime by an LLM-driven strategy; methods with real bodies run deterministic Python. The model performs actions by writing Python in a Jupyter-style REPL with access to self, imports, and helpers, thus avoiding separate tool-schema definitions. The framework provides typed input/output with auto-retry, live-object arguments passed by reference, and model-callable context and event APIs. Tracing is enabled by default, logging every LLM call, code execution, and method invocation with parent-child spans. The nooa CLI offers a trace viewer (http://localhost:5001) and eval runner. Agents run locally in the Python environment and can call external APIs (e.g., OpenAI, Anthropic, Ollama, vLLM) for inference.
- A developer wanting to build a customer-support agent that accesses a database and handles tickets, using Python objects for state and methods for tools.
- A team that needs typed outputs (e.g., ensure the model returns a
Ticketobject) with automatic retries on validation failures. - A developer who wants to debug an agent using standard Python testing, tracing, and refactoring workflows.
- An agent requiring long-term memory via the optional
MemoryManagersubsystem, integrated with the framework. - A researcher benchmarking agent capabilities on SWE-bench Verified and Terminal-Bench 2.0.
- A developer who prefers Python methods as tools instead of writing separate tool-schema definitions.
How do you install or deploy this agent?
Install the core framework with uv add nooa or pip install nooa. Optional sub-packages include nooa-cli (CLI, trace viewer), nooa-memory (long-term memory), and nooa-bench (benchmarks), installed via uv add nooa[cli,memory] etc. For source install, clone the repo and run uv sync --group dev. Requires Python environment.
How do you use this agent?
First, configure a model client: llm = get_llm_client("gpt-5-mini") or use Ollama (ollama_chat/qwen3:1.7b). Then define an agent class inheriting from Agent, e.g., class FeedbackAgent(Agent, llm=llm): with a method async def analyze_feedback(self, text: str) -> str: .... Run with uv run python examples/quickstart/01_first_generation_method.py or your own script. To view traces, run uv run nooa start-dev and open http://localhost:5001.
What are this agent's strengths and limitations?
- Object-oriented design unifies state, capabilities, prompts, and typed interfaces in a single class, following Python conventions.
- The model acts by writing Python code, eliminating separate tool-schema definitions and making code the action.
- Typed I/O with auto-retry improves reliability.
- Tracing is enabled by default, aiding debugging and observability.
- Model-agnostic, supporting multiple providers through LiteLLM.
- Includes CLI and memory subsystem for extended functionality.
- Research software with rough edges and possibly incomplete documentation.
- Executing LLM-generated code is risky; requires OS-level sandboxing (e.g., container, VM, or NVIDIA OpenShell), adding deployment complexity.
- Dependency on LiteLLM introduces additional dependencies and learning curve.
- Requires Python environment and uv tooling; not friendly to non-Python stacks.
- Benchmark and eval pipeline are not published to PyPI; must be installed from GitHub.
- Model provider API keys (e.g., OpenAI, Anthropic) are necessary, increasing cost and setup.
How does this agent compare with similar options?
The framework may offer a more Pythonic interface compared to other agent frameworks like LangChain, but the source doesn't explicitly name competitors.
Key facts side by side with the most closely related agents.
| Agent | Source review | Form / cost | Stars | Updated | Language | Full support on |
|---|---|---|---|---|---|---|
| NVIDIA-labs Object-Oriented Agents (OO Agents) This agent | 64 · Some gaps | Library / SDKFree + model costs | ★ 2.3k | 3d ago | Python | OpenAI API · Claude API |
| Marvin – A Python Framework for AI Workflows | 45 · Major gaps | Library / SDKFree + model costs | ★ 6.2k | 25d ago | Python | OpenAI API |
| Pydantic AI | 65 · Some gaps | Library / SDKFree + model costs | ★ 21k | today | Python | OpenAI API · Claude API |
| Atomic Agents | 64 · Some gaps | Library / SDKFree + model costs | ★ 6.3k | today | Python | OpenAI API · Claude API |
How does FollowAgents rate this agent?
Why each dimension lost points
Evidence: README explicitly warns LLM-generated code can be dangerous and recommends sandboxing; pyproject.toml pins dependencies with security considerations (e.g., litellm>=1.84.0 fixes CVE); CI includes secret scanning and frontend build reproducibility checks. However, user confirmation mechanisms, data flow transparency details, sensitive data handling policies, and rollback mechanisms are absent. Deductions: user confirmation and rollback not evidenced in files.
Evidence: CI tests, linting, type checking, and tests covering multiple modules; dependency versions have explicit constraints; README and code comments provide error handling info. But static review cannot verify actual runtime reliability. Deductions: no execution, so actual reliability unconfirmed.
Evidence: README provides multiple usage scenarios (quick start, examples, paper, blog), supports multiple model providers, has optional subpackages; capability boundaries are described (e.g., sandbox recommendation). But detailed trigger precision and environment-specific adaptation details are missing. Deductions: trigger precision and environment fit specifics not detailed in files.
Evidence: README structure clear, install instructions detailed, naming consistent (nooa package), examples and FAQ links, known limitations mentioned, license Apache 2.0, versioning via uv-dynamic-versioning and changelog link, maintenance responsibility in CONTRIBUTING.md. Deductions: some info (e.g., changelog content) not directly in provided files.
Evidence: README shows clear output examples (e.g., feedback analysis), framework offers object-oriented agent development, marginal value evident; cost-benefit clear from dependencies and install instructions. But no actual performance data or cost analysis. Deductions: cost-benefit not quantified.
Evidence: README claims (e.g., performance results) reference paper and blog, test files provide specific verification (e.g., guardrails tests), facts and inferences are distinguished in docs. But static review cannot verify all claims. Deductions: some claims rely on external links, not directly verified in files.
- LLM-generated code may execute dangerous actions; sandboxing is mandatory.
- Dependency versions have security considerations, but regular updates are needed to address new vulnerabilities.
- Static review cannot verify actual runtime reliability; dynamic testing is recommended.
Recent releases
Latest entries from the project's GitHub Releases. Notes are quoted from upstream as written, not rewritten or tested by FollowAgents.
-
v0.0.10 NOOA 0.0.10
Release notes excerpt
What's Changed * docs: add notebook tutorials v0 by @alessiodevoto in https://github.com/NVIDIA-NeMo/labs-OO-Agents/pull/142 * fix(tools): keep the shell parser away from the control protocol by @maemayv in https://github.com/NVIDIA-NeMo/labs-OO-Agents/pull/149 * Fix nooa-bench OTLP trace usage extraction by @cpakkamisaac-sae in https://github.com/NVIDIA-NeMo/labs-OO-Agents/pull/154 * Add CI-controlled release gate by @sklinglernv in https://github.com/NVIDIA-NeMo/labs-OO-Agents/pull/163 …View on GitHub ↗ -
v0.0.9 NOOA 0.0.9
Release notes excerpt
What's Changed * docs(cybergym): simplify README into a script-driven walkthrough by @sklinglernv in https://github.com/NVIDIA-NeMo/labs-OO-Agents/pull/60 * feat(cli): let external packages add nooa subcommands via entry points by @sklinglernv in https://github.com/NVIDIA-NeMo/labs-OO-Agents/pull/62 * docs(nooa_memory): fixed broken tests/memory/ link in README by @shivaperumalsamy in https://github.com/NVIDIA-NeMo/labs-OO-Agents/pull/64 * Docs/cybergym cleanups by @nv-pberard in https://github.com/NVIDIA-NeMo/labs-OO-Agents/pull/63 …View on GitHub ↗ -
v0.0.8 NOOA 0.0.8
Release notes excerpt
What's Changed * docs: install from PyPI, and fix the broken image on pypi.org by @sklinglernv in https://github.com/NVIDIA-NeMo/labs-OO-Agents/pull/57 Full Changelog: https://github.com/NVIDIA-NeMo/labs-OO-Agents/compare/v0.0.7...v0.0.8View on GitHub ↗
FAQ
Which models does NOOA support?
claude-haiku-4-5, gpt-5-mini, ollama_chat/qwen3:1.7b, and hosted_vllm/.... Requires API keys or local endpoints.How can I ensure the safety of generated code?
Can NOOA be used in production?
How do I debug an agent?
uv run nooa start-dev to start the trace viewer at http://localhost:5001.Does NOOA support long-term memory?
nooa-memory sub-package, which provides a long-term memory subsystem (MemoryManager). Install with uv add nooa[memory].