NOVA: The Object-Oriented Agent Framework — One Class per Agent

By Deepak Bagada, CEO at SaaSNext & AI Principal Architect.

July and August 2026 have been unkind to the "agent stack" status quo. In the last two years we stretched prompt scaffolding, tool registries, message queues, and orchestration graphs into sprawling multi-file projects that are nearly impossible to audit, version, or trace end to end. Then NVIDIA shipped NOVA, an object-oriented agent framework whose entire pitch fits in one sentence: an agent is a Python class. Methods are actions. Fields are state. Docstrings are prompts. Annotations are contracts. At face value it sounds almost naive — but the numbers behind the philosophy are the real headline.

NOVA reports 82.2% on SWE-bench Verified and 86.8% on CyberGym L1 while consuming roughly half the tokens of comparable pipelines. That combination — competitive accuracy at materially lower token spend — is what makes it interesting to every engineering manager who signed a six-figure model bill last quarter. And right now the framework is a pip install nooa alpha, which means it is shipping fast, breaking often, and demanding real engineering discipline from anyone who touches it.

This article walks through NOVA's object model, why the "one class per agent" design sounds like hype but actually compounds, the benchmark evidence, and — critically — the OS-isolation requirements you cannot skip if you intend to run it in production.

The problem: agent codebases decay faster than they ship

Before we talk about the fix, sit with the pain. A typical 2025-vintage agentic pipeline contains five artifacts:

• A prompt template file that must never drift from the persona you described in your documentation.
• A tool registry exporting serializable JSON schemas that are manually mirrored from Python type hints.
• A callback module firing "before_tool_call", "after_tool_call", and "on_failure" hooks across a contract nobody remembers writing.
• A workflow graph file — YAML or Python dict — that routes messages between sub-agents.
• A state store, sometimes the same memory store as the chat history, sometimes not.

These five artifacts live in different directories, reference each other through string IDs, and age at different speeds. The prompt says one thing, the tool schema says another, the orchestration layer handles nothing, and when a run misbehaves you spend a day diffing four files only to discover the prompt and the schema had already diverged.

This is not a skill gap — it is an architecture problem. The object model was right there the entire time.

The bet: Python's object model is the only agent contract you need

NOVA's reasoning, visible in the alpha release notes and developer docs, is that a programming-language class already provides every affordance an agent needs, if you load the binding deliberately:

The consequences are not cosmetic. There is exactly one source of truth per agent: the Python file itself. Your tool schema stops being a hand-maintained JSON blob and becomes the output of inspect.signature over your methods. The prompt for any given tool lives in that tool method's own docstring, next to the code it describes, so the "prompt vs. schema drift" class of bugs cannot occur in the framework runtime.

A minimal NOVA agent in one class

Here is what the alpha actually looks like — a full review agent expressed as one unit:

from nooa import Agent, field, tool

class PRRefiner(Agent):
    """You are a senior staff engineer reviewing pull requests.
    Follow repo conventions. Never invent tests you did not run.
    Verdicts: approve, request_changes, or merge_with_blockers."""

    owner: str = field(default="acme/oss-repo")
    base_branch: str = field(default="main")
    resolved_blockers: list[str] = field(default_factory=list)

    @tool
    def review_hunk(self, diff: str, diff_base: str) -> str:
        """Analyze exactly this patch. You may invoke linters or mocks."""
        ...

    @tool
    def comment_on_line(self, path: str, line: int, body: str) -> None:
        """Leave a line-level comment using the repo's convention."""
        ...

    @tool
    def merge(self, force: bool = False) -> str:
        """Merge the target branch after checks pass. Force only in staging."""
        ...

    async def on_final(self, result) -> None:
        self.resolved_blockers.append(result)

In this alpha, the framework treats the class as the source of truth: it reads the docstring (system prompt), the @tool methods (tool library), the fields (conversation state), and the callable graph (the actions with guard rails against mismatch). Calling an agent instance runs a standard tool loop — plan, call, observe, repeat — while keeping every contract local to the file.

Docstrings as prompts: the underrated part

You might reasonably ask: docstring tricks? Really? And that skepticism is fair until you consider what docstrings buy that separate prompt files do not:

