82.2% on SWE-Bench Verified. Three points above the previous state of the art. 1.1 million tokens per task instead of 2.2 million. And the model underneath? GPT-5.5 — nothing new, nothing frontier-exclusive, nothing you couldn't call today.
The framework that produced these numbers didn't come from OpenAI, Anthropic, or Google. It came from NVIDIA — the company that sells the GPUs everyone else trains on. And the core idea isn't a novel prompting technique or a better attention mechanism. It's simpler than that: an agent should be a Python class.
On July 27, NVIDIA Labs open-sourced NOOA (NVIDIA Object-Oriented Agents) under Apache 2.0. The accompanying paper, published to arXiv, lays out a programming model that collapses the sprawling mess of prompt templates, tool schemas, callback chains, and workflow DAGs into a single Python object. The benchmark results suggest they might be onto something that the rest of the industry is still tiptoeing around.
What NOOA Actually Is
Most agent frameworks represent the same four things — what the model can do, what it knows, what it's told, and how it's structured — as four separate abstractions. Tools are JSON schemas. Prompts are template strings. Workflows are graph nodes. State is a dictionary that gets threaded through or stashed in a store. Each abstraction has its own lifecycle, its own debugging surface, and its own way of going wrong.
NOOA collapses all of it into one Python class. The rules are simple enough to fit in a sentence:
- Fields are state. Instance variables hold the agent's durable context — no separate state store, no serialization layer.
- Methods are capabilities. What the model can do is literally the methods on the object. No tool-schema file. No function registry.
- Docstrings are prompts. The instruction the model sees is the Python docstring on the method it's executing.
- Type annotations are contracts. Input and output types are validated automatically — and the validation triggers retries on failure.
- A method body of
...is LLM-completed. Write...and the framework replaces it with an agentic loop at runtime. Write real Python and it stays deterministic. Same class, same object, same interface.
The ... convention is the elegant part. In standard Python, ... is a no-op placeholder — you see it in stub files and abstract base classes. NOOA reuses it to mean "the model fills this in." Everything else — methods with real bodies, property decorators, async methods, context managers — works exactly as a Python developer expects. You can pytest your agent. You can git blame a decision. You can refactor a capability.
This isn't a gimmick. NVIDIA's paper surveyed fourteen existing agent frameworks and harnesses — including Microsoft Agent Framework, smolagents, Claude Agent SDK, OpenAI Codex, LangGraph, and Google ADK — scoring each on six capabilities: typed input/output, pass-by-reference over live objects, code as action, programmable loop engineering, explicit object state, and model-callable harness APIs. None of the fourteen combined all six on a single surface. Most exposed subsets to developers but not to the model itself. The newest features from Microsoft, Pydantic, and OpenAI — harness providers, code mode, sandbox agents — shipped during NOOA's evaluation window, most flagged experimental or opt-in. NVIDIA's read: the field is converging on these ideas, but nobody has unified them yet.
The Benchmark Numbers
The proof is in the numbers, and they're worth looking at carefully.
SWE-Bench Verified: 82.2% accuracy using GPT-5.5, compared to a previous state-of-the-art of 79.2%. That's a 3-point absolute improvement — meaningful in a benchmark where progress has been measured in fractions. More importantly, NOOA consumed 1.1 million tokens per task. Less efficient harnesses required 2.2 million for comparable or worse results. Half the tokens, higher accuracy. The harness, not the model, made the difference.
CyberGym L1: 86.8% task completion rate — leading among open-source agents on this cybersecurity benchmark. NOOA's typed I/O and deterministic validation steps (real Python method bodies) proved especially valuable here, where reliability matters more than creativity.
ARC-AGI-3: 85.1% RHAE (Relative Hypothesis Accuracy Error) using GPT-5.6-sol. The framework compressed what was previously a multi-agent world-model system into a single agent with a one-page skill — advancing the benchmark's score-cost Pareto frontier. Total cost per task: under $20.
Strip away the framework name and the pattern is familiar. When you improve the harness — better context management, fewer redundant serializations, tighter feedback loops — the same model does more with less. We've seen this from Databricks (GLM 5.2 matching Opus 4.8 at 34% lower cost through harness efficiency). We've seen it from xAI (Grok 4.5 trained alongside its harness for token efficiency). Now NVIDIA is showing it with a framework you can read end-to-end in an afternoon and run yourself.
Why Pass-By-Reference Changes Everything
Here's the mechanism that drives the token savings, and it's worth understanding because it reveals something structural about how most harnesses waste money.
In a typical agent framework, when a tool returns a result — say, a parsed data structure with 200 fields — the harness serializes that result into a string, injects it into the conversation context, and sends the entire serialized blob to the model. If the model calls the same tool again, the result is serialized again. If the model needs to reference a sub-field, it has to parse the serialized version from its context window. Every round trip duplicates data.
NOOA's pass-by-reference changes this. The model interacts with live Python objects, not serialized strings. When a method returns a complex object, the model gets a reference to it — it can call methods on it, access attributes, pass it to other functions. The object stays in the harness's memory space. Only the relevant interface (method signatures, type annotations) gets communicated to the model, not the full serialized payload. This is why NOOA can hit higher accuracy with half the tokens: the model spends its context budget on reasoning, not on re-parsing serialized state it already has access to.
This has implications beyond cost. Pass-by-reference means the model can write Python code that directly manipulates live objects — which is the "code as action" pillar. Instead of calling a tool through a JSON-RPC interface and receiving a serialized result, the model writes Python that calls methods on the agent object itself. The agent's methods, fields, and helpers are all in the namespace. This is closer to how a developer actually works with an API — and LLMs have seen vastly more Python code than they have agent tool-call schemas. The training distribution favors this interface.
The Containment Question
If the model writes and executes Python with access to self, imports, and the filesystem, security isn't optional. NOOA is direct about this in its own repository: the framework's AST checks and module deny-lists are "defense-in-depth controls, not a containment boundary."
NVIDIA places the actual containment boundary outside NOOA itself. Agents that execute LLM-generated code must run behind OS-level isolation — a container, a VM, or NVIDIA's own OpenShell sandbox runtime. NOOA provides inspection and tracing; the OS-level sandbox provides containment. This is the correct separation. Code execution without sandboxing is a vulnerability, not a feature — and NVIDIA is making the boundary explicit rather than hiding it behind a magic flag.
This matters because the industry is still learning where agent security boundaries actually live. Claude Code's recent sandbox.network.strictAllowlist setting, GitHub's approval-mode work in JetBrains, and the MCP 2026-07-28 spec's OAuth hardening all point in the same direction: the agent's execution environment needs to be isolated, auditable, and revocable. NOOA's design — harness for inspection, OS for containment — is a clean articulation of that principle.
What NVIDIA Gets Out of This
NVIDIA is primarily a hardware company. They sell GPUs. So why open-source an agent framework?
Because agent workloads are the highest-margin compute workload in the industry, and harness efficiency determines how much compute each agent run consumes. A framework that halves token usage while improving accuracy doesn't reduce GPU demand — it increases it. Cheaper, better agents mean more agents, more runs, more inference. NVIDIA wants the agent ecosystem to grow, and the bottleneck isn't model quality anymore. It's harness quality. By open-sourcing a reference implementation that demonstrates what a good harness looks like, NVIDIA is doing what it did with CUDA: removing friction at the layer above its hardware.
The Open Secure AI Alliance — a 37-member coalition announced alongside NOOA — reinforces this. Its scope covers identity, permissions, isolation, guardrails, and secure coding workflows for agents. That's the infrastructure layer that needs to stabilize before enterprise adoption scales. NVIDIA is positioning itself as the steward of that layer, the same way it positioned itself as the steward of the deep learning training stack a decade ago.
What This Means for Harness Engineering
NOOA validates a thesis that's been building for months: the harness is the product, and the abstraction you choose for your harness determines your cost structure, your testability, and your team's velocity.
The specific claim — agents should be Python objects — won't be the last word. Graph-based frameworks (LangGraph, Microsoft Agent Framework) have real advantages for multi-agent orchestration and complex state machines. DSL-based approaches work well for declarative workflows. But the OO model has a property none of the others share: it requires zero new concepts. Every Python developer already knows classes, methods, fields, decorators, type hints, and docstrings. The learning curve is zero. The tooling support — linters, type checkers, debuggers, test runners — already exists and already works.
For teams building agent infrastructure, the practical takeaway is architectural. If your agent code lives in a separate world from your application code — different tooling, different debugging, different mental model — you're paying a complexity tax that may not be justified. The closer your agent abstraction is to the abstractions your team already uses, the faster you move and the fewer bugs you ship. NOOA's bet is that the closest possible abstraction is the one Python already has.
The benchmark data makes the cost case concrete. A 50% token reduction across an agent fleet isn't a rounding error — it's the difference between a product that's profitable per run and one that isn't. And the improvement came entirely from harness design, not from model selection or fine-tuning. This is the pattern that's repeated across every major harness benchmark this year: change the harness, keep the model, get double-digit improvements.
What to Do This Week
Three concrete actions, in priority order:
1. Audit your token-to-task ratio. If you're running coding agents in production, measure how many tokens each task consumes relative to the output it produces. The gap between 1.1M and 2.2M tokens per SWE-Bench task is the gap between NOOA and a typical harness. Your number is probably closer to 2.2M. That gap is pure waste — tokens you're paying for that contribute nothing to the result.
2. Read the NOOA paper. It's on arXiv (2607.20709) and the code is on GitHub under NVIDIA-NeMo/labs-OO-Agents. Even if you never adopt the framework, the comparison table against fourteen existing systems is a useful diagnostic tool. Score your own harness on the six capabilities. If you're missing pass-by-reference and model-callable context APIs, you're leaving performance on the table.
3. Prototype one agent as a Python object. Pick a simple agent — one that calls two tools and returns a structured result. Build it the NOOA way: a class with typed methods, ... bodies for LLM-completed steps, real Python for deterministic ones. Compare the development experience, the testability, and the token consumption to your current approach. The point isn't to prove NOOA right. It's to feel the difference between an agent that fits in your codebase and one that sits beside it.
The broader lesson is one this space keeps rediscovering: the most important decisions in agent engineering are not about which model to use. They're about how you structure the system around the model. NVIDIA — a company with every incentive to sell you more compute — just open-sourced a framework that uses less of it. That should tell you where the real leverage is.