NOOA: What If an AI Agent Were Just a Python Object?

by Pierre
NOOA: What If an AI Agent Were Just a Python Object?

Analysis — September 2026

In July, NVIDIA Labs released a framework that does the exact opposite of what everyone has been building for two years. No orchestration graph. No YAML. No hand-written JSON tool schemas. No prompt files lying around next to the code. An agent is a Python class, full stop.

It is called NOOA (NVIDIA Object-Oriented Agents), it ships under Apache 2.0, and the paper is here: arXiv 2607.20709.

Spoiler: the real question is not “do we migrate”. It is which of NOOA’s ideas will end up becoming the norm everywhere, and which are better watched from a distance a while longer.

1. The principle: four correspondences and one character

It all fits in a table of correspondences:

PythonAgent
ClassThe agent
MethodAn action the model can take
Typed fieldThe agent’s state
DocstringThe prompt for that action
Type annotationA contract validated at runtime
Body ...This step goes to the LLM
Normal bodyDeterministic Python, zero model calls
from nooa import Agent


class FeedbackAgent(Agent, llm=llm):
    """You are an agent specialised in analysing customer feedback."""

    async def analyze_feedback(self, text: str) -> str:
        """Analyse sentiment and key topics in one sentence."""
        ...

Rename the method, and the output changes. Of course: the name, the parameters and the docstring are the prompt. And the boundary between “the model decides” and “the code decides” comes down, literally, to three dots.

That is the clever part. Most agent bugs do not come from the model, they come from the orchestration: something that should have been deterministic went through an LLM because it was easier to wire up. NOOA makes determinism free and the model call explicit. You have to ask for it.

2. The six claimed capabilities

The paper announces six ideas NOOA would be the first to bring together in one place: typed I/O, pass-by-reference on live objects, code as action, a programmable loop, explicit object state, and harness APIs the model can call itself for context and events. NVIDIA also scored fourteen other frameworks on the same axes (LangGraph, Google ADK, PydanticAI, smolagents, Claude Agent SDK, OpenAI Codex, OpenHands…) and finds only partial coverage everywhere else.

The most interesting by far is pass-by-reference. Arguments arrive as real, live Python objects. The model only sees a preview: the type, the actual length, a sample of the start and the end. A hundred-item list fits in about thirty tokens, while the full variable stays in the REPL. Context itself is split into a cacheable static prefix, an append-only history of typed events, and dynamic blocks at the end — which keeps the KV cache reusable from one turn to the next.

Translation: we stop dumping entire payloads into the context window. That is structural, not cosmetic.

3. The numbers, and what they are really worth

NVIDIA reports 82.2% on SWE-bench Verified with GPT-5.5, 86.8% on CyberGym L1 with the network cut, 85.1% average RHAE on ARC-AGI-3. All of it with a generic 253-line agent, against 78.6% for OpenCode and 78.2% for PI on the same model. And 79.8% with Claude Opus 4.6.

But the number that counts is not accuracy. It is efficiency: roughly 1.1 million tokens and 28 model calls per task, against 2.2 million and 66 calls for the compared approaches. Half. Trace analysis attributes part of the gain to validated termination: the other harnesses stop when the model answers without calling a tool, whereas NOOA requires a typed TaskResult with evidence and a verification command.

Two readings, both honest. The friendly one: 3.6 points of gap at identical model is a real result, and getting it in 253 lines suggests the abstraction removes complexity rather than relocating it. The wary one: SWE-bench Verified is patching Python repositories, harness scores there are hypersensitive to scaffolding, and these are numbers published by the vendor itself.

The genuinely good signal is the GPT-5.5 / Opus 4.6 gap: 2.4 points. Frameworks that call themselves “agnostic” usually collapse as soon as you change model, because they were tuned on the quirks of a single one. Not here.

4. What is genuinely good

  • You learn nothing. No framework vocabulary. A Python developer reads the class and has understood everything in a minute.
  • All existing tooling works again. pytest, ruff, pyright, git diff, tracing. This is probably the most underrated argument of the lot.
  • Contracts, not defensive prompts. Annotations are validated, not suggested. A large share of the reliability comes from there, not from the model.
  • Context economy is free. Large objects stay in the REPL, they do not travel.
  • Genuinely agnostic. Open source, no need for a GPU or NVIDIA hardware, any local or API LLM through LiteLLM.
  • Readable by the agents themselves. Ordinary Python is what models were trained on. A coding agent understands a NOOA agent infinitely better than a graph DSL.

