Six Agent Harness Capabilities for Higher Model Performance | NVIDIA Technical Blog

Technical Blog

Subscribe

Related Resources

Agentic AI / Generative AI

English한국어中文

Six Agent Harness Capabilities for Higher Model Performance

Jul 27, 2026

By Ricardo Silveira Cabral and Paul Furgale

Like

Discuss (0)

AI-Generated Summary

Like

Dislike

NOOA, developed by NVIDIA Labs, is an open-source, object-oriented agent framework that structures agents as single Python classes, integrating capabilities, state, and prompts via methods, fields, and docstrings, with type annotations serving as enforced contracts; LLM-driven loops complete method bodies marked by ellipses at runtime.<br>The NOOA harness enables agents to curate and persist long-term, typed, and relational memory in a human-readable SQLite store, supporting knowledge accumulation, efficient context management through pass-by-reference, and eliminating the need for context compaction or summarization pipelines.<br>Across benchmarksSWE-bench Verified, CyberGym L1, and ARC-AGI-3NOOA demonstrates state-of-the-art performance and efficiency, achieving higher accuracy and lower token cost compared to prior harnesses, with reproducible, inspectable workflows and open evaluation methodology, all released publicly by NVIDIA for community adoption and extension.

AI-generated content may summarize information incompletely. Verify important information. Learn more

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):<br>"""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:<br>"""Return whether an order is eligible for a refund."""<br>return order.delivered and order.days_since_delivery TicketKind:<br>"""Classify the customer message into the best ticket kind."""<br>...

async def triage(self, message: str, photo: Image | None,<br>order: Order | None) -> Ticket:<br>"""Triage a customer message and create a support ticket."""<br>...

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