Slack

Live

OAUTH 2.0

COMMUNICATION

Communication

Decisions, blockers, and context move through Slack before they make it anywhere else. Your agent can search messages, read channel history, and surface signals, scoped to the member who authorized it.

  • Acts as the member: Message history and channel access stay tied to the workspace user who authorized the agent.
  • Credentials stay vaulted: AES-256, resolved at request time, never in LLM context.
  • Scoped before every call: User permissions enforced. 90-day audit trail.
Slack
agent · Acme Q3
Run
What did the team decide in #product-updates this week?
S
slack_fetch_conversation_history
72ms
Messaging agent
3 decisions logged. Feature freeze confirmed for Nov 1. Pricing model approved. New onboarding flow greenlit for Q4.
Sources: #product-updates, 12 messages, Oct 28 to Nov 1
slackmcp
12 messages
18:29
Message Claude...

Tools your messaging agent reaches for on Slack, scoped per user.

CALL ANY TOOL
Read channels, send messages, look up members, and upload files. Same toolkit, every framework, no auth plumbing to maintain.
slack_accept_shared_invite
Invite accept shared
Accepts a Slack Connect invitation, creating or joining the shared channel it refers to. Requires a valid Slack OAuth2 connection with the conversations.connect:write scope.
Parameters
Name
Type
Required
Description
channel_name
string
Required
Name to give the channel being created from this invite
invite_id
string
Required
ID of the invite to accept
channel_id
string
Optional
ID of an existing channel to accept the invite into, if renaming an existing channel rather than creating a new one
free_trial_accepted
boolean
Optional
Whether the free trial terms for Slack Connect have been accepted
is_private
boolean
Optional
Whether the channel being created should be private
team_id
string
Optional
Encoded team ID, required only when using an org-level token
user_id
string
Optional
ID of the user accepting the invite, for org admin use on behalf of another user
slack_add_bookmark
Add bookmark
slack_archive_channel
Archive channel
slack_complete_reminder
Complete reminder
slack_complete_upload_external
Complete upload external
slack_create_canvas
Create canvas
slack_delete_file
Delete file
slack_edit_bookmark
Edit bookmark
slack_end_dnd_snooze
End dnd snooze
slack_fetch_conversation_history
Fetch conversation history
slack_get_bot_info
Get bot info
slack_get_dnd_info
Get dnd info
slack_get_reminder_info
Get reminder info
slack_get_upload_url_external
Get upload url external
slack_kick_from_conversation
Kick from conversation
slack_list_bookmarks
List bookmarks
slack_list_connect_invites
List connect invites
slack_list_reactions
List reactions
slack_list_user_conversations
List user conversations
slack_mark_conversation_read
Read mark conversation
slack_open_conversation
Open conversation
slack_publish_view
Publish view
slack_remove_bookmark
Remove bookmark
slack_rename_channel
Rename channel
slack_search_all
Search all
slack_send_ephemeral_message
Send ephemeral message
slack_set_channel_purpose
Set channel purpose
slack_set_conversation_topic
Set conversation topic
slack_share_file_public_url
Share file public url
slack_update_message
Update message

For more tools, view docs.

Build your Agent
Drop the toolkit in, point it at the user, and your agent can read Slack messages, send replies, and look up team members from the first run.
Python · LlamaIndex
import { ScalekitClient } from "@scalekit-sdk/node";
import { DynamicStructuredTool } from "@langchain/core/tools";
import { createReactAgent } from "@langchain/langgraph/prebuilt";
import { z } from "zod";

const sk = new ScalekitClient(envUrl, clientId, clientSecret);

const { tools } = await sk.tools.listScopedTools("user_123", {
filter: { connectionNames: ["slack"], toolNames: ["slack_list_channels", "slack_fetch_conversation_history", "slack_send_message"] },
pageSize: 100,
});

const lcTools = tools.map((t) => new DynamicStructuredTool({
name: t.tool.definition.name,
description: t.tool.definition.description,
schema: z.object({}).passthrough(),
func: async (args) => {
const { data } = await sk.tools.executeTool({
toolName: t.tool.definition.name,
identifier: "user_123",
params: args,
});
return JSON.stringify(data);
},
}));

const agent = createReactAgent({ llm, tools: lcTools });
import { ScalekitClient } from "@scalekit-sdk/node";
import OpenAI from "openai";

const sk = new ScalekitClient(envUrl, clientId, clientSecret);
const openai = new OpenAI();

