# OpenBot on your cloud: agent install guide

> **For the customer's coding agent** (Claude Code, Codex, Cursor or similar). Point your agent at this page and say: _"Install OpenBot on our cloud from this guide. Ask me for anything you need."_ The agent reads it top to bottom, asks the questions in Step 1, tells you what to fetch and how, and does the install on Kubernetes with the OpenBot Helm chart.

**What you end up with:** OpenBot on the web at your own HTTPS address, in your own cloud, with your company's single sign-on. Everything runs in the same cluster. Nothing is hosted by CopilotKit.

**Time:** about 2 to 3 hours with a person at the keyboard, most of it waiting on the identity provider, DNS and the certificate. Creating an EKS cluster alone takes about 20 minutes.

---

## Before you start: what the customer needs to have

Agent: show this list to the person first, before running anything, so they can line things up. Mark each one as they confirm it.

**Accounts and access**

- [ ] **A cloud account where they can create a Kubernetes cluster:** AWS (EKS), Google Cloud (GKE) or Azure (AKS). A blank account or project with billing on is best. Or an existing cluster: Kubernetes 1.28 or later, with a default StorageClass that uses `WaitForFirstConsumer`.
- [ ] **That cloud's CLI, signed in on this machine** (`aws`, `gcloud` or `az`), plus `kubectl`, `helm` 3.12 or later, and `node`/`npx`. The agent can install the tools.
- [ ] **A CopilotKit account and organization**, with self-hosted (enterprise) entitlements turned on by CopilotKit. The licence key comes from it. See Step 3.

**AI model**

- [ ] **A model API key:** OpenAI (the default, and the easiest), or Anthropic. Or an OpenAI-compatible gateway, which needs its base URL, a key and a model name. OpenBot's automatic learning also spends this key.

**Web address**

- [ ] **A hostname** for OpenBot, usually `openbot.<your-domain>`. This exact origin (https, no port, no path, no trailing slash) is used everywhere below.
- [ ] **Someone who can add DNS records** for that domain (often a platform team). If DNS changes go through tickets, a temporary `nip.io` hostname on a static IP works until the real record is in.
- [ ] **A TLS certificate the browser trusts.** The cloud's managed certificate (AWS Certificate Manager, Google-managed, Azure Key Vault) is the usual choice. If the domain has CAA records, they must allow that issuer.

**Single sign-on (identity provider)**

- [ ] **Admin access to the company's identity provider:** Microsoft Entra ID, Okta or Google Workspace (built in). Any other OIDC or SAML provider is added after install from OpenBot's Admin screen.
- [ ] For the provider, they will hand over:
  - **Entra ID:** application (client) ID, directory (tenant) ID, and the client secret **value** (not the secret ID).
  - **Okta:** client ID, client secret, and the issuer URL (for example `https://<company>.okta.com/oauth2/default`).
  - **Google:** OAuth client ID and secret, from a Google Cloud project, with the consent screen set to **Internal**. This only exists for Google Workspace organizations. A Microsoft-only company must use Entra ID.
- [ ] **The first administrators' email addresses.** Nobody else can grant the admin role at first.
- [ ] **The company's email domain(s)**, so only company accounts can sign in.

**Network**

- [ ] The cluster can reach out to: the model provider, `ghcr.io` and `docker.io` (images), `github.com` (the chart), and the identity provider's issuer URL. On a chart above 1.1.2, also CopilotKit's management service over HTTPS (`*.bot.copilotkit.ai`), unless they turn it off (Step 10). People's browsers can reach the hostname (over VPN is fine).
- [ ] If the company inspects TLS (Zscaler and similar), note it now. It breaks the CopilotKit CLI until Node trusts the system certificates (Step 3).

**Optional, for production later** (not needed for the first install)

- [ ] A managed PostgreSQL (RDS, Cloud SQL, Azure Database) with pgvector 0.8.0 or later and an admin role that can create roles, databases and extensions. The bundled database works for a pilot but has no backups.
- [ ] SMTP details, if OpenBot should send email.

---

## Rules for the agent

