Generated by Codex with GPT 5.6 Sol XHigh

The system around the model is part of the model’s performance

The official NVIDIA Technical Blog published this post on July 27, 2026. Its central claim is easy to underestimate: an agent benchmark does not measure a language model in isolation. It measures the model together with the harness that chooses what context it sees, how tools are exposed, where state lives, how actions are executed, and when the task ends. Change that surrounding architecture and the same model can produce materially different accuracy and cost.

NVIDIA Labs Object-Oriented Agents, or NOOA, turns that observation into an open-source research preview. Instead of spreading an agent across prompt templates, tool schemas, callbacks, workflow graphs, and loosely structured message history, NOOA represents the agent as one Python class. Methods define capabilities, fields hold explicit state, docstrings supply instructions, and type annotations become runtime-enforced contracts. A method with a normal body remains deterministic software; a method whose body is an ellipsis is completed by a language-model loop at runtime.

That split matters because it gives probabilistic behavior an ordinary software boundary. A refund policy, for example, can remain a tested Python function, while classification or triage can be model-driven methods with validated inputs and outputs. The agent can be diffed, reviewed, unit-tested, traced, versioned, and refactored using familiar engineering practices. NOOA is therefore less a new prompting style than an attempt to make an agent’s cognitive interface into a maintainable program.

Six capabilities reinforce one another

The post attributes NOOA’s performance to six related interface choices: typed input and output, pass-by-reference objects, code as action, programmable orchestration loops, explicit object state, and model-callable access to the harness itself.

Typed calls narrow the gap between what a prompt requests and what the surrounding program can safely consume. Instead of asking the model to emit loosely formatted prose and hoping a parser reconstructs intent, a method accepts declared arguments and returns a validated value. This does not make the model deterministic, but it moves many failures from silent semantic drift into visible contract violations.

Pass by reference addresses a different source of waste. Conventional tool loops serialize search results, files, database rows, or other large values back into the transcript, even when the model only needs a small preview and a stable handle. NOOA keeps the full Python object alive in the execution environment and shows the model a bounded representation. Later code can operate on the referenced value without repeatedly copying it through the context window. The immediate benefit is fewer tokens; the deeper benefit is that the transcript can stay append-only and cache-friendly rather than being periodically rewritten by context compaction.

Code as action gives the model a compact language for control flow, variable binding, and composition. Rather than emitting a succession of isolated JSON tool calls, it can write Python that loops, branches, calls several typed methods, and preserves intermediate objects. Programmable loop engineering extends the same idea to orchestration: the control loop is normal code that developers can inspect and modify, not an opaque framework convention.

Explicit state and model-callable harness APIs complete the design. Durable facts can live as typed fields instead of being inferred from a growing conversation, while the model can inspect context blocks and event history through defined interfaces. Taken together, the six capabilities reduce translation layers. The model reasons over a surface that looks much more like the program it is trying to operate, while the host application retains conventional points for validation and observability.

There is a real security tradeoff behind this convenience. Letting a model write executable Python is more expressive than granting a fixed menu of tools, but it also expands the action surface. The post’s benchmark results show what that expressiveness can buy; a production deployment would still need sandboxing, least-privilege object access, resource limits, audit trails, and explicit boundaries around side effects. Typed interfaces improve control, but types alone are not an authorization system.

Memory becomes managed state, not an ever-growing transcript

NOOA’s long-term memory follows the same philosophy. The agent deliberately writes, queries, and corrects records through tools instead of relying on a hidden summarizer to compress everything it has seen. Records have types, importance scores, and tags, and typed links such as “supports,” “contradicts,” and “derived from” turn the store into a small knowledge graph rather than a flat diary. A reflection pass can merge duplicates, connect related entries, distill episodes, and prune stale material.

The backing store is a human-readable SQLite file. That is a deliberately unglamorous choice with useful operational consequences: teams can inspect it, back it up, query it, review changes, and share it across agents while preserving ownership. Stored memories can also refer to live agent state, separating a durable relationship or conclusion from the current value of the object it concerns.

