OpenClaw Slack Integration: How to Run an AI Agent in Slack

Slack is where a lot of work actually happens, which is exactly why OpenClaw can be so useful there.

When an AI agent lives in Slack, it is not living on a demo screen. It is sitting inside planning threads, ops channels, launch rooms, customer escalations, and internal handoffs. That is powerful, but it also means setup needs to be clean. A Slack agent that posts in the wrong channels, ignores mention rules, or responds without enough guardrails becomes annoying fast.

The good news is that OpenClaw gives you strong control over how Slack works: Socket Mode, HTTP mode, DM pairing, channel allowlists, mention gating, thread handling, and separate sessions for channels and threads.

This guide shows how to set up OpenClaw Slack integration the practical way, with the pieces that matter most once you move past the hello-world phase.

For official references, review the Slack docs, OpenClaw getting started, and the GitHub repo. For surrounding workflow structure, also read Setup Guide, Skills, Multi-Agent, and OpenClaw for teams.

Why Slack is different from Telegram or Discord

Slack is more operational by default.

People do not usually message Slack bots like a private assistant first. They drop them into shared channels, threads, and internal workflows. That means the most important questions are not just “how do I connect it?” but also:

• which channels can it respond in?
• who is allowed to trigger it?
• does it need an @mention?
• how should it behave in threads?
• what should it do in DMs versus shared channels?

OpenClaw has answers for all of those, which is a big reason it fits better than a generic Slack bot wrapper when you want a real agent.

The fastest way to think about Slack setup

OpenClaw supports two Slack connection modes:

• Socket Mode, which is the default and easiest for many setups
• HTTP Events API mode, which is useful when you want Slack to send events to a webhook endpoint

For most people, start with Socket Mode.

The official docs list the required tokens as:

• an App Token (xapp-...) with connections:write
• a Bot Token (xoxb-...)

That is the core pair for Slack Socket Mode.

Step 1: create the Slack app and tokens

In Slack app settings:

1. create a new Slack app
2. enable Socket Mode
3. create an App Token with connections:write
4. install the app to your workspace
5. copy the Bot Token

In practice, you are preparing two things:

• the connection that lets OpenClaw receive events
• the bot identity that lets OpenClaw read and write in Slack

Then configure OpenClaw like this:

{
  "channels": {
    "slack": {
      "enabled": true,
      "mode": "socket",
      "appToken": "xapp-...",
      "botToken": "xoxb-..."
    }
  }
}

The docs also note that SLACK_APP_TOKEN and SLACK_BOT_TOKEN can be used as environment-variable fallbacks for the default account.

Step 2: subscribe the right Slack events

This part is easy to skip and then regret later.

The Slack docs call out bot events like:

• app_mention
• message.channels
• message.groups
• message.im
• message.mpim
• reaction_added
• reaction_removed
• channel and member events
• pin events

If your event subscriptions are incomplete, the agent can feel randomly blind. So before you blame the model or the gateway, make sure Slack is actually sending the events you need.

Also enable App Home messages if you want good DM behavior.

Step 3: understand the Slack manifest and scopes

OpenClaw's Slack docs include a full manifest example with a large bot-scope list. You do not need to memorize the entire thing, but you do need the right mental model.

Slack scopes are what decide what the agent is even allowed to do.

Examples from the docs include:

• app_mentions:read
• channels:history
• channels:read
• chat:write
• commands
• groups:history
• im:history
• mpim:history
• pins:read
• pins:write
• reactions:read
• reactions:write
• users:read

That list tells you something important about OpenClaw's design. It is not only a reply bot. It is designed to live in Slack as an operating assistant that can work with channels, threads, reactions, pins, and other context.

Step 4: start the gateway and verify Slack is live

Once your config and tokens are in place, start the gateway:

openclaw gateway

Unlike Telegram, Slack setup is less about pairing first and more about verifying the app is connected cleanly and receiving events.

If you are testing with DMs, remember that Slack DMs default to pairing mode in OpenClaw. That means the first inbound DM may need approval before it becomes a normal direct conversation.

Step 5: decide how DMs should work

Slack DM access follows a familiar OpenClaw pattern.

channels.slack.dmPolicy can be:

• pairing
• allowlist
• open
• disabled

For private owner workflows, pairing is still the safest starting point.

For example:

{
  "channels": {
    "slack": {
      "dmPolicy": "pairing"
    }
  }
}

If you want durable access control, use allowlist and define the allowed senders explicitly.

This matters more in Slack than some people expect because workspaces often include many people, many channels, and multiple contexts where the bot can be encountered.

Step 6: lock down channel behavior before inviting the agent everywhere

This is the most important part of a good Slack rollout.

