NVIDIA NOOA

The Problem with Ephemeral Agents

Most AI agent frameworks today treat agents as ephemeral conversation sessions. You create an agent, it runs for a while, and when the conversation ends, the agent disappears. There's no persistent identity, no way to modify an agent mid-task, and no clean lifecycle management. This works fine for short, one-off tasks, but it breaks down completely for long-horizon autonomous work.

NVIDIA Research has published a paper and open-source framework that fundamentally rethinks this model. They call it NVIDIA NOOA (NVIDIA Open Object-oriented Agents), and it applies the principles of object-oriented programming to AI agents — treating them as persistent objects with state, behavior, and a full lifecycle.

The NOOA Design

NOOA introduces a framework where agents are modeled as objects that can be:

• Instantiated — created with specific parameters, state, and capabilities
• Modified — updated mid-task with new instructions, tools, or parameters
• Deleted — properly decommissioned when their task is complete

This is a significant departure from the conversation-based agent model. Instead of starting a new chat every time you need an agent, you create an agent object that persists across interactions, maintains its own state, and can be modified as the task evolves.

Three Pillars of the Framework

1. Persistent State

Each NOOA agent maintains its own internal state — memory, context, task progress, and configuration. This state persists across multiple interactions and sessions, enabling agents to work on tasks that span hours, days, or even weeks without losing their place.

2. Well-Defined Behavior

Agents have clearly defined methods and capabilities. They can be called like functions, passed as arguments to other agents, and composed into larger workflows. The behavior is deterministic and inspectable — you can see what an agent knows, what it's doing, and what it's capable of at any point in time.

3. Full Lifecycle Management

NOOA provides explicit lifecycle operations for agents. You can create agents programmatically, modify their parameters mid-execution, and delete them when they're no longer needed. This enables dynamic agent orchestration where a supervisor can spawn workers, adjust their behavior based on progress, and clean up resources efficiently.

Multi-Agent Orchestration

The framework supports multi-agent setups where a supervisor agent manages a team of worker agents. The supervisor can instantiate new agents, modify existing ones, and delete completed agents — all while maintaining a global view of task progress.

The paper demonstrates this with a software development scenario where a supervisor agent manages code review and testing agents, dynamically adjusting their parameters based on task progress.

Benchmarks

NVIDIA evaluated NOOA across multiple task categories and compared it against traditional chat-based agents and other frameworks. The results showed significant improvements for long-horizon tasks:

For medium-horizon tasks (spanning hours), NOOA showed moderate improvements. For short-horizon tasks, the improvement was minimal — which makes sense, since the object-oriented approach is specifically designed for persistent, long-running scenarios.

Code Example

Here's how the NOOA API looks in practice — a supervisor agent managing a code review workflow:

# Instantiate a code review agent with specific parameters
code_reviewer = NOOA.create_agent(
    name="code_reviewer",
    capabilities=["code_analysis", "security_scan"],
    config={"strictness": "high"}
)

# The agent runs its task, maintaining persistent state
code_reviewer.run(task="Review PR #1234")

# Modify the agent mid-task based on new requirements
code_reviewer.modify(config={"strictness": "maximum"})

# When done, properly decommission the agent
code_reviewer.delete()

This is fundamentally different from the typical agent pattern where you'd start a new conversation, paste instructions, and hope the agent remembers context from previous turns. With NOOA, the agent is a first-class object with explicit state management.

Use Cases

The framework is designed for scenarios where agents need to persist beyond a single conversation:

• Customer service systems — agents that maintain context across multiple customer interactions over weeks
• Research assistants — agents that track ongoing research projects, accumulating knowledge over months
• Autonomous vehicles — coordinating multiple agents for navigation, perception, and control
• Software development — teams of agents collaborating on complex codebases with persistent project context

Availability

The NOOA framework is open-source, released under Apache 2.0. The code is available on GitHub at github.com/NVIDIA-NeMo/labs-OO-Agents [Link] and includes a Python SDK, example implementations, and benchmark tools. The paper is available on arXiv: 2607.20709 [Link].

Implications

This is not just another agent framework. It's a fundamental rethinking of how AI agents should be architected. By treating agents as objects rather than conversations, NOOA enables a new class of applications — truly persistent, long-running autonomous systems that can maintain context, evolve over time, and be properly managed throughout their lifecycle.

For developers building multi-agent systems, this is particularly relevant. The ability to programmatically create, modify, and delete agents opens up dynamic orchestration patterns that weren't possible with conversation-based approaches. You can build systems where agents are spawned on demand, adjusted based on real-time feedback, and cleaned up when their work is done.

The benchmarks suggest this approach is particularly valuable for tasks that span multiple days or weeks — exactly the kind of long-horizon work that current agent frameworks struggle with. If you're building anything that requires persistent agent memory and lifecycle management, NOOA is worth looking at.

Built on NVIDIA's NeMo framework, this is also positioned for production deployment at scale. It's not a research prototype — it's a framework designed for real-world use cases where agents need to be reliable, inspectable, and manageable over extended periods.