NVIDIA Labs Introduces NOOA: An Open-Source Object-Oriented Agent Harness

NVIDIA Labs Introduces NOOA: An Open-Source Object-Oriented Agent Harness NVIDIA Labs has released Object-Oriented Agents (NOOA), an open-source research preview treating AI agents as single Python classes. The harness architecture emphasizes typed inputs, pass-by-reference execution, and agent-curated memory, demonstrating substantial benchmark improvements and token savings across software engineering, cybersecurity, and reasoning tasks. NOOA structures an agent as a single Python class where methods define capabilities, fields store explicit state, docstrings serve as prompts, and ellipsis methods are executed by LLM loops. The harness architecture relies on six principles: typed input/output, pass by reference, code as action, programmable loops, explicit object state, and model-callable harness APIs. NOOA incorporates an agent-curated SQLite-based memory system featuring typed relationships and background reflection, which boosted ARC-AGI-3 performance by 11.8 points over file-based notes. Using GPT-5.5, NOOA achieved 82.2% on SWE-bench Verified at approximately half the token cost of comparison harnesses without requiring context compaction. The framework scored 86.8% on CyberGym L1 vulnerability discovery with network access disabled and reached 85.1% mean RHAE on ARC-AGI-3 using GPT-5.6-sol for about $13.3 per game. Object-Oriented Design and Core Principles Rather than relying on disjointed prompt templates, callback chains, and workflow graphs, NOOA consolidates agent development into standard Python classes. Methods completed with an ellipsis execute via an LLM runtime, while normal methods execute deterministically. This enables standard software engineering practices such as unit testing, diffing, version control, and refactoring by both human engineers and AI coding assistants. The interface is organized around six core ideas: typed input and output, pass-by-reference handling of live objects, code-based action execution, programmable loops, explicit durable object state, and model-callable harness APIs. Agent-Curated Memory and Token Efficiency Instead of automatic background summarization, NOOA equips agents with tools to deliberately query, write, and correct memory records stored in a single human-readable SQLite file. Stored records are structured into a typed knowledge graph and refined through a background reflection pass that merges duplicates and distills insights. Efficiency is further amplified by pass-by-reference mechanics: the model views bounded previews while keeping full data in the live execution environment. This append-only design avoids context compaction and summarization on SWE-bench Verified, keeping prompt token peaks between 22k and 72k tokens while maintaining prefill cache validity. Benchmark Results Across Domains NOOA was evaluated across multiple tasks without domain-specific steering prompts. On SWE-bench Verified, a 253-line agent achieved 82.2% with GPT-5.5 using roughly 1.1M tokens across 29 calls, outperforming alternative harnesses requiring 2.2M tokens across 66 calls for lower accuracy. On CyberGym L1, the system achieved 86.8% with network access completely blocked and rule-based trajectory checks. In ARC-AGI-3 grid games, a single agent using a 45-line world-modeling skill reached 50.2% mean RHAE with GPT-5.5 ($17.85 per game) and 85.1% with GPT-5.6-sol ($13.3 per game), solving 19 of 25 games under a two-hour cap. Cybersecurity Validation and Open Availability For vulnerability discovery, NOOA combines LLM reasoning with deterministic Python gates on a single object. These gates verify raw crash outputs, ensure crashes match reported vulnerabilities, and rerun inputs to verify reproducibility before findings are accepted. Deployed under layered sandboxing—including cell guards, OS privilege drops, and NVIDIA OpenShell compatibility—audits showed zero leakage across tens of thousands of logs. NVIDIA Labs has open-sourced NOOA's framework, benchmarks, test suites, and technical report as an experimental foundation for transparent, inspectable agent systems.