const { tools } = await sk.tools.listScopedTools("user_123", {
filter: { connectionNames: ["slack"], toolNames: ["slack_list_channels", "slack_fetch_conversation_history", "slack_send_message"] },
pageSize: 100,
});

// shape tools as OpenAI function definitions
const llmTools = tools.map((t) => ({
type: "function" as const,
function: {
name: t.tool.definition.name,
description: t.tool.definition.description,
parameters: t.tool.definition.input_schema,
},
}));

const resp = await openai.responses.create({
model: "gpt-4o", input: prompt, tools: llmTools,
});
import { ScalekitClient } from "@scalekit-sdk/node";
import Anthropic from "@anthropic-ai/sdk";

const sk = new ScalekitClient(envUrl, clientId, clientSecret);
const anthropic = new Anthropic();

const { tools } = await sk.tools.listScopedTools("user_123", {
filter: { connectionNames: ["slack"], toolNames: ["slack_list_channels", "slack_fetch_conversation_history", "slack_send_message"] },
pageSize: 100,
});

const llmTools = tools.map((t) => ({
name: t.tool.definition.name,
description: t.tool.definition.description,
input_schema: t.tool.definition.input_schema,
}));

const msg = await anthropic.messages.create({
model: "claude-sonnet-4-6", max_tokens: 1024,
tools: llmTools,
messages: [{ role: "user", content: prompt }],
});
import { Agent } from "@google/adk/agents";
import {
MCPToolset, StreamableHTTPConnectionParams,
} from "@google/adk/tools/mcp";

const toolset = new MCPToolset({
connectionParams: new StreamableHTTPConnectionParams({
url: "https://mcp.scalekit.com/slack",
headers: { Authorization: `Bearer ${userScopedToken}` },
}),
});

const agent = new Agent({
name: "agent", model: "gemini-2.0-flash",
tools: await toolset.getTools(),
});
Try these prompts
These are the questions teams ask Slack every day. Copy any prompt, paste into your agent, watch it route to the right channel with the member's scope.
Search & recall
Copy the prompt
Copied
What was decided in #engineering this week?
Copy the prompt
Copied
What did [person] say about [topic] in [channel]?
Copy the prompt
Copied
Find all messages mentioning [keyword] in #general.
Copy the prompt
Copied
What threads are unresolved in #customer-support?
Action & outreach
Copy the prompt
Copied
Send a message to #announcements: [message text].
Copy the prompt
Copied
Post a follow-up to the thread in #sales from yesterday.
Copy the prompt
Copied
DM [user] with these meeting notes.
Copy the prompt
Copied
Upload this summary to #weekly-updates.
Team & context
Copy the prompt
Copied
Who is on the #design team?
Copy the prompt
Copied
List all active channels in this workspace.
Copy the prompt
Copied
What was the last message from [person] in #general?
Copy the prompt
Copied
Find [user] by their email address.
SEE HOW AUTH WORKS
Your users authorize Slack once. Their workspace credentials stay vaulted, every call is checked, and every action is logged.
1
Authorize
Your user connects
Slack
once. We tie it to their identity and the meetings they approved — no shared bot account, no org-wide access
Who:
user ‘A’
when:
Once per user
access:
Limited to user
2
Store
Their
Slack
token lives in a vault scoped to them. User A's meetings are never reachable by an agent acting for user B, even on the same connection
vault:
encrypted
scope:
per-user
tokens:
auto-refreshed
3
Resolve
When your agent calls a
Slack
tool, we fetch the right token server-side. It never touches your agent, never appears in the LLM context, never shows up in your logs
speed:
~40ms
check:
before every call
seen by:
nobody
4
Audit
Every
Slack
tool call is logged — who triggered it, which meeting was fetched, what came back. 90 days of history, tied to the user who authorized it
history:
90 days
export:
SIEM-ready
logged:
every call
Test other agents
Same per-user auth pattern across other messaging agents and MCP connectors. Working code, live demos, fork what fits.
Engineering Teams
Slack triage
Polls Slack for new messages, classifies bugs and support requests with a LangGraph router, files GitHub issues or Zendesk tickets, and confirms in the thread.
Engineering Teams
Auto release notes agent
Reads merged GitHub PRs, groups them into structured release notes, publishes the page to Notion, and announces the release in Slack. Every call runs on the engineer's own delegated OAuth.
Engineering Teams
DevOps assistant agent
Polls GitHub for failing checks and stale PRs, opens Linear issues for the ones that need work, and posts a daily digest to Slack. It acts as the engineer, not a shared service account.
Engineering Teams
Engineering standup agent
Pulls commits from GitHub and GitLab, tracks issue movement in Jira, and posts a per-engineer standup brief to Slack. Each engineer's activity is read on their own delegated OAuth.
Test other agents
Same per-user auth pattern across other messaging agents and MCP connectors. Working code, live demos, fork what fits.
ENGINEERING
DevOps assistant agent
Poll GitHub for failing checks and stale pull requests, open Linear issues for the ones that need work, and digest to Slack.
ENGINEERING
Slack triage agent
Classify new Slack messages as bugs or support requests, file the GitHub issue or Zendesk ticket, and reply in the thread.
ENGINEERING
Auto-release notes agent
Group merged GitHub PRs into structured release notes, publish the page to Notion, and announce the release in Slack.
ENGINEERING
Engineering standup agent
Pull commits from GitHub and GitLab, track Jira issue movement, and post a per-engineer standup brief to Slack.
Why Scalekit
Secure your agent's access. Connectors ship in minutes
01.
Messages posted from the wrong identity
A shared Slack bot token looks fine in a demo. In production, every message the agent posts appears as the bot, not the user who triggered it. Channel attribution breaks. DM replies come from the wrong identity. Scalekit resolves the actual user's token, so messages come from the right person.
// shared bot token
token = "sk_slack_shared_xxx"
audit → bot_service_account
user_filter → broken

