Guides

Agent Channels

Reach a deployed agent from Slack: the app manifests, the service account it acts as, and what each credential does and does not permit.

A channel is a place people reach a portable agent from: an AI app, a task board, a chat tool. This page says which channels work today, which are on the way, and how to connect a chat tool yourself until they arrive.

Where to find it

Channels live on the Channel tab of an agent, and creating an agent has the same step. Only an orchestrator has the tab. A subagent has no triggers or channels: only an orchestrator, or a person in an AI app, starts it.

A channel is not part of the agent definition, so it is not part of what a host loads when it runs the agent: what a host fetches is the prompt and the model preference, never a Slack workspace. (Skills are not part of it either: the agent discovers them at run time from what its identity is granted.)

What the tab lists

ChannelStateHow people reach the agent
Any AI appAlways onName the agent in an app connected to airlock. The tab has the sentence to copy, for example "Use the triage agent."
Work boardFor organizations that use airlock workGive it a task on the work board
SlackComing soonSee below
Microsoft TeamsComing soonTag it in a chat or a channel
WhatsAppComing soonMessage its business number
Its own mail addressComing soonMail it, or copy it in
A phone numberComing soonCall it
Your websiteComing soonA chat or voice widget

Below the channels, an agent that runs in airlock work has What starts it on its own: its working hours and the signals it watches in its connectors. Set them while you create the agent, or on this tab later; Generate from its job proposes signals from what the agent does.

Slack

A shared agent gets its own Slack app, with the agent's name and picture, that people message directly or tag in a channel. It answers in the thread, and a follow-up in the same thread continues the same task. Who it works as follows from Signs in as:

  • Its own Agent ID: everyone who asks gets the same access, the Agent ID's.
  • The user: each person who asks gets the agent with their own access, never the owner's. The first time, the agent asks them to connect airlock work once and links it.
  • A personal agent gets no Slack app of its own. It will be reached through the airlock assistant, and the tab shows that as coming soon.

To add it, turn Slack on while you create the agent (the setup opens as soon as it exists), or on this tab later:

  1. The first time in a workspace, airlock needs a Slack configuration token: on api.slack.com/apps, under Your App Configuration Tokens, click Generate Token, pick the workspace, and paste both values into the one box. airlock keeps it encrypted, so later agents in that workspace skip this step.
  2. Click Add to Slack. airlock creates the app and Slack asks you to allow it.
  3. Click Allow. The agent sends you a welcome message and appears under Direct messages.

Anyone who messages it must be a member of your Slack workspace whose email is an active airlock account with access to the agent's space. A step that needs approval waits, and the agent says so in the thread. Slack as a channel needs airlock work; without it the row says so.

Connecting a chat tool yourself

Until a channel you need is on the tab, you can connect it yourself: run a small listener in your own infrastructure that receives the message, decides which agent should answer, and calls airlock's MCP endpoint as an Agent ID.

Slack  ->  your listener  ->  airlock MCP endpoint  ->  your tools

What airlock sees is an ordinary authenticated tool call, exactly like one from any other client. It is not in the message path: it does not receive the message, cannot see whether your listener is running, and keeps no record of which channels a listener serves. It governs the calls your listener makes through it. The Control Room has nothing to set for this, and no longer generates Slack app manifests for it.

The steps below use Slack. Any chat tool that can deliver a message to your own code works the same way.

Step 1: choose the Agent ID

This is the most consequential decision on the page.

When your listener calls airlock, airlock evaluates policy for the acting principal, which is the Agent ID (service account) the listener authenticated as. So:

The agent can do exactly what that Agent ID can do. No more, and no less.

A narrower agent is a narrower Agent ID. Give it only the integrations, skills and tools this agent needs, grant it the agent itself, and create a dedicated one instead of reusing a broad one across several agents. See Service Accounts for how to create one and grant it access.

Step 2: issue the token your listener authenticates with

Create a token for it under Identities → Agent IDs. It is shown once, and your listener presents it as its airlock identity.

Revoking the token, or disabling the Agent ID, is how you stop the listener reaching airlock. There is no other switch, because airlock is not in the message path.

Step 3: create the Slack app your listener runs as

Create a Slack app at api.slack.com/apps and install it into your workspace. If your listener uses Socket Mode, which needs no public endpoint of its own, also generate an app-level token with the connections:write scope. Socket Mode needs that scope specifically and the bot token cannot stand in for it.

You hold these tokens, and airlock never sees them.

A listener that answers mentions and direct messages, and follows a thread, needs these bot scopes:

ScopeWhy
app_mentions:readReceive at-mentions in channels
chat:writePost the answer, and update it as it streams
im:historyReceive direct messages
channels:history, groups:historyRead a thread's replies, so a follow-up needs no re-tag
users:readResolve the sender's display name and time zone

Step 4 (optional): let the agent use Slack as a tool

Only if you want the agent to use Slack as a tool, for example posting a summary into a channel or reading a channel's history, and not only reply where it was addressed.

That goes through airlock's Slack connector, with a credential of its own. Keep that credential out of your listener's environment, and save it on the Agent ID, not on your own user. airlock injects credentials per calling principal, and your listener calls as the Agent ID from Step 1. So:

  1. Grant that Agent ID access to the Slack connector.
  2. Open the Agent ID (Identities in the sidebar, its Agent IDs tab, then the account) and enter the credential under Credentials.

A credential entered as your own connection is stored against you. The connector will look connected while you are signed in, and every Slack tool call the agent makes will still fail for want of a credential.

Strongly consider setting its send-message tool to require approval. Outbound messages to people, under your organization's name, written by a model, are the textbook case for a human gate.

Step 5: invite the app to the channels it should see

A bot token only reads and posts where its app is a member, so invite it to each channel deliberately. Treat that as a feature: your agent's reach becomes explicit and revocable per channel instead of "the whole workspace, forever".

Step 6: check that it answers

Mention the agent in a channel you invited it to and confirm it replies. That check is the only confirmation there is: airlock does not route these messages and never observes your listener, so it cannot tell you whether the wiring works, and it will not report a listener that has stopped.

What is enforced for your own listener, and by what

Three different things are doing the work, and they do not survive the same changes.

Enforced by the Slack credential. A bot token cannot read history in, or post into, a channel its app was never invited to, as long as the app does not hold chat:write.public. This holds whatever your listener's code does.

Direct messages are not channels. That bound is a channel bound, and it does not reach DMs. With im:history the app reads the full history of any direct message its bot takes part in, and there is no invite to withhold. chat:write writes back into those same conversations.

Nor is listing bounded by membership. Membership gates content, not existence. users:read enumerates your entire workspace user directory.

Enforced by the listener's code. Replying only in a thread, or only where the bot already participates, is a rule in the code you run. Change that code and this changes with it.

Not governed at all. Within the channels it was invited to, your listener reads history and posts using its own Slack token, directly. Those calls do not pass through airlock. airlock governs what your listener asks airlock to do, not what it does in Slack.

Size your trust to that.

Troubleshooting

The agent never answers a mention. Check that the app is invited to the channel, and that your listener's connection to Slack is up. airlock has no visibility into either.

The agent answers but every tool call is refused. The Agent ID it authenticates as has no grant for that integration. Access is the Agent ID's, not the agent's.

The very first call answers not-found. The Agent ID was not granted the agent itself. An Agent ID holds only what it is explicitly granted.

Calls stopped after a token change. A rotated or revoked token is refused from the next call onward. Issue a new one under Identities → Agent IDs and update the listener.