A detailed architectural comparison of how the official Claude Code Telegram plugin, OpenClaw, and Hermes actually solve the "agent ↔ Telegram" problem.
The grammy + MCP server that started it all. Extremely strong on security, pairing, access control, and being a well-behaved MCP channel.
A complete, independent Telegram bot implementation tightly integrated into OpenClaw's plugin-sdk, conversation threading model, and runtime.
A first-class pluggable gateway platform with exceptional focus on real-world delivery reliability, networking resilience, and multi-platform consistency.
A relatively focused implementation whose primary job is to be an excellent MCP server that emits notifications/claude/channel blocks. The heavy lifting for access control, pairing, and security lives in the combination of the server + the two management skills (/telegram:access and /telegram:configure).
Make Telegram feel like a first-class, secure, auditable channel for Claude Code sessions. Strong emphasis on "who is allowed to talk to this agent and when."
OpenClaw built a complete, parallel Telegram bot system from the ground up inside extensions/telegram/. It is not an adaptation of the Claude plugin — it is its own full-featured implementation that deeply understands OpenClaw's threading model, plugin system, approval flows, and conversation runtime.
Hermes treats messaging platforms as pluggable adapters behind a common gateway abstraction. The Telegram implementation (gateway/platforms/telegram.py + telegram_network.py) is one of many (Discord, WhatsApp, Signal, etc.). The standout characteristic is obsessive focus on reliable delivery in hostile network conditions.
Relies on the channel notification system + basic DM vs group distinction. Threading is relatively lightweight compared to the other two.
Extremely sophisticated. Has thread-bindings.ts, auto topic labeling, DM thread management, topic-agentid mapping, and deep integration with the conversation runtime. One of the most advanced Telegram threading systems in the agent space.
Strong forum and topic support (see dedicated tests for forum commands). Focuses more on clean message delivery into the gateway than on ultra-complex internal threading models.
Standard grammy + HTTP. No special handling for censored networks or API IP blocking documented in the core channel.
Has request timeout handling, 401 backoff for sendChatAction, and network error tagging. Solid but not the primary focus.
Best in class. Dedicated telegram_network.py with DoH-based discovery of fallback IPs for api.telegram.org, custom AsyncBaseTransport that preserves SNI while retrying on different IPs, and explicit support for heavily censored environments. This is a major differentiator.
Has the famous remote permission relay (inline keyboards in DMs for approving tool use). Very Claude-specific interactive model.
Deep native approval system (approval-native.ts, exec-approval-forwarding.ts, etc.). Tightly integrated with how OpenClaw wants approvals to feel inside Telegram.
Approvals are handled at the gateway/agent level rather than being a core feature of the Telegram platform adapter itself. More "deliver the message reliably" than "build approval UX in Telegram."
| Dimension | Claude Official | OpenClaw | Hermes |
|---|---|---|---|
| Primary Style | MCP Channel + strong security layer | Full custom bot runtime + deep SDK integration | Pluggable gateway platform + resilience focus |
| Threading Sophistication | Moderate | Very High (one of the best) | Good (especially forums/topics) |
| Network Resilience | Standard | Good | Excellent (DoH fallbacks, custom transport) |
| Approval UX in Telegram | Strong (remote relay via DMs) | Very strong (native, deeply integrated) | Delegated to agent/gateway level |
| Multi-Platform Abstraction | Telegram-only (by design) | Telegram-focused with channel system | Excellent (many platforms behind same gateway) |
| Native Commands / UI Polish | Basic | Extensive (bot-native-commands, inline keyboards, menus) | Solid but more gateway-oriented |
| Coupling to Agent Runtime | Loose (MCP channel contract) | Very tight (designed for OpenClaw runtime) | Medium (clean gateway boundary) |
Given what we've learned from the three mature implementations, here is a pragmatic recommendation for building a first-class Telegram experience for Grok (building on the existing excellent analysis in feral-cc-bots/grok/telegram-channel/).
Start with the existing high-quality plan in feral-cc-bots (minimal fork of the Claude grammy MCP server, fix paths/branding, make permission relay optional). This gets you 80-90% of the value with low risk.
This comparison was built by actually reading the source of all three implementations (plus the existing Grok plans in feral-cc-bots).