1. They sit beside the code. A tool method's specification and its implementation cannot disagree over months of refactors.
2. They are cheap tokens. A focused class docstring beats a 3,000-token "system prompt + few-shot + rubric" blob injected on every turn.
3. They version naturally. Git history becomes your prompt-debug battle log: revert the intent, the prompt behavior reverts with it. No "which prompt file was live?" archaeology.
4. They scale to sub-agents. A supervisor class that owns a team: list[Agent] composes naturally, and the nested docstructs stitch into a coherent narrative.

The token claim compounds on the same logic. Most agent pipelines resend the same instructions and schema on every single model call. NOVA caches and reuses the contract at the object layer and crafts runtime messages from the docstring once. Repeat that over dozens of turns and multi-hour tasks and the savings become real.

Where NOVA actually wins: the evals

NOVA's own harness reports 82.2% SWE-bench Verified and 86.8% CyberGym L1. SWE-bench Verified measures resolving real GitHub issues; CyberGym L1 evaluates command-plane capability in a defensive harness. Both numbers are competitive with the best coding and cyber agents of 2026, and the framework credits the accuracy not just to the model backbone but to the compact, consistent perception a single-class contract buys — fewer contradictory instructions, fewer hallucinated tool signatures.

The boundary number worth quoting in planning meetings is the token one: comparable accuracy at roughly half the tokens on the same workloads.

Does that mean NOVA beats everything everywhere? No. It is an alpha, it changes fast, and a single-class model is a stretch for genuinely episodic multi-surface workflows where you have just a few very different one-shot workers — the explicit graph still reads better in the rare case. The point is that for roughly 85% of shipped agents — one stateful worker that acts in cycles, rewrites files, calls tools, resumes from snapshots — the class model is strictly simpler, cheaper, and more debuggable.

The costs: token math with real money

Let's make "half the tokens" concrete. Assume the common workload: an autonomous code-review-and-merge agent on every PR of a mid-size team (say 2,400 PRs per year). Under a classical stack the agent consumes roughly 120K tokens per PR (system prompt + schema + context reassembly + tool results), of which 55–70% is repeated scaffolding. NOVA, via docstring sourcing and cached contracts, drops that toward 55–60K per PR.

That is roughly $446 per team per use case — before counting the consulting hours you will save by never debugging four disagreeing files. For an enterprise running twenty autonomous workers across developer tooling, the "clean fuel" (token) savings land in the $9–15K range annually, plus the debugging hours you never consume. And the high-stakes punchline: 82.2% accuracy at the same or fewer tokens means you never "pay more for safety" — you pay less.

The isolation contract (read this before you deploy)

NOVA also ships an unusual security posture: because agents are full stateful classes with arbitrary tool calls, it assumes OS-level isolation. This is a hard requirement in the quickstart: do not run a NOVA agent in a process that may contact your production databases directly. The correct deployment is:

• One OS container (K8s pod, VM, or Firecracker/gVisor micro-VM) per agent replica
• An egress policy that limits network access to your tool allowlist
• No mounted secrets beyond session-relevant credentials
• A snapshot and rollback plugin so any fault resumes cleanly

This is not a flaw — it is an honestly stated requirement that many stacks obscure. In exchange you get the ability to hard-stop, snapshot, fork, and diff agents. For a DevKit like NOVA, "OS isolation required" is the sentence that should make you budget for a sandbox layer early. Amortize 500 ms cold spawns across a batch and it is genuinely serverless-doable — but build the budget.

Where this leaves the 2026 agent market

Two months ago agents were going to be the new "microservices." NOVA demonstrates that the mature answer is something more surprising: the object model was built by Python years ago, and the winners are keeping promises, schemas, state, and workflow in one file type with type annotations native to it. NVIDIA's eval is good but self-reported — run your own harness before you adopt. Your own issue triage, your own tool set, a fresh handful of real tickets: that beats any framework's home bench.

Go deeper. For pre-built agent and automation blueprints that follow the same single-contract discipline, browse the AI Workflows hub. If you wire NOVA to an MCP tool runtime, the curated registry at MCP Directory is the fast path to tools without keystroke-by-keystroke contract drift. For the alpha's every-other-week breaking changes, Latest AI News keeps you current.

Bottom line: agent frameworks that superclass designs on trees and JSON files were a ROIRO detour. The object-oriented agent — one class, one contract, half the tokens — is the destructive simplification 2026 was waiting for. The risk is not adoption; it is running it without isolation. Run your own eval this week, then sandbox before you celebrate.