Six Agent Harness Capabilities for Higher Model Performance

NVIDIA Labs' NOOA (NVIDIA Labs Object-Oriented Agents) is an open-source research preview framework whose core idea is to define an Agent as a single Python class. Fields are state, methods are capabilities, docstrings are prompts, and type annotations are enforced contracts. Methods with an ellipsis (...) body are completed at runtime by an LLM-driven loop; methods with a normal body execute as deterministic Python.

This design brings Agent development back to traditional software development: Agents can be diffed, code-reviewed, unit-tested, traced, version-controlled, and refactored—using the same tools available to humans or AI coding agents.

The NOOA architecture identifies six model-facing interface capabilities: typed input/output (Agent calls have typed parameters and validated return values, not free text), pass-by-reference (models operate on live Python objects, seeing bounded previews instead of serialized dumps), code-as-action (models act by writing Python, including control flow and inline method calls), programmable loop engineering (orchestration loops are ordinary Python, writable by developers and the model itself), explicit object state (persistent, typed state lives on the Agent object, not just conversation history), and model-callable Harness API (context blocks and event history are APIs the model can inspect and manage).

These capabilities are validated on multiple benchmarks. On SWE-bench Verified, NOOA with GPT-5.5 achieves 82.2%, surpassing the public leaderboard SOTA at submission (79.2%); with Opus 4.6 it reaches 79.8%, and the Agent is only 253 lines of generic code with no benchmark-specific prompts. On CyberGym L1, NOOA with GPT-5.5 solves 86.8% of tasks, the highest-scoring open-source Agent, with network access blocked and results derived from reasoning over code alone, without cybersecurity-specific bootstrapping. On ARC-AGI-3, a single NOOA Agent with GPT-5.5 achieves 50.2% mean RHAE (skill baseline +8.5 points, memory subsystem +11.8 points), and with GPT-5.6-sol it reaches 85.1%, costing under $20 per game.

In terms of efficiency, NOOA with GPT-5.5 on SWE-bench Verified uses 29 LLM calls and ~1.1M tokens/task to achieve 82.2%. In comparison, a baseline requires 66 calls and 2.2M tokens for 78.2%, or 29 calls and 1.3M tokens for 78.6%. NOOA achieves comparable or better performance at roughly half the cost.

NOOA includes a long-term memory subsystem, but it is not an automatic background summarization pipeline. Instead, the Agent autonomously curates it through model-callable tools—actively writing, querying, and correcting records, while spontaneous memories relevant to the current turn automatically surface into context. Records carry types, importance, and tags; typed relationships (e.g., "supports", "contradicts", "derived from") connect records into a knowledge graph rather than a flat log. A background reflection process consolidates storage by merging duplicates, linking related records, distilling episodes into insights, and pruning no-longer-relevant information.

Agents can accumulate knowledge across sessions without retraining. Everything is persisted in a human-readable SQLite file, which teams can inspect, back up, and review using standard practices. Stored memories can reference live Agent state, keeping knowledge current. Multiple Agents can share the same storage while retaining independent ownership. In the ARC-AGI-3 evaluation, the memory subsystem improved the system's RHAE by +11.8 points compared to the same Agent using file-based notes.

NOOA's efficiency stems from two mechanisms. First, pass-by-reference: tool results become live Python variables, composed directly in code, rather than being shuttled as text through the context window. The model sees typed, bounded previews, while the full value remains in the execution environment. Second, because of pass-by-reference, NOOA solves SWE-bench without context compaction: median session peak prompt tokens are 22–72k, while the window is 200–400k. Since tool results are passed by reference rather than serialized into the context window, the transcript remains append-only and cache hits accumulate throughout the task. No summarization step is needed, and pre-filled cache hits accumulate across the task.