NVIDIA-NeMo/labs-OO-Agents

NVIDIA Object Oriented Agents: the Pythonic way to build AI Agents.

What it solves

NOOA provides a more intuitive, Pythonic way to build AI agents by consolidating prompts, tools, capabilities, and state into a single Python class. It eliminates the need to manage these as separate abstractions, allowing developers to use familiar software engineering practices like type annotations, docstrings, and object-oriented programming to define agent behavior.

How it works

The framework treats agents as Python objects. It uses a unique approach where methods with empty bodies (...) are designated as "generation methods" that are implemented at runtime by an LLM.

  • Prompts as Docstrings: The agent's docstring and method docstrings serve as the prompt.
  • Capabilities as Methods: Python methods define the agent's tools and interfaces.
  • State as Fields: Typed fields on the object store the agent's state.
  • Code as Action: The model interacts with the environment by writing Python code in a Jupyter-style REPL, accessing self and other helpers directly.

Who it’s for

Python developers building AI agents who want to use standard software development workflows (testing, tracing, and refactoring) and a model-agnostic framework that supports various LLMs via LiteLLM.

Highlights

  • Object-Oriented Interface: Unifies state, prompts, and tools within a single class.
  • LLM-Driven Methods: Allows seamless mixing of deterministic Python code and LLM-generated logic.
  • CodeAct Workflow: Uses a Python REPL for tool use, reducing the need for manual tool-schema definitions.
  • Model Agnostic: Supports a wide range of hosted and local models (e.g., Claude, GPT, Ollama, vLLM).
  • Integrated Tracing: Built-in support for tracing LLM calls and code execution via a dedicated CLI and viewer.

Related

  • Project
    jjyaoao/HelloAgents

    HelloAgents is a Python library that provides a production‑grade framework for building multi‑agent AI applications. It wraps OpenAI‑compatible, Anthropic, and Gemini LLMs, offers built‑in tools (file I/O, task delegation, todo tracking), and includes engineering features such as context management, session persistence, circuit‑breaker, optimistic locking, observability, streaming SSE, and async lifecycle. Install via `pip install hello-agents`, configure a `.env` with your API credentials, and start agents like `ReActAgent` with a registered tool set.

  • Project
    trycua/cua

    Cua is an open‑source stack that gives AI agents the ability to control desktop applications in the background across macOS, Windows, Linux and Android. It includes cross‑OS drivers, a Python sandbox SDK for spinning up VMs/containers, a benchmark suite (Cua‑Bench) for evaluating computer‑use agents, and Lume for fast macOS virtualization on Apple Silicon. The project is MIT‑licensed and targets researchers and developers building autonomous agents that need to interact with real GUIs.

  • Project
    cloudflare/agents

    Cloudflare Agents is a TypeScript SDK that turns Cloudflare Durable Objects into persistent, real‑time AI/agent workloads. It provides type‑safe RPC (`@callable`), WebSocket sync, scheduling, AI chat, tool‑calling, voice, email, payments (x402), workflows, and a full React hook library. Agents hibernate when idle and can be deployed at millions‑scale with zero idle cost.

  • Project
    yzhao062/agent-style

    agent‑style is a Python/Node library that supplies 21 classic‑and‑LLM‑observed writing rules for AI coding‑and‑writing agents. The rules are injected into the model’s system prompt (soft enforcement) and can also be applied as a post‑generation review skill. Benchmarks on Claude Opus, GPT‑5.4, and Gemini 3 Flash show sizable drops in mechanical rule violations, proving the approach can make AI‑generated technical prose clearer.

  • Project
    agiresearch/AIOS

    AIOS is an open‑source “operating system” for LLM‑based agents. The kernel (this repo) manages LLM instances, memory, storage, and tool sandboxing, exposing a syscall‑style API via the Cerebrum SDK. It supports many model back‑ends (Ollama, vLLM, HuggingFace, Deepseek), integrates external tools, and offers several deployment modes—from local single‑machine setups to remote, personal, and virtualized kernels. Installation is via a Python 3.10/3.11 environment, configuration is done in `config.yaml`, and agents can be run through a web UI or a natural‑language terminal. The project is research‑grade (multiple conference papers) and actively maintained.