Channels

Channels connect agents to messaging platforms so users can interact with them in the tools they already use. Slack, Discord, and Telegram are supported today, each with its own transport mechanism but a shared interface underneath.

How channels work

Every channel connector implements the same Connector interface. This means the system above it -- the ChannelManager -- does not care whether a message came from Slack, Discord, or Telegram. It routes messages to agent sessions and routes agent responses back to the correct thread or conversation.

The flow looks like this:

1. A user sends a message on a connected platform.
2. The connector receives the event through its platform-specific transport.
3. ChannelManager maps the message to an agent session (creating one if needed).
4. The agent processes the message and produces a response.
5. The response is formatted for the target platform and sent back to the original thread.

This is fully bidirectional. Agents can also initiate messages when triggered by other events, not only in response to user input.

Supported platforms

Slack

Slack uses Socket Mode, which means Everstack connects to Slack over a WebSocket rather than requiring an inbound webhook URL. This is simpler to set up because you do not need to expose a public endpoint.

Capabilities:

• Message and interaction handling
• Thread history for maintaining conversation context
• Block Kit formatting for rich message layouts
• Rich embeds for structured agent responses

Discord

Discord uses a full event listener that connects to the Discord gateway. It supports:

• Message events in configured channels
• Button interactions for human-in-the-loop (HITL) approval and denial workflows
• Rich embeds and formatted responses

The HITL button interactions are particularly useful for agents that need human approval before executing high-impact actions. The agent posts a message with approve/deny buttons, and the user's click is routed back to the agent session as an interaction event.

Telegram

Telegram uses a polling-based message handler. Everstack periodically polls the Telegram Bot API for new messages rather than receiving push events.

Capabilities:

• Text message handling
• Message routing to agent sessions

Telegram's polling approach is the simplest of the three transports and works well behind firewalls where inbound connections are restricted.

Setting up a channel

curl -X POST https://{instance}.{region}.everstack.ai/v1/channels \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "platform": "slack",
    "config": {
      "bot_token": "xoxb-...",
      "app_token": "xapp-..."
    },
    "agent_id": "agent_abc123"
  }'

Channel discovery

For platforms that support it, Everstack can discover available channels and conversations. This lets you browse Slack channels, Discord text channels, or Telegram groups from the dashboard and select which ones the agent should listen in.

Managing channels

The channel API supports the full lifecycle:

All operations are available through both the dashboard UI and the REST API. See the API Reference for endpoint details.

Plans and limits

Channels are metered by messages, not connections. Connecting another Slack workspace, Discord server, or Telegram group never changes what you pay, and every plan reaches every platform.

Each hosted plan carries a monthly channel message allowance, which is the meter that actually prices channel usage. See pricing for current allowances.

A message counts when a user sends one to a connected channel. Agent replies, cron notifications, and messages refused by a limit are not counted. The meter stores no message content, only which tenant, channel, and platform the message arrived on.

Creating a channel past the Starter count returns resource_exhausted with the current usage in the message. Channels already connected keep running; only the create is refused.

Passing the monthly message allowance behaves differently by plan. On Starter, agent replies pause until the month rolls over. On paid plans nothing pauses and nothing extra is billed: the channel notes the overage once and it shows in your usage dashboard. Either way the channel says so at most once every few hours, not on every message.

Tenant isolation

Channel bindings are strictly scoped to the tenant that created them. A Slack workspace connected by one tenant is invisible to every other tenant. Connector credentials are stored encrypted and never shared.

Next steps

• GitHub -- source control integration for repo access and webhooks
• Webhooks -- trigger agents from generic HTTP events
• Agents -- build the agents that respond on your channels