Connect Intelligence in 5 minutes

npm install @copilotkit/runtime

import {
  CopilotKitIntelligence,
  CopilotRuntime,
} from "@copilotkit/runtime/v2";

// Create the Intelligence client with your project API key. Keep this key on the server.
const intelligence = new CopilotKitIntelligence({
  apiKey: process.env.CPK_INTELLIGENCE_API_KEY!,
});

const runtime = new CopilotRuntime({
  agents,
  // Pass the Intelligence client to the runtime
  intelligence,
  // Identify the user from a verified session or token
  identifyUser: async (request) => {
    const user = await authenticateApplicationUser(request);
    if (!user) throw new Error("Unauthorized");
    return { id: user.id, name: user.name };
  },
});

const runtime = new CopilotRuntime({
  agents,
  runner: new InMemoryAgentRunner(), 
  intelligence, 
  identifyUser,
});

Intelligence Runtime auto-wires its own `runner`; passing `runner` alongside
`intelligence` is not supported.

import { createCopilotRuntimeHandler } from "@copilotkit/runtime/v2";

const handler = createCopilotRuntimeHandler({
  runtime,
  basePath: "/api/copilotkit",
});

export const GET = handler;
export const POST = handler;
export const PATCH = handler;
export const DELETE = handler;

python -m pip install copilotkit-intelligence-runtime==0.1.0 uvicorn

export CPK_INTELLIGENCE_API_KEY="your-project-api-key"
export AG_UI_AGENT_URL="http://localhost:8001/agent"
export APP_AUTH_TOKEN="replace-with-a-random-local-development-token"
export APP_USER_ID="local-user"

import hmac
import os

from starlette.requests import Request
from copilotkit_runtime import HttpAgent, IntelligenceRuntime, RuntimeConfig, User

app_token = os.environ["APP_AUTH_TOKEN"]
user_id = os.environ["APP_USER_ID"]
if not app_token or not user_id:
    raise ValueError("APP_AUTH_TOKEN and APP_USER_ID must not be empty")


async def identify_user(request: Request) -> User | None:
    supplied = request.headers.get("authorization", "").encode()
    expected = f"Bearer {app_token}".encode()
    if not hmac.compare_digest(supplied, expected):
        return None
    return User(id=user_id)


app = IntelligenceRuntime(
    RuntimeConfig(
        api_key=os.environ["CPK_INTELLIGENCE_API_KEY"],
        base_path="/api/copilotkit",
        allowed_origins=("http://localhost:3000",),
    ),
    agents={"default": HttpAgent(os.environ["AG_UI_AGENT_URL"])},
    identify_user=identify_user,
)

python -m uvicorn app:app --host 127.0.0.1 --port 8200

go mod init example.com/copilotkit-app
go get github.com/CopilotKit/CopilotKit/packages/runtime-go@v0.0.0-20260930161409-37b078290a51

export CPK_INTELLIGENCE_API_KEY="your-project-api-key"
export AG_UI_AGENT_URL="http://localhost:8001/agent"
export APP_AUTH_TOKEN="replace-with-a-random-local-development-token"
export APP_USER_ID="local-user"

package main

import (
    "context"
    "crypto/subtle"
    "errors"
    "log"
    "net/http"
    "os"
    "os/signal"
    "syscall"
    "time"

    copilotkit "github.com/CopilotKit/CopilotKit/packages/runtime-go"
)

func required(name string) string {
    value := os.Getenv(name)
    if value == "" {
        log.Fatalf("Missing environment variable: %s", name)
    }
    return value
}

func main() {
    token, userID := required("APP_AUTH_TOKEN"), required("APP_USER_ID")
    rt, err := copilotkit.New(copilotkit.Config{
        APIKey: required("CPK_INTELLIGENCE_API_KEY"),
        BasePath: "/api/copilotkit",
        AllowedOrigins: []string{"http://localhost:3000"},
        Agents: map[string]copilotkit.Agent{
            "default": &copilotkit.HTTPAgent{URL: required("AG_UI_AGENT_URL")},
        },
        IdentifyUser: func(r *http.Request) (copilotkit.User, error) {
            if subtle.ConstantTimeCompare(
                []byte(r.Header.Get("Authorization")), []byte("Bearer "+token),
            ) != 1 {
                return copilotkit.User{}, errors.New("unauthorized")
            }
            return copilotkit.User{ID: userID, Name: "Local user"}, nil
        },
    })
    if err != nil {
        log.Fatal(err)
    }
    defer func() {
        if err := rt.Close(); err != nil {
            log.Printf("Runtime shutdown: %v", err)
        }
    }()

    mux := http.NewServeMux()
    mux.Handle("/api/copilotkit/", rt)
    server := &http.Server{Addr: "127.0.0.1:8200", Handler: mux, ReadHeaderTimeout: 10 * time.Second}
    stopped, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
    defer stop()
    serverErrors := make(chan error, 1)
    go func() { serverErrors <- server.ListenAndServe() }()
    select {
    case <-stopped.Done():
    case err := <-serverErrors:
        if !errors.Is(err, http.ErrServerClosed) {
            log.Printf("HTTP server: %v", err)
        }
    }
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()
    if err := server.Shutdown(ctx); err != nil {
        log.Printf("HTTP shutdown: %v", err)
    }
}

