Claude Code Channels: Your AI Just Learned to Listen

The Big Idea (No Jargon)

Until now, using Claude was a one-way street. You go to Claude, type something, get an answer.

Channels flips that. Now things come TO Claude.

Your CI pipeline breaks at 2am? Claude sees it. Someone messages your Telegram bot asking a question? Claude reads it, thinks about it, and responds. A monitoring alert fires? Claude investigates your logs before you even wake up.

Think of it like giving Claude ears. It was already smart. Now it can hear what's happening around it and react.

Real Examples (What This Actually Looks Like)

Your Build Breaks

Before Channels: Your CI fails. You get an email notification at 3am. You wake up, read the logs, figure out the issue, fix it.

With Channels: Your CI fails. The webhook hits Claude's channel. Claude reads the error, looks at the code, and either fixes it or has a detailed analysis ready when you wake up.

Someone DMs Your Bot

Before Channels: You build a bot on Telegram. It can only do what you pre-programmed.

With Channels: Someone messages your Telegram bot. Claude reads the message with full context of your project, your codebase, your docs. It responds intelligently because it's not a scripted bot, it's Claude.

Monitoring Alert

Before Channels: PagerDuty fires. You get paged. You SSH in. You check logs. You investigate.

With Channels: The alert hits Claude's webhook channel. Claude checks the logs, the recent deployments, the error patterns. By the time you look at your phone, there's a diagnosis waiting.

How It Compares (The Landscape)

If you've been following AI assistants, you might be thinking "wait, isn't this what OpenClaw and Claude Dispatch do?" Sort of. But they're different tools for different jobs.

The key difference: Channels is event-driven. It's not just chat. It can react to CI pipelines, monitoring alerts, database events, cron triggers, or anything that can send an HTTP request. OpenClaw and Dispatch are primarily chat interfaces.

Getting Started (The Easy Way)

What You Need

• ●Claude Code v2.1.80 or later
• ●A claude.ai account (Pro or Max)
• ●Bun installed (the channel plugins use it)
• ●If you're on a Team/Enterprise plan, your admin needs to enable channels

Try the Demo First

Before connecting Telegram or Discord, try the built-in demo that runs on localhost:

Step 1: Open Claude Code and install the demo plugin:

/plugin install fakechat@claude-plugins-official

Step 2: Restart Claude Code with the channel flag:

claude --channels plugin:fakechat@claude-plugins-official

Step 3: Open http://localhost:8787 and type a message. Watch it appear in your Claude Code session. Claude reads it, does the work, and sends a reply back to the browser.

That's it. You just gave Claude ears.

Connect Telegram (5 Minutes)

Step 1: Open Telegram, find @BotFather, send /newbot. Give it a name. Copy the token.

Step 2: In Claude Code:

/plugin install telegram@claude-plugins-official
/telegram:configure <your-token>

Step 3: Restart with channels:

claude --channels plugin:telegram@claude-plugins-official

Step 4: Message your bot on Telegram. It replies with a pairing code. Back in Claude Code:

/telegram:access pair <code>
/telegram:access policy allowlist

Done. Now when you message your Telegram bot, Claude reads it and responds with full access to your project files, terminal, and tools.

Connect Discord

Same flow but with a Discord bot. Create one in the Developer Portal, enable Message Content Intent, invite it to your server, then:

/plugin install discord@claude-plugins-official
/discord:configure <your-token>
claude --channels plugin:discord@claude-plugins-official

DM the bot, pair with the code, set the allowlist policy.

Connect iMessage (macOS Only)

iMessage works differently from Telegram and Discord. There is no bot token and no external service. The plugin reads your Mac's Messages database directly using AppleScript.

Step 1: Install the plugin:

/plugin install imessage@claude-plugins-official

Step 2: Grant Full Disk Access to your terminal app (Terminal, iTerm, or VS Code) in System Settings > Privacy & Security > Full Disk Access. Without this, the plugin cannot read the Messages database.

Step 3: Restart with channels:

claude --channels plugin:imessage@claude-plugins-official

Step 4: Send a text message to yourself to get started. Then allowlist other contacts:

/imessage:access allow +15551234567

That's it. No bot creation, no tokens, no third-party APIs. Just your Messages app and Claude.

Permission Relay

One of the biggest pain points with running Claude remotely was permission prompts. If Claude needed approval to run a command or access a file, it would pause and wait until you were back at the keyboard.

Permission Relay solves this. Channels can now forward permission prompts directly to you on Telegram, Discord, or iMessage. You see the prompt on your phone, tap approve or deny, and Claude continues working.

