NVIDIA Launches NOOA — Coding AI Agents as Python Objects

The days of having to draw complex workflow graphs or learn unfamiliar domain-specific languages (DSLs) just to build an AI agent might finally be over. NVIDIA’s open-source agent framework, NOOA (labs-OO-Agents), brings this complex development process into the familiar world of everyday Python classes and objects. Instead of prompt templates or tangled execution flows, it offers a simple and powerful way to implement agents using the object-oriented approach that software developers know best.

'Classes' and 'Docstrings' Instead of Graphs and Prompt Templates

The operating principle behind NOOA is highly intuitive. It applies the concepts of Object-Oriented Programming (OOP)—the most familiar paradigm for software developers—directly to AI agent development.

Fields in an agent class act as the 'state' that the model monitors and updates in real-time, while the docstrings written inside methods serve as 'prompt templates' that the LLM reads to understand how to act.

By incorporating standard Python type hints, it strictly defines the specifications for input and output data. Developers can design how an agent behaves using the familiar Python code format they already use, rather than learning obscure configuration files or new prompt orchestration tools.

The LLM Engine That Works with a Single Ellipsis (...)

Within a class, standard methods function accurately and safely according to the rules we write. However, when you leave a simple Python ellipsis ('...') instead of writing out the specific code implementation, something magical happens. This placeholder is filled at runtime by a 'CodeAct' loop where the LLM generates and executes code in real-time.

Thanks to this, you can keep parts that require rigid rules—like data validation or local file handling—strictly defined with regular Python code, while naturally delegating only the creative judgment or complex reasoning tasks to the LLM.

# Python 3.10+ 및 NOOA v0.1 기준
from oo_agents import Agent

class BugFixer(Agent):
    """
    깃허브 이슈를 분석하고 버그를 해결하는 전문 개발 에이전트입니다.
    """
    code_base: str = ""
    is_solved: bool = False

    def run_tests(self) -> bool:
        # 개발자가 직접 작성한 안전하고 결정론적인 테스트 규칙
        return "FAIL" not in self.code_base

    def resolve_issue(self, issue_desc: str) -> str:
        """
        주어진 이슈 설명과 현재 코드를 기반으로 버그를 수정합니다.
        """
        # 생략 기호를 사용하면 이 메서드는 LLM 기반의 CodeAct 루프로 실행됩니다.
        ...

This integration method is much safer than the unfettered prompt execution seen in existing agent tools. Because the LLM isn't running in an uncontrolled state, but rather operating within the strict bounds of type hints and method specifications defined by the developer, it’s like an AI safely accelerating along a precisely programmed track.

Possibilities Proven by 82.2% Performance on SWE-bench Verified

Ease of use doesn't come at the cost of performance—quite the opposite. By leveraging the 'xhigh reasoning effort' mode, the top tier of GPT-5.5's reasoning capabilities, NOOA achieved an 82.2% pass rate on the notoriously difficult software engineering benchmark, 'SWE-bench Verified'.

This performance easily outpaces existing agent frameworks that rely on layers of complex graphs and heavy orchestration tools. The streamlined Python object structure allows the model to stay focused on solving the problem without getting lost.

Even more notable is the efficiency in cost and resources. NOOA significantly reduces total token consumption and meaningless repetitive calls compared to using traditional, dedicated execution harnesses. It serves as proof that the more intuitive and lightweight an agent's framework, the more clearly an LLM can grasp the situation and reach the correct answer quickly.

Agent Development is Ultimately Software Engineering

NVIDIA NOOA has untangled the knots of complex agent development by getting back to the basics: plain old Python objects. Instead of clinging to unfamiliar frameworks or template-specific rules, we can now build agents using the same classes and functions we use every day.

Ultimately, the secret to building more robust AI systems isn't about learning entirely new technologies. It’s about applying familiar, proven software engineering principles to the AI development space—that is the real shift we should be paying attention to.