NVIDIA Labs published NOOA (NVIDIA Labs Object-Oriented Agents), an open-source research preview that treats agents as Python objects. The framework focuses on the harness around the model—how context is rendered, actions are executed, state is managed, and task completion is decided—and provides code, a memory subsystem, capability tests, and benchmark agents so the community can reproduce and extend the results.
Agent-as-object approach
NOOA simplifies agent development by making an agent a single Python class: fields represent durable state, methods represent capabilities, docstrings function as prompts, and type annotations act as enforced contracts. Methods with an ellipsis (…) are filled at runtime by an LLM-driven loop; ordinary Python methods execute deterministically. This design lets agents be treated like normal software artifacts: diffed, code-reviewed, unit-tested, traced, versioned, and refactored by humans and AI coding agents.
Six model-facing design ideas
The NOOA architecture identifies six interface ideas that materially affect agent performance:
- Typed input/output: calls use typed arguments and validated returns rather than free text.
- Pass by reference: the model operates on live Python objects, seeing bounded, typed previews instead of serialized text dumps.
- Code as action: the model performs actions by writing Python, including control flow and inline method calls.
- Programmable loop engineering: orchestration loops are plain Python, writable by developers and by the model itself.
- Explicit object state: durable, typed state lives on the agent object rather than only in conversation history.
- Model-callable harness APIs: context blocks and event history are exposed as APIs the model can inspect and manage.
Memory curated by the agent
NOOA includes a long-term memory subsystem that agents curate using model-callable tools: agents deliberately write, query, and correct records as part of their workflows, while spontaneous, turn-relevant memories surface automatically into context. Records carry types, importance, and tags; typed relationships such as "supports", "contradicts", and "derived-from" link records into a knowledge graph rather than a flat log. A background reflection pass consolidates the store by merging duplicates, linking related records, distilling episodes into insights, and pruning irrelevant data.
All persistent data is stored in a single human-readable SQLite file that teams can inspect, back up, and review. Stored memories can reference live agent state to keep knowledge current, and multiple agents can share a store while retaining separate ownership. In the ARC-AGI-3 evaluation cited, the NOOA memory subsystem improved RHAE by +11.8 points versus file-based notes.
More capability with the same models
NOOA’s six capabilities produce measurable gains across domains using the same generic interface:
-
Software engineering: On SWE-bench Verified, NOOA reached 82.2% with GPT-5.5, exceeding the published leaderboard SOTA at submission (79.2%). With Opus 4.6, NOOA scored 79.8% using a general-purpose, 253-line agent without benchmark-specific prompts.
-
Cybersecurity: On CyberGym L1, NOOA solved 86.8% with GPT-5.5—positioning it ahead of many leading closed-source systems among open-source agents. The runs were executed with network access blocked and a rule-based cheat check over every trajectory, indicating results came from code reasoning rather than external lookups.
-
General reasoning: On ARC-AGI-3, a single NOOA agent achieved 50.2% mean RHAE with GPT-5.5 (world-modeling contributed +8.5 points over a hypothesis-driven baseline; memory contributed +11.8 over file-based notes). The GPT-5.6-sol fleet reached 85.1% while advancing the benchmark’s score–cost Pareto frontier at under $20 per game (reported costs: ~$17.85 and ~$13.3 per game), and solved 19 of 25 games fully.
Efficiency: similar or better performance at roughly half the token cost
NOOA yields not only accuracy improvements but also lower token costs. With GPT-5.5, NOOA reached 82.2% on SWE-bench Verified using 29 LLM calls and ~1.1M tokens per task. Comparison harnesses required 66 calls and 2.2M tokens to reach 78.2%, or 29 calls and 1.3M tokens to reach 78.6%—so NOOA achieves parity or better at about half the token cost.
Two mechanisms drive this efficiency:
- Pass by reference: tool outputs become live Python variables composed directly in code instead of being round-tripped through the context window as text. The model sees a typed, bounded preview while the full value remains live in the execution environment.
- No need for context compaction: because results pass by reference instead of serializing into the context window, transcripts remain append-only and cache-valid across the session; median session prompt peaks reported at 22–72k tokens versus model windows of 200–400k, removing the need for summarization passes and improving prefill cache hits.
ARC-AGI-3 world-modeling and safety
ARC-AGI-3 tasks place an agent into unknown grid games where rules and objectives must be discovered by acting. NOOA’s example compresses a DreamTeam-style multi-agent architecture into one agent with a 45-line world-modeling skill. The game runs in a separate harness process that exchanges states and actions through append-only files. Each turn, the agent builds Python programs that encode observed state and predict the next state; it retrodicts and revises models on mismatch.
Under a two-hour cap in competition mode, the GPT-5.5 fleet reached 50.2% mean RHAE; the GPT-5.6-sol fleet reached 85.1% at about $13.3 per game. Both fleets stayed under $20 per game. Runs used layered sandboxing (in-process cell guard, per-run OS privilege drop, anonymized game identities, and kernel-enforced per-cell sandboxes). Red-team audits (18 passes over the live GPT-5.5 run and a nine-scanner audit of the GPT-5.6-sol run) examined 13,335 and 10,107 logs respectively and found no leakage on any rule. For production, NOOA pairs with the NVIDIA OpenShell secure runtime.
Vulnerability discovery use case
Vulnerability discovery requires finding candidate bugs in large codebases and proving them by producing crashing inputs that reproduce. NOOA simplifies implementing such pipelines as a single object where the model writes and runs Python that calls the agent’s typed methods. Deterministic gates—methods that convert raw outputs into crash/no-crash verdicts, confirm matches to reported vulnerabilities, and rerun inputs for reproducibility—ensure findings are accepted only when the code enforces them. In internal NVIDIA research, a NOOA-based validation pipeline solved 86.8% of CyberGym L1 tasks with a commodity model and no network access.
An open research surface
NVIDIA positions NOOA as a contribution to the open agent ecosystem: a transparent, typed, inspectable agent framework with human-readable state, queryable event histories, and standard interfaces that integrate with security review, access control, and observability practices. The project is published as an experimental surface rather than a drop-in replacement for existing harnesses, and the techniques are documented for others to adopt or challenge.
Getting started
- Read the technical report.
- Get the code, including the framework, capability tests, and benchmark agents.
- Run examples/arc_agi_3 to try the world-model solver with the fleet runner.
- For secure deployment, use NVIDIA OpenShell.
NOOA presents an object-oriented agent harness that yields measurable improvements in accuracy and token efficiency across multiple benchmarks while providing an inspectable, open framework for the agent ecosystem.
