Ask a team running an agent in production the one question that matters after something goes wrong — "walk me through exactly how it did that" — and most can't. The prompt is somewhere, the tool calls are half-logged, the model's reasoning evaporated. The OpenAI/Hugging Face sandbox escape was the loud version of this problem: capability arrived before anyone could trace it. NOOA is NVIDIA's answer, and it's the harness-layer piece of the new Open Secure AI Alliance.

What it is: your agent, as a plain Python class#

NOOA — NVIDIA-labs OO Agents — is a model-agnostic, open-source Python framework released on July 27, 2026 (GitHub). Its one idea is a good one: an agent should be an ordinary object, built the way you build any other reliable software. Concretely:

Illustratively, the shape looks like normal Python — one typed, documented method per thing the agent can do:

class RefundAgent:
    """Handles customer refund requests under a hard cap."""

    daily_spent: float = 0.0          # field = state

    def issue_refund(self, order_id: str, amount: float) -> RefundResult:
        """Refund an order. Only call for a verified order under the daily cap."""
        ...                            # method = a capability, typed as a contract

Because the agent is a real class, it drops straight into the tooling you already trust — pytest, tracing, code review diffs, git. Check the repository README for the exact base class and install command; the API is evolving, but the model above is the point of the thing.

What it buys you: auditability by construction#

The payoff is that NOOA records model calls, code execution, and method invocations as the agent runs. When you need to answer "why did it do that?", you have the trace: which capability ran, with which inputs, driven by which model call. NVIDIA is explicit that NOOA targets tracing, testing, auditing, and governance — not raw reasoning scores. It doesn't make your agent smarter; it makes your agent explainable.

NOOA doesn't make your agent smarter. It makes your agent explainable — which, after an incident, is the only property that matters.

That framing is why it shipped inside a security alliance rather than as a competitor to LangGraph. It's an orthogonal axis: orchestration frameworks optimize for building behavior fast; NOOA optimizes for behavior you can test, diff, and defend.

Who should pick it up#

If your fastest goal is a demo, an orchestration framework gets you there quicker, and a bolt-on tracer gives you dashboards without rewriting anything. NOOA earns its keep when the stakes are different: a regulated vertical, anything touching money or a customer's data, or any team that has already been burned by an agent action nobody could reconstruct. Pairing it with a human sign-off gate on irreversible actions gives you both prevention and a paper trail.

The cost is honest: you write your agent as disciplined, typed, documented methods instead of an ad-hoc loop. That's not free — but it's the same discipline that separates software you can maintain from software you can only pray to. For once, the "governance" tool is also just the well-engineered one.