# Configure the Channel in Intelligence

> Create a managed Channel, connect Slack or Teams, and hand its exact Code and runtime credentials to your SDK process.

This walkthrough starts with an Intelligence project and ends with a configured
platform connection waiting for your Channels SDK runtime.

In the managed path, Intelligence owns the provider connection and durable
delivery edge. Your long-running process owns the agent, application tools,
interactive behavior, state, and deployment.

## Create and configure your Channel [#create-and-configure-your-channel]

Use the browser wizard below to create the Channel, store its provider
credentials, and inspect its health and threads. It is the released setup path
for both Slack and Microsoft Teams.

<OpsPlatformCTA
  variant="inline"
  title="Get started with CopilotKit Intelligence"
  body="Create a free project to configure and manage your Slack Channel."
  surface="docs:slack/quickstart:intelligence"
/>

<Image
  src="/images/channels/intelligence-channels-overview.png"
  alt="The CopilotKit Intelligence channel creation wizard showing the channel name, Code, and Slack and Teams platform options."
  width={3188}
  height={1778}
  className="my-8 w-full rounded-xl border border-fd-border"
/>

<Callout type="info" title="One Channel can serve both providers">
  Attach Slack, Microsoft Teams, or both to one Intelligence Channel. The
  Channel uses one Code and one SDK handler set; each event and reply remains in
  its originating provider conversation.
</Callout>

<Steps>
  <Step>
    ### Open the Channels area [#open-the-channels-area]

    In CopilotKit Intelligence, open your project, go to **Channels**, and click
    **Add channel**. In an empty project, the action is **Create channel**.

    The wizard has three phases: **Name & platforms**, **Setup**, and **Review**.

  </Step>

  <Step>
    ### Set the Display name and Code [#set-the-display-name-and-code]

    Enter a human-readable **Display name**. Intelligence derives the **Code**
    automatically; click **Edit** only if you need to change it.

    The Code is part of the runtime contract:

    - 3 to 64 characters
    - starts with a lowercase letter
    - lowercase letters and numbers separated by single hyphens
    - project-unique
    - cannot be `channels`

    Your SDK declaration must use that exact Code:

    ```ts title="channel.ts"
    import { createChannel } from "@copilotkit/channels";
    import { makeAgent } from "./agent.js";

    const channel = createChannel({
      name: process.env.CHANNEL_CODE,
      identifyUser: "platform",
      agent: makeAgent,
    });
    ```

    `CHANNEL_CODE` holds the exact Code from this Channel.

    A mismatch leaves the Channel at **Waiting for runtime**.

  </Step>

  <Step>
    ### Choose providers [#choose-providers]

    Select Slack, Microsoft Teams, or both. Each connection has its own setup
    and installation steps but shares this Channel's Code and runtime
    declaration.

    Configure Slack for this guide. You can attach Teams to the same Channel
    now or later without changing the Code.

    Slack and Teams use the same managed delivery path. If a provider says
    **Not on your plan**, change the project entitlement before continuing.

    Cloud-hosted Intelligence support for Discord and WhatsApp shows **Coming
    soon**. The Channels SDK already exports developer-operated direct adapters
    for those providers.

  </Step>

  <Step>
    ### Connect Slack [#connect-slack]

    1. Copy the generated manifest, open Slack's app-creation flow, and create
       the app **From a manifest** using the YAML.
    2. In **OAuth & Permissions**, click **Install to Workspace**. Approve the
       complete scope set from the current manifest. Copy the `xoxb-…` **Bot
       User OAuth Token** into **Bot token**. If you change scopes later,
       reinstall the app and copy the new token.
    3. In **Basic Information → App Credentials**, copy the
       **Signing Secret** into Intelligence.
    4. Invite the app to a channel with `/invite @<app-handle>`, or open a
       direct message with it.

    Slack sends signed Events API requests to the public Intelligence URL in
    the generated manifest. Cloud-hosted Intelligence provides that URL; a
    self-hosted deployment must expose it. Managed slash commands are not part
    of the Channels product surface.

  </Step>

  <Step>
    ### Review and create [#review-and-create]

    In the **Review** phase, confirm the Display name, Code, and selected
    platform, then click **Create channel**.

    Credential validation is not an end-to-end message test.

    A valid but mismatched Slack token pair can still fail at runtime.

  </Step>

  <Step>
    ### Configure the runtime handoff [#configure-the-runtime-handoff]

    1. On the new Channel page, open **Connect a runtime**. The **Environment
       file (.env)** block names the Intelligence variables with blank values.
    2. In the directory of your Channels process, sign in and select the
       project. `project select` writes `CPK_INTELLIGENCE_API_KEY`:

       ```bash title="Terminal"
       npx copilotkit@latest login
       npx copilotkit@latest project select
       ```

    3. Set `CHANNEL_CODE` to the Code of this Channel.

    If the process does not load that `.env` file, store the key in your secret
    manager. The project **API Keys** page is the other way to copy a key.
    Configure the process with:

    ```dotenv title=".env"
    CPK_INTELLIGENCE_API_KEY=<project-api-key>
    CHANNEL_CODE=<your-channel-code>

    # Optional paired overrides for self-hosted or non-production Intelligence:
    # INTELLIGENCE_API_URL=https://intelligence.example.com
    # INTELLIGENCE_GATEWAY_WS_URL=wss://realtime.intelligence.example.com
    ```

    Cloud-hosted Intelligence supplies both default base URLs. If you
    override them for a self-hosted or non-production deployment, replace both
    together. The REST and realtime planes use separate hosts, so do not derive
    the WebSocket URL by changing the API URL's scheme. Pass bare base URLs:
    the client appends `/api/...`, `/runner`, `/client`, or `/channels` itself.
    Do not append `/api`, `/socket`, `/runner`, `/client`, or `/channels`.

    You choose `CHANNEL_CODE` from the exact Code above, and the selected agent
    framework adds its own backend variables. The SDK receives the Intelligence
    values through the `apiKey` constructor property and optional `apiUrl` /
    `wsUrl` overrides shown in the platform connection guides.

    Never expose the Intelligence key, Slack tokens, or Teams client secret in
    browser code or source control.

  </Step>
</Steps>

## Next step [#next-step]

Your Slack Channel should now be **Waiting for runtime**. Continue to
[Connect and run your agent](/slack/connect) with `CHANNEL_CODE` and
`CPK_INTELLIGENCE_API_KEY`.
