.png)
Your team already lives in Slack. It is where decisions are made, where status updates land, and where questions get asked and answered in real time. In short, it's where work actually gets done.
That makes it a little strange that most AI agents still sit off to the side, tucked behind separate chat interfaces that people only open when they remember to. That gap creates friction, and friction quietly kills adoption. If an agent cannot show up in the same thread where the work is happening, it never really becomes part of the team.
Agno approaches this differently. Instead of treating Slack as just another integration, it is built in as a first-class interface, so agents can operate directly where your team already communicates.
What are the two ways to integrate Agno agents with Slack?
There are two ways to use Agno with Slack, and understanding the difference matters.
SlackTools gives your agents the ability to take action inside Slack. They can send messages, read channel history, and navigate workspaces. This is what lets an agent do things on behalf of your team, like posting updates or pulling context from past conversations.
SlackAPI turns your agent into a Slack app. It listens for messages, responds in threads, and participates like any other member of the workspace. This is what allows it to engage naturally in conversations as they happen.
Most production use cases end up needing both. One gives your agent the ability to act, and the other gives it a presence. Together, they let the agent operate as a fully integrated part of your team.
What is SlackTools and how does it let an agent act inside Slack?
SlackTools is a pre-built toolkit that drops directly into any Agno agent. With a single import, your agent gains the ability to send messages to channels, retrieve conversation history, and enumerate the channels in your workspace.
import os
from agno.agent import Agent
from agno.tools.slack import SlackTools
slack_tools = SlackTools()
agent = Agent(tools=[slack_tools])
# Send a daily digest to #engineering
agent.print_response(
"Summarize today's pull request activity and post it to #engineering",
markdown=True
)
# Pull recent context before making a decision
agent.print_response(
"Get the last 20 messages from #incidents and tell me if anything is still unresolved",
markdown=True
)
Setup requires just the slack-sdk library and a bot token:
uv pip install -U "agno[slack]"
export SLACK_TOKEN=***
The toolkit is designed to be granular and flexible. Each capability can be enabled or disabled on its own, which gives you precise control over what an agent is allowed to do in your workspace.
That control makes it straightforward to shape agents for very specific roles. You might create a read-only monitoring agent that can pull context from Slack but never post a message, or a tightly scoped notification agent that can post to a single channel and nowhere else.
What is SlackAPI and how does it turn an agent into a Slack app?
SlackTools is powerful, but it's only half the picture. It gives your agent the ability to reach into Slack, while SlackAPI enables people in Slack to reach out to your agent.
With SlackAPI, you wrap any Agno agent or team with a FastAPI server that handles incoming Slack events such as app mentions, direct messages, and slash commands, then routes them to your agent. The agent processes each request and posts a response back into the same thread where the question was originally asked.
from agno.agent import Agent
from agno.db.sqlite import SqliteDb
from agno.models.openai import OpenAIChat
from agno.os.app import AgentOS
from agno.os.interfaces.slack import Slack
agent_db = SqliteDb(session_table="agent_sessions", db_file="tmp/persistent_memory.db")
basic_agent = Agent(
name="Basic Agent",
model=OpenAIChat(id="gpt-4o"),
db=agent_db,
add_history_to_context=True,
num_history_runs=3,
add_datetime_to_context=True,
)
agent_os = AgentOS(
agents=[basic_agent],
interfaces=[Slack(agent=basic_agent)],
)
app = agent_os.get_app()
if __name__ == "__main__":
agent_os.serve(app="basic:app", reload=True)
Two environment variables are all you need:
export SLACK_TOKEN="xoxb-your-bot-user-token" # Bot User OAuth Token
export SLACK_SIGNING_SECRET="your-signing-secret" # App Signing Secret
For local development, ngrok handles the tunneling:
ngrok http 7777
Once you point your Slack app’s event subscription URL to your ngrok tunnel, your agent can start receiving and responding to events right away.
What can you build with Agno's Slack integration?
Bringing SlackTools and SlackAPI together opens the door to a wide range of real production use cases.
A reasoning finance bot. You can wrap an agent with YFinanceTools and ThinkingTools and deploy it through SlackAPI, allowing anyone on your team to @mention it in a channel and ask about stock prices, analyst recommendations, or company news. The agent responds directly in the thread with a structured, reasoned answer, often including tables.
An incident responder. An agent with access to your monitoring tools, your runbooks through a knowledge base, and SlackTools can watch for alerts, pull in recent channel history for context, and post a structured incident summary to your #incidents channel automatically, often before an engineer has even had time to step in.
A workspace assistant. By combining SlackTools with access to internal documentation and a database, then deploying the agent through SlackAPI, your team can ask questions like what was decided about a pricing change last week or request the latest message from the customer success team about a specific account. The agent can retrieve the relevant context and respond with a clear, useful answer.
A multi-agent team in a channel. SlackAPI supports teams as well as individual agents, which means you can introduce a coordinator agent that routes questions to specialized sub-agents, whether for data, customer context, or engineering. From the user’s perspective, it all feels like interacting with a single, cohesive Slack bot that can handle a wide range of requests.
Why should you deploy AI agents inside Slack instead of a separate interface?
Every extra click is a reason not to use something.
When your agent lives in a separate interface, adoption depends on people remembering to go there. When it lives in Slack, adoption is automatic—because the questions are already happening in Slack. The agent naturally becomes the fastest way to get answers.
There's also a compounding effect: agents that are easy to access get used more, which means they get tested more, which means they get better faster. The tightest feedback loop between users and your agentic system is the one that requires the least context switching.
How to get started building Slack-native agents with Agno
Install the dependencies:
uv pip install openai slack-sdk
For the SlackTools toolkit, grab a bot token from the Slack API console and set SLACK_TOKEN.
For a full SlackAPI deployment, you'll also need your app's signing secret (SLACK_SIGNING_SECRET) and an event subscription URL pointing at your server.
From there, the full Slack documentation covers toolkit params, the SlackAPI configuration, and ready-to-run examples including a reasoning finance agent and an agent with persistent user memory.
Your team is already in Slack. Your agent should be too.