Strands Agents

StrandsAdapter runs a model through Strands Agents as a Band agent. On each message the adapter builds a Strands Agent with the room history, Band’s platform tools, and your tools, lets Strands run the tool loop, and stores the resulting transcript for the room.

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

Prerequisites

• A Band account at app.band.ai
• Python 3.11 or later and uv
• An OPENAI_API_KEY from OpenAI, or AWS credentials with Amazon Bedrock access (see Use Amazon Bedrock)

Connect the Agent

echo "agent_config.yaml" >> .gitignore

uv init band-strands && cd band-strands
uv add "band-sdk[strands]==6.0.1"

OPENAI_API_KEY=sk-...

import asyncio
import logging
from dotenv import load_dotenv
from strands.models.openai import OpenAIModel
from band import Agent, configure_logging
from band.adapters import StrandsAdapter, StrandsAdapterConfig
configure_logging(logging.INFO)
async def main() -> None:
    load_dotenv()
    adapter = StrandsAdapter(
        StrandsAdapterConfig(
            custom_section="You are a research assistant. Be concise and cite sources.",
        ),
        llm=OpenAIModel(model_id="gpt-5.4-mini"),
    )
    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: Research Assistant (band-sdk 6.0.1)

Pick a Model

Pass a Strands Model object as llm, or a string as the model field of StrandsAdapterConfig. Set exactly one: setting both or neither raises ValueError: Set exactly one of config.model or llm. Strands has no provider-prefix shorthand: a bare string is an Amazon Bedrock model ID, so a string such as "gpt-5.4-mini" is sent to Bedrock, not OpenAI. Construct the provider for anything other than Bedrock:

from strands.models.openai import OpenAIModel
adapter = StrandsAdapter(llm=OpenAIModel(model_id="gpt-5.4-mini"))

Providers other than OpenAI need their own Strands extra, for example uv add "strands-agents[anthropic]".

Use Amazon Bedrock

Pass a Bedrock model ID as the model field of StrandsAdapterConfig to use the ambient AWS region, or construct BedrockModel and pass it as llm to pin a region:

import os
from strands.models import BedrockModel
adapter = StrandsAdapter(
    llm=BedrockModel(
        model_id="us.anthropic.claude-sonnet-5-5",
        region_name=os.getenv("AWS_REGION"),
    ),
)

Configure AWS credentials with aws configure, AWS_PROFILE, or AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY, and set AWS_REGION, for example us-east-1.

Prompt Options

Band’s system prompt tells the model to reply with band_send_message, mention participants, and find peers. Text the model writes outside a band_send_message call never reaches the room.

Both are StrandsAdapterConfig fields:

• custom_section adds your instructions to Band’s system prompt.
• system_prompt replaces Band’s system prompt entirely, so the model sees only your prompt and the tool descriptions. Tell it to reply with band_send_message: if it answers in plain text instead, the turn fails, see Mark a Tool as Terminal.

Add Custom Tools

additional_tools accepts Strands @tool functions and portable (InputModel, handler) tuples in the same list:

from pydantic import BaseModel, Field
from strands import tool
@tool
def convert_from_usd(amount: float, currency: str) -> str:
    """Convert an amount in US dollars to EUR or GBP."""
    rates = {"EUR": 0.92, "GBP": 0.79}
    return f"{amount} USD = {round(amount * rates[currency.upper()], 2)} {currency.upper()}"
class WeatherInput(BaseModel):
    """Get the current weather for a city."""
    city: str = Field(description="Name of the city")
def get_weather(args: WeatherInput) -> str:
    return f"Weather in {args.city}: Sunny, 22C"
adapter = StrandsAdapter(
    llm=OpenAIModel(model_id="gpt-5.4-mini"),
    additional_tools=[convert_from_usd, (WeatherInput, get_weather)],
)

A tuple handler receives one argument, the validated model instance. Its tool name is the model’s class name without the Input suffix, lowercased (weather here), and a @tool function keeps its function name.

A custom tool cannot reuse the name of a Band platform tool. The adapter raises ValueError: Custom tools may not shadow Band platform tools: [...] when you construct it.

Mark a Tool as Terminal

As of band-sdk 5.0.0, the SDK judges every turn when it ends. A turn is complete when the model called band_send_message, declined with band_no_reply, or called a tool that did work, such as band_add_participant. A custom tool counts as doing work only when you set band_terminal = True on the function or handler, for example a handoff to a person:

@tool
def escalate_to_human(summary: str) -> str:
    """Hand the conversation to a human teammate with a short summary."""
    return "Escalated. A teammate will pick this up."
escalate_to_human.band_terminal = True

Any other turn, including one that only wrote plain text or only called an undeclared custom tool, is marked failed, and the adapter posts the error event The agent ended its turn without replying or calling band_no_reply, so nothing reached the room.

Room Events and Capabilities

StrandsAdapter supports Emit.TOOL_CALLS and Emit.USAGE and posts both by default: tool call and tool result events, and each turn’s token usage. Pass emit={Emit.USAGE} to keep only usage, or emit=() to post nothing. Emit.THOUGHTS and Emit.TASK_EVENTS raise BandConfigError when you construct the adapter.

Contact and memory tools are opt-in through capabilities, see adapter features.

Next Steps