Slack channels should be treated as deliberate environments, not as a free-for-all.

The channel policy side of the docs centers around:

• groupPolicy
• channels.slack.channels
• requireMention
• per-channel user allowlists

A strong default looks like this:

{
  "channels": {
    "slack": {
      "groupPolicy": "allowlist",
      "channels": {
        "C0123456789": {
          "requireMention": true
        }
      }
    }
  }
}

That means:

• the bot only works in explicitly allowed channels
• it does not jump into conversation unless mentioned

That single design choice prevents most “why is this bot talking here?” frustration.

If you later want a private ops channel where the agent can respond without @mentions, make that a specific exception, not the global default.

Step 7: use threads on purpose

Slack gets messy when one conversation spills into everything else. OpenClaw helps because it models sessions explicitly.

According to the docs:

• DMs route as direct chats
• channels route as channel sessions
• thread replies can create thread-specific session suffixes
• Slack has thread history controls such as initialHistoryLimit

This is a big deal for teams.

It means you can keep:

• a launch thread separate from the main marketing channel
• a customer issue thread separate from the support channel backlog
• a planning thread separate from general chat noise

In practice, Slack threads become much more useful when the agent can treat them as focused workspaces instead of one merged blob.

Step 8: mention gating is your friend

A lot of teams disable mention gating too early.

That is usually a mistake.

In Slack, mention gating gives you a social contract. The assistant only speaks when someone deliberately pulls it in, unless you explicitly configure a channel for more ambient behavior.

The Slack docs note that mention sources can include:

• explicit app mentions
• configured mention patterns
• reply-to-bot thread behavior

That is enough flexibility for most teams. Keep it strict by default. Loosen it only in channels where the assistant has a clear role.

If you are running multi-role setups, review Multi-Agent and OpenClaw for teams before expanding behavior.

Step 9: know when Slack should be the main interface, and when it should not

Slack is excellent for:

• shared team workflows
• channel-based operations
• thread-based reviews
• announcements and summaries
• internal agent handoffs

Slack is not always the best place for:

• deeply personal memory
• one-owner confidential planning
• messy draft work you do not want visible in a team workspace

A common pattern is:

• Telegram or direct channels for private owner interaction
• Slack for team-facing coordination

That split works well because OpenClaw can behave differently by channel while keeping the broader system coherent.

A practical Slack setup I would use

If I were setting up Slack for a small team today, I would do this:

1. connect through Socket Mode
2. keep DMs on pairing
3. allow only two or three specific channels at first
4. require mentions in all shared channels
5. keep one private ops channel as the only place where the bot can be more active

Then I would back it with a clear workspace file like this:

# AGENTS.md

Slack rules:
- Be concise in shared channels.
- Default to draft-first for external actions.
- Only answer when mentioned unless the channel is explicitly open.
- In threads, stay on the thread topic.
- Summaries first, details second.

That sounds basic, but it creates a much better Slack experience than trying to make the model improvise channel etiquette on its own.

Common Slack mistakes

Installing the app without the right event subscriptions

If events are missing, the assistant will seem inconsistent.

Letting the bot into too many channels too quickly

Start narrow. Expand later.

Turning off mention gating everywhere

That is usually how a promising Slack bot turns into channel clutter.

Ignoring threads

Slack threads are one of the best organizational tools in the product. Use them.

Treating Slack like a private notebook

Remember that many Slack messages are team-visible by default. Design workflows with that in mind.

FAQ

Is Socket Mode the best starting point for OpenClaw Slack integration?

Yes. The official docs present Socket Mode as the default, and it is usually the simplest place to begin.

What tokens do I need for Slack?

For Socket Mode, you need an App Token (xapp-...) and a Bot Token (xoxb-...).

Does OpenClaw support Slack DMs and channels?

Yes. Slack is production-ready for both DMs and channels.

How should I control where the bot can speak in Slack?

Use groupPolicy, an explicit channel allowlist, and requireMention so the bot only participates in approved places.

Can OpenClaw work well in Slack threads?

Yes. Slack threading and session handling are one of OpenClaw's biggest strengths in team workflows.

Should I use Slack as my only OpenClaw channel?

Maybe, but many people prefer a private channel like Telegram for personal conversations and Slack for shared team operations.

Where should I learn more about OpenClaw team structure?

Read Multi-Agent, Skills, and OpenClaw for teams.

Final take

OpenClaw Slack integration works best when you treat Slack like an operating environment, not just a chat window.

Set up Socket Mode cleanly, scope the app properly, keep channel access narrow, and use mention gating plus thread structure to keep the assistant useful. Done right, Slack becomes one of the best places to run a team-facing OpenClaw agent because the work is already happening there.