NVIDIA推出开源面向对象智能体框架NOOA：通过测试鞍架构优化模型性能与效率 NVIDIA Labs发布开源研究预览版面向对象智能体框架NOOA，将智能体抽象为单一Python类，通过类型化输入输出、引用传递和代码行动等六大接口特性，在软件工程、网络安全及通用推理等基准上显著提升表现并降低Token成本。 NOOA将智能体定义为单一Python类，普通方法为确定性代码，省略号方法由LLM驱动，开发与测试体验对齐传统软件工程。 采用“引用传递”机制，模型直接操作Python动态对象而非序列化文本，避免了上下文压缩，使SWE-bench Verified的Token成本降低约一半。 搭载自主维护的SQLite长期记忆子系统，通过类型化关系构建知识图谱，并结合后台反思机制进行去重与提炼。 在SWE-bench Verified达82.2%（GPT-5.5），在CyberGym L1达86.8%，并在ARC-AGI-3以低于每局20美元的成本取得85.1% RHAE（GPT-5.6-sol）。 面向对象架构与六大核心接口特性 NOOA认为智能体测试鞍（harness）的架构设计对性能有决定性影响。框架将智能体收敛为单个Python类，属性代表状态，文档字符串代表提示词，类型标注提供强约束合约。系统确立了六项模型交互特性：类型化输入输出、操作活动对象的引用传递、以Python代码作为行动、可由开发者或模型编写的可编程循环、显式对象状态，以及模型可调用的测试鞍API。 自主管理图谱记忆与无上下文压缩效率 NOOA配备长期记忆子系统，由智能体通过工具主动读写和纠正，并自动将关联记忆浮现至上下文中。记忆条目具备类型与权重，通过支持、矛盾等类型化关系连接为知识图谱，后台反思流程负责合并去重与修剪。由于工具返回结果以引用形式传递而非全量序列化输出，会话转录保持纯追加与缓存有效，测试过程无需上下文压缩，在SWE-bench任务中以约一半Token消耗达到或超越对比方案。 多领域基准评测：软件、网络安全与通用推理 在软件工程基准SWE-bench Verified上，通用253行NOOA智能体搭配GPT-5.5达到82.2%（Opus 4.6为79.8%）。在CyberGym L1漏洞重现测试中，断网并经规则防作弊审查下取得86.8%成绩。在ARC-AGI-3测试中，单个智能体通过45行世界模型技能与记忆系统，在两小时限制下以GPT-5.5取得50.2%均值RHAE，GPT-5.6-sol更达到85.1%且单局成本约13.3美元。 漏洞验证确定性门控与安全沙箱机制 在漏洞发现流程中，NOOA将验证管线实现为单个对象，设置了三个确定性类型化门控方法，分别用于裁定崩溃结果、确认崩溃与报告匹配，以及复现验证输入，确保漏洞结论完全由代码判定。此外，ARC-AGI-3集群运行在多层沙箱机制下，包括进程内守卫、运行时OS降权、身份匿名化和内核沙箱，并与NVIDIA OpenShell安全运行时适配。