5. Where it falls short

  • Security: this is not a sandbox. NVIDIA says so in black and white. AST validation and module deny-lists are defence in depth, not a containment perimeter. And they explain why: a static checker on Python cannot guarantee it. open() gives arbitrary file access, importlib loads a module from a path, and reflection does the rest. Containment means a container or a VM, there is no shortcut. The scenario to fear, incidentally, is not a malicious model: it is indirect prompt injection. The agent reads a file, an issue comment or a web page crafted to steer it, and generates code that obeys.
  • You lose the map. LangGraph makes control flow a first-class object: you render it, you diff it, you reason about every edge before executing anything. NOOA hides it inside method calls. Far more readable, much harder to visualise or analyse statically. For auditing or genuinely complex branching, the graph remains more honest.
  • It is young. Research preview, classified alpha on PyPI, v0.0.8, Python 3.12–3.13, public API not stabilised and liable to move from one release to the next. To be wrapped behind an application interface — and certainly not imported all over the business code.
  • Interop. NOOA defines its tools through its methods, while the ecosystem has largely settled behind MCP. Framework-native tools are pleasant; protocol-native ones are portable. You have to choose.
  • Python and nothing else. No TypeScript or browser entry point. On a front-end-heavy stack (WebXR, three.js), NOOA remains a strictly back-end matter.
  • Non-determinism becomes invisible. A ... looks like code. Except it costs tokens, latency, and it can fail differently on every run. The readability you gain can make you forget the real price of that line.

6. What it changes for development

Beyond NOOA’s own fate, four underlying shifts:

  1. The harness becomes a measurable engineering concern. Several benchmark points at constant model and half the tokens: the architecture around the model is no longer an integration detail. It is a lever with direct ROI on the inference bill.
  2. Typed contracts replace the defensive prompt. A -> TypedTicket validated at runtime beats three paragraphs begging the model to respect a format. Prompt engineering slides towards interface design.
  3. Code as action eats into tool schemas. A frozen menu of serialised tools is expensive and constraining. Letting the model write Python that calls the object’s methods is far more expressive — at the exact price of a non-negotiable sandbox.
  4. Agents enter CI. If an agent is ordinary code, it can be tested, versioned and read in review. That is the condition for an agent to reach production without being a black box.

NVIDIA acknowledges as much: the community is already converging on several of these ideas, often as partial or experimental features, and the comparison is published precisely to push adoption. That is probably the most credible scenario — an abstraction that looks odd at first and becomes obvious afterwards, whether under this name or inside the frameworks we already use.

The takeaway

NOOA is the most interesting agentic abstraction of 2026, and for a rare reason: it removes concepts instead of adding them. The reliability gain does not come from a prompting trick, it comes from an architectural decision — making determinism free and the model call explicit.

One rule remains non-negotiable all the same: a framework that executes generated Python is powerful in exact proportion to the damage it can cause.

Sources

Primary sources

Third-party analysis and coverage

  • MarkTechPost — NVIDIA AI Releases NOOA: An Object-Oriented Python Framework That Turns an AI Agent Into a Single Python Class, Asif Razzaq, 7 August 2026 (benchmark detail, PredictStrategy / CodeActStrategy strategies, memory subsystem) — marktechpost.com
  • CodeOxi — NVIDIA NOOA: AI Agents as One Python Class, 8 August 2026 (LangGraph comparison, critical reading of the 82.2%, threat model) — codeoxi.com/blog/nvidia-nooa-python-agents
  • Wavect — NVIDIA NOOA Review: Object-Oriented AI Agents, 9 August 2026 (buy/pilot angle, wrapping behind an application interface) — wavect.io
  • Cobus Greyling (Medium) — NVIDIA-labs Object Oriented Agent Framework (NOOA), August 2026 (positioning vs smolagents and LangGraph, NVIDIA moving up the stack) — cobusgreyling.medium.com
  • DEV Community — NOOA: What If an AI Agent Was Just a Python Object?, Gaurav Talesara, 12 August 2026 (0.x maturity, API stability) — dev.to
  • AI Weekly — NVIDIA open-sources NOOA, a single-class Python agent framework, 10 August 2026 (token efficiency reading) — aiweekly.co
  • AI Wiki — NOOA entry (summary of the six capabilities and the fourteen compared frameworks) — aiwiki.ai/wiki/nooa

Figures and versions verified in September 2026. NOOA being a research preview, the API and the results may evolve.

Related Content