This architecture draws a useful distinction between context and memory. Context is the bounded working set needed for the present step; memory is curated state that survives across tasks. Treating the two as separate systems avoids using the prompt as both CPU cache and database. In NVIDIA’s ARC-AGI-3 experiment, the structured memory subsystem improved mean reward-horizon adjusted efficiency by 11.8 points over file-based notes. The result is specific to that agent and benchmark, but it supports the broader mechanism: useful persistence depends not only on storing more text, but on giving the agent reliable operations for maintaining what it stores.

The evaluations measure harness leverage

NVIDIA evaluates the same general interface across software engineering, vulnerability rediscovery, and unfamiliar interactive games. On SWE-bench Verified, NOOA reports a solve rate of 82.2 percent with GPT-5.5 and 79.8 percent with Claude Opus 4.6, using a 253-line general-purpose agent without benchmark-specific prompts. On CyberGym L1, it reports 86.8 percent with GPT-5.5. Those runs blocked network access and applied a rule-based check to trajectories, reducing the chance that the agent succeeded by looking up disclosed vulnerabilities rather than analyzing code.

The efficiency comparison is as important as the pass rates. With GPT-5.5, the SWE-bench configuration used 29 model calls and roughly 1.1 million tokens per task to reach 82.2 percent. The comparison harnesses cited in the post used 66 calls and 2.2 million tokens for 78.2 percent, or 29 calls and 1.3 million tokens for 78.6 percent. NOOA still consumes a large absolute token budget, but the result illustrates that tool and state representation can change the amount of inference required to extract a given level of capability from one model.

The authors connect that saving to pass by reference and stable transcripts. Median sessions reportedly peaked between 22,000 and 72,000 prompt tokens within model context windows of 200,000 to 400,000 tokens, so the agent completed the tasks without a context-compaction pass. Because old turns were not rewritten, prefix-cache hits could accumulate over the session. This is a systems optimization as much as an agent-design choice: a representation that preserves cacheable history can reduce both model confusion and repeated prefill work.

ARC-AGI-3 tests a different kind of loop. The agent enters unknown grid-based games and must infer their controls, rules, and objectives from interaction. A 45-line skill has it maintain executable world models, predict the next state, compare predictions with observations, and revise its hypotheses when they disagree. NVIDIA reports that the skill adds 8.5 points over a hypothesis-driven baseline and that NOOA with GPT-5.6 Sol reaches 85.1 percent mean reward-horizon adjusted efficiency, fully solving 19 of 25 games at about 13.3 dollars per game.

These are vendor-reported results for a research preview, not a controlled proof that one harness dominates all alternatives. Leaderboard positions are snapshots; models, task budgets, scaffolds, and evaluation rules differ; and a strong score can depend on details outside the six named capabilities. The unusually broad set of released code, data, trajectories, and evaluation methods is therefore more important than the state-of-the-art label. It gives others a chance to separate general architectural gains from benchmark-specific tuning and implementation effects.

The broader engineering lesson

NOOA’s most transferable idea is that an agent harness should be treated as a first-class performance layer. A team can spend more on a larger model while losing much of the gain through repeated serialization, ambiguous tool contracts, hidden state, destructive context compaction, or an orchestration loop that is difficult to inspect. Conversely, a cleaner interface can improve accuracy, latency, cache use, and debuggability without changing model weights.

The post also argues for a useful convergence between agent engineering and ordinary software engineering. State should have an owner. Interfaces should be typed. Deterministic policy should remain deterministic code. Model decisions should be bounded by contracts and visible in traces. Persistence should be queryable and correctable. The probabilistic core does not eliminate these disciplines; it makes them more important.

The practical takeaway is not that every agent should become a single Python class. It is that the shape of the model-facing environment determines how much useful work the model can do per token and how safely that work can be integrated. Better agent systems will come partly from better models, but also from reducing the friction between reasoning, state, tools, and software controls. NOOA is a concrete demonstration that harness architecture is not plumbing around intelligence. It is one of the mechanisms through which intelligence becomes usable.