Skip to main content

Channels — Technical Reference

This page describes how channels work beneath the UI, in technical terms, for developers and technically-inclined users. It focuses on the model and observable behavior, not implementation internals.

Architecture model​

A channel is the surface where an agent receives messages and sends replies. The same agent logic runs across every channel — what changes is the input shape (how a message arrives) and the output shape (what the agent can render in reply).

Two kinds of channels exist:

  • Web app — the in-product chat. Full output options: rich displays, file viewers, downloadable datasets, interactive components.
  • External channels — WhatsApp, Instagram, Messenger, Telegram, Slack, Discord, Teams, web embed, chatbot widget, API. Output is restricted to what each platform supports (typically: text, images, files).

How an inbound message reaches the agent​

External channels deliver messages through an automatic alert (webhook) — the channel calls a URL on the platform with each new message. Each agent that's connected to that channel has its own incoming address; the address is protected by a secret key so other people can't post fake messages.

  • Each external channel has its own send actions — sending a message on Telegram is a different operation than sending a message on Slack, even when the agent's intent is the same. The platform exposes the right send actions to the agent based on which channel triggered the turn.
  • Web embed and API channels still go through this loop but use a simpler authenticated request shape.

Per-session execution serialization​

In the web app, the UI prevents the user from sending a second message until the agent has finished its reply. External channels don't have that affordance — users can (and do) send several messages in a row while the agent is still working.

To keep a conversation from corrupting itself, one message runs at a time per conversation. Messages that arrive while the agent is busy are queued and processed after the current turn finishes.

  • The serialization is per conversation, not per agent — two different conversations on the same agent still run in parallel.
  • A stale lock (e.g., the previous turn was interrupted) is released automatically after a bounded timeout so the next message isn't stuck waiting.

File uploads on external channels​

When a user attaches a file in an external channel, the file is uploaded as a normal message — there is no separate "uploaded ✓" confirmation reply. The agent sees the file alongside any caption the user wrote (or a placeholder caption if none) and decides what to do with it as part of its normal reasoning.

This makes the conversation feel natural — the user just sends a photo, the agent looks at it and responds.

Output rules per channel​

The agent's reply is filtered to what the channel supports:

ChannelTextImagesFilesRich components
Web app✓✓✓✓ (apps, file viewers, datasets)
WhatsApp / Instagram / Messenger✓✓✓— (sent as text or media)
Telegram / Slack / Discord / Teams✓✓✓—
Web embed / chatbot widget✓✓✓—
API✓✓✓—

When the agent tries to render something the channel can't show, the platform downgrades it gracefully (e.g., a rich data card becomes a compact text summary), so the agent's logic doesn't have to know which channel it's running on.

Meta channels — one-per-agent rule​

WhatsApp, Instagram, and Messenger share a single Meta sign-in per number/account/Page. As a result:

  • One WhatsApp business number can be connected to one agent at a time.
  • One Instagram account can be connected to one agent at a time.
  • One Messenger Page can be connected to one agent at a time.

Reassigning one of these channels to a different agent disconnects it from the previous one.

Other channels (Telegram, Slack, Discord, Teams) follow each platform's own rules; in practice each bot/app credential is also dedicated to one agent.

Channel selection at agent runtime​

When an agent runs, it sees:

  • The channel-specific send actions for the channel that delivered the message.
  • A platform-aware output rule that constrains what it should try to render.
  • The same tools, knowledge, and skills as on every other channel — channel choice never changes the agent's core capabilities.

This is how a single agent definition produces consistent behavior across many surfaces without needing per-channel logic.

Limits and guarantees​

  • The agent never sees a credential's secret value — only the credential ID it should use.
  • Inbound webhooks are rejected if the secret key is missing or wrong.
  • Messages within one conversation are serialized; messages across conversations on the same agent are processed in parallel.
  • One Meta channel (WhatsApp number, Instagram account, Messenger Page) ↔ one agent.
  • Usage is metered as credits per turn, the same way it is in the web app.

What's next​