# CopilotKit Channels SDK: Bringing AI Agents Into Slack and Microsoft Teams

> Channels SDK is an open-source Node.js library from CopilotKit that connects any AG-UI-compatible AI agent to Slack and Microsoft Teams, rendering native interactive UI (Block Kit, Adaptive Cards) and supporting human approval gates in the conversation. The SDK manages the channel connection through CopilotKit Intelligence, keeping the agent and its business logic entirely in your own infrastructure.

**CopilotKit/channels-sdk** — The open-source SDK for bringing any agent into any chat platform: Slack, Microsoft Teams, Discord, Telegram - with native, Interactive UI.

- Repository: https://github.com/CopilotKit/channels-sdk
- Website: copilotkit.ai/try-channels
- Stars: 922 · Forks: 64
- Language: Unknown
- License: MIT
- Published: 2026-09-17 · Updated: 2026-09-17 · Language: en
- Canonical page: https://hysenlabs.com/projects/copilotkit-channels-sdk

## What Channels SDK Solves: Agents Belong Where Work Happens

AI agents built with LangGraph, CrewAI, Mastra, Pydantic AI, Google ADK, or CopilotKit's own runtime typically run as background services or inside developer-facing tooling. Getting those agents into the communication platforms where teams actually work, meaning Slack and Microsoft Teams, requires writing a platform integration, mapping rich messages to each platform's native UI format, and building the state machine that handles streaming, tool calls, and human approval steps.

Channels SDK handles those concerns. Your agent keeps its existing tools, model, and business logic unchanged. The SDK adds the channel adapter: it delivers each conversation turn to a long-running Channels process in your infrastructure, streams the response, renders the output as native Slack Block Kit or Teams Adaptive Cards, and provides buttons and approval gates directly in the conversation.

The managed connection between the platform and your process runs through CopilotKit Intelligence, a CopilotKit-hosted service that handles the Slack and Teams app registration on one side and forwards messages to your listener on the other. Your code runs on your servers. CopilotKit Intelligence is the relay.

## How the SDK Connects an Agent to a Channel

The AG-UI protocol is the interface the SDK relies on. Any agent framework that implements AG-UI can be used behind a Channel without changing the SDK code. The README explicitly lists LangGraph, CrewAI, Mastra, Pydantic AI, and Google ADK as compatible frameworks in addition to CopilotKit's built-in agent.

A Channels process is a long-running Node.js server that imports the SDK and creates a channel listener. When a message arrives in Slack or Teams, CopilotKit Intelligence routes it to the listener. The listener creates an agent instance, runs the conversation turn, and returns the response. The response is delivered to the platform as native UI without any manual formatting step.

Managed connections for Slack and Microsoft Teams are available through CopilotKit Intelligence. Discord and Telegram are mentioned as future targets in the README. The SDK does not include self-hosted channel connections for any platform: the Intelligence service is required for the platform-side integration.

## Installing the SDK and Creating a Channel Listener

The SDK requires Node.js 22 or later. Install the SDK and runtime together:

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

The README notes that Channels and Runtime ship together as a tested pair and should be upgraded together. A channel listener imports from both packages:

```ts
import { createServer } from "node:http";
import { createChannel } from "@copilotkit/channels";
import {
  BuiltInAgent,
  CopilotKitIntelligence,
  CopilotRuntime,
} from "@copilotkit/runtime/v2";
import { createCopilotNodeListener } from "@copilotkit/runtime/v2/node";
```

The built-in agent is constructed with a model identifier. The README shows:

```ts
const agent = new BuiltInAgent({ model: "openai:gpt-5.4-mini" });
```

To use a different agent framework, replace makeAgent with any AG-UI-compatible factory. The channel lifecycle does not change. The runtime expects OPENAI_API_KEY and INTELLIGENCE_API_KEY environment variables. The Channel Code and project-scoped Intelligence API key come from the CopilotKit Intelligence console.

## The Setup CLI: Letting a Coding Agent Drive the Configuration

Building a complete Channels integration involves creating a project and agent in CopilotKit Intelligence, registering a Slack or Teams app, wiring credentials, and starting the long-running process. The SDK provides a CLI workflow that delegates most of these steps to your existing coding agent:

```sh
npx copilotkit@latest channels setup
```

