CopilotKit Channels SDK: Putting an AG-UI Agent Inside Slack and Microsoft Teams

The problem Channels SDK solves: agents that cannot live where people talk

An agent that runs in a terminal or a web app is separated from the conversation it is supposed to help with. Moving it into Slack or Microsoft Teams normally means building the platform integration yourself: a bot app, an event endpoint, a token store, and a renderer that turns your agent's output into Block Kit on one platform and Adaptive Cards on another. Channels SDK exists to remove that second job.

The README states the split plainly: your agent and application logic run in your infrastructure, while CopilotKit Intelligence manages the platform connection and delivers each turn to your long-running Channels process. The SDK is the part that runs on your side. Its target reader is an engineer who already has an agent and wants it reachable in a chat client without writing a Slack-specific and a Teams-specific front end.

The supported channels named in the README are Slack and Microsoft Teams, with managed connections available through CopilotKit Intelligence and more channels described as on the way. Discord and Telegram appear in the repository description and in the demo image set, but the build instructions cover Slack and Teams only, so treat Discord and Telegram support as unverified by the README.

How the agent-to-channel loop works

The mechanism is a long-running process. A Channels process stays up, receives turns from the managed connection, and hands them to an agent factory. The README's own summary of what the agent can do in a turn is specific: understand the conversation, stream a response, call tools, work with files, render interactive UI, and pause for human approval.

Rendering is described as write once, render natively: you describe a message once and it becomes Slack Block Kit, Teams Adaptive Cards, and platform-specific UI. That is the architectural bet. Your code does not branch on platform for presentation, and the SDK carries the platform knowledge instead.

Agent compatibility is through AG-UI. The README names CopilotKit's built-in agent plus LangGraph, CrewAI, Mastra, Pydantic AI, and Google ADK as AG-UI agents that can be connected. The example in the install steps uses CopilotKit's built-in agent and says you can replace `makeAgent` with any AG-UI-compatible agent factory without changing the Channel lifecycle. That sentence is the important one: the lifecycle is the contract, and the agent is a swappable component.

Human control is a first-class part of the loop rather than an afterthought. Buttons, choices, and approval gates go into the conversation before the agent acts, which is what makes the approval flow in the Slack demo screenshot possible.

Installing Channels SDK and running a first channel

There are two paths. The fast path is to let a coding agent drive the setup, which the README recommends because a working Channels agent spans a project, an agent, a managed Channel, a provider app, and a long-running runtime. The command installs a skill, prints a prompt, and copies it to your clipboard:

npx copilotkit@latest channels setup

The README notes that the installed skill is a pointer: it fetches the workflow from copilotkit.ai/channels-guide.md when your agent needs it, so the steps stay current even if the installed skill is months old. The guide asks which platform you want, Slack or Microsoft Teams, and which agent framework. Your agent drives the Slack and Intelligence consoles in your own signed-in session, and you type the secrets yourself. If the README's warning about `Unknown option '--skill'` appears, an older globally installed or cached `copilotkit` is shadowing the current CLI; keeping `@latest` is what forces npx to fetch the current version.

If you prefer the Slack skill on disk rather than the hosted guide, the README gives this command:

npx copilotkit@latest skills install --skill setup-slack-channel -y

The `-y` flag installs that one skill without opening a picker, and the skill is scoped to Slack. The manual path starts with creating a Channel in CopilotKit Intelligence and connecting Slack, keeping the Channel Code and the project-scoped Intelligence API key for later. You need Node.js 22 or later and a long-running Node process or container. Then:

npm install @copilotkit/channels @copilotkit/runtime
npm install --save-dev tsx typescript @types/node
npm pkg set type=module

Channels and Runtime are described as shipping together as a tested pair, so upgrade both packages together or not at all. The listener itself is a TypeScript file, `channel.ts`, that imports `createServer` from `node:http` and `createChannel` from `@copilotkit/channels`, and starts from CopilotKit's built-in agent. The README truncates before the rest of that file, so the full listener body is in the guide rather than in the repository README. On the Intelligence side, `copilotkit channels add --adapter slack` declares the Channel and attaches the adapter, and `copilotkit channels status` compares your configuration, your code, and the server. What stays in the browser is the provider side, meaning the Slack app creation and installation plus issuing the project API key. No CLI flag accepts a credential value, so the bot token and signing secret stay in your `.env`.