- **Read this whole page before running anything.** If something here disagrees with what you see (a newer chart, a changed CLI), trust what you see, adapt, and tell the person.
- **Work in a new, empty directory.** Not inside the customer's own code. Install OpenBot as released: no changes, no custom Bots, no migrations of their agents.
- **Ask before every step that changes their cloud** (creating a cluster, a load balancer, DNS records, `helm install`). Confirm the cloud account, region, cluster and namespace with them first. Show `kubectl config current-context`.
- **Never sign in as them.** They run `copilotkit login` and `copilotkit license` themselves. Never echo a secret back, and never print one into the chat.
- **Secrets go in one file outside any repository**, which you tell them about, for example `~/openbot-secrets.yaml`. Never commit it.
- **When they don't know how to get something**, search the web for the current steps for their provider and walk them through it, one screen at a time.
- **When a step fails**, read the error. The chart and the server refuse with one sentence naming the problem. Fix that and retry. Don't start over.
- The public guide in the OpenBot repository (`prompt.txt`, section C) covers the same chart in more depth. Use it as a reference.

---

## Step 1: Ask the person these questions

Ask one at a time, and write the answers into a short plan you show back to them.

1. Which cloud: **AWS, Google Cloud or Azure**? Which account or project, and which region?
2. **New cluster or an existing one?** If existing: its name, and does it already have an ingress controller or Gateway?
3. Which **identity provider**: Entra ID, Okta or Google Workspace?
4. What **hostname**? Who controls DNS for that domain, and where are the records actually hosted? (The registrar is not always where the records live.)
5. Which **model provider**: OpenAI, Anthropic, or their own OpenAI-compatible gateway?
6. Who are the **first admins** (emails), and which **email domains** may sign in?
7. Does the company inspect TLS on this machine (Zscaler or similar)?
8. Bundled database for now (recommended for a first install), or their own PostgreSQL?
9. **CopilotKit management:** on a chart above 1.1.2, the install connects to CopilotKit by itself to report its version and health (never conversations or data), and CopilotKit can run upgrades in a maintenance window once they set that up. Keep it on, or install with it off? They can change their mind at any time. See Step 10.

## Step 2: Prepare this machine

1. Install what's missing: the cloud CLI, `kubectl`, `helm`, Node.js (for `npx`).
2. They sign in to their cloud CLI themselves.
   - **AWS:** `aws login` or `aws sso login`, in a **separate terminal window** so this session isn't blocked. Then set the region explicitly.
   - **Google Cloud:** `gcloud auth login`, then `gcloud config set project <project>`. Billing must be on.
   - **Azure:** `az login`, then `az account set --subscription <id>`.
3. Confirm the identity: `aws sts get-caller-identity`, `gcloud config list` or `az account show`.

## Step 3: The CopilotKit licence

The person runs these themselves (not the agent):

```bash
npx --yes copilotkit@latest login
# pick the company's organization when asked
npx --yes copilotkit@latest license --print
```

- **This licence is temporary.** It is enough to install and run the pilot, but it does not last forever. Running OpenBot past the pilot needs an **annual licence** from CopilotKit. The agent tells the person this now, and again at the end (Step 9).
- **One organization for the company.** If each teammate made their own, pick one, invite the others (Organization settings → Members), and sign in again choosing it.
- **Self-hosted entitlements are turned on by CopilotKit.** If `license` says the organization isn't entitled, contact your CopilotKit contact with the organization's name.
- This CopilotKit organization is only for the licence. It is not OpenBot's own organization, and it is unrelated to their agents.
- Type `npx`, not `npm`, and `copilotkit` as one word.
- The secrets file needs the **key itself**, not a path to a file holding it.
- **Corporate TLS inspection** ("unable to get local issuer certificate" or "fetch failed"): make Node use the system certificates. Use `export NODE_USE_SYSTEM_CA=1` on Node 23.8 or later, or `export NODE_EXTRA_CA_CERTS=<path to the company root CA .pem>`. Then rerun.

## Step 4: The single sign-on app

The redirect URI is `https://<hostname>/api/auth/callback/<provider>`, where `<provider>` is `microsoft`, `okta` or `google`. It must match character for character. Watch for a stray `.` or `/` at the end when copying. The app can be created before the cluster exists.

**Microsoft Entra ID**

1. Entra admin center → App registrations → New registration, named `OpenBot`. Single tenant.
2. Platform **Web**, with redirect URI `https://<hostname>/api/auth/callback/microsoft`.
3. Certificates & secrets → New client secret. Copy the **Value** straight away; it is only shown once.
4. Hand over: Application (client) ID, Directory (tenant) ID, and the secret value. Use the real tenant ID, not `common`. `common` lets in personal Microsoft accounts, and the server refuses it together with allowed email domains.