That command installs a setup skill, prints a prompt describing the full workflow, and copies it to the clipboard. Pasting the prompt into a coding agent (such as Claude Code or Cursor) lets the agent drive the Intelligence console and provider configuration in your signed-in browser session. The README describes the agent doing the clicking while you supply the secrets. If the agent does not have browser or computer-use tools yet, the skill will ask you to add one; the README states this is the intended path, not a fallback.

The setup skill fetches the current workflow guide from copilotkit.ai/channels-guide.md when the agent needs it. This means the steps stay current even if the installed skill is months old. The guide prompts for the target platform (Slack or Teams) and the agent framework before proceeding.

For Slack specifically, there is also a self-contained skill that can be installed on disk without the full guide:

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

The `-y` flag installs the skill directly without opening a picker. For Microsoft Teams, the README directs users to the full guide rather than this Slack-only skill. After a Channel is created, `copilotkit channels add --adapter slack` registers it on the CLI side, and `copilotkit channels status` checks that the configuration, code, and server are aligned. If you have an older globally installed `copilotkit` CLI shadowing the current version, the README recommends keeping the `@latest` tag in the npx call to force a current version fetch.

## Native Interactive UI and Human Approval Gates

One rendering call in the SDK produces the right output for each connected platform. A message described once is rendered as Slack Block Kit in Slack and as Teams Adaptive Cards in Microsoft Teams. The SDK handles the translation; the agent code does not branch on the target platform.

Approval gates are a first-class feature. Buttons, choices, and confirmation dialogs can be placed directly into the conversation before an agent takes an action. This allows teams to require human sign-off on operations like sending a message, modifying a record, or triggering a workflow, without building a separate approval flow outside the chat interface.

The examples/ directory in the repository includes OpenTag, a complete Channels application. There is also a minimal-channel example and a mastra-sandbox example for testing with the Mastra agent framework.

## When to Use Channels SDK and When to Use Slack's Bolt Framework Instead

Slack's Bolt framework is the official Slack SDK for building Slack apps in Node.js. It is well-known, stable, and handles direct Slack API calls, event subscriptions, and message formatting. Bolt does not include an AG-UI agent abstraction, a built-in streaming layer for LLM responses, or CopilotKit-managed credentials. Building an AI agent into a Slack app with Bolt means building those layers yourself.

Channels SDK is the right choice when you already have an AG-UI-compatible agent and want native UI in Slack or Teams without writing platform integration code from scratch. It is a poor choice when you need a general-purpose Slack app with custom event handling outside a conversational pattern, when you need full control over the platform connection without an external service dependency, or when your target platform is not Slack or Teams.

The repository has no GitHub releases. The last push was on 2026-08-14. The project is MIT-licensed. The examples/ directory and the linked copilotkit.ai/channels-guide.md are the primary references beyond the README.

## Conclusion

Channels SDK suits teams that already run an AG-UI-compatible agent (LangGraph, CrewAI, Mastra, Pydantic AI, Google ADK, or CopilotKit's built-in agent) and want to deploy it into Slack or Microsoft Teams without building a custom bot integration. It is not a general Slack bot framework: it requires CopilotKit Intelligence for the managed connection, which means a dependency on a CopilotKit-hosted service. Before starting, confirm that your agent framework is AG-UI-compatible and that your target platform (Slack or Teams) is on the currently available list, since Discord and Telegram are described as future targets, not yet available.

## FAQ

### What agent frameworks work with CopilotKit Channels SDK?

The README lists LangGraph, CrewAI, Mastra, Pydantic AI, Google ADK, and CopilotKit's own built-in agent as compatible frameworks. Any agent that implements the AG-UI protocol can be connected to a Channel without changing the SDK code.

### Does CopilotKit Channels SDK require a CopilotKit account?

Yes. The managed channel connection runs through CopilotKit Intelligence, which requires a project API key. The key is obtained from the CopilotKit Intelligence console and set as INTELLIGENCE_API_KEY in the environment.

### Which chat platforms does Channels SDK currently support?

Managed connections for Slack and Microsoft Teams are available through CopilotKit Intelligence. The README mentions Discord and Telegram as future targets but does not describe them as currently available.

## Sources

- [CopilotKit/channels-sdk on GitHub](https://github.com/CopilotKit/channels-sdk)
- [Issues](https://github.com/CopilotKit/channels-sdk/issues)
- [License: MIT](https://github.com/CopilotKit/channels-sdk/blob/main/LICENSE)
- [README](https://github.com/CopilotKit/channels-sdk/blob/main/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/copilotkit-channels-sdk