// scalekit · per-user
token = resolve(user_id)
audit → user_abc
scope → enforced ✓
02.
Authentication is not authorization
03.
Multi-tenancy is architectural
04.
Slack today. Gmail, Outlook, Teams tomorrow.
“Our agents act across Salesforce, Gong, Google Drive, and more, on behalf of every customer. Scalekit behind the scenes meant we can keep adding tools without ever rebuilding how credentials or tool calling work.”
Venu Madhav Kattagoni
Head of Engineering / Von
FAQs
Frequently Asked Questions

Does the agent access Slack as the user or as a shared key?
As the user. Each workspace member authorizes once and Scalekit resolves their credential at request time. Audit logs attribute every action to that user, not a shared service account.

Where is the Slack OAuth token stored?
In Scalekit's managed AES-256 token vault, namespaced per tenant. Refresh is automatic. Revocation is a single dashboard action. Tokens never appear in prompts, logs, or LLM context.

Can I limit what the agent is allowed to do in Slack?
Yes. Pass a tool name filter to listScopedTools so the messaging agent only sees the subset you authorize. Pre-API-call scope checks block out-of-policy actions before the request reaches Slack.

What happens when a user revokes Slack access?
The connection is invalidated on the next tool call. Subsequent requests for that user fail closed with a clear error. Other users in the tenant remain unaffected. The event is logged for audit.

Can the agent post to private channels?
Only if the authorizing user is a member of that channel. Scalekit resolves the user's Slack credential, so private channel posts inherit the user's actual access. No bot membership trick needed.

What other MCP connectors does Scalekit support?
Scalekit runs the Discord MCP server, Outlook MCP server, and Gmail MCP server on the same per-user auth, token vault, and audit trail. Browse 1,000+ connectors in the MCP connector directory.

How do I build a Slack agent?
Follow a step-by-step tutorial: Automate HubSpot CRM updates to Slack with an AI agent; Automating Salesforce customer insights with Slack and Scalekit; Automating Slack workflows: LangGraph and Scalekit for bug triage, support. Each one covers per-user auth, tool scoping, and working agent code for Slack.

Start in your coding agent
Up and running in one command
Install the Scalekit skill in your editor of choice. Connector, auth, tools, prompt, all wired up
Claude Code REPL
/plugin marketplace add scalekit-inc/claude-code-authstack
/plugin install agentkit@scalekit-auth-stack
Cursor Code REPL
# ~/.cursor/mcp.json
{
""mcpServers"": {
""slack"": {
""url"": ""https://mcp.scalekit.com/slack"",
""headers"": { ""Authorization"": ""Bearer $SCALEKIT_TOKEN"" }
}
}
}
Codex Code REPL
# ~/.codex/config.toml
[mcp_servers.slack]
url = ""https://mcp.scalekit.com/slack""
auth_env = ""SCALEKIT_TOKEN""
Copilot Code REPL
# .vscode/mcp.json
{
""servers"": {
""slack"": {
""url"": ""https://mcp.scalekit.com/slack"",
""type"": ""http""
}
}
}