**Okta**

1. Admin console → Applications → Create App Integration → **OIDC - OpenID Connect**, type **Web Application**. Do not tick SAML; an app created with SAML can't be switched and must be recreated.
2. Grant type **Authorization Code**. Sign-in redirect URI `https://<hostname>/api/auth/callback/okta`; sign-out redirect URI `https://<hostname>`.
3. Assignments: allow everyone in the organization (or the pilot group).
4. Skip provisioning (SCIM), "Initiate login URI" and cross-app access.
5. Hand over: client ID, client secret, and the issuer, for example `https://<company>.okta.com/oauth2/default`.
6. **Do this now, or the first sign-in fails with "Policy evaluation failed":** Security → API → Authorization Servers → `default` → Access Policies → Add policy, then Add rule. Grant type Authorization Code, any assigned user, scopes at least `openid` (or any scopes).

**Google Workspace**

1. Google Cloud console → a project for OpenBot → APIs & Services → OAuth consent screen → **Internal**. If Internal isn't offered, the company isn't on Workspace: use Entra ID or Okta.
2. Credentials → Create credentials → OAuth client ID → Web application. Authorized redirect URI `https://<hostname>/api/auth/callback/google`.
3. Hand over: client ID and client secret.

Scopes OpenBot asks for: `openid email profile offline_access`.

## Step 5: The cluster

Skip to Step 6 if they have a cluster. Otherwise create one with them, after they confirm name, region and size. Search the provider's current docs for exact flags. What OpenBot needs is in the bullets.

**What the bundle asks of the cluster:** about 3.2 vCPU and 9.3 GiB of memory in requests, plus about 0.4 vCPU while the install jobs run. Volumes total about 55 GiB. x86-64 (amd64) nodes are simplest. On arm64 nodes, add `--set intelligence.embeddings.enabled=false` to the install, because the embeddings image is amd64 only.

**AWS (EKS)**

- 3 nodes of `t3.large` or larger. Two `t3.large` leave a pod Pending on "Insufficient cpu".
- **Default StorageClass:** `eksctl` creates `gp2` without the default mark, using a dead provisioner. Install the EBS CSI driver and create a `gp3` class (`provisioner: ebs.csi.aws.com`, `volumeBindingMode: WaitForFirstConsumer`, annotation `storageclass.kubernetes.io/is-default-class: "true"`).
- Install the **AWS Load Balancer Controller** for HTTPS through an ALB.
- Certificate: request one in **AWS Certificate Manager** for the hostname, with DNS validation. Add the validation CNAME. If the domain has CAA records, add one allowing `amazon.com` (keep the existing ones).
- Hardening for later: set `disablePodIMDS` and `disableIMDSv1` on node groups, so a Bot's shell can't reach the node's IAM role.

**Google Cloud (GKE)**

- One zone and `e2-standard-4` nodes are enough for a pilot. The first create can fail on a flag combination; read the error and rerun.
- Reserve a **global static IP** for the load balancer.
- HTTPS: a **Gateway** (`gke-l7-global-external-managed`) with a Google-managed certificate, or an Ingress with a `ManagedCertificate`. The certificate stays "Provisioning" until the load balancer serves traffic and DNS points at it. That's normal.
- No DNS access yet? Use `openbot.<static-ip>.nip.io` as the hostname. Use the same value in the identity provider's redirect URI.

**Azure (AKS)**

- 3 nodes of `Standard_D4s_v5` (or similar).
- Enable the **application routing** add-on (ingress class `webapprouting.kubernetes.azure.com`), with a certificate from Azure Key Vault.

After creating it: `kubectl config current-context` shows the new cluster (creating one switches the context, which matters for people with several), and `kubectl get sc` shows exactly one default class.

## Step 6: Write the values file