This is officially supported and works with any channel plugin. When Claude hits a permission prompt, the channel sends you the details. You reply with your decision. No more stalled sessions because you walked away from your desk.

Going Deeper (For the Builders)

If you're a developer who wants to build custom integrations, this is where it gets interesting.

The Architecture

A channel is just an MCP server with a special capability flag. Claude Code spawns it as a subprocess. Your server bridges the gap between external systems and Claude's session.

Two patterns:

• ●Chat channels (Telegram, Discord): Your server polls the platform API for new messages. When one arrives, it pushes it to Claude.
• ●Webhook channels (CI, monitoring): Your server listens on a local HTTP port. External systems POST to it. Your server pushes the payload to Claude.

Build a Webhook Receiver (15 Lines)

This is a complete channel that turns any HTTP POST into a Claude Code event:

#!/usr/bin/env bun
import { Server } from '@modelcontextprotocol/sdk/server/index.js'
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'

const mcp = new Server(
  { name: 'webhook', version: '0.0.1' },
  {
    capabilities: { experimental: { 'claude/channel': {} } },
    instructions: 'Events arrive as <channel source="webhook">. Read them and act.',
  },
)

await mcp.connect(new StdioServerTransport())

Bun.serve({
  port: 8788,
  hostname: '127.0.0.1',
  async fetch(req) {
    const body = await req.text()
    await mcp.notification({
      method: 'notifications/claude/channel',
      params: {
        content: body,
        meta: { path: new URL(req.url).pathname, method: req.method },
      },
    })
    return new Response('ok')
  },
})

Register it in .mcp.json:

{
  "mcpServers": {
    "webhook": { "command": "bun", "args": ["./webhook.ts"] }
  }
}

Test it:

claude --dangerously-load-development-channels server:webhook

Now any curl -X POST localhost:8788 -d "build failed" arrives in Claude's session as:

<channel source="webhook" path="/" method="POST">build failed</channel>

Making It Two-Way

Add a reply tool so Claude can respond through the channel. This turns a one-way alert forwarder into a two-way chat bridge:

import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js'

mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: [{
    name: 'reply',
    description: 'Send a message back',
    inputSchema: {
      type: 'object',
      properties: {
        chat_id: { type: 'string' },
        text: { type: 'string' },
      },
      required: ['chat_id', 'text'],
    },
  }],
}))

mcp.setRequestHandler(CallToolRequestSchema, async req => {
  if (req.params.name === 'reply') {
    const { chat_id, text } = req.params.arguments as any
    await yourPlatform.send(chat_id, text)
    return { content: [{ type: 'text', text: 'sent' }] }
  }
  throw new Error(`unknown tool: ${req.params.name}`)
})

Security: Sender Allowlists

Every channel should gate on sender identity. Without this, anyone who can reach your endpoint can inject text into Claude's session. That's a prompt injection vector.

const allowed = new Set(loadAllowlist())

if (!allowed.has(message.from.id)) {
  return  // drop silently
}
await mcp.notification({ ... })

Gate on the sender's ID, not the room/channel ID. In group chats, these differ. Gating on the room would let anyone in that group inject messages.

The Bigger Picture

Channels is Anthropic's answer to "how do we make Claude react to the real world?" It's the missing piece between Claude as a chatbot and Claude as an autonomous agent.

Combined with:

• ●Claude Code's file access and terminal for executing actions
• ●MCP servers for connecting to databases, APIs, and tools
• ●Subagents for parallelizing work
• ●CLAUDE.md for persistent project context

...Channels turns Claude Code into an event-driven AI system that can respond to the world without you being at the keyboard.

The research preview ships with Telegram, Discord, and iMessage. But the real power is custom channels. Any system that can send an HTTP request or a chat message can now trigger Claude to do real work.

Current Limitations

• ●Research preview - syntax and protocol may change
• ●Session must be running - events only arrive while Claude Code is open (use a persistent terminal or background process for always-on)
• ●Claude.ai login required - API key auth not supported
• ●Approved plugins only - custom channels need --dangerously-load-development-channels during preview
• ●Team/Enterprise - admin must explicitly enable channelsEnabled
• ●Permission prompts - handled via Permission Relay (channels forward prompts to your phone for remote approval/denial)

Channels are just one of four ways Claude works when you are not at the keyboard. Dispatch, Remote Control, and Cowork Computer Use each solve a different problem. Read the full comparison.

Find Your Perfect AI Match

Not sure which AI tools fit your workflow? Take our free quiz to get matched with the right models and learning track for your specific use case.