> ## Documentation Index
> Fetch the complete documentation index at: https://docs.abundly.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Slack

> Chat with your agent in Slack, or drive it from Slack events

Your agent can communicate with you and your team in Slack. People mention it in a channel or DM it, and the agent replies in the same thread — using its full context, capabilities, and history — just like it does in the portal chat. It can also search, read, post messages, add files, and react with emoji.

Each Slack-enabled agent has its own identity in Slack, with its own Slack app, bot user, and token.

## How to enable

Go to **Settings → Capabilities** and enable **Slack**. Then pick a Slack mode, paste in your bot token and Slack app ID, and point your Slack app's Event Subscriptions URL at the webhook Abundly shows you. See the step-by-step guide below.

## Slack modes

The Slack capability has two modes, selectable on the capability card. You can switch modes at any time under **Settings → Capabilities → Slack**.

### Chat mode (default)

The natural choice for most agents. Slack threads and DMs behave as persistent agent chats — the same abstraction as the portal chat. People start a conversation by @mentioning the agent in a channel or sending it a DM, and then keep replying in the same thread without having to @mention every time.

Chat mode already supports everything most agents need on Slack, including:

* Posting proactively to any channel the bot has been invited to
* Sending DMs
* Adding reactions
* Running all Slack tools (search, user lookup, etc.)

You do **not** need Trigger mode just to post to a channel, react, or run Slack tools — Chat mode handles all of that.

### Trigger mode

Each Slack event your app subscribes to is forwarded to the agent as a raw trigger payload for it to interpret with your instructions. There is no automatic reply; the agent only responds or takes action if your instructions call for it.

Trigger mode is intended for ambient monitoring or custom automations on specific event types (for example: "whenever someone reacts with 🚨 in #alerts, file an incident"). It is **not** the right mode for normal interactive Slack use.

<Warning>
  Trigger mode can produce a high volume of events. If multiple Trigger-mode agents share a channel they can end up reacting to each other's messages and spiral into an infinite reply loop, which consumes credits quickly.

  Before using Trigger mode:

  * Narrow the `bot_events` in your Slack app to only the specific event types you care about, rather than using the full recommended manifest.
  * Avoid putting multiple Trigger-mode agents in the same channel unless you've designed them not to react to each other.
  * Consider whether Chat mode already covers your use case — it almost always does.
</Warning>

## Example use cases

* "Post a daily standup summary to #engineering every morning"
* "Whenever a new potential customer is mentioned on the #sales channel, research how the customer fits our ideal profile, and add relevant info to the slack thread"
* "Notify #alerts when you are unable to solve a support ticket"
* "When a support request needs follow-up, add an :eyes: reaction so the team sees it's being handled"
* "When a teammate shares a design mockup in a Slack thread, summarize the feedback and save the file as an agent document for follow-up"

## How to connect to your Slack workspace

