What are Claude Code channels? Push events, chat bridges, and mobile development with Telegram and Discord

Claude Code channels just changed the game. Instead of being tethered to your terminal, you can now message Claude Code from your phone via Telegram or Discord - and it works against your real files, in your real session, on your real machine.

This isn't another chatbot integration. It's a bridge between messaging platforms and a running Claude Code session - meaning Claude has access to your codebase, your tools, and your full development context, all controlled from wherever you are.

What are Claude Code channels?

A channel is an MCP server that pushes events into your running Claude Code session. Instead of Claude waiting for you to type something in the terminal, external systems can push messages, alerts, and webhooks directly into your active session. Claude reads the event and can reply back through the same channel - like a two-way chat bridge.

The key insight: events arrive in the session you already have open. This isn't spinning up a new cloud sandbox or polling for updates. Your files are already loaded, your context is preserved, and Claude picks up exactly where you left off.

Channels shipped on March 20, 2026 in Claude Code v2.1.80 as a research preview with Telegram, Discord, and a localhost demo called fakechat.

The problem it solves: the terminal bottleneck

Every developer who uses Claude Code knows this friction:

1. You start a task in Claude Code that takes a few minutes
2. You step away from your desk - meeting, lunch, commute
3. Claude hits a permission prompt or finishes the work
4. Everything is frozen until you get back to your terminal

Channels eliminate the terminal bottleneck. You can message Claude from your phone, check on progress, approve actions, or kick off new tasks - all without opening a laptop.

But channels aren't just about convenience. They unlock a fundamentally different interaction model: push-based development. Instead of you polling Claude for updates, external systems push events to Claude - CI failures, monitoring alerts, webhook payloads - and Claude reacts while you're away.

How it works: supported channels

The research preview ships with three channel types, each installed as a plugin:

Telegram

The most popular setup for mobile development. Here's how to get it running:

1. Create a bot via BotFather in Telegram - it takes 30 seconds
2. Install the plugin in Claude Code:

/plugin install telegram@claude-plugins-official

3. Configure your bot token:

/telegram:configure <your-token>

4. Launch with channels enabled:

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

5. Pair your account by messaging your bot, getting a pairing code, and running:

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

Once paired, you DM your Telegram bot and the message lands in your Claude Code session. Claude does the work, and the reply shows up in your Telegram chat.

Discord

Same flow, different platform. Create a Discord bot in the Developer Portal, install the plugin, configure the token, and pair your account. Discord is popular for developers who already live in Discord servers for their open source communities.

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

Fakechat (localhost demo)

For testing the channel concept without setting up a real platform, fakechat runs a chat UI at http://localhost:8787. Type a message in the browser, and it arrives in your Claude Code session. Great for building and testing custom channels.

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

Beyond chat: webhook receivers

Channels aren't just for chat platforms. The same architecture supports any external system that can send an HTTP request. You can build a custom channel that receives webhooks from:

• CI/CD pipelines - build failures arrive where Claude already has your code open
• Error monitoring - Sentry alerts land in your session with full codebase context
• Deploy pipelines - deployment status updates trigger Claude to verify or rollback
• Custom automation - any system that can POST to localhost

Here's a minimal webhook channel in about 30 lines of TypeScript:

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 from the webhook channel are one-way alerts. 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')
  },
})

Send a POST to localhost:8788 and it arrives in Claude's context as a <channel> tag. Claude reads it and acts - no human in the loop required.

Security: sender allowlists

Channels aren't a free-for-all. Every approved channel plugin maintains a sender allowlist - only IDs you've explicitly paired can push messages. Everyone else is silently dropped.

The pairing flow works like this:

1. Send a message to your bot from your real account
2. The bot replies with a one-time pairing code
3. Approve the code in your Claude Code session
4. Your sender ID is added to the allowlist
5. Lock down with /telegram:access policy allowlist

On top of that, you control which servers are enabled per session with --channels. Being listed in .mcp.json isn't enough - a server has to be explicitly named in the --channels flag to push events.

For Team and Enterprise plans, organization admins control channel availability through managed settings. Channels are disabled by default until explicitly enabled.

How channels compare to other Claude Code features

Claude Code has several ways to connect to systems outside the terminal. Here's where channels fit:

Channels fill a unique gap: they're the only option that pushes events from non-Claude sources into your already-running local session. Remote Control lets you drive the session, but channels let the session react to the world around it.

Why this matters for teams using Cyrus

Channels represent a shift from synchronous to asynchronous development. Instead of sitting at your terminal waiting for Claude to finish, you fire off tasks and get notified when they need attention. This is exactly the model that Cyrus already enables through Linear - assign issues to your AI developer, and it works asynchronously, asking questions when it needs input.

Channels amplify this pattern:

• Mobile-first development - Review Claude's work and provide guidance from your phone between meetings
• Event-driven workflows - CI failures, monitoring alerts, and deploy events can trigger automatic investigation
• Always-on agents - Run Claude in a persistent terminal and interact from anywhere
• Reduced context switching - Stay in the messaging platform you're already using instead of switching to a terminal

The teams building with AI agents in 2026 aren't just using them as faster typists. They're building asynchronous development workflows where AI agents work continuously and humans provide direction when needed. Channels are a critical piece of that infrastructure.

The bigger picture

For years, the interaction model with AI coding assistants has been fundamentally synchronous: you sit down, you type, the AI responds, you type again. Channels break that loop open.

When your CI pipeline can push a build failure directly into a Claude Code session that already has your code loaded, something interesting happens: the response time between "something broke" and "here's the fix" collapses. Claude doesn't need to be briefed on the codebase, doesn't need to clone a repo, doesn't need context. It's already there.

This is the difference between an AI assistant and an AI colleague. An assistant waits to be asked. A colleague reacts to what's happening. Channels give Claude Code the ability to react.

What to watch for:

The research preview ships with Telegram, Discord, and fakechat. But the channel architecture is built on standard MCP - meaning any developer can build a channel for any platform. Expect the ecosystem to expand rapidly as developers build channels for Slack, Microsoft Teams, email, SMS, and platforms we haven't thought of yet.

We're moving from "AI tools you use" to "AI agents that work alongside you." Channels are how they stay connected.