> For the complete documentation index, see [llms.txt](https://docs.warp.dev/llms.txt).
> Markdown versions of each page are available by appending .md to any URL.

# Connect Slack to your factory

Connect Slack to your factory so your team can start work with mentions, direct messages, and automations, and get results back in the same thread.

Connect a factory to Slack so your team can send work without leaving their conversations. Mention the factory in a channel or send it a direct message, and it picks up the request with the conversation as context, then posts progress and results back into the same thread.

Each factory appears in Slack as its own app with the factory’s name and avatar. A channel can host several factories, and you choose which one to mention.

## Prerequisites

-   Permission to install Slack apps in the target workspace.
-   Permission to update the factory’s configuration.

## Permissions

Each factory’s Slack app uses a bot token. Managed setup also requests separate permissions from the person authorizing app provisioning.

**Installed-grant verification pending.** The bot and manager-user scopes below are defined in Warp’s app-generation and authorization paths. Confirm the production manager app’s own bot scopes and each installed factory app’s consent before approval; those grants can differ from the generated defaults.

### Factory app bot scopes

The scope meanings follow [Slack’s scope reference](https://docs.slack.dev/reference/scopes/). These grants aren’t limited to messages that start a run.

| Scope | Granted access | Function in Warp | Boundary |
| --- | --- | --- | --- |
| `app_mentions:read` | Read messages that mention the app | Receive mention requests | Conversations the app belongs to |
| `assistant:write` | Act as a Slack app agent | Support Slack’s agent experience | Not a workspace administration grant |
| `channels:history` | Read public-channel messages and content | Supply channel and thread context | Public channels the app has joined |
| `channels:manage` | Manage joined public channels and create channels | Provision channels for factory work | Broader than reading or posting messages |
| `channels:read` | Read public-channel metadata | Resolve channel names and choices | Metadata access isn’t message-history access |
| `chat:write` | Send messages as the app | Post progress and results | Uses the bot’s identity and conversation access |
| `chat:write.customize` | Customize the sender name and avatar | Present factory-branded messages | Doesn’t grant access to another user’s account |
| `files:read` | Read accessible shared files | Include supported attachments as context | Files visible to the app |
| `files:write` | Upload, edit, and delete files as the app | Share output artifacts | Broader than downloading attachments |
| `groups:history` | Read private-channel messages and content | Supply private-channel context | Private channels the app has joined |
| `groups:read` | Read private-channel metadata | Resolve accessible private channels | Requires channel membership |
| `im:history` | Read direct-message content | Supply direct-message context | Direct messages involving the app |
| `im:read` | Read direct-message metadata | Identify direct-message conversations | Not other people’s private conversations |
| `im:write` | Start direct messages | Send messages to people as the app | Distinct from reading existing messages |
| `mpim:history` | Read group direct-message content | Supply group-conversation context | Conversations the app has joined |
| `mpim:read` | Read group direct-message metadata | Identify accessible group conversations | Not all group conversations in the workspace |
| `reactions:read` | Read reactions and associated content | Match reaction-based automations | Accessible conversations |
| `reactions:write` | Add and edit reactions | Acknowledge requests | Actions as the app |
| `usergroups:read` | Read user groups | Resolve group membership | Workspace directory data |
| `users:read` | Read workspace member profiles | Resolve people and user names | Directory access isn’t limited to a trigger’s author |
| `users:read.email` | Read member email addresses | Match accounts and look up people | Email access is separate from `users:read` |

### Managed setup user scopes

These scopes authorize app management, not factory access to your personal message history.

| Scope | Granted access | Function in Warp | Boundary |
| --- | --- | --- | --- |
| `app_configurations:read` | Read configurations of apps created by the manager app | Inspect factory app configuration | Limited by Slack to that manager’s apps |
| `app_configurations:write` | Create apps and change their configuration | Create and update factory apps | Limited by Slack to that manager’s apps |
| `managed_apps:install` | Install managed child apps | Install each factory’s Slack app | Subject to your workspace’s app policy |

Channel invitations constrain bot access. Automation filters constrain which events start work, not what an authorized bot token can read. For example, a keyword filter doesn’t remove the app’s history access to other messages in a joined channel. See [disconnecting Slack](#troubleshooting-and-reconnection) to remove the factory app; review the manager authorization separately when withdrawing setup permissions.

## Connect the factory

1.  **Select Slack while creating a factory**, or connect it later from the factory’s **Settings**. Warp installs its Slack app for you.
2.  **Complete the install if it can’t finish on its own.** This usually happens when your workspace requires administrator approval. Click **Add to Slack** in factory setup to finish.
3.  **Invite the app to each channel it should listen in.** Private channels always need an invitation.
4.  **Confirm the connection.** Mention the app in one of those channels. It reacts with 👀 to show it picked up the request.

## Configure factory automations for Slack

Use a factory automation to start work from Slack activity automatically, without anyone mentioning the app, such as on every message in a triage channel or on a specific emoji reaction. Add a **Slack** trigger to an automation and pick one of these events. To learn how to edit those filters, see [Automations](https://docs.warp.dev/factories/automations/#edit-filters-on-an-automation).

-   **App mentioned** - Filter by joined conversations, authors, and keywords.
-   **Direct message received** (`message_dm`) - Filter by direct-message conversations, authors, and keywords.
-   **Message posted in channel** - Filter by joined conversations, authors, and keywords.
-   **Reaction added** - Filter by conversations, reactors, keywords, emoji, and reacted-message authors.
-   **Member joined channel** - Filter by conversations and members.

For the exact `event` value each of these triggers uses in a definition file, see [triggers](https://docs.warp.dev/factories/factory-as-code/#triggers).

The reaction-intake automation in [`06-common-automations`](https://github.com/warpdotdev/warp-factory-examples/tree/main/examples/06-common-automations) in the [warp-factory-examples](https://github.com/warpdotdev/warp-factory-examples) repository files a GitHub issue when someone reacts with `:ticket:`:

```markdown title="automations/slack-reaction-intake/automation.md"
---
triggers:
  - provider: slack
    event: reaction_added
    filter:
      channels: [your-intake-channel]
      emojis: [ticket]
---
Someone reacted with :ticket: to a Slack message. Read the thread, file a
GitHub issue that captures the request with a link back to the thread, and
reply in the thread with the issue link. Do not start the work; this
automation only files it.
```

The **Conversations** picker only shows conversations the factory’s app has joined. If a channel is missing, invite the app to it; for direct messages, send the app a DM first. Then refresh the automation editor.

A single Slack message can match more than one automation. For example, if one automation triggers on **App mentioned** and another triggers on **Message posted in channel** in the same channel, a channel message that mentions the app starts two separate runs, one for each automation. To avoid duplicate runs, don’t point both triggers at the same channel.

## Use integration-provided tools

When Slack is connected to a factory, Warp automatically gives its agents Slack tools during factory runs. The tools let an agent read channels and threads that the app can access, reply in a thread, and post a new top-level message to a channel. The run doesn’t need to start from Slack.

Warp also automatically makes tools from a connected Linear or Jira issue tracker available to the factory’s agents. These are Warp-managed, integration-provided capabilities, separate from the [MCP servers you configure for cloud agents](https://docs.warp.dev/platform/mcp/). They may not appear alongside user-configured MCP servers in the factory’s MCP list.

You don’t need to install a separate Slack MCP server to post factory output to Slack. The connected Slack app’s authorization still controls which channels the tools can access, so invite the app to the destination channel first.

## Post a scheduled factory digest to Slack

A scheduled automation can compile a nightly report and post it to Slack. Put the destination’s Slack channel ID directly in the automation instructions. An explicit channel ID is the most reliable way to target the intended channel.

This automation runs every night at 2:00 AM UTC and tells the agent where to post:

```markdown title="automations/nightly-factory-digest/automation.md"
---
agent: foreman
triggers:
  - provider: schedule
    event: cron_fired
    schedule:
      name: nightly-factory-digest
      cron: "0 2 * * *"
---
Summarize factory work completed or blocked in the last 24 hours.
Post the digest as a new top-level message to Slack channel ID C0123456789
using the connected Slack tools. Include links to each work item or pull
request, and report the Slack posting error if delivery fails.
```

Replace `C0123456789` with the destination’s channel ID. See [Factory definition syntax](https://docs.warp.dev/factories/factory-as-code/#automationsnameautomationmd) for the other automation fields and schedule options.

## Start and continue work from Slack

Mention the app in a channel or thread, or send it a direct message, to start work. The factory picks up the message, including available thread history and supported attachments, and replies in the same place with an acknowledgment, progress updates, and links to results.

A plain reply in a thread continues work only if that thread already has a factory work item; to start new work in a channel, mention the app instead. Slack activity that matches an automation starts work the same way, without a mention, using the event details and the automation’s assigned agent.

You can attach files to a request or a follow-up. The factory includes the files it supports, and a file it can’t include doesn’t stop the text of your request from going through.

## Follow work and review outputs

The Slack thread where work started is also where you follow it: the factory posts progress and the final response there. Reply in the thread to add information or attachments while work is active, or to pick the same work item back up later.

![A Slack thread where the Warp Factories app replies with tracking and triage progress updates, including links to open the session and view it in the factory.](https://docs.warp.dev/_astro/slack-factory-thread-reply.IqsWzCLm_1o1zNQ.webp?dpl=dpl_BfY66qhFfmzKoFv6hUojP5c1Xhrd)

The factory’s Slack app posting progress updates in the thread where work started.

For an overview of the factory’s work items, open the app’s **Home** tab in Slack. It groups them by stage (Triage, Planning, Building, Reviewing, Complete, and Cancelled), offers stage and date filters, and links each work item back to its Slack thread, factory run, issue, or pull request when available.

Work that starts in Slack still ends at a pull request for a person to review — see [How Warp Factories work](https://docs.warp.dev/factories/how-factories-work/).

## Who can start work

To start work with a mention or direct message, your Slack account must be linked to an active member of the factory’s Warp team. If it isn’t, the app prompts you to connect an account instead of starting work.

Work started by an automation runs as the factory agent you chose for it, not as whoever triggered it.

## Troubleshooting and reconnection

-   **The app doesn’t acknowledge a request** - Confirm Slack is connected for that factory, that you mentioned the right factory’s app, and that the app is in the channel.
-   **A channel is missing from an automation** - Invite the app to that channel, then reload the **Conversations** picker.
-   **Installation is pending** - Ask a Slack workspace administrator to approve the app, then finish the installation.
-   **The app asks you to link an account** - Follow the prompt while signed in to the Warp account that belongs to the factory’s team, then send the request again. Connecting the factory’s Slack app doesn’t link every teammate’s account.
-   **Two runs start for one mention** - Remove or narrow overlapping app-mention and channel-message triggers.

To disconnect Slack, either delete the factory — which removes its Slack app along with it — or [remove the app from your Slack workspace](https://slack.com/help/articles/360003125231-Remove-apps-and-custom-integrations-from-your-workspace), which stops new Slack requests reaching that factory. To reconnect afterward, click **Add to Slack** in factory setup again.

To route work into the factory from other tools, see [Connect your factory](https://docs.warp.dev/factories/connect-your-factory/).

## Privacy

The factory uses message content and supported attachments for its work, and your Slack profile email to map you to your Warp account. Its [bot scopes](#factory-app-bot-scopes) also authorize reading history in conversations the app has joined, including through [integration-provided tools](#use-integration-provided-tools); mentions and automation filters aren’t a message-level access boundary. Data is handled per the [Warp Privacy Policy](https://www.warp.dev/privacy).

## Related pages

-   [Permissions for factory integrations](https://docs.warp.dev/factories/integrations/permissions/) - Compare grants and review status across providers
-   [Factory automations](https://docs.warp.dev/factories/automations/)
-   [Factory troubleshooting](https://docs.warp.dev/factories/troubleshooting/#work-isnt-starting)