OpenClaw auf mehreren Kanälen: Telegram, Discord und WhatsApp gleichzeitig betreiben

Warum ein Kanal nicht reicht

In der Theorie klingt ein Kanal nach genug. Der Agent ist auf Telegram, du schickst ihm Nachrichten — fertig.

In der Praxis sieht es anders aus. Dimitrios nutzt Telegram für schnelle persönliche Updates. Das Entwicklerteam ist auf Discord. Ein Kunde möchte WhatsApp. Und der interne Morgenreport soll in einen Discord-Kanal, nicht in einen privaten Chat.

Wenn dein Agent nur auf einem Kanal ist, entstehen Brüche. Informationen gehen verloren. Kontext fehlt. Und man fängt an, Nachrichten manuell weiterzuleiten — genau das, was man automatisieren wollte.

OpenClaw unterstützt mehrere gleichzeitige Kanäle. Dieser Post zeigt, wie wir das für unser 6-Agenten-Team eingerichtet haben.

---

Wie Multi-Channel in OpenClaw funktioniert

OpenClaw behandelt jeden Kanal als eigenständige Verbindung. Das Gateway verwaltet alle Kanäle parallel — jede eingehende Nachricht trägt den Kanal-Kontext mit, sodass der Agent weiß, woher sie kommt und wohin er antworten soll.

```

Gateway

├── Telegram (Sam, persönlicher Chat)

├── Discord (Team-Server, mehrere Channels)

├── WhatsApp (Kunden-facing)

└── Signal (intern, optional)

```

Konfiguration in der OpenClaw-Config (vereinfachtes Schema):

```yaml

channels:

telegram:

token: ${TELEGRAM_TOKEN}

allowedUsers:

- "123456789" # Dimitrios

discord:

token: ${DISCORD_TOKEN}

guildId: ${DISCORD_GUILD_ID}

allowedRoles:

- "Team"

- "Admin"

whatsapp:

token: ${WHATSAPP_TOKEN}

allowedNumbers:

- "+49123456789"

```

Jeder Kanal hat seine eigene Allowlist. Ein Discord-Nutzer ohne "Team"-Rolle kann dem Agenten keine Befehle schicken — auch wenn er den Server findet.

---

Schritt 1: Telegram einrichten

Telegram ist typischerweise der erste Kanal — einfach einzurichten, zuverlässig, keine App-Genehmigungsprozesse.

```bash

# 1. Telegram-Bot erstellen: @BotFather auf Telegram

# /newbot → Name eingeben → Token erhalten

# 2. Token in .env speichern

echo 'TELEGRAM_TOKEN=8234567890:AAHxxxxxxxx' >> ~/.openclaw/workspace/.env

# 3. Deine eigene Telegram-User-ID herausfinden

# Schicke @userinfobot eine Nachricht auf Telegram → gibt deine ID zurück

# 4. OpenClaw konfigurieren

openclaw configure

# → Kanal: telegram

# → Token: $TELEGRAM_TOKEN

# → Allowed users: deine User-ID

```

Wichtig: Den Bot-Token niemals in der Config als Klartext eintragen. Immer als Umgebungsvariable referenzieren.

Nach `openclaw gateway restart` ist der Agent auf Telegram erreichbar. Test:

```

Du auf Telegram: "Hallo, bist du da?"

Agent: "Ja. Was kann ich tun?"

```

---

Schritt 2: Discord einrichten

Discord ist komplexer als Telegram, aber mächtiger für Team-Szenarien — Threads, Rollen, mehrere Channels.

```bash

# 1. Discord Application erstellen

# → https://discord.com/developers/applications

# → "New Application" → Name eingeben

# → Bot-Sektion → Bot erstellen → Token kopieren

# 2. Bot-Berechtigungen setzen (im Developer Portal unter OAuth2 → URL Generator):

# Scopes: bot

# Bot Permissions:

# - Read Messages / View Channels

# - Send Messages

# - Read Message History

# - Add Reactions

# - Manage Messages (für Pin-Funktionen)

# - Create Public Threads

# 3. Bot zu Server einladen über die generierte URL

# 4. Token in .env speichern

echo 'DISCORD_TOKEN=MTIxNTxxxxxxxx.xxxxxx.xxxxxxxxxx' >> ~/.openclaw/workspace/.env

# 5. Server-ID (Guild-ID) finden:

# Discord → Server-Einstellungen → Rechtsklick auf Server-Icon → "Server-ID kopieren"

echo 'DISCORD_GUILD_ID=1234567890123456789' >> ~/.openclaw/workspace/.env

```

Discord-Kanal-Routing: Unser Agent Sam reagiert nicht in jedem Discord-Kanal. Sie ist nur in bestimmten Kanälen aktiv:

