NVIDIA、AI エージェントの性能向上に寄与するハッチス設計を解説

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):

order_db: OrderDB

def is_refund_eligible(self, order: Order) -> bool:

return order.delivered and order.days_since_delivery <= 30

@strategy(PredictStrategy())

async def classify(self, message: str) -> TicketKind:

...

async def triage(self, message: str, photo: Image | None,

order: Order | None) -> 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:

• Typed input/output: Agentic calls have typed arguments and validated return values, not free text.

• Pass by reference: The model operates on live Python objects, seeing bounded previews instead of serialized dumps.

• Code as action: The model acts by writing Python, with control flow and inline method calls.

• Programmable loop engineering: Orchestration loops are ordinary Python, writable by developers and by the model itself.

• Explicit object state: Durable, typed state lives on the agent object, not just in conversation history.

• 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 engineeringOn 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.

CybersecurityOn 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 reasoningOn 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, GPT-5.6-sol).

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 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). 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), 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 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.

• Get the code 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.