# How to Connect Your Agents to Slack

> Learn how to connect your agents to Slack. We'll talk about the app manifest, credentials, monitoring, and the security details that keep a public platform safe.

- Published: 2026-08-04
- Author: Ashpreet Bedi
- Category: Engineering
- Canonical: https://agno-com-nine.vercel.app/articles/connect-agents-to-slack
- Markdown: https://agno-com-nine.vercel.app/articles/connect-agents-to-slack.md

Today I'll show you how to connect your agents to Slack. It's one of the first things you'll do when you start building agents: put them where your team works. One agent becomes two, two become five and suddenly any task that can be done by humans becomes a message to an agent.

Here's what it looks like:

<Video
  src="/videos/slack-intro.mp4"
  controls
  preload="metadata"
  aria-label="Agents working in Slack"
/>

Normally agents operate in channels like #sales and #engineering. This video is from our testing channel: #agents. If you look closely you can see Sam trying to hack my personal context agent. Everything you see works out of the box: streaming, tool calls rendered as they run, human-in-the-loop, memory of the person the agent is talking to. We'll get to how all of that works.

## One backend, many frontends

A big advantage of having your own agent platform is that the same backend connects to every frontend. So the same agent is available over Slack, a custom UI, or AI apps like Claude and ChatGPT. The key is setting up the platform right, so it can serve any frontend.

## Do it yourself

Here's what we'll do to get our agents in Slack:

1. Set up our agent platform
2. Deploy our platform (Slack needs a public URL)
3. Connect our agent to Slack

End to end this should take ~20 minutes. We'll use coding agents for steps 1 and 2 so you'll move through this pretty quickly and the only manual setup is creating the Slack app. Let's go.

## Set up your platform

If there's one thing you take away from my posts, it's that you need your own agent platform: shared execution, shared security, shared context, and a consistent way of exposing your agents over REST, MCP, and chat interfaces like Slack.

Your code lives in one place, easy to scale beyond your first agent. Sessions, memory, and traces are stored in your database and can be mined for self-improvement. Platform access and security are managed in one place, and the best part: the whole thing can be done by coding agents. Let's start by setting up our platform.

**Step 1:** Start up your coding agent. I'm using claude code with `--dangerously-skip-permissions` (fine here, it's a fresh project).

<Video
  src="/videos/start-coding-agent.mp4"
  controls
  preload="metadata"
  aria-label="Start Claude Code"
/>

**Step 2:** Create your agent platform using one prompt.