Building a great AI agent isn’t just about choosing the right models. The harness is the architecture surrounding the model. How it renders context, executes actions, manages state, and decides when a task is done shapes outcomes just as much as the model itself. Harness design alone can account for double-digit swings in benchmark results and significant differences in token cost, with the same underlying model. NVIDIA Labs Object-Oriented Agents (NOOA) is an open-source **research preview** built on this insight. It has a Python framework, memory system, capability tests, and benchmark agents with code, data, and evaluations released so the community can reproduce, challenge, and build on these results. ## An agent is a Python object Agent development has involved coordinating multiple moving parts across prompt templates, tool schemas, callback code, and workflow graphs. NOOA takes a simpler approach: **an agent is a single Python class**. Its methods are its capabilities. Its fields are its state. Its docstrings are its prompts. Its type annotations are enforced contracts. A standard Python method whose body is an ellipsis (…) is completed at runtime by an LLM-driven loop. Method with a normal body run as ordinary, deterministic Python. ``` class SupportAgent(Agent): """You are a support agent for a customer service system.""" order_db: OrderDB # object state: model-visible, passed by reference def is_refund_eligible(self, order: Order) -> bool: """Return whether an order is eligible for a refund.""" return order.delivered and order.days_since_delivery <= 30 @strategy(PredictStrategy()) async def classify(self, message: str) -> TicketKind: """Classify the customer message into the best ticket kind.""" ... async def triage(self, message: str, photo: Image | None, order: Order | None) -> Ticket: """Triage a customer message and create a support ticket.""" ... ``` The payoff is that **agent development becomes traditional software development**. An agent can be diffed, code-reviewed, unit-tested, traced, versioned, and refactored—by humans *and* by AI coding agents, using the same tools they already use for every other codebase. ## Six ideas, one surface The NOOA architecture identifies six model-facing interface ideas that drive agent performance: 1. **Typed input/output**: Agentic calls have typed arguments and validated return values, not free text. 2. **Pass by reference**: The model operates on live Python objects, seeing bounded previews instead of serialized dumps. 3. **Code as action**: The model acts by writing Python, with control flow and inline method calls. 4. **Programmable loop engineering**: Orchestration loops are ordinary Python, writable by developers and by the model itself. 5. **Explicit object state**: Durable, typed state lives on the agent object, not just in conversation history. 6. **Model-callable harness APIs**: Context blocks and event history are APIs the model can inspect and manage. ## The agent curates its own memory NOOA includes a long-term memory subsystem. Rather than an automatic background summarization pipeline, memory is a store **the agent curates** through model-callable tools— deliberately writing, querying, and correcting records as part of its work—while **spontaneous memories** relevant to the current turn surface automatically into context. Records carry types, importance, and tags. Typed relationships such as “supports”, “contradicts”, and “derived-from” connected the 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 information that is no longer relevant. Agents accumulate knowledge across sessions without retraining. Everything persists in one human-readable SQLite file that teams can inspect, backup, and review using standard practices. Stored memories can reference live agent state, keeping knowledge current. Multiple agents can share a store while retaining separate ownership. In the following ARC-AGI-3 evaluation, the system improved RHAE by +11.8 points over the same agent with file-based notes. ## More capability from the same model The six capabilities are measurable across several different domains, with the same generic interface delivering advanced results: **Software engineering** On SWE-bench Verified, NOOA reaches **82.2%** with GPT-5.5 above the published leaderboard SOTA at submission (79.2%)—and 79.8% with Opus 4.6, using a general-purpose, 253-line agent with no benchmark-specific prompts. **Cybersecurity** On CyberGym L1, NOOA solves **86.8%** with GPT-5.5. The **top-scoring open-source agent**, ahead of the majority of leading closed-source systems. It ran with network access *blocked* and a rule-based “cheat check” over every trajectory, so the result comes from reasoning over the code itself, not from looking up disclosed vulnerabilities. No cybersecurity-specific steering was used. **General reasoning** On ARC-AGI-3, a single NOOA agent reaches 50.2% mean RHAE with GPT-5.5 (skill: +8.5 points over a hypothesis-driven baseline; memory: +11.8 over file-based notes) and **85.1% with GPT-5.6-sol** — advancing the benchmark’s score–cost Pareto frontier at **under $20 per game across the board** ($17.85 and $13.3; scorecards: [GPT-5.5](https://arcprize.org/scorecards/b2aa2240-8cd7-41cf-ad83-edf8c2836084), [GPT-5.6-sol](https://arcprize.org/scorecards/7a511ea0-dfa1-47ed-8a99-52a80f3cdbaa)). ## Same performance, half the tokens and no context compaction Harness engineering doesn’t only buy accuracy it also buys efficiency. With GPT-5.5, NOOA reaches 82.2% on SWE-bench Verified using 29 LLM calls and \~1.1M tokens per task. The comparison harnesses need 66 calls and 2.2M tokens to reach 78.2%, and 29 calls at 1.3M to reach 78.6%. **Parity or better, at roughly half the cost.** Two mechanisms drive this. First, *pass by reference*: tool results become live Python variables composed directly in code, instead of round-tripping through the context window as text. The model sees a typed, bounded preview; the full value stays live in the execution environment. Second, that same property means **NOOA doesn’t need context compaction to solve SWE-Bench with frontier models**: median sessions peak at 22–72k prompt tokens against 200–400k windows. Because NOOA passes tool results by reference instead of serializing them into the context window, transcripts remain append-only and cache-valid throughout the session. No summarization pass is needed and prefill cache hits compound across the full task. ## Reaching 85.1% RHAE on ARC-AGI-3 for under $20/game ARC-AGI-3 places an agent in an unknown grid game. The rules, objective, and controls must be discovered by acting. The NOOA example is a single-agent port of the companion [DreamTeam](https://arxiv.org/abs/2605.09650) architecture with six specialized agents coordinating around a shared, executable world model reduced to **one agent and one 45-line skill**. The game is running in a separate harness process that exchanges states and actions through append-only files. The skill instructs the agent to build a world model as a set of Python programs in its workspace that encode the observed state and predict the next one. Each turn the agent retrodicts— comparing its predictions against what actually happened—and revises its models and hypotheses on mismatch. In competition mode under a **two-hour cap**, the GPT-5.5 fleet reaches 50.2% mean RHAE ([scorecard](https://arcprize.org/scorecards/b2aa2240-8cd7-41cf-ad83-edf8c2836084)). The world-modeling skill contributes +8.5 points over a hypothesis-driven baseline, and the memory subsystem +11.8 over file-based notes. The GPT-5.6-sol fleet reaches **85.1% at about $13.3 per game** ([scorecard](https://arcprize.org/scorecards/7a511ea0-dfa1-47ed-8a99-52a80f3cdbaa)), advancing the benchmark’s score–cost Pareto frontier, with 19 of 25 games solved in full. Both fleets stay under $20 per game. The fleets run under layered sandboxing—an in-process cell guard, a per-run OS privilege drop, end-to-end anonymization of game identities, and a kernel-enforced per-cell sandbox. Red-team audits of both fleets—18 passes over the live GPT-5.5 run and a nine-scanner audit of the GPT-5.6-sol run—found no leakage on any rule (13,335 and 10,107 logs examined). For production deployment, NOOA pairs with the [NVIDIA OpenShell](https://developer.nvidia.com/blog/run-autonomous-self-evolving-agents-more-safely-with-nvidia-openshell/) secure runtime. ## Applying NOOA to vulnerability discovery Vulnerability discovery is a demanding test for an agent framework. An agent has to find a candidate bug in a large codebase and then prove it is real by producing an input that crashes the vulnerable code. The proof step is unforgiving. The crash has to be the right one, and it has to reproduce, or the finding is worthless. NOOA can make this kind of workflow easier to build. Deterministic checks and model reasoning live on one typed object, so each verification step runs as enforced code instead of a prompt instruction the model may or may not follow. In recent internal NVIDIA research implemented the validation pipeline as a single NOOA object. The model writes and runs Python that calls the agent’s own methods, keeping exploration and checks in one place instead of routing them through a fixed menu of tools. Three of those methods are deterministic gates. The first turns the verifier’s raw output into a clear crash-or-no-crash verdict. The second confirms the crash matches the reported vulnerability. The third reruns the input to check it reproduces. Because the gates are ordinary typed methods, not free-form text passed between separate processes, a finding is accepted only when the code says so, and the whole run is a single trace we can inspect and test. On CyberGym L1, a benchmark of real vulnerability rediscovery, the NOOA augmented research harness solved 86.8% of tasks with a commodity model and no network access. ## A research preview for the open agent ecosystem The agent ecosystem has advanced rapidly through contributions to orchestration, tools, memory, model interfaces, and evaluation across a wide range of open and purpose-built systems. NOOA is a contribution to that progress: open agent harness research in the form of an object-oriented agent framework that reaches state-of-the-art results across software engineering, cybersecurity, and reasoning benchmarks. NVIDIA is making the framework, tests, benchmark agent, and evaluation methodology public. Open implementations matter because teams can inspect the approach rather than trust it. They can build on transparent, typed, inspectable agents with human-readable state in a single store, queryable event histories, and standard interfaces that support existing security review, access control, and observability practices teams can build on. NOOA is available as an open experimental surface, not a replacement for existing harnesses. The techniques in the report are documented so any project can adopt, challenge, or improve on them. ## Get started - Read the [technical report](https://arxiv.org/abs/2607.20709). - Get the [code](https://github.com/nvidia-nemo/labs-OO-Agents) with framework, capability tests, and benchmark agents. - Run `examples/arc_agi_3` the world-model solver with the fleet runner. - Deploy safely with [NVIDIA OpenShell](https://github.com/NVIDIA/OpenShell).