NOOA: NVIDIA's Object-Oriented Agent Framework Explained

NVIDIA Labs has open-sourced NOOA (NVIDIA Object-Oriented Agents), a model-agnostic Python framework that collapses the fragmented anatomy of a modern AI agent—prompt templates, tool schemas, callbacks, workflow graphs—into a single Python class. The release, versioned 0.0.8 and dated July 30, 2026, is available via pip install nooa under Apache 2.0, requires Python 3.12–3.13, and is classified alpha on PyPI. For practitioners tired of reasoning about agent behavior across multiple abstraction layers, the consolidation alone is worth attention. The benchmark numbers make it harder to ignore: 82.2% on SWE-bench Verified, 86.8% on CyberGym L1, and 85.1% mean RHAE on ARC-AGI-3—delivered at roughly half the token cost of the open harnesses NVIDIA compared it against.

An Agent Is One Python Class

The core design premise is that methods are the actions a model can take, fields are agent state, docstrings are prompts, and type annotations are contracts the runtime enforces. The split between agentic and deterministic behavior is encoded directly in method bodies: a method whose body is ... is completed at runtime by an LLM-driven loop, while a method with a real body stays deterministic Python the model can call as a tool. Two execution strategies ship with the framework. PredictStrategy issues a single typed LLM call with a local retry loop that fires on validation failure. CodeActStrategy runs an iterative Python REPL where the model calls execute_python(...) until it submits return_result(...), which is then validated against the return annotation. Because both strategies operate through the same class interface, agent behavior can be tested, traced, refactored, and version-controlled like ordinary software.

Six Capabilities, One Surface

NVIDIA's research team claims NOOA is the first framework to combine six model-facing properties on a single interface: typed input/output, pass by reference over live objects, code as action, programmable loop engineering, explicit object state, and model-callable harness APIs. The team scored fourteen frameworks and harnesses—including LangGraph, Google ADK, PydanticAI, smolagents, the Claude Agent SDK, OpenAI Codex, and OpenHands—against those same axes and reports partial coverage across all of them.

Pass by reference is the load-bearing capability. Arguments arrive as live Python objects; the model sees only a bounded preview showing the concrete type, true length, and a head/tail sample. A hundred-element list renders in roughly thirty tokens while the full variable remains resident in the REPL, eliminating the context compaction overhead that affected the SWE-bench runs against competing harnesses. Context itself is structured as a cacheable static prefix, an append-only typed event history, and dynamic blocks at the tail—a layout designed to preserve KV-cache reuse across turns. An optional memory subsystem, attachable to an unmodified agent, exposes seven model-callable tools that write and recall records ranked by ACT-R activation, all stored in a single human-inspectable SQLite file. This approach to structured agent memory echoes architectural choices seen in TencentDB Agent Memory v2.0, which similarly centralizes recall in an inspectable store rather than scattering it across in-context history.

Benchmark Results and Efficiency

NOOA's capability test suite ran 88 tests five times across ten models, producing 4,309 passing records out of 4,400 (97.9%). A six-family stress subset covering batching, error recovery, and decomposition passed at 84.7%, with the performance gap between small and frontier models widening from 3.2 to 23 percentage points.

The end-to-end results come from a benchmark-agnostic agent written in 253 lines.

Trace analysis attributes the efficiency advantage partly to termination semantics. OpenCode halts when the model replies without a tool call; NOOA requires a typed TaskResult carrying both evidence and a verification command, a constraint that forces the model to confirm its work rather than exit on ambiguity.

Deployment Constraints and Model Compatibility

Models plug in through LiteLLM, covering hosted APIs, Ollama, and vLLM endpoints without framework changes—relevant for teams already running self-hosted inference stacks. The security posture is explicitly bounded: NVIDIA describes its AST checks and module deny-lists as defense-in-depth guardrails, not a containment boundary. The containment boundary is the operator's responsibility—a container, VM, or NVIDIA OpenShell. Generated code execution in an uncontained environment is unsupported. The framework's alpha classification and NVIDIA's own "research preview" label mean regulated production workloads should wait for a stable release; the target audience for now is AI-native startups, mid-market platform teams, and applied-research groups running evaluations or pilots.

NOOA's deeper signal is that NVIDIA is betting the agent abstraction war can be won at the language level rather than the orchestration level. Make the class the contract, and you sidestep the prompt-engineering and schema-maintenance tax that compounds with every new tool. The token-efficiency gap over open harnesses, if it holds across more tasks and models, would matter far more than benchmark rankings in cost-sensitive production workloads—and whether alpha-quality software can preserve that advantage as NOOA matures toward a stable API is the question practitioners should track.