```yaml

channels:

discord:

token: ${DISCORD_TOKEN}

guildId: ${DISCORD_GUILD_ID}

activeChannels:

- "sam-direct" # Direkter Kanal für Sam

- "team-general" # Allgemeiner Team-Kanal

- "dev-alerts" # Automatische Alerts

allowedRoles:

- "Team"

- "Admin"

```

In `#marketing` oder `#random` bleibt Sam stumm — außer wenn direkt erwähnt (`@Sam`).

---

Schritt 3: WhatsApp (für Kunden-facing-Szenarien)

WhatsApp ist für Unternehmensnutzung über die WhatsApp Business API erhältlich. Für Testzwecke und kleinere Setups bietet [WhatsApp Cloud API](https://developers.facebook.com/docs/whatsapp/cloud-api) eine kostenlose Variante.

```bash

# WhatsApp Cloud API Setup (vereinfacht):

# 1. Meta Business Account erstellen

# 2. WhatsApp Business App im Developer Portal einrichten

# 3. Webhook-URL konfigurieren → OpenClaw Gateway-Endpunkt

# 4. Phone Number ID und Access Token in .env:

echo 'WHATSAPP_PHONE_NUMBER_ID=123456789012345' >> .env

echo 'WHATSAPP_TOKEN=EAAxxxxxxxxxxxxxxxx' >> .env

```

Wichtiger Hinweis: WhatsApp Business API ist für Produktionsbetrieb gedacht und erfordert einen Genehmigungsprozess. Für interne Team-Kommunikation ist Telegram oder Signal einfacher.

Wir nutzen WhatsApp in unserem Setup nur für eine spezifische Anwendung: Kunden können eine WhatsApp-Nummer anschreiben, und Alex (unser Alltagsagent) nimmt erste Anfragen entgegen und leitet sie weiter. Für alles andere: Telegram.

---

Routing: Welcher Agent antwortet auf welchem Kanal?

Das ist die kritische Frage bei Multi-Agenten + Multi-Channel. Wenn auf dem Discord-Server eine Nachricht ankommt — welcher der 6 Agenten sollte antworten?

Unsere Strategie: ein Agent pro Kanal-Kontext.

| Kanal / Kontext | Agent | Begründung |

|----------------|-------|-----------|

| Telegram → Dimitrios persönlich | Sam | Teamlead, persönlicher Assistent |

| Telegram → Alerting | Sam | Direkte Benachrichtigungen |

| Discord → `#sam-direct` | Sam | Persönlicher Kanal |

| Discord → `#dev-alerts` | Sam (schreibt), Peter (arbeitet) | Sam koordiniert, Peter executiert |

| Discord → `#team-general` | Sam (bei Erwähnung) | Reaktiv |

| WhatsApp → Kunden-Nummer | Alex | Erstanfragen, FAQ |

Das vermeidet das größte Multi-Agent-Problem: zwei Agenten antworten gleichzeitig auf dieselbe Nachricht und widersprechen sich.

Regel: Jeder eingehende Nachrichtenfluss hat genau einen primären Agenten.

---

Kontext-Trennung: Was der Agent "weiß"

Ein subtiles aber wichtiges Thema: Was darf der Agent in welchem Kanal preisgeben?

Beispiel: Sam hat Zugriff auf Dimitrios' persönliche E-Mails, Kalender und ClickUp-Tasks. Im Discord-Server sind aber auch andere Team-Mitglieder. Sam sollte dort nicht "Dimitrios hat heute Nachmittag einen Zahnarzttermin" erwähnen — auch wenn das in ihrer MEMORY.md steht.

Wir lösen das mit Kontext-Regeln in SOUL.md:

```markdown

Kanal-spezifische Regeln

Telegram (Dimitrios persönlich): Vollzugriff auf alle Informationen.

Persönlicher Kontext, private Details — alles okay.

Discord (Team-Server): Nur arbeitsbezogene Informationen.

Keine persönlichen Details über Dimitrios.

Keine privaten Kosten, persönliche Termine oder vertrauliche Geschäftsdaten.

WhatsApp (Kunden-facing): Nur öffentlich verfügbare Informationen.

Kein Zugriff auf interne Systeme, keine Preise ohne Freigabe.

Immer: "Ich leite Sie gerne an unser Team weiter."

```

Der Agent liest diese Regeln und justiert automatisch, was er wo teilt.

---

Proaktive Nachrichten: An welchen Kanal wohin?

Neben eingehenden Nachrichten schickt Sam auch proaktive Nachrichten — Morgenreport, Alerts, Blog-Post-Ankündigungen. Jede dieser Nachrichten hat eine klare Zieladresse:

```python

# In Cron-Job-Prompts explizit definiert:

# Morgenreport → immer Telegram an Dimitrios

"Sende den Report per Telegram."

# Blog-Post deployed → Discord #announcements

"Kündige den neuen Post in Discord #announcements an."

# Kritischer Server-Alert → Telegram sofort

"Bei Disk > 90%: sofort per Telegram melden."

# Wochenbericht → Discord #weekly-reports

"Schick den Bericht in Discord #weekly-reports."

```

Durch explizite Kanal-Angaben im Prompt wird verhindert, dass der Agent "vergisst" wohin die Nachricht soll.

---

Häufige Probleme und Lösungen

Problem: Agent antwortet doppelt (einmal Telegram, einmal Discord)

Ursache: Zwei Kanäle empfangen dieselbe Art von Nachricht, und der Agent sendet an beide.

Lösung: Klare Kanal-Präferenz in SOUL.md:

```markdown

Proaktive Nachrichten an Dimitrios: immer Telegram, nie Discord.

Discord nur für Team-Kommunikation und Ankündigungen.

```

Problem: Bot-Token läuft ab / wird widerrufen

Ursache: Discord-Tokens laufen nicht ab, aber Telegram-Tokens können widerrufen werden (z.B. wenn man /revoke bei @BotFather eingibt).

Diagnose:

```bash

openclaw channels list

# Zeigt: telegram → disconnected / error

```

Lösung: Neuen Token erstellen, in .env ersetzen, Gateway neu starten.

Problem: Agent antwortet auf alle Nachrichten im Discord-Server

Ursache: Keine `activeChannels`-Konfiguration gesetzt.

Lösung: In der Discord-Konfiguration explizit Kanäle angeben:

```yaml

activeChannels:

- "sam-direct"

- "team-updates"

```

Und in SOUL.md:

```markdown

Im Discord-Server: nur antworten wenn in einem der konfigurierten Kanäle

oder wenn direkt per @Sam erwähnt.

```

Problem: WhatsApp-Webhook wird nicht empfangen

Ursache: Der OpenClaw Gateway ist nicht von außen erreichbar (lokale Installation ohne öffentliche IP).

Lösung: Tailscale + Tailscale Serve für einen sicheren, internen Webhook-Endpunkt:

```bash

# Nur innerhalb des Tailscale-Netzwerks:

tailscale serve https / http://localhost:3000

# Niemals:

# tailscale funnel — das wäre ein öffentlicher Port!

```

Für WhatsApp's Webhook brauchst du eine öffentliche URL. Die sichere Lösung: ein separater Reverse-Proxy (nginx auf einem VPS) der WhatsApp-Webhooks intern weiterleitet. Nicht in 5 Minuten einzurichten — aber der richtige Weg.

---

Unser tatsächliches Kanal-Setup

Zur Referenz — wie wir es wirklich betreiben:

Sam:

Peter:

Maya:

Alex:

Atlas:

Iris:

Jeder Agent hat seinen eigenen Bot-Account — keine geteilten Tokens zwischen Agenten. Das ist sowohl für Sicherheit als auch für Klarheit wichtig.

---

Token-Verwaltung bei mehreren Kanälen

Mit 6 Agenten und je 2-3 Kanälen kommt man schnell auf 15+ API-Keys. Ordnung ist hier wichtig.

In unserem Setup: eine zentrale `.env` pro Agent, nicht eine globale `.env` für alle:

```

/opt/agents/workspaces/

├── sam/.env # Sam's Telegram + Discord Token

├── peter/.env # Peter's Discord Token

├── maya/.env # Maya's Discord Token

├── alex/.env # Alex's Telegram + WhatsApp Token

├── atlas/.env # Atlas's Telegram Token (privat)

└── iris/.env # Iris's Discord Token

```

Wenn Peter's Discord-Bot kompromittiert wird: nur Peters Token wird widerrufen. Die anderen Agenten sind nicht betroffen.

---

Fazit

Multi-Channel ist kein Luxus — es ist der natürliche nächste Schritt, wenn Agenten über ein persönliches Setup hinaus in Team-Szenarien genutzt werden. Die Konfiguration ist in OpenClaw unkompliziert; die eigentliche Arbeit liegt im Routing-Design und den Kontext-Regeln.

Das vollständige Kanal-Setup für alle 6 Agenten — inklusive YAML-Konfigurationen, SOUL.md-Kanal-Regeln und dem WhatsApp-Reverse-Proxy-Setup — ist im OpenClaw Setup Playbook dokumentiert.

Komplett auf Deutsch verfügbar. 🇩🇪