NVIDIA NeMo Agent Toolkit

Not in the preview yet. This feature is built in the repository but is off in the v2.2.6 preview (test mode). Do not treat this page as available on a preview core. See ../preview.md and the release notes.

dynamoprotocol-nemo adds Dynamo to NVIDIA NeMo Agent Toolkit (NAT). Every agent function in a workflow gets its own capped slice of one budget. An agent that invokes another agent opens a child slice under itself, which can never exceed what its parent has left. A run that would go over its slice is refused before it starts.

NAT has no hook that can refuse an individual model call made through a framework wrapper, so this plugin reserves per agent run (the spawn-scoped profile), not per model call.

The plugin is not published. It installs from a clone of the repository.

Install and try it

These are the commands from the plugin README. They boot a local core in Control Mode, build a venv from the hash-checked locks/test.txt and run the offline containment demo with scripted agent functions: no provider key, no model called. You need Node 22.12 or later, pnpm 9, curl, openssl and Python 3.11 (set PYTHON=python3.11 if python3 is another version). Set DYNAMO_REPO to your clone.

cd "$DYNAMO_REPO"
pwd
pnpm install --frozen-lockfile
pnpm --filter @dynamo/core-host... -r build
export DYNAMO_OWNER_TOKEN="dp-local-owner-$(openssl rand -hex 16)"
export DYNAMO_CORE_URL="http://127.0.0.1:${DYNAMO_CORE_PORT:-8790}"
[ -s .dynamo-local.key ] || (umask 077 && openssl rand -hex 32 > .dynamo-local.key)
export CORE_KEY_ENCRYPTION_KEY="$(cat .dynamo-local.key)"
OWNER_API_TOKEN="$DYNAMO_OWNER_TOKEN" PLUGIN_WIRE_TOKEN="dp-local-wire-$(openssl rand -hex 16)" \
  OWNER_API_PORT="${DYNAMO_CORE_PORT:-8790}" CORE_DB="$PWD/.dynamo-local/core" CORE_LOG=off \
  CORE_RATE_LIMIT_RPS=200 CORE_RATE_LIMIT_BURST=400 \
  node deploy/image/entry.mjs > .dynamo-local.log 2>&1 &
CORE_PID=$!
trap 'kill "$CORE_PID"' EXIT
"${PYTHON:-python3}" -m venv .venv-nemo
PIP_ONLY_BINARY=":all:" .venv-nemo/bin/pip install --quiet --require-hashes -r packages/plugin-nemo/locks/test.txt
.venv-nemo/bin/pip install --quiet --no-deps ./packages/sdk-python ./packages/plugin-nemo
for _ in $(seq 150); do curl -fsS "$DYNAMO_CORE_URL/healthz" > /dev/null 2>&1 && break; sleep 0.2; done
.venv-nemo/bin/python packages/plugin-nemo/examples/containment/run.py
kill "$CORE_PID"; trap - EXIT

Delete .venv-nemo when you are done.

Wrap an agent run in a budget

This is packages/plugin-nemo/examples/app/with_dynamo.py: an orchestrator function that invokes a researcher function, built with WorkflowBuilder, with Dynamo added. make test-plugin-nemo runs it against a local core (tests/test_examples.py).

# SPDX-License-Identifier: Apache-2.0
"""A small multi-agent app on NVIDIA NeMo Agent Toolkit — with Dynamo.

Runs offline: scripted agent functions stand in for real ones (no model is called).
"""

import asyncio

from nat.builder.workflow_builder import WorkflowBuilder

from dynamoprotocol_nemo import AgentConfig, DynamoBudgetMiddlewareConfig, DynamoNAT, usd
from dynamoprotocol.testing import mock_prices
from dynamoprotocol_nemo.testing import SCRIPTS, Script, ScriptedAgentConfig, Spawn

AGENTS = ("orchestrator", "researcher", "writer")
SCRIPTS["app"] = Script()
SCRIPTS["app"].queues["orchestrator"].append(Spawn("researcher", text="three sources found"))


async def main():
    dyn = await DynamoNAT.connect(prices=mock_prices(), cap=usd("5"), mandate={"categories": ["research", "writing", "review"], "maxDepth": 3},
        agents={"orchestrator": AgentConfig(usd("5"), "review"), "researcher": AgentConfig(usd("1"), "research"), "writer": AgentConfig(usd("1"), "writing")},
        run_budgets={name: usd("0.10") for name in AGENTS})
    async with WorkflowBuilder() as builder:
        await builder.add_middleware("dynamo", DynamoBudgetMiddlewareConfig())
        for name in AGENTS:
            await builder.add_function(name, ScriptedAgentConfig(script="app", middleware=["dynamo"]))
        orchestrator = await builder.get_function("orchestrator")
        print(await orchestrator.ainvoke("Write a brief on grid-scale storage"))
    await dyn.close()


asyncio.run(main())

before one of its runs.

middleware=["dynamo"] on every agent function put each run under the budget.

DYNAMO_CORE_URL and DYNAMO_OWNER_TOKEN point it at your core. With a real model, pass your price table instead of mock_prices().

What a refusal looks like

A refusal raises DynamoCapExceeded, DynamoMandateRefused, DynamoRevoked, DynamoUnpricedModel, DynamoFrozen, DynamoStopped, DynamoApprovalPending, DynamoApprovalDenied or DynamoAmendmentRefused, all subclasses of DynamoNATError. It is raised before the function body runs. An agent without a run budget is refused, and a streamed function call is refused (stream_unsupported).

Funding modes

always a Control Mode budget: every check runs and no money moves. The quickstart and every test of this plugin use one.

budget by id (budget_id=). The plugin does not refuse it, but no test runs the plugin on one. In those modes the core requires signed hops by default, and a child slice opened without its delegator's signature is refused hop_unsigned. Pass hops= (a LayerHops from dynamoprotocol.agents: the delegator's key and each payee's own signed offer) so the plugin signs every hop it opens.

operator allows it, and real-money settlement is not released.

Known limits

Read packages/plugin-nemo/KNOWN-LIMITS.md in the repository before you rely on the plugin. It covers the cryptography advisories that NAT's pin leaves in your install.