# CopilotKit Channels SDK: Connect One AG-UI Agent to Slack and Teams

> Launch one AG-UI agent across Slack, Microsoft Teams and React with the Channels SDK: setup, generative UI, approvals, MCP, memory and managed delivery.

- **Published**: 2026-08-19
- **Category**: AI Infrastructure
- **URL**: https://agentpedia.codes/blog/copilotkit-channels-sdk-agent-channels-guide

---

> **Important callout**

**Bottom line:** The CopilotKit Channels SDK (announced **August 4, 2026**) connects any AG-UI agent to Slack, Microsoft Teams, and other chat platforms from one codebase. Slack and Teams are managed today through CopilotKit Intelligence, which handles credentials, delivery, ordering, and deduplication. The agent runs in your own infrastructure, and replies render as native platform UI: Block Kit in Slack, Adaptive Cards in Teams.

CopilotKit [announced the Channels SDK on August 4, 2026](https://www.copilotkit.ai/blog/channels-sdk). The pitch: your users already work in Slack and Microsoft Teams, and getting an agent into those channels normally means a separate integration per platform, each with its own provider setup, message format, and delivery rules. The SDK replaces that with one open-source library that brings an AG-UI agent to any channel while keeping the agent's memory and context in the thread.

This guide covers the scaffold command, the channel runtime pattern, generative UI and approvals, tools and MCP, memory across platforms, what the managed layer does, and when the SDK is the right call.

## What the Channels SDK launches

The launch is two pieces that work together:

- **The Channels SDK**, an open-source library that takes an AG-UI or CopilotKit agent and exposes it to chat platforms through `createChannel`.
- **CopilotKit Intelligence**, the managed layer that holds platform credentials, receives events, and delivers turns to your bot over a persistent connection, keeping delivery ordered and deduplicated.

Channels today: **Slack and Microsoft Teams**, both fully managed through Intelligence, with more channels announced as coming soon.

The setup entry point is one command:

```bash
npx copilotkit@latest channels setup
```

A complete working example is available by cloning OpenTag from GitHub, or by following the quickstart in the Channels docs. CopilotKit also hosts public Slack and Teams channels at copilotkit.ai/try-channels so you can try the agent live.

## Scaffold and first channel

The core runtime pattern wires one agent to one or more channels:

```js
import { createChannel } from "@copilotkit/channels";
import { CopilotRuntime, CopilotKitIntelligence } from "@copilotkit/runtime/v2";
import { createCopilotNodeListener } from "@copilotkit/runtime/v2/node";
import { agent } from "./agent"; // any AG-UI or CopilotKit agent

const channel = createChannel({ name: "support-bot", identifyUser: "platform", agent });

channel.onMessage(({ thread, message }) => thread.runAgent({ prompt: message.text }));

const runtime = new CopilotRuntime({
  agents: {},
  intelligence: new CopilotKitIntelligence({
    apiKey: process.env.INTELLIGENCE_API_KEY!, // free to start
  }),
  channels: [channel],
});

await createCopilotNodeListener({ runtime }).channels?.ready();
```

The agent's reply streams into the channel and updates in place as the agent writes. The same handler works in every channel. For the full setup, environment variables, JSX config, and run steps, read the quickstart guide.

## One codebase, every channel

Adding a channel is a dashboard action rather than a code change: connect Slack or Teams in the dashboard, point your runtime at your agent, and the rest of the code stays the same.

Replies render as each platform's own UI from a single JSX message you write once:

```jsx
import { Message, Section, Actions, Button } from "@copilotkit/channels/ui";

await thread.post(
  <Message>
    <Section>Deploy v1.4.2 to production?</Section>
    <Actions>
      <Button onClick={({ thread }) => thread.post("Shipping.")}>Ship it</Button>
      <Button>Cancel</Button>
    </Actions>
  </Message>,
);
```

The Channels component library covers sections, headers, buttons, tables, and more, and each piece becomes a native component on the target platform.

The SDK also bundles features the agent gets out of the box:

- **Generative UI** -- the agent renders interactive components in the chat, such as charts.
- **Human-in-the-loop** -- critical actions wait for approval.
- **Persistence** -- thread state survives restarts and instances.
- **MCP servers** -- connect tools from other services.
- **Slash commands and reactions** -- `/commands` and react-to-any-message handlers.
- **Files and multimodality** -- users drop images and files for the agent to read.
- **Custom tools** -- functions you define to act on your own systems.

## Generative UI and approval flows

The approval flow matters for production agents. A channel message can carry an action that changes real state, and the SDK gates it behind a button the user must click. In the deploy example above, the "Ship it" button fires the handler only when the user confirms, and "Cancel" does nothing.

The same JSX primitive composes richer interfaces. Because the components render natively per platform, an approval card in Slack uses Block Kit buttons and the equivalent Adaptive Card in Teams, both authored once.

## Tools and MCP servers

A tool lets the agent do more than answer: it calls your code to open a PR, file an issue, or trigger a deploy, then posts the result back into the thread.

```js
import { defineChannelTool } from "@copilotkit/channels";
import { z } from "zod";

// The Linear issue step from the bug flow above. You'd define open_pr the same way.
const createLinearIssue = defineChannelTool({
  name: "create_linear_issue",
  description: "Create a Linear issue from a reported bug",
  parameters: z.object({ title: z.string(), body: z.string() }),
  async handler({ title, body }) {
    const url = await createIssue({ title, body }); // your code
    return `Created a Linear issue: ${url}`;
  },
});

// createChannel({ name, agent, tools: [createLinearIssue] })
```

Already have tools in an MCP server? Connect the server and the agent gets those alongside the ones you define.

## Memory and cross-platform transcripts

The agent remembers in two ways:

- **Conversation history** -- recalling the current thread, works out of the box, handled by Intelligence with nothing stored on your side.
- **Transcripts** -- memory across platforms, so someone who asked in Teams can follow up in Slack with the earlier conversation already in context.

Transcripts live in the store you pass to `createChannel`. In development the store stays in memory and resets on restart. For production, plug in a durable store so transcripts and pending approvals survive a restart:

```js
createChannel({
  name: "support-bot",
  identifyUser: ({ actor }) =>
    actor.email ? { id: actor.email, name: actor.name ?? actor.email } : null,
  agent,
  store: {
    adapter: new MyStore(),            // Redis, Postgres
    transcripts: { retention: "30d" }, // memory that follows the user
  },
});
```

## Managed Slack and Teams delivery

The SDK is open source, and every channel runs on a CopilotKit Intelligence key. Your agent runs in your own infrastructure, connected over AG-UI, and Intelligence sits between it and the platforms.

Doing this yourself means owning everything on the platform side:

- provider setup, tokens, and permissions;
- the webhook or socket connection that receives events;
- durable state so threads resume on the right agent;
- reliable delivery with retries when something drops.

Intelligence holds the credentials, receives each event, and delivers the turn to your bot over a persistent connection, keeping delivery ordered and deduplicated, so your process just runs the agent. Adding another platform is a click in the dashboard.

## When to use it

**Use the Channels SDK when:**

- You already have an AG-UI or CopilotKit agent and want it in Slack or Teams without writing a platform integration per channel.
- You need approvals, generative UI, or cross-platform memory and want those handled by a managed layer.
- Your team lives in Slack or Teams and a web chat is not the primary surface.

**Skip it when:**

- Your agent is not AG-UI compatible and you do not want to adapt it.
- You need to own the platform-side integration, credentials, and delivery yourself for compliance or cost reasons.
- A single web chat channel is all you need and a dashboard-managed channel adds unnecessary moving parts.

**Caveats to confirm before production:** managed availability and pricing for CopilotKit Intelligence need confirmation against current docs; the free Intelligence key is stated as free to start, not free forever at production scale.

## Adoption checklist

- [ ] Confirm your agent speaks AG-UI (or wrap it for CopilotKit)
- [ ] Run `npx copilotkit@latest channels setup`
- [ ] Create a free Intelligence key and connect the first channel in the dashboard
- [ ] Implement `createChannel` with `identifyUser` and the agent reference
- [ ] Add a durable store (Redis or Postgres) with a transcript retention policy before production
- [ ] Define approval-gated tools for any action that changes external state
- [ ] Connect MCP servers for existing tools
- [ ] Test streaming replies, slash commands, and reactions in both Slack and Teams
- [ ] Confirm pending approvals survive a restart of your runtime
- [ ] Verify the Intelligence key's rate limits and pricing at your expected volume

## FAQ

**What does the Channels SDK actually connect?**

It connects an AG-UI or CopilotKit agent to chat platforms. Slack and Microsoft Teams are managed today through CopilotKit Intelligence, which handles credentials, delivery, ordering and deduplication, while your agent runs in your own infrastructure connected over AG-UI.

**Is the Channels SDK open source?**

Yes. The SDK is open source, and every channel runs on a CopilotKit Intelligence key. The agent runs on your infrastructure; Intelligence sits between it and the platforms.

**How do agent replies render in Slack versus Teams?**

You compose one rich reply in JSX from the Channels component library, and the pieces become native components per platform: Block Kit in Slack and Adaptive Cards in Teams.

**Does the agent remember conversations across platforms?**

Conversation history for the current thread works out of the box. Transcripts add memory across platforms, so a user can follow up in Slack after a Teams conversation, with the earlier context in scope. Transcripts require a durable store in production, such as Redis or Postgres.

## All Sources and Links

- [Introducing Channels SDK (official blog)](https://www.copilotkit.ai/blog/channels-sdk) -- CopilotKit, August 4, 2026, accessed August 19, 2026
- [CopilotKit Channels documentation](https://docs.copilotkit.ai/) -- official docs
- [OpenTag on GitHub](https://github.com/CopilotKit/opentag) -- complete working example referenced by the launch post
- [AG-UI protocol](https://ag-ui.com/) -- the agent protocol the SDK connects

Related AgentPedia guides: [GitHub Copilot SDK Agent Integration](https://agentpedia.codes/blog/github-copilot-sdk-agent-integration-guide), [OpenAI Agents SDK Sandbox and Memory](https://agentpedia.codes/blog/openai-agents-sdk-sandbox-memory-coding-guide), [Microsoft Agent Framework Caching and Tool Replay](https://agentpedia.codes/blog/microsoft-agent-framework-1-12-1-caching-tool-replay-guide).


---

- [All articles](https://agentpedia.codes/blog)