`
Then pair and lock access the same way.
iMessage: no token required
iMessage works differently — no bot account, no external service. It reads your Messages database directly and replies through AppleScript.
`bash
/plugin install imessage@claude-plugins-official
claude --channels plugin:imessage@claude-plugins-official
`
macOS will prompt for Full Disk Access. Grant it. Then text yourself — self-chat bypasses the access gate with no setup. To allow other contacts:
`bash
/imessage:access allow +15551234567
`
Test without a real account
If you want to see how channels work before wiring up a bot, there's a fakechat demo that runs a chat UI on localhost with nothing to configure:
`bash
/plugin install fakechat@claude-plugins-official
claude --channels plugin:fakechat@claude-plugins-official
open http://localhost:8787
`
Type in the browser. The message arrives in your terminal session. Claude replies and it shows up in the UI. Five minutes to understand the full event flow without creating any bot accounts.
!Split view of a terminal session and a Discord chat, showing the same event flowing between them
The Always-On Problem
There's a catch that matters for production use: events only arrive while the session is open. If you close the terminal, messages sent during that window are gone.
The docs recommend running Claude Code inside tmux or screen for always-on operation. In practice, this means a setup like:
`bash
Start a persistent named session
tmux new-session -d -s claude-agent
Launch Claude Code with channels inside it
tmux send-keys -t claude-agent 'claude --channels plugin:telegram@claude-plugins-official' Enter
Attach to check on it
tmux attach -t claude-agent
`
The session persists through disconnects. If your machine reboots, you need to restart it — but for day-to-day use, this gives you a continuously running agent that's always ready for inbound messages.
If you hit a permission prompt while you're away, the session pauses waiting for your response. Channel plugins that declare the permission relay capability can forward these prompts back through the channel itself — so you can approve or deny tool use directly from Telegram. For fully unattended environments, --dangerously-skip-permissions bypasses prompts entirely, but only on machines and projects where you've explicitly decided to trust that.
!A Mac with a tmux terminal showing a persistent Claude Code session running in the background
Beyond Chat: Webhooks Into Your Session
The chat bridge use case is the one everyone demos. But the more interesting application is webhooks.
A channel doesn't have to receive messages from humans. It can receive events from systems — CI pipelines, error trackers, deploy services, monitoring tools. The channel pushes the event into your session exactly the same way. Claude reads it and can act on it.
Build a webhook receiver that listens for CI failures and routes them into your running session. When the build breaks, Claude already has your files open. It knows what you were working on. It can read the failure, check the relevant code, and either fix it or draft a summary — before you've even noticed the build broke.
The channel reference documentation includes a full webhook receiver example. The core pattern:
Register an HTTP endpoint that accepts POST requests from your CI system
Declare the claude/channel capability in your MCP server
Push events as channel messages — the same format that Telegram and Discord use
Launch Claude Code with --dangerously-load-development-channels for testing
The same architecture works for any event source that can send an HTTP request: error tracking, infrastructure alerts, code review completion, deploy status changes.
!A CI pipeline failure notification arriving in a terminal Claude Code session, with code being fixed automatically
Enterprise Controls
For Team and Enterprise plans, channels are off by default. Admins enable them through the claude.ai Admin console or managed settings:
`json
{
"channelsEnabled": true,
"allowedChannelPlugins": [
{ "marketplace": "claude-plugins-official", "plugin": "telegram" },
{ "marketplace": "claude-plugins-official", "plugin": "discord" },
{ "marketplace": "your-org-plugins", "plugin": "internal-ci-alerts" }
]
}
`
When allowedChannelPlugins is set, it replaces Anthropic's default allowlist. Only the plugins you list can register. An internal CI alert plugin can be added alongside the official Telegram and Discord plugins — the organization controls the full set.
Pro and Max individual users skip these checks. Channels are available and you opt in per session with --channels`.
!An admin dashboard showing allowedChannelPlugins configuration for an enterprise team
What This Signals
When Anthropic built Channels, they didn't build a chat wrapper. They built a protocol — a way for any external system to push events into a running agent session.
The current plugins (Telegram, Discord, iMessage) are the accessible entry points that make the capability concrete. But the underlying architecture is a general-purpose event bus for local sessions. CI systems, monitoring tools, incident response workflows, customer feedback pipelines — anything that can emit an HTTP event can now route that event to an agent that has full context about your codebase.
The VentureBeat framing — "OpenClaw killer" — captures the competitive angle. The more important framing might be: this is what ambient AI development infrastructure looks like. Not an agent you invoke, but an agent that's running, listening, and ready to respond to whatever happens next in your system.
Try It Yourself
The fastest path to a working channel is the fakechat demo — no bot account, no configuration, just the event flow itself. Start there.
After that, Telegram is the quickest real integration: BotFather takes two minutes, the three commands take thirty seconds, and you have a working mobile interface to your local codebase.
For teams: the webhook receiver use case — routing CI failures directly into a running agent session — is worth prototyping even before you have a formal Channels-based workflow. The signal-to-effort ratio is high. A build breaks, the agent is already looking at your files. That's a meaningfully different debugging loop than "get an email, open a laptop, clone context."
The research preview flag is a signal about API stability, not about production readiness. The protocol contract may change. The capability is real.