Find the latest stable OpenBot release at [https://github.com/CopilotKit/OpenBot/releases](https://github.com/CopilotKit/OpenBot/releases) (v1.1.2 when this was updated). Use its `openbot-bundle-<version>.tgz` asset: everything OpenBot needs in one chart, with one PostgreSQL. Pin by release tag and check the asset's sha256 from `release-charts.json`. Read its guide with `helm show readme <asset url>`.

Generate the session secret: `openssl rand -base64 32`.

Write `~/openbot-secrets.yaml` (outside any repository). The person pastes the values. Everything under `openbot:` configures OpenBot.

```yaml
openbot:
  secrets:
    licenseToken: "<CopilotKit licence key>"
    modelApiKey: "<OpenAI API key>"            # or anthropicApiKey: "<Anthropic key>"
    betterAuthSecret: "<openssl rand -base64 32>"
    microsoftClientSecret: "<secret value>"     # or oktaClientSecret / googleClientSecret
```

Write `~/openbot-values.yaml` (no secrets in it):

```yaml
openbot:
  config:
    publicUrl: https://openbot.example.com      # the exact origin
    initialAdminEmails: "admin1@example.com,admin2@example.com"
    allowedEmailDomains: "example.com"
    auth:
      microsoft:
        clientId: "<application (client) ID>"
        tenantId: "<directory (tenant) ID>"
      # okta:
      #   clientId: "<client ID>"
      #   issuer: "https://<company>.okta.com/oauth2/default"
      # google:
      #   clientId: "<client ID>.apps.googleusercontent.com"
    # model:
    #   provider: anthropic                     # only with an Anthropic key
    #   openaiBaseUrl: "https://<gateway>/v1"   # only for an OpenAI-compatible gateway
    #   name: "<model name the gateway publishes>"
  computers:
    mode: shared
    sharedModeAcknowledged: true                # a pilot: all Bots share one computer
```

Then add the routing for their cloud under `openbot:`.

**AWS (EKS), ALB Ingress:**

```yaml
  ingress:
    enabled: true
    className: alb
    annotations:
      alb.ingress.kubernetes.io/scheme: internet-facing   # internal for VPN-only
      alb.ingress.kubernetes.io/target-type: ip
      alb.ingress.kubernetes.io/certificate-arn: "<ACM certificate ARN>"
      alb.ingress.kubernetes.io/listen-ports: '[{"HTTP":80},{"HTTPS":443}]'
      alb.ingress.kubernetes.io/ssl-redirect: "443"
      alb.ingress.kubernetes.io/load-balancer-attributes: idle_timeout.timeout_seconds=3600
    hosts:
      - host: openbot.example.com
        paths:
          - path: /
            pathType: Prefix
  computers:
    persistence:
      storageClass: gp3
```

**Google Cloud (GKE), Gateway API:**

```yaml
  ingress:
    enabled: false
  httpRoute:
    enabled: true
    parentRefs:
      - name: openbot-gateway
        namespace: gateway-system
    hostnames:
      - openbot.example.com
```

Create the Gateway first: class `gke-l7-global-external-managed`, the static IP, and the managed certificate. Raise the backend timeout to 3600 seconds with a `GCPBackendPolicy`, because conversations hold long WebSockets.

**Azure (AKS), application routing:**

```yaml
  ingress:
    enabled: true
    className: webapprouting.kubernetes.azure.com
    hosts:
      - host: openbot.example.com
        paths:
          - path: /
            pathType: Prefix
    tls:
      - hosts: [openbot.example.com]
        secretName: openbot-tls
```

One hostname is enough; the bundle routes everything behind it. Load balancers must not cut long WebSockets, so raise idle timeouts to about an hour.

## Step 7: Install

Confirm cluster and namespace with the person, then:

```bash
helm install openbot https://github.com/CopilotKit/OpenBot/releases/download/<tag>/openbot-bundle-<version>.tgz \
  --namespace openbot --create-namespace \
  --values ~/openbot-values.yaml \
  --values ~/openbot-secrets.yaml \
  --timeout 15m
```

- **Optional, on a chart above 1.1.2 only:** add `--set openbot.management.enabled=false` to install without CopilotKit's management agent, so nothing connects to CopilotKit (Step 10). To keep it off through later upgrades, put `management: { enabled: false }` under `openbot:` in `~/openbot-values.yaml` instead. Charts 1.1.2 and earlier have no agent, so leave it out there.
- Use release name `openbot` and namespace `openbot`, so names match the docs (`openbot-server`, `openbot-secrets`). One bundle per namespace.
- Install with `helm` itself, not `helm template` or Argo CD. The chart generates its own keys and passwords and reads them back on every upgrade.
- The first install takes several minutes. Watch it with `kubectl -n openbot get pods,jobs -w`.
  - OpenBot's server pods wait in `wait-for-database`, then migrate as they start.
  - A migration job retries until the database is up.
  - A one-time setup job (`openbot-intelligence-bootstrap-1`) finishes the install.

## Step 8: DNS and certificate

1. Get the load balancer address: `kubectl -n openbot get ingress` (or the Gateway's IP).
2. In the place the domain's records actually live, add:
   - The certificate's validation record, if the cloud asks for one (ACM: a CNAME).
   - A CAA record allowing the issuer, if the domain has CAA records.
   - The hostname record: a **CNAME** to the ALB hostname (AWS), or an **A** record to the static IP (GKE, AKS).
3. Some DNS providers reject a target that ends in `.`; remove it. Don't repeat the domain in the record name (`openbot`, not `openbot.example.com.example.com`).
4. Wait for DNS and the certificate. Usually minutes, sometimes up to an hour, rarely a day. Poll with `dig openbot.example.com` and `curl -I https://openbot.example.com`. If it works for you but not for them, they flush their local DNS cache.

## Step 9: Check it works

1. `kubectl -n openbot get pods,jobs`: everything Running or Completed, nothing Pending, crash-looping or failing to pull.
2. Open `https://<hostname>`. Sign in with a first-admin account.
3. Click **Get started**, say hi to a Bot, then ask it to open a public website and show a small chart. A plain text answer doesn't prove the browser tools work.
4. Open **Admin**: People, Permissions, Boundaries, Activity, Identity providers. Other people sign in, and an admin promotes whoever else needs it.
5. Tell the person where their secrets live (`~/openbot-secrets.yaml`, and in the cluster `openbot-secrets` and `openbot-intel-*`). Tell them not to lose `key-encryption-key` in `openbot-secrets`; every stored credential is encrypted with it.
6. **Tell CopilotKit it's installed.** The licence from Step 3 is temporary. The person tells their CopilotKit contact that OpenBot is running, with the CopilotKit organization's name, so CopilotKit can set up the annual licence before the temporary one runs out. When the new key arrives, it goes in `openbot.secrets.licenseToken` in `~/openbot-secrets.yaml`, followed by a `helm upgrade` (After the pilot).

## Step 10: CopilotKit management

Check the chart version that was installed: `helm list -n openbot` (the CHART column).

**1.1.2 or earlier:** nothing to do. These charts install no management agent, nothing in the cluster connects to CopilotKit, and the customer upgrades OpenBot themselves (After the pilot). A later release brings management in; see the last point below.

**Above 1.1.2:** the chart also installs CopilotKit's management agent, in the namespace `openbot-system`. With the team licence from Step 3, OpenBot connects the install to CopilotKit by itself. There is no enrollment step: it tries when it starts, and every hour until it is connected. Explain this to the person and decide together whether to keep it on.

- **What it sends.** A heartbeat every minute, always outbound; nothing connects in. The heartbeat carries OpenBot's version, chart version and image digests, the last database migration, each workload's ready and desired replica counts, and the upgrade state. Health metrics (request rate, errors and latency, database reachability, pod restarts, CPU and memory) are sent only once managed upgrades are set up, and can be switched off then.
- **What never leaves the cluster.** Conversations, messages, files, prompts, Bot settings, people's names or email addresses, secrets, logs and database contents.
- **What it does.** On commands CopilotKit signs, it can restart a workload or write a support bundle to a volume in the cluster, which is never uploaded. It upgrades nothing by default.
- **Managed upgrades** stay off until the one-time setup in [docs/managed-upgrades.md](https://github.com/CopilotKit/OpenBot/blob/main/docs/managed-upgrades.md). After that, CopilotKit upgrades OpenBot only inside the agreed maintenance window (Tuesdays, 14:00 to 18:00 UTC by default), and only after a verified database backup.
- It never runs on the personal edition, on OpenBot Cloud, or without a team licence.

**Check it:**

1. Open **Admin → Managed updates** as a first admin. It shows **Connecting**, then **Connected**, with the last heartbeat, the agent version, and Upgrades: **Not set up**. **Not connected** means OpenBot tries again within the hour; **Connect** tries now. **Not in your licence** means the licence doesn't include managed updates and nothing connects; the person can ask their CopilotKit contact.
2. `kubectl -n openbot-system get pods`: the management agent is Running.

**If they'd rather turn it off:**

- **From Admin:** press **Disconnect** on Admin → Managed updates. OpenBot stops connecting and stays off through restarts and upgrades, until an admin presses **Connect**. The agent's pod stays until it is also turned off with Helm.
- **With Helm:** put `management: { enabled: false }` under `openbot:` in `~/openbot-values.yaml` and run the upgrade (After the pilot) with both values files. No agent is installed and OpenBot never connects by itself. About five minutes later, press **Disconnect** on Admin → Managed updates so CopilotKit retires the install. The namespace `openbot-system` and its Secret `openbot-agent-credentials` stay; delete them if the person wants nothing left.
- **Upgrading from 1.1.2 or earlier** to a later release turns management on, as above, unless the values file already has `management: { enabled: false }` under `openbot:`. Ask the person before that upgrade.

---

## When something goes wrong

**The install is refused before anything is created.** The message names the value:

- A message that the CopilotKit licence is needed: the secrets file wasn't passed, or `licenseToken` is empty.
- "Nobody could sign in": no identity provider in the values.
- A message about shared computers: add `openbot.computers.sharedModeAcknowledged: true` (or use sandbox mode, below).

**A pod stays Pending:** `kubectl -n openbot describe pod <pod>`.

- "Insufficient cpu": add a node or use bigger ones.
- A volume claim that never binds: no default StorageClass, or one without `WaitForFirstConsumer`.
- A node-affinity conflict on a multi-zone cluster: the StorageClass isn't `WaitForFirstConsumer`.

**ImagePullBackOff:** on the embeddings image, the nodes are arm64 (reinstall with `--set intelligence.embeddings.enabled=false`). Otherwise, check egress to `ghcr.io` and `docker.io`, and Docker Hub rate limits.

**The server stops at start:** `kubectl -n openbot logs deploy/openbot-server`. It says what's wrong in one sentence (a missing or invalid licence, a bad key, a missing secret).

**`intelligence-entitlement-not-ready` in OpenBot's log:** the licence isn't valid for a self-hosted install. Check the organization's entitlements with CopilotKit.

**Sign-in fails:**

- "redirect_uri mismatch": the URI registered in the provider differs from `https://<hostname>/api/auth/callback/<provider>` (trailing character, http vs https, wrong hostname).
- Okta "Policy evaluation failed": add the access policy and rule (Step 4, Okta step 6).
- A user signs in but has no Admin: they aren't in `initialAdminEmails`. An existing admin promotes them in Admin → People.
- Someone outside the company can't sign in: that's `allowedEmailDomains` working.

**The page loads but chat stalls or reconnects:** the load balancer is cutting WebSockets. Raise its idle timeout (Step 6).

**The model doesn't answer:** the key has no credit or quota, the provider is wrong (`model.provider: anthropic` for an Anthropic key), or a gateway needs its base URL and the exact model name it publishes.

**A certificate stays pending:** DNS doesn't point at the load balancer yet, or a CAA record blocks the issuer.

**The wrong product:** OpenBot is CopilotKit's, from [github.com/CopilotKit/OpenBot](https://github.com/CopilotKit/OpenBot). `openbot.run` is a different, unrelated project.

---

## After the pilot

- **Upgrades** (until managed upgrades are set up; after that, CopilotKit upgrades OpenBot in the maintenance window, Step 10): `helm upgrade openbot <new release's bundle URL> --namespace openbot` with the same two `--values` files and `--timeout 15m`. Never use `--reuse-values`. After a failed upgrade, pass the values files again.
- **A computer per person (sandbox mode):** install the agent-sandbox controller, then set `openbot.computers.mode: sandbox`:

  ```bash
  kubectl apply --server-side -f https://github.com/kubernetes-sigs/agent-sandbox/releases/download/v0.5.6/sandbox-with-extensions.yaml
  ```

- **A production database:** set `postgresql.enabled: false`, `externalDatabase.host` and `parameters: sslmode=require`, and put the admin URL in Secret `openbot-database-admin` (key `admin-url`). Also set `openbot.database.inRelease: false` and `openbot.secrets.keyEncryptionKey` / `computerToken`. The bundle's guide (`helm show readme`) has the details.
- **Their own agents:** New Bot → Connect custom agent, with an AG-UI URL and bearer token. Add the agent's host to the allowed hosts setting, then upgrade.
- **The annual licence:** when CopilotKit sends it, put the key in `openbot.secrets.licenseToken` and run the upgrade above. Renew it with CopilotKit each year, before it expires.
- **More environments:** each staging or dev install may need its own licence. Ask CopilotKit.
