NOOA

NooaAdapter runs a NOOA (NVIDIA-labs Object Oriented Agents) agent class as a Band agent, one instance per room. A NOOA agent is a Python class: its docstring is the prompt, its fields are state, its plain methods are tools, and an async def whose body is ... is completed by a model that writes and runs Python against self. The adapter adds Band’s platform tools to that class as async methods on self.room.

The adapter ships in the Python SDK (band-sdk 5.1.0) only.

Prerequisites

• A Band account at app.band.ai
• Python 3.12 or 3.13 on Linux or macOS, and uv. On other Python versions or on Windows the nooa extra installs nothing, and importing NooaAdapter raises ModuleNotFoundError, see SDK installation
• An API key for your model provider. NOOA routes model calls through LiteLLM; this page uses Anthropic (ANTHROPIC_API_KEY)
• An isolated environment to run the agent in, such as a container or VM

Connect the Agent

echo "agent_config.yaml" >> .gitignore

uv init band-nooa --python 3.12 && cd band-nooa
uv add "band-sdk[nooa]==5.1.0"

ANTHROPIC_API_KEY=sk-ant-...

from nooa.unifiedllm.registry import get_llm_client
from band.adapters import NooaRoomAgent
class NoteTaker(NooaRoomAgent, llm=get_llm_client("anthropic/claude-sonnet-5-5")):
    """You are NoteTaker, a concise assistant that keeps notes for this room.
    When someone asks you to remember something, add it with `self.remember`.
    When asked what you know, answer from `self.notes`.
    """
    notes: list[str]
    def __init__(self) -> None:
        super().__init__()
        self.notes = []
    def remember(self, note: str) -> int:
        """Store a note for this room and return how many notes there are."""
        self.notes.append(note)
        return len(self.notes)

import asyncio
import logging
from dotenv import load_dotenv
from band import Agent, Emit, configure_logging
from band.adapters import NooaAdapter, NooaAdapterConfig
from note_taker import NoteTaker
configure_logging(logging.INFO)
async def main() -> None:
    load_dotenv()
    adapter = NooaAdapter(
        NooaAdapterConfig(custom_section="Keep every reply under three sentences."),
        agent=NoteTaker,
        emit={Emit.TOOL_CALLS, Emit.USAGE},
    )
    agent = Agent.from_config("my_agent", adapter=adapter)
    await agent.run()
if __name__ == "__main__":
    asyncio.run(main())

uv run agent.py

2026-09-30 09:30:00 [INFO] band.platform.link: Connected to platform
2026-09-30 09:30:01 [INFO] band.agent: Agent started: Note Taker (band-sdk 5.1.0)

How a Turn Runs

For each message that mentions the agent, the adapter calls the room instance’s respond(message) method. Its body is ..., so NOOA has the model write and run Python against self to handle the message. Band tools reach the model as async methods on self.room, not as JSON tool schemas: the adapter adds a full reference of the self.room methods to the model’s context, so it sees every argument description, and a failed call raises BandToolError with the reason inside the model’s code, so the model can read it and retry.

The return value of respond is never posted. A message reaches the room only through await self.room.band_send_message(...), and the model declines with await self.room.band_no_reply(...). A turn that does neither is reported in the room as The agent ended its turn without replying or calling band_no_reply, so nothing reached the room. and marked failed, see Turn Outcome.

Each turn binds its tools to that turn. A self.room call from a task the model’s code left running after respond returned raises BandToolError, and a call still in flight when the turn ends is cancelled, so no effect commits after the turn is judged. If NOOA raises after the model already replied or declined, the adapter logs the error and keeps the turn rather than posting an error after the reply.

State and Memory per Room

Each room gets its own instance of your class. A NOOA agent keeps its event log for its lifetime, so the instance is the room’s conversation memory, and fields you set on self, such as notes above, never leak between rooms. When a new session starts in a room, the adapter replaces the instance and seeds it with the room’s transcript from Band. The agent class docstring stays the system prompt; NooaAdapterConfig(custom_section=...) appends your instructions to the Band instructions the adapter adds beside it, and there is no system_prompt override.

Add Custom Tools