<Steps>
  <Step title="Create a Slack app from the manifest">
    Abundly generates an app manifest tailored to your agent. It includes the webhook URL, OAuth scopes, and the event subscriptions Slack needs for threads, DMs, and group DMs.

    1. In Abundly, go to **Settings → Capabilities**, enable **Slack**, and copy the **App Manifest**.
    2. Visit [api.slack.com/apps](https://api.slack.com/apps) and click **Create New App → From a manifest**.
    3. Select your workspace, paste the manifest, then click **Next** and **Create**.

    The manifest looks like this (your agent's name and webhook URL are filled in automatically):

    ```json Manifest template theme={null}
    {
      "display_information": {
        "name": "YOUR_AGENT_NAME",
        "description": "YOUR_AGENT_DESCRIPTION",
        "background_color": "#24a18d"
      },
      "features": {
        "app_home": {
          "messages_tab_enabled": true,
          "messages_tab_read_only_enabled": false
        },
        "bot_user": {
          "display_name": "YOUR_AGENT_NAME",
          "always_online": true
        }
      },
      "oauth_config": {
        "scopes": {
          "bot": [
            "channels:read",
            "chat:write",
            "groups:read",
            "im:read",
            "users:read",
            "channels:history",
            "groups:history",
            "im:history",
            "channels:join",
            "im:write",
            "mpim:history",
            "reactions:write",
            "reactions:read",
            "files:read",
            "files:write"
          ]
        }
      },
      "settings": {
        "event_subscriptions": {
          "request_url": "YOUR_WEBHOOK_URL",
          "bot_events": [
            "message.channels",
            "message.groups",
            "message.im",
            "message.mpim"
          ]
        },
        "org_deploy_enabled": false,
        "socket_mode_enabled": false,
        "token_rotation_enabled": false
      }
    }
    ```
  </Step>

  <Step title="Install the app and copy your credentials">
    After creating the app:

    1. Copy the **App ID** from the Basic Information page.
    2. Go to **Install App** in the left sidebar and click **Install to Workspace**, then authorize the app.
    3. Copy the **Bot User OAuth Token** from the **OAuth & Permissions** page.
  </Step>

  <Step title="Configure in Abundly">
    Back in **Settings → Capabilities → Slack**, paste the bot token and app ID and save. Click **Test connection** to confirm Abundly can reach your workspace.
  </Step>

  <Step title="Verify the Event Subscriptions URL in Slack">
    Slack does **not** verify the Request URL when you paste the manifest — it just saves it. You have to trigger the verification yourself, once, before any Slack events will reach your agent.

    1. Go back to your app at [api.slack.com/apps](https://api.slack.com/apps) and open **Event Subscriptions** in the left sidebar.
    2. The Request URL is already filled in from the manifest, but you'll see a banner saying the URL isn't verified. Click **Click here to verify** (or **Retry**).
    3. Slack sends a test request to Abundly and the banner should change to **Verified** ✓.
    4. Click **Save Changes** at the bottom of the page.

    <Tip>
      Abundly's webhook responds to Slack's verification request immediately, so this works whether or not you've pasted the bot token yet — you can do this step in any order.
    </Tip>
  </Step>

  <Step title="Invite to channels">
    In each Slack channel where you want the agent to work, type `/invite @YourAgentName`.
  </Step>
</Steps>

## How conversations work in Chat mode

With the default manifest and Chat mode, the agent listens broadly but replies selectively:

* **@mentions in a channel** start a new chat — the agent replies in the thread with full context.
* **DMs and group DMs** start (or continue) a chat — the agent replies naturally.
* **Follow-up thread replies** in a thread the agent already joined continue the same chat, so you don't need to @mention on every message.
* **Replies to agent-initiated threads** — When the agent posts a top-level message in a channel (e.g. a scheduled update or proactive notification), replies to that thread also continue the conversation without needing @mention.
* **All other messages** are ignored silently, so normal channel chatter doesn't spam the agent.

These conversations show up in the sidebar alongside portal chats, and can be filtered using the chat filter pill (e.g. *Hide remote chats*). The agent has the same instructions, memory, and capabilities as it does in the portal — so handoffs between Slack and the portal are seamless.

<Tip>
  Slack-originated chats are marked as "remote" and are read-only in the portal — reply from Slack to keep the thread in the agent's working context.
</Tip>

## Customizing scopes and events

The manifest includes defaults that work for most use cases. You can customize them in your Slack app settings:

| Setting        | Description                                                                                         |
| -------------- | --------------------------------------------------------------------------------------------------- |
| **Scopes**     | What the agent can do in Slack. See the [full list of scopes](https://api.slack.com/scopes).        |
| **Bot events** | Which events Slack sends to the agent. See the [full list of events](https://api.slack.com/events). |

If you don't want the agent to see all channel messages, remove `message.channels` and `message.groups` and add `app_mention` instead — the agent will then only receive @mentions and DMs.

## Accessing other Slack API methods

Beyond posting messages, reading channels, and reacting to messages, your agent can call any [Slack Web API method](https://api.slack.com/methods) — for example pinning messages, adding bookmarks, or listing user groups. Just ask in plain language:

* "Pin the latest status update in #launch"
* "Add a bookmark to #onboarding linking to our new-hire checklist"
* "List all user groups in the workspace and tell me who's in @design-team"

If a method requires an OAuth scope your app doesn't have yet, the agent will tell you exactly which scope to add. Open your Slack app settings, add the scope under **OAuth & Permissions → Bot Token Scopes**, reinstall the app to the workspace, and update the new bot token in Abundly.

## Working with file attachments

Your agent can both receive files from Slack and send files back into Slack messages and DMs.

**Incoming files.** When people share files in Slack, your agent can download those attachments into [agent documents](/features/documents) and use them in multi-step workflows — for example, reading and summarizing an attached PDF, saving it to the document library, or forwarding it to another capability like Notion.

**Outgoing files.** The agent can attach files when it posts to a channel or sends a DM. Supported sources include agent documents, images and other files produced by other capabilities, external URLs, and raw SVG content (auto-converted to PNG). Multiple files can be attached to a single message.

Example prompts:

* "Generate a pie chart of last month's sales by region and post it to #sales with a short summary"
* "When the weekly report PDF is ready, DM it to @Jane"
* "Take the diagram you just drew and share it in the thread"

The default manifest already includes `files:read` and `files:write`, which are needed for file workflows.

## Troubleshooting

<AccordionGroup>
  <Accordion title="Agent isn't responding to messages">
    1. **Check the mode** — In **Settings → Capabilities → Slack**, confirm you're in Chat mode if you expect the agent to reply automatically. Trigger mode does not auto-reply unless your instructions say so.
    2. **Check event subscriptions** — In your Slack app settings, go to **Event Subscriptions** and ensure:
       * The Request URL matches the webhook URL shown in Abundly.
       * The "Enable Events" toggle is ON.
       * The bot events from the manifest are present (`message.im` for DMs, plus `message.channels` / `message.groups` for public / private channel messages — or `app_mention` with `app_mentions:read` if you've narrowed to mention-only).
    3. **Invite the agent** — Type `/invite @YourAgentName` in the channel, or DM the bot directly.
    4. **Test the connection** — Use the **Test connection** button in Abundly to confirm the bot token is valid.
  </Accordion>

  <Accordion title="Agent replies only to @mentions, never to regular channel messages">
    By default, the agent listens to all messages in channels it's in, but only *replies* to @mentions, DMs, and follow-ups inside threads it's already part of. That's intentional — it keeps the agent from jumping into every conversation. To change this behavior, adjust your agent's instructions or customize the bot events in your Slack app.
  </Accordion>

  <Accordion title="Agent is responding to too many messages">
    By default the agent receives all messages in channels, groups and DMs it's a member of, so it can keep a conversation going in a thread without requiring an @mention every time. If you'd rather have it respond only when directly @mentioned:

    1. In your Slack app's **Event Subscriptions**, replace `message.channels` and `message.groups` in the bot events with `app_mention`.
    2. Add `app_mentions:read` to `scopes.bot` on **OAuth & Permissions**.
    3. Reinstall the app from the **Install App** page, then update the new bot token in Abundly.

    You can also remove the agent from noisy channels rather than changing scopes.
  </Accordion>

  <Accordion title="Permission errors">
    Ensure your Slack app has these minimum scopes:

    * `channels:read`, `groups:read`, `im:read` — To see public channels, private channels, and DMs
    * `channels:history`, `groups:history`, `im:history`, `mpim:history` — To read message content in each conversation type
    * `chat:write` — To send messages
    * `im:write` — To open DM conversations
    * `users:read` — To resolve user IDs and display names

    If you've added new scopes, reinstall the app from the **Install App** page in the left sidebar, then update the new bot token in Abundly.
  </Accordion>
</AccordionGroup>