Strands Agents
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-strands adds Dynamo to Strands Agents. Every agent in a run gets its own capped slice of one budget. A hand-off (Agent.as_tool(delegate=True) or a Swarm hand-off) or an agent used as a tool opens a child slice, which can never exceed what its parent has left. A model call that would go over its slice is refused before the model is called.
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 on a scripted mock model: 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-strands
PIP_ONLY_BINARY=":all:" .venv-strands/bin/pip install --quiet --require-hashes -r packages/plugin-strands/locks/test.txt
.venv-strands/bin/pip install --quiet --no-deps ./packages/sdk-python ./packages/plugin-strands
for _ in $(seq 150); do curl -fsS "$DYNAMO_CORE_URL/healthz" > /dev/null 2>&1 && break; sleep 0.2; done
.venv-strands/bin/python packages/plugin-strands/examples/containment/run.py
kill "$CORE_PID"; trap - EXIT
Delete .venv-strands when you are done.
Wrap an agent run in a budget
This is packages/plugin-strands/examples/app/with_dynamo.py: an orchestrator that delegates to specialists exposed with as_tool(delegate=True), with Dynamo added. make test-plugin-strands runs it against a local core (tests/test_examples.py).
# SPDX-License-Identifier: Apache-2.0
"""A small multi-agent app on Strands Agents — with Dynamo.
Runs offline: the scripted mock model stands in for a real one.
"""
import asyncio
from strands import Agent
from dynamoprotocol_strands import AgentConfig, DynamoStrands, usd
from dynamoprotocol.testing import mock_prices
from dynamoprotocol_strands.testing import ScriptedModel, Text, ToolCall, Upstream
upstream = Upstream()
SCRIPT = {"orchestrator": [ToolCall("researcher", {"input": "find sources"})], "researcher": [Text("three sources found")], "writer": [Text("draft written")]}
def model(name):
m = ScriptedModel("mock/scripted-1", upstream, agent=name)
m.queue.extend(SCRIPT[name])
return m
def agent(name, **kwargs):
return Agent(model=model(name), name=name, callback_handler=None, hooks=[dyn.hooks(name)], **kwargs)
async def main():
global dyn
dyn = await DynamoStrands.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")})
specialists = [agent("researcher").as_tool(delegate=True), agent("writer").as_tool(delegate=True)]
orchestrator = agent("orchestrator", tools=specialists)
result = await dyn.run(orchestrator, "Write a brief on grid-scale storage")
print(str(result).strip())
await dyn.close()
asyncio.run(main())
hooks=[dyn.hooks(name)]on eachAgentgates its model calls and its
tool hand-offs. An agent's name is its Dynamo key.
dyn.run(agent_or_swarm, prompt)runs the entry agent on its slice.- The model's config needs
model_idand a completion limit (max_tokens,
max_completion_tokens, max_output_tokens or maxTokens), or pass default_completion_tokens to connect; a call with no limit is refused (unbounded). The worst case of each call is reserved before it is made.
DYNAMO_CORE_URL and DYNAMO_OWNER_TOKEN point it at your core. With a real model, pass your price table instead of mock_prices(); an unknown model is refused.
What a refusal looks like
A refusal raises DynamoCapExceeded, DynamoMandateRefused, DynamoRevoked, DynamoUnpricedModel, DynamoFrozen, DynamoStopped, DynamoApprovalPending, DynamoApprovalDenied or DynamoAmendmentRefused, all subclasses of DynamoStrandsError. It is raised in BeforeModelCallEvent, before the model is streamed. A refused hand-off aborts the caller before the tool runs. dyn.run re-raises a refusal that a Swarm recorded as a failed node.
Funding modes
- Control Mode (Live). A budget the plugin opens itself (
cap=) is
always a Control Mode budget: every check runs and no money moves. The quickstart and every test of this plugin use one.
- A funded budget. You can pass an existing stablecoin or credit card
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.
- Real money (Release-gated). A core runs a money mode only when its
operator allows it, and real-money settlement is not released.
Known limits
Read packages/plugin-strands/KNOWN-LIMITS.md in the repository before you rely on the plugin.