Slack

SlackAdapter puts a Band agent into Slack. It wraps the framework adapter that does the agent’s reasoning, such as AnthropicAdapter or LangGraphAdapter, and binds each Slack thread to a Band room. People mention the bot in a channel or DM it, the agent answers in the thread, and it can @mention other Band agents in the bound room to get their help.

Slack is an app integration: it connects an app where people already work to Band, around an agent you connect with any framework adapter. To connect another app, see Build an App Integration.

How the Slack Adapter Works

The adapter runs in one process as one Band agent. It takes messages from two sides and hands both to the wrapped adapter, called the inner adapter here:

Each Slack thread maps to one Band room, keyed by app, channel, and thread. The first message in a thread creates the room, with the agent as its only participant, and records the binding as a task event, Slack thread context. The map lives in memory. After a restart, the adapter reads a room’s binding back when that room next delivers a Band message to the agent, so a Slack reply in an older thread before that opens a new room.

The person in Slack is not a Band participant and cannot be @mentioned. The adapter adds a note to every Slack turn that tells the inner adapter to answer with slack_send_message:

The adapter does not relay plain text from the inner adapter to Slack. An answer reaches the thread only through slack_send_message. As of band-sdk 5.0.0, a Slack turn that ends with neither slack_send_message, band_send_message, nor band_no_reply posts the error event The agent ended its turn without replying or calling band_no_reply, so nothing reached the room. to the bound room, and the thread gets no answer.

While the inner adapter works, the thread shows the status is thinking…, and each tool call appears as a Slack plan block that updates to done or error. Each Slack message that triggers a turn is also copied into the room as a thought event, so people reading the room in Band see the Slack side of the conversation. Agents never receive events, so the copy does not trigger anyone.

Prerequisites

• Python 3.11 or later and uv
• A Band account at app.band.ai
• A Slack workspace where you can create and install apps
• An Anthropic API key for the inner adapter on this page. Any Python framework adapter works in its place.

Install the SDK

uv init slack-agent && cd slack-agent
uv add "band-sdk[slack,anthropic]==6.0.1"

The slack extra installs slack-sdk, starlette, uvicorn, and aiohttp. The base package already includes python-dotenv, which loads .env. SlackAdapter is Python only: @band-ai/sdk 0.6.0 has no Slack adapter.

Create Your Agent in Band

1. In the Band web app, open Agents in the sidebar and click Connect remote agent.

2. In the Connect Remote Agent dialog, enter an Agent name (3 to 24 letters, numbers, or spaces) and a Description of at least 10 characters. Handle fills in from the name, and Tag your agent is optional. Other people and agents see the description when they look for an agent to add, so say what the agent does.

3. Click Connect Agent.

4. In the Agent Created Successfully! dialog, copy the ID and the API Key. The dialog shows the API key only once. If you lose it, open the agent’s menu and choose Regenerate API key, which invalidates the old key.

5. In your project directory, create agent_config.yaml and paste both values under the key my_agent:

   agent_config.yaml

   my_agent:
     agent_id: "<ID>"
     api_key: "<API Key>"

   The SDK looks up the agent by this key, so code that loads my_agent reads these two values. Add one top-level key per agent to keep several agents in the same file.

echo "agent_config.yaml" >> .gitignore

Create the Slack App

SLACK_BOT_TOKEN=xoxb-...
SLACK_APP_TOKEN=xapp-...
ANTHROPIC_API_KEY=sk-ant-...

Create the Bridge

import asyncio
import logging
import os
from dotenv import load_dotenv
from band import Agent, Emit
from band.adapters import AnthropicAdapter, AnthropicAdapterConfig
from band.integrations.slack import SlackAdapter, SlackAdapterConfig, SlackApp
logging.basicConfig(level=logging.INFO)
async def main() -> None:
    load_dotenv()
    inner = AnthropicAdapter(
        AnthropicAdapterConfig(
            model="claude-sonnet-5-5",
            custom_section=(
                "You are a helpful Slack assistant. Keep replies concise and "
                "use Slack-flavored markdown when it improves readability."
            ),
        ),
        emit=Emit.TOOL_CALLS,
    )
    slack = SlackAdapter(
        SlackAdapterConfig(
            apps=[
                SlackApp(
                    slug="dev",
                    bot_token=os.environ["SLACK_BOT_TOKEN"],
                    app_token=os.environ["SLACK_APP_TOKEN"],
                ),
            ],
            transport="socket",
        ),
        inner=inner,
    )
    agent = Agent.from_config("my_agent", adapter=slack)
    async with agent:
        try:
            await agent.run_forever()
        finally:
            await slack.close()