Where Channels SDK stops being the right tool

The clearest limitation is the dependency on CopilotKit Intelligence. The README is explicit that the platform connection is managed there, and that creating a Channel in Intelligence is step one of the manual path. If your organization requires the Slack app, the event delivery, and the credential handling to live entirely inside your own infrastructure, the SDK's model does not match that requirement. You would be adopting a client for a hosted connection layer, not a self-contained Slack integration.

The second limitation is the channel list. Slack and Microsoft Teams have managed connections and documented setup. Discord and Telegram appear in the repository description and in demo imagery, but the README's build instructions and the `--adapter slack` example cover Slack, and the Teams path is routed through the hosted guide rather than a skill on disk. Anyone whose users are on Discord should verify adapter availability before planning around it.

The third is operational shape. A Channels process is long-running, by design, and the README asks for a long-running Node process or container. That rules out request-scoped serverless functions as the host for the listener, and it means you own process supervision and restarts. The fourth is version coupling: because Channels and Runtime ship as a tested pair, you cannot upgrade one independently, which constrains dependency updates in a larger application.

Channels SDK against building the Slack and Teams integration yourself

The real alternative is not another SDK with the same shape. It is the direct route: write a Slack app with Bolt, write a separate Microsoft Teams bot with the Bot Framework, and translate your agent's output twice, once into Block Kit and once into Adaptive Cards. That approach keeps everything in your infrastructure and gives you full control over event handling, but it makes every UI change a two-platform change, and it puts token storage, signature verification, and app installation on your team.

The difference in approach is where the platform knowledge sits. In the direct route, your code knows about Slack and Teams. In Channels SDK, the SDK knows about them and your code describes a message once. The trade is that the platform connection moves to a managed service. If you have already invested in a Bolt app with custom middleware, the direct route is not obviously worse; if you have an AG-UI agent and no platform front end, Channels SDK removes the larger half of the work. A second alternative worth weighing is staying in the web app where the agent already runs and linking to it from chat, which avoids the integration entirely at the cost of the native conversation surface.

Maintenance, licence, and what upgrading costs

The repository is not archived, and the last push was on 2026-08-14. That is a recent push, so the project is being changed, but the README should not be read as a stability guarantee: no releases were retrieved for this article, so there is no published release history to judge cadence against.

The licence is MIT, stated in the README badge and in the repository's LICENSE file. MIT is permissive: it allows commercial use, modification, and redistribution with the licence text and copyright notice retained. It does not grant trademark rights and it carries no warranty. That covers the SDK code. It does not describe the terms of the managed CopilotKit Intelligence connection, which is a separate service and governed by its own terms, not by the MIT licence on this repository. Anyone evaluating the project for a regulated environment should read those terms separately rather than assuming the permissive licence extends to the hosted layer.

Upgrade cost has one concrete rule from the README: Channels and Runtime ship together as a tested pair and should be upgraded together. Beyond that, the moving parts are the installed skill or the hosted guide, the Channel configuration in Intelligence, and your `.env` secrets. The README does not document a rollback procedure for a Channel configuration change, and it does not describe a migration path between SDK versions.

Editorial conclusion

Adopt Channels SDK if your agent already speaks AG-UI and your users live in Slack or Microsoft Teams, since the lifecycle code is small and the platform rendering is handled for you. Do not adopt it if you need a channel the README does not list, or if you cannot accept that the Slack and Teams connection is a managed CopilotKit Intelligence service rather than something you host. Before writing code, confirm you have Node.js 22 or later, create the Channel in CopilotKit Intelligence, and run `copilotkit channels status` once the adapter is attached.

Frequently asked questions

Official sources

1. CopilotKit/channels-sdk on GitHub
2. Issues
3. License: MIT
4. README