Here's a situation most people recognize: your work team communicates on Slack, your close friends are on WhatsApp, your gaming community lives on Discord, and your personal contacts prefer Telegram. You end up with four apps open, four notification streams, and four separate contexts to manage.
Now imagine your AI assistant worked in all of them simultaneously — with shared memory, so it remembers what you told it on Telegram when you ask about it on Discord. One assistant, everywhere you already are.
That's what ZeroClaw's multi-channel architecture makes possible, and the setup is simpler than you might expect.
How It Works Under the Hood
ZeroClaw's channel system is built on Rust traits. Each channel — Telegram, Discord, WhatsApp, Signal, Matrix, IRC — is an independent adapter that implements the same interface. They all share a single AI provider connection, a single memory database, a single config file, and a single process running as one binary.
The practical consequence is that when you tell your bot something on Telegram, it remembers when you ask about it on Discord. The memory is channel-agnostic. ZeroClaw stores conversations in a unified SQLite database with metadata about which channel each message came from, but retrieval works across all channels. Your context follows you.
Setting Up Telegram
Message @BotFather on Telegram to create a new bot and get your token. Then message @userinfobot to get your user ID. Add this to your config:
```toml [channels.telegram] token = "123456:ABCdefGHIjklMNO" allowed_users = [your_user_id] ```
The `allowed_users` list is important — it ensures only you (or whoever you specify) can interact with your bot.
Setting Up Discord
Go to discord.com/developers, create an application, add a bot, and copy the token. Enable Message Content Intent in the bot settings — without this, the bot can't read messages. Use the OAuth2 URL generator to invite the bot to your server.
```toml [channels.discord] token = "MTk4NjIz..." guild_ids = [your_server_id] allowed_roles = ["ai-users"] ```
The `allowed_roles` field lets you restrict which Discord users can interact with the bot — useful if you're adding it to a shared server.
Setting Up WhatsApp
ZeroClaw uses a WhatsApp Web bridge that works without any special API access:
```toml [channels.whatsapp] enabled = true allowed_numbers = ["+1234567890"] ```
On first start, ZeroClaw displays a QR code in the terminal. Scan it with WhatsApp on your phone to pair. After that, it stays connected automatically.
Starting Everything
```bash zeroclaw start ```
One command. All three channels connect simultaneously:
``` [INFO] Telegram channel connected [INFO] Discord channel connected (1 guild) [INFO] WhatsApp channel paired [INFO] ZeroClaw ready — 3 channels active ```
Shared Memory in Practice
The cross-channel memory is the feature that makes this genuinely useful rather than just technically interesting. Here's what it looks like:
You send a message on Telegram: > "Remember that my project deadline is March 15th" > "Got it — your project deadline is March 15th."
Later, on Discord: > "When is my deadline?" > "Your project deadline is March 15th, as you mentioned earlier."
The bot didn't need to be told again. It didn't need you to be in the same channel. The memory is shared across the entire ZeroClaw instance.
Tuning Behavior Per Channel
Different platforms have different conventions. Discord users expect markdown formatting and concise responses. WhatsApp conversations are more casual and don't render markdown. Telegram supports longer, more detailed replies. ZeroClaw lets you tune behavior per channel:
```toml [channels.discord] token = "..." system_prompt_append = "You are in a Discord server. Keep responses concise. Use markdown formatting." max_response_length = 1500
[channels.telegram] token = "..." system_prompt_append = "You are in a private Telegram chat. Be conversational and detailed." max_response_length = 4000
[channels.whatsapp] enabled = true system_prompt_append = "You are on WhatsApp. Keep responses short — no markdown, plain text only." max_response_length = 500 ```
Same AI, same memory, different personality per platform.
Access Control
When your bot is accessible across multiple channels, access control matters. ZeroClaw gives you per-channel controls:
```toml [channels.telegram.permissions] tools = ["web_search", "file_read", "file_write"]
[channels.discord.permissions] tools = ["web_search"] # read-only in public server ```
You can grant your private Telegram chat full tool access while keeping the Discord bot limited to web search. The permissions are enforced at the channel level, not the user level.
Adding More Channels
ZeroClaw supports 30+ channels. Adding another is just more config:
```toml [channels.slack] token = "xoxb-..." channels = ["C01234567"]
[channels.signal] enabled = true phone_number = "+1234567890"
[channels.matrix] homeserver = "https://matrix.org" username = "@zeroclaw:matrix.org" password = "..." ```
Each additional channel adds roughly 0.5MB of RAM. Ten channels simultaneously still runs under 10MB total.
The Bigger Picture
The multi-channel setup solves a real problem: your life doesn't happen in one app, and your AI assistant shouldn't either. One binary, one config file, one memory database, and your assistant is present in every conversation platform you use — remembering context across all of them, using less RAM than a single browser tab.
No microservices. No message queues. No container orchestration. Just a single process that happens to speak thirty different chat protocols.