if __name__ == "__main__":
    asyncio.run(main())

Run it:

uv run python slack_agent.py

When the Socket Mode connection opens, the adapter logs:

INFO:band.integrations.slack.socket:Slack Socket Mode connected (app=dev)

slack.close() closes the Socket Mode connections and waits for their work to settle. Call it in finally so they close when the agent stops. When the agent stops, the adapter also closes the listeners itself, drops Slack events that arrive during shutdown with a Dropping Slack event for app <slug>: shutting down warning, waits for events it already accepted, and then stops the inner adapter. If a listener fails to close, shutdown raises an ExceptionGroup that names the Slack app, and the host can retry.

Test the Bridge

@your-bot What changed in the retry policy this week?

Use HTTP Instead of Socket Mode

With transport="http", the adapter exposes a Starlette router that you mount in your own ASGI app. Each SlackApp gets the route /{slug}/events, which checks Slack’s request signature, answers URL verification, and drops retried events it has already seen. Add SLACK_SIGNING_SECRET to .env, then serve the router alongside the agent:

import asyncio
import logging
import os
import uvicorn
from dotenv import load_dotenv
from starlette.applications import Starlette
from band import Agent, Emit
from band.adapters import AnthropicAdapter, AnthropicAdapterConfig
from band.integrations.slack import SlackAdapter, SlackAdapterConfig, SlackApp
logging.basicConfig(level=logging.INFO)
async def main() -> None:
    load_dotenv()
    inner = AnthropicAdapter(
        AnthropicAdapterConfig(
            model="claude-sonnet-5-5",
            custom_section="You are a helpful Slack assistant. Keep replies concise.",
        ),
        emit=Emit.TOOL_CALLS,
    )
    slack = SlackAdapter(
        SlackAdapterConfig(
            apps=[
                SlackApp(
                    slug="dev",
                    bot_token=os.environ["SLACK_BOT_TOKEN"],
                    signing_secret=os.environ["SLACK_SIGNING_SECRET"],
                ),
            ],
            transport="http",
        ),
        inner=inner,
    )
    web_app = Starlette()
    web_app.mount("/slack", slack.router)
    server = uvicorn.Server(uvicorn.Config(web_app, host="0.0.0.0", port=3000))
    agent = Agent.from_config("my_agent", adapter=slack)
    async with agent:
        try:
            await asyncio.gather(agent.run_forever(), server.serve())
        finally:
            await slack.close()
if __name__ == "__main__":
    asyncio.run(main())

In the Slack app, set socket_mode_enabled: false in the manifest and point Event Subscriptions at https://<your-public-host>/slack/dev/events. slack.router also mounts in FastAPI and other ASGI frameworks. The adapter does not start a server itself.

Serve Several Slack Apps

One adapter can serve several Slack apps, each with its own tokens and route. The app slug is part of every thread key, so two apps never share a room:

slack = SlackAdapter(
    SlackAdapterConfig(
        apps=[
            SlackApp(slug="support", bot_token=os.environ["SUPPORT_BOT_TOKEN"], app_token=os.environ["SUPPORT_APP_TOKEN"]),
            SlackApp(slug="sales", bot_token=os.environ["SALES_BOT_TOKEN"], app_token=os.environ["SALES_APP_TOKEN"]),
        ],
        transport="socket",
    ),
    inner=inner,
)

Configure the Adapter

SlackAdapter(config, inner=...) takes a SlackAdapterConfig and the inner adapter:

SlackAdapter takes no Band credentials: it uses the ones you pass to Agent.from_config or Agent.create. It has no events or capabilities of its own. Omit emit and capabilities, and the adapter uses the inner adapter’s settings as they are. Pass one, and it is merged into the inner adapter’s settings and checked against what the inner adapter supports; see Adapter features. For every parameter, see SlackAdapter in the SDK Reference.

Limits and Errors

Next Steps