1. Make sure [Docker](https://www.docker.com/products/docker-desktop/) is installed and running.
2. Export your OpenAI API key using `export OPENAI_API_KEY=...`
3. Get your prompt from [os.agno.com](https://os.agno.com) and give it to your coding agent.

And that's it. Your coding agent will set up and run your agent platform locally.

<Video
  src="/videos/create-agent-platform.mp4"
  controls
  preload="metadata"
  aria-label="Create your agent platform"
/>

## Deploy your platform

Slack needs the agent to be available over a public URL. When you copied the prompt from [os.agno.com](https://os.agno.com), you chose a cloud to deploy your platform to (I chose Railway).

Let's deploy our platform so slack can reach our agent. `cd` into your agent platform, start your coding agent so the slash commands are available and run:

> /deploy-platform

<Video
  src="/videos/deploy-platform.mp4"
  controls
  preload="metadata"
  aria-label="Deploying the platform"
/>

I'm telling the skill to deploy to the AB workspace because I already have my internal company platform running in my main account. The skill checks the prerequisites (may ask you to log in), provisions the services, and pauses for the JWT key. This is important.

One mistake I see agent builders make all the time is deploying their agents to a public URL with no authentication. If the open URL gets discovered, strangers have unrestricted access to your agents. The platforms I build come with JWT auth on by default, so a production deploy needs a JWT verification key before it will even start.

You can mint one yourself, or get one from [os.agno.com](https://os.agno.com).

Connect to your AgentOS on [os.agno.com](https://os.agno.com), flip on token-based authorization, and paste in the verification key when the skill pauses for it. Your coding agent deploys the platform and hands you a live URL.

## Connect to Slack

Now for the main event. We will:

1. Create the app
2. Install it to your workspace
3. Add the credentials to your platform
4. Chat with Chief over Slack (the agent that's pre-wired)
5. View the chat sessions on the AgentOS UI.

Here's me doing it end to end:

<Video
  src="/videos/connect-slack.mp4"
  controls
  preload="metadata"
  aria-label="Connect Slack"
/>

**Step 1: Create the Slack app from a manifest.**

- Grab this [manifest.json](https://github.com/agno-agi/agno/blob/main/libs/agno/agno/os/interfaces/slack/manifest.json) and replace `https://YOUR-URL` with your AgentOS URL. The events URL becomes `YOUR-AGENTOS/slack/events` and the interactivity URL becomes `YOUR-AGENTOS/slack/interactions`. Also update the `display_information` and `bot_user.display_name`.
- Then go to [api.slack.com/apps](https://api.slack.com/apps) and **Create New App** → **From a manifest**, pick your workspace, and paste in the manifest. The manifest pre-configures everything: the scopes, the event subscriptions, interactivity.

> Note: create the app after your platform is live. Slack sends a verification challenge to `/slack/events` and AgentOS answers it automatically, so the URL is verified on creation.

**Step 2: Install it to your workspace.**

Click **Install App** → **Install to Workspace** → **Allow**. Copy two values: the Bot User OAuth Token (starts with `xoxb-`) from the install page, and the Signing Secret from **Basic Information**.

**Step 3: Add the credentials to your platform.**

Open the `.env.production` file and add both values to `SLACK_BOT_TOKEN` and `SLACK_SIGNING_SECRET`, then sync and redeploy. You can just tell your coding agent to redeploy the platform or run the following commands manually.

```bash
./scripts/railway/env-sync.sh
./scripts/railway/redeploy.sh
```

That's it. Find your agent under **Apps** in Slack and say hello. Then invite it to a channel and mention it:

```
/invite @Chief
@Chief tell me about yourself.
```

If you want to see the code, open `app/main.py` and you'll see:

```python app/main.py
if SLACK_BOT_TOKEN and SLACK_SIGNING_SECRET:
    interfaces.append(
        Slack(
            agent=chief,
            streaming=True,
            resolve_user_identity=True,
            token=SLACK_BOT_TOKEN,
            signing_secret=SLACK_SIGNING_SECRET,
        )
    )
```

## How it works

When you message the agent, Slack sends an event to `https://your-url/slack/events`. There AgentOS runs a signature check and responds in a thread. Streaming is on by default, so responses appear as they're generated, with task cards showing progress on longer work.

Two details worth understanding:

- **Threads are sessions.** Each Slack thread maps to one session (the ID is literally `chief:{channel_id}:{thread_ts}`).
- With `resolve_user_identity=True`, each sender resolves to their email, so the agent knows who it's talking to. Chief keeps a private profile and memory for every person, while notes and entities stay shared across the team. Ask the same question as two different people and you'll get answers shaped by what Chief knows about each person.

## Monitoring and Observability

Open the [AgentOS UI](https://os.agno.com) and go to the Sessions and Traces tabs. Every Slack thread is there with its full history. You can also ask the Platform Manager about usage, run activity, and tool activity.

## A couple of notes on security

You just deployed a public agent platform. It's important to understand your security posture. Your platform has two entry points:

**The platform entry point.** JWT auth is on by default in production. Every API and MCP request needs a valid bearer token, and the verification key you pasted during deploy is what checks them. The MCP endpoint adds OAuth on top (`MCP_CONNECT_SECRET`) so chat apps like claude.ai can connect with authentication.

**The Slack entry point.** The events webhook is public by design. That's safe because every request carries an HMAC signature computed with your signing secret. Requests older than five minutes are rejected.

## Wrapping up

Here's the picture after this post:

```
                 ┌──►  AgentOS UI    build, monitor, improve
                 │
                 ├──►  Slack         where your team works   ◄── you are here
  Your agents ───┤
                 ├──►  MCP           claude.ai, ChatGPT, Claude Code, Cursor
                 │
                 └──►  REST API      your own product
```

One backend for every frontend. Your agent now lives where your team works, with auth on both entry points and full visibility from the AgentOS UI.

Thanks for reading!

Ashpreet