CopilotKit Open Sources Channels SDK: An MIT Licensed Library That Runs Any AG-UI Agent Inside Slack And Microsoft Teams

CopilotKit has just released the Channels SDK. It is an open source library that puts an existing agent inside a messaging platform. The core assumption is focused and verifiable. You already have an agent. It already has a model, tools and business logic. Channels gives it a place to work with people, without a rewrite per platform.

It runs on Slack and Microsoft Teams as early access surfaces. Discord and Google Chat are named as planned.

Installation is two packages:

npm install @copilotkit/channels @copilotkit/runtime

The connection to your agent is AG-UI, the agent-user interaction protocol CopilotKit maintains. Anything that speaks AG-UI works. That includes LangGraph, CrewAI, Mastra, Pydantic AI, Google ADK, and a plain HTTP agent you wrote yourself. Your model and orchestration layer stay where they are.

The distinction that matters is what a channel is not. It is not a second agent. It is a transport along with a rendering target. You write a message once, and the adapter lowers it into each platform’s native format. That means Block Kit in Slack and Adaptive Cards in Teams. Not a text blob pushed through a webhook.

Is It Deployable?

Yes. The SDK is published, MIT licensed, and has a documented runtime contract.

How One Turn Actually Flows

Here is the single path for every turn:

A person messages your app in Slack or Microsoft Teams.
CopilotKit Intelligence receives the platform event and delivers it to your Channels process.
Channels runs your agent over AG-UI, executes tools, and renders the result.
Intelligence sends native platform UI back into the conversation.

The split of responsibility follows from that. You run your agent, model credentials, tools and business logic. You run the long-running Channels listener, plus application state, deployment and logs. Intelligence manages the Slack and Teams platform credentials. It also owns platform ingress, credentialed delivery, runtime registration, health and reconnects.

Rendering is worth one more sentence. Messages are authored as JSX and lowered to a serializable intermediate representation. The adapter translates that into the platform’s native format, and interactive handlers are bound through an action store.

The Runtime Contract

The lifecycle is the part worth understanding. There is no channel.start(). The runtime owns activation.

import { createChannel } from “@copilotkit/channels”;
import { CopilotRuntime, CopilotKitIntelligence } from “@copilotkit/runtime/v2”;
import { createCopilotNodeListener } from “@copilotkit/runtime/v2/node”;

const channel = createChannel({
name: process.env.CHANNEL_CODE,
provider: “slack”,
agent: makeAgent,
});

const runtime = new CopilotRuntime({
agents: {},
intelligence: new CopilotKitIntelligence({ apiKey: process.env.INTELLIGENCE_API_KEY }),
identifyUser: () => ({ id: “channels-runtime”, name: “Channels Runtime” }),
channels: [channel],
});

const listener = createCopilotNodeListener({ runtime, basePath: “/api/copilotkit” });
await listener.channels.ready({ timeoutMs: 30_000 });

Creating the listener starts the channel connection. Awaiting channels.ready() makes a broken configuration fail startup loudly instead of silently. channels.status() returns an overall state you can gate on, and channels.stop() tears the channel down for graceful shutdown.

The runtime exposes listeners for Node, Hono and Express through the @copilotkit/runtime/v2/* subpaths.

createChannel takes more than a name and an agent. The shipped options include tools, context, components, commands, store, sanitizeAgentEvents, showToolStatus and replyContinuation. Registering named JSX components is what lets a channel re-render and re-fire handlers after a restart. Without registration, a click on a message posted before the restart degrades to an expired action.

What The Agent Can Do Inside The Channel

The feature set targets work that happens in a thread, not chat for its own sake.

Generative UI, so the agent renders interface when the task calls for it.
Human in the loop, so a person approves before a critical action runs.
Tools, so the agent can file an issue, book a meeting or open a pull request.
A persistence layer, plus transcripts that carry memory across platforms.
Slash commands and mentions, mapped to the right agent interaction.

OpenTag demonstrates the approval pattern concretely. Every Linear and Notion mutation is intercepted in code before the MCP request runs. The interceptor emits a confirm_write and proceeds only after approval. Reads and rendering do not pause.

Key Takeaways

@copilotkit/channels 0.5.0 is live on npm under MIT, with Slack and Microsoft Teams as the early access surfaces.
Every channel requires a CopilotKit Intelligence API key, on the managed path and the direct path.
Slack is generally available as a managed provider; Teams is listed as early access but still carries a gating note in the shipped types.
Discord, Telegram and WhatsApp adapters ship in the package as upcoming integrations.
Deployment needs Node.js 22+, an ESM project, and a long-running process; serverless will not hold the connection.

Thanks to the Copilotkit team for the thought leadership / resources for this article. This article is sponsored by Copilokit.

Asif Razzaq is the CEO of Marktechpost Media Inc.. As a visionary entrepreneur and engineer, Asif is committed to harnessing the potential of Artificial Intelligence for social good. His most recent endeavor is the launch of an Artificial Intelligence Media Platform, Marktechpost, which stands out for its in-depth coverage of machine learning and deep learning news that is both technically sound and easily understandable by a wide audience. The platform boasts of over 2 million monthly views, illustrating its popularity among audiences.

Source link