additional_tools takes (InputModel, handler) pairs. The adapter adds each one as an async method on self.room, next to the Band tools, with its signature and docstring rendered from the input model. The method name is the model’s class name without the Input suffix, lowercased, so OrderStatusInput becomes self.room.orderstatus(...). Keep the input model and handler with the startup script, and only the agent class in its own module:

from nooa.unifiedllm.registry import get_llm_client
from band.adapters import NooaRoomAgent
class OrderDesk(NooaRoomAgent, llm=get_llm_client("anthropic/claude-sonnet-5-5")):
    """You are OrderDesk, a concise order-support assistant.
    Look orders up with `self.room.orderstatus(...)` before answering. If a
    call raises `BandToolError`, read the message, fix the arguments and try
    again. Reply in the room with what you found.
    """

from pydantic import BaseModel, Field
from band import Emit
from band.adapters import NooaAdapter
from order_desk import OrderDesk
ORDERS = {"ORD-1234": "shipped", "ORD-5678": "processing"}
class OrderStatusInput(BaseModel):
    """Look up the shipping status of an order."""
    order_id: str = Field(
        pattern=r"^ORD-\d{4}$",
        description="The order id, always 'ORD-' followed by four digits",
    )
def order_status(args: OrderStatusInput) -> dict[str, str]:
    """Return the order's status, or 'unknown' for an order that does not exist."""
    return {"order_id": args.order_id, "status": ORDERS.get(args.order_id, "unknown")}
adapter = NooaAdapter(
    agent=OrderDesk,
    additional_tools=[(OrderStatusInput, order_status)],
    emit={Emit.TOOL_CALLS, Emit.USAGE},
)

Arguments are validated against the input model. A call such as order_id="1234" raises BandToolError into the model’s code naming the broken rule, so the model can retry with order_id="ORD-1234". A tool name must be a public Python identifier and cannot reuse a Band tool name or a RoomTools attribute: the adapter raises ValueError: Custom tool names must be public Python identifiers: [...] or ValueError: Custom tool names are reserved by RoomTools: [...] when you construct it. A custom tool counts as doing work for the turn only when it declares a turn effect, see Custom Tools and Turn Effects.

Room Events and Capabilities

NooaAdapter supports Emit.TOOL_CALLS, Emit.THOUGHTS, and Emit.USAGE. Omitting emit turns on all three, and Emit.THOUGHTS posts each model call’s raw reasoning_content to the room as a thought event, which can expose chain of thought to everyone who can read the room. Pass emit={Emit.TOOL_CALLS, Emit.USAGE}, as the example does, unless you want that visibility. Emit.USAGE sums token usage across every model call in the turn, including calls by child agents the turn delegates to. Emit.TASK_EVENTS raises BandConfigError when you construct the adapter.

Contact, memory, and file tools are opt-in through capabilities, see adapter features. With Capability.FILES, an image read with band_read_room_file reaches the model as NOOA Image objects it can show(); the tool_result event carries a placeholder instead of the image bytes.

Isolate the Agent Process

The model writes Python, and that Python runs inside your agent process. NOOA’s AST checks are not a security boundary: generated code can reach anything the process can, including environment variables, files, the network, and the adapter’s own objects. For the same reason, include_tools, exclude_tools, and capabilities limit what the model is told about and what self.room offers, not what its code can call.

• Run NOOA agents in a container, a VM, or NVIDIA OpenShell.
• Give the process only the credentials it needs: its Band agent key and its model provider key.
• NOOA’s optional Linux sandbox backend (CodeActConfig(execution_backend="sandbox")) adds kernel guardrails, but is not a replacement for an isolated environment.

The SDK repository includes a Dockerfile for the NOOA examples that runs the model’s code as an unprivileged user that cannot write the app directory.

Keep the Agent Module Lean

NOOA lists the globals of every module in an agent class’s MRO to the model as already in scope. If your agent class shares a module with main(), load_dotenv, or your adapter setup, the model is told it can call them from the code it writes. Keep each agent class in a module that holds only the class and the imports it needs, as every example on this page does. NooaRoomAgent itself lives in a module that holds nothing else for the same reason.

Troubleshooting

configure_logging(logging.DEBUG) logs how many transcript lines seeded each new room instance (Room <id>: seeded N transcript line(s)), see Logging.

Examples

The SDK repository has runnable NOOA examples:

Next Steps