source 'https://rubygems.org'
gem 'copilotkit-runtime', '0.1.0.rc.1'
gem 'rack', '~> 3.1'
gem 'rackup', '~> 2.2'
gem 'puma', '~> 6.0'

export CPK_INTELLIGENCE_API_KEY="your-project-api-key"
export AG_UI_AGENT_URL="http://localhost:8001/agent"
export APP_AUTH_TOKEN="replace-with-a-random-local-development-token"
export APP_USER_ID="local-user"

require 'rack'
require 'copilotkit/runtime'

token = ENV.fetch('APP_AUTH_TOKEN')
user_id = ENV.fetch('APP_USER_ID')
raise 'APP_AUTH_TOKEN and APP_USER_ID must not be empty' if token.empty? || user_id.empty?

runtime = CopilotKit::Runtime.new(
  api_key: ENV.fetch('CPK_INTELLIGENCE_API_KEY'),
  agents: {
    'default' => CopilotKit::HttpAgent.new(url: ENV.fetch('AG_UI_AGENT_URL'))
  },
  cors_origins: ['http://localhost:3000'],
identify_user: lambda do |env|
    supplied = env.fetch('HTTP_AUTHORIZATION', '')
    if Rack::Utils.secure_compare(supplied, "Bearer #{token}")
      { id: user_id }
    end
  end
)

at_exit { runtime.close(timeout: 10) }

map '/api/copilotkit' do
  run runtime
end

bundle exec puma config.ru --bind tcp://127.0.0.1:8200 --workers 0

dotnet new web --framework net8.0 --name CopilotKitApp
cd CopilotKitApp
dotnet add package CopilotKit.Intelligence.Runtime --version 0.1.0-rc.1

export CPK_INTELLIGENCE_API_KEY="your-project-api-key"
export AG_UI_AGENT_URL="http://localhost:8001/agent"
export APP_AUTH_TOKEN="replace-with-a-random-local-development-token"
export APP_USER_ID="local-user"

using System.Security.Cryptography;
using System.Text;
using CopilotKit.Intelligence;

static string Required(string name) =>
    Environment.GetEnvironmentVariable(name) is { Length: > 0 } value
        ? value : throw new InvalidOperationException($"Missing {name}");

var token = Required("APP_AUTH_TOKEN");
var userId = Required("APP_USER_ID");
var expected = Encoding.UTF8.GetBytes($"Bearer {token}");
using var agentClient = new HttpClient(new SocketsHttpHandler
{
    PooledConnectionLifetime = TimeSpan.FromMinutes(2)
}) { Timeout = Timeout.InfiniteTimeSpan };

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddSingleton<IntelligenceRuntime>(_ => new IntelligenceRuntime(
    new RuntimeOptions
    {
        ApiKey = Required("CPK_INTELLIGENCE_API_KEY"),
        AllowedOrigins = new HashSet<string> { "http://localhost:3000" },
        Agents = new Dictionary<string, IRuntimeAgent>
        {
            ["default"] = new HttpAgent(new Uri(Required("AG_UI_AGENT_URL")), agentClient)
        },
        IdentifyUser = (context, cancellationToken) =>
        {
            cancellationToken.ThrowIfCancellationRequested();
            var supplied = Encoding.UTF8.GetBytes(context.Request.Headers.Authorization.ToString());
            RuntimeUser? user = CryptographicOperations.FixedTimeEquals(supplied, expected)
                ? new RuntimeUser(userId) : null;
            return ValueTask.FromResult(user);
        }
    }));

await using var app = builder.Build();
app.Services.GetRequiredService<IntelligenceRuntime>().Map(app, "/api/copilotkit");
await app.RunAsync("http://127.0.0.1:8200");