Open-source AI coworkers that each get a computer of their own: a browser, files and tools, with every action decided before it happens and recorded after. Bring any AG-UI agent.
# OpenBot, on any Kubernetes cluster.
#
# THE DEFAULTS ARE WHAT A PLAIN CLUSTER CAN DO. Every place the clouds genuinely differ is a value,
# and its default is whatever a self-hosted cluster with no cloud features does: the cluster's own
# default StorageClass, no RuntimeClass, a plain Kubernetes Secret, bundled PostgreSQL, an Ingress.
# A deployment on EKS, GKE or AKS turns things on; a self-hosted one changes nothing and still works.
# There is no cloud branching anywhere in the templates, and there should never be: a chart that only
# installs cleanly on a managed cluster has failed the thing this repository is for.
nameOverride: ""
fullnameOverride: ""
image:
repository: ghcr.io/copilotkit/openbot
# Empty means the chart's appVersion prefixed with `v` (the form published tags take), so an
# upgrade of the chart moves the image with it. A value set here is used verbatim.
tag: ""
# The image digest, `sha256:` and 64 hex characters, from the release's `container-images.json`.
# Set, the image becomes `repository:tag@digest` and Kubernetes pulls exactly those bytes, which is
# how docs/releasing.md says to deploy: a tag can be moved, a digest cannot. The tag stays in the
# reference for whoever reads it. Empty pulls by tag alone, as before.
digest: ""
pullPolicy: IfNotPresent
imagePullSecrets: []
server:
replicaCount: 2
# Two by default because horizontal is the point. Everything that has to survive a replica is in
# PostgreSQL, and one replica hides every bug that is not.
# THE BROWSER IS NOT IN THIS POD. The image runs a Bot's computer beside the API for the
# one-container case; a replica of the API must not carry one, because a browser is a few hundred
# megabytes holding one Bot's logins, and scaling the API would scale those with it.
embeddedComputer: false
resources:
requests:
cpu: 250m
memory: 512Mi
limits:
memory: 2Gi
# Off by default. Turn it on and set the metric you actually want to scale on.
autoscaling:
enabled: false
minReplicas: 2
maxReplicas: 10
targetCPUUtilizationPercentage: 70
targetMemoryUtilizationPercentage: null
behavior: {}
podDisruptionBudget:
enabled: true
minAvailable: 1
maxUnavailable: null
# Spread replicas so a node or zone going away does not take the deployment with it. Soft by
# default: a single-node cluster still schedules, which is what a first `helm install` runs on.
topologySpreadConstraints: []
podAntiAffinity: soft
nodeSelector: {}
tolerations: []
affinity: {}
podAnnotations: {}
podLabels: {}
service:
type: ClusterIP
port: 3001
annotations: {}
# WHO MAY REACH IT, when the type is LoadBalancer. Empty means everybody, which is what a cloud
# load balancer does by default and almost never what somebody wants for an internal tool. Narrow
# it to the addresses your people come from. Not every cloud honours this on every load balancer
# type, so treat it as one layer rather than the only one.
loadBalancerSourceRanges: []
# Probes hit the API's own health route.
livenessProbe:
initialDelaySeconds: 20
periodSeconds: 20
timeoutSeconds: 5
failureThreshold: 6
readinessProbe:
initialDelaySeconds: 5
periodSeconds: 10
timeoutSeconds: 5
failureThreshold: 3
startupProbe:
periodSeconds: 5
failureThreshold: 60
serviceAccount:
create: true
name: ""
# ONE MAP, THREE CLOUDS. IRSA on EKS, Workload Identity on GKE and on AKS are all annotations on a
# ServiceAccount, so this covers every one of them and the chart needs no idea which it is on.
# eks.amazonaws.com/role-arn: arn:aws:iam::<account>:role/<role>
# iam.gke.io/gcp-service-account: <name>@<project>.iam.gserviceaccount.com
# azure.workload.identity/client-id: <client-id>
annotations: {}
automountServiceAccountToken: false
# The database migrations, run as a Job before the API starts. A pre-upgrade hook, so a rollout
# never puts a new replica in front of a schema it has not seen.
migrations:
enabled: true
backoffLimit: 3
# How long to wait for the database to accept connections before giving up. A pre-install hook runs
# before the chart's own resources, so on a first install with the bundled database this Job starts
# before the database does.
waitForDatabaseSeconds: 300
# A ceiling on the whole Job, so a migration that hangs fails the release rather than holding it.
activeDeadlineSeconds: 900
# Kept on failure so somebody can read why. Helm deletes it before the next run.
resources:
requests:
cpu: 100m
memory: 256Mi
limits:
memory: 1Gi
# What OpenBot needs to run. Anything secret belongs in `secrets` below, never here.
config:
# Where people reach this deployment. Sets the OAuth callback and the trusted origin.
publicUrl: ""
# Web Bot Auth: every request a Bot's browser makes is signed as coming from this deployment, and
# the public key is published at `<publicUrl>/.well-known/http-message-signatures-directory`, so a
# site behind Cloudflare that allows signed agents lets the Bot through instead of challenging it.
# Off unless "on": signing announces the deployment's URL to every site a Bot visits. "on" needs an
# https `publicUrl` (verifiers fetch the key from it) and earns nothing until the deployment is
# registered with Cloudflare, a manual step described in the chart README. The key is derived from
# `secrets.keyEncryptionKey` unless `secrets.webBotAuthKey` gives one.
webBotAuth: ""
# Administrators by email address, comma-separated. Required unless singleUser is on.
initialAdminEmails: ""
# Email domains admitted at sign-in, comma-separated. Empty admits everybody, which is what the
# providers below already do on their own: the Entra tenant is `common` unless you set it, which
# is any Microsoft account including personal ones, and Okta has no equivalent setting.
#
# A filter, not a boundary. It is checked against the address the provider returns, and OpenBot
# does not require a verified one, so the server REFUSES this combined with an Entra tenant of
# `common`: there the address is written by the tenant signing in. Set `auth.microsoft.tenantId`.
#
# Matched exactly, no wildcards: `example.com` admits neither `sub.example.com` nor
# `evil-example.com`. Name every domain your staff use.
allowedEmailDomains: ""
# Every request is one fixed administrator. Local trials only; the deployment refuses to start
# with no identity provider unless this says somebody meant it.
singleUser: false
# How people sign in. One of these, or `singleUser` above, and nothing else will do: the server
# refuses to start rather than serve a deployment where every visitor is an administrator.
#
# Client secrets go under `secrets` below. Only the public halves belong here.
auth:
google:
clientId: ""
microsoft:
clientId: ""
# `common` is Microsoft's own default and admits personal accounts as well as work ones. A
# company that means "our staff" puts its directory GUID here.
tenantId: ""
okta:
clientId: ""
issuer: ""
tenantPackageDir: /app/examples/fintech
# CopilotKit Intelligence, which OpenBot requires. All four values are needed together: the server
# refuses to start on a partial set, deliberately, because a half-configured Intelligence is a
# mistake somebody made rather than a deployment that meant to run without one.
intelligence:
apiUrl: ""
gatewayWsUrl: ""
# The two secret halves live under `secrets` below, never here.
# Learning defaults on; collection and delivery require an existing, assigned container.
# With nothing saved in Admin and no containerId below, the server assigns the project's openbot
# container on its own once it exists. The runtime key cannot create it, so `setup` below gives the
# chart a credential that can; without one, the server log and Admin → Automatic Learning say
# exactly what to run (scripts/setup-learning.ts, from a computer that can sign in to Intelligence).
# Optional initial defaults; saved Admin → Automatic Learning settings take precedence, including off.
learning:
containerId: ""
revision: ""
# false stops the automatic assignment (OPENBOT_LEARNING_AUTO_ASSIGN=false).
autoAssign: true
# Creating the container. Name either Secret and a Job runs on every install and upgrade that
# creates it in the runtime key's project, proves it with that key, and exits; the server then
# assigns it. Both Secrets are yours: create them before installing.
setup:
# A CopilotKit CLI login, for managed Intelligence. Sign in into an empty folder and store the
# file it writes (a person's 30-day session, so keep the Secret as tight as that warrants):
# COPILOTKIT_CONFIG_DIR="$(mktemp -d)"; export COPILOTKIT_CONFIG_DIR
# npx --yes copilotkit@latest login
# kubectl create secret generic openbot-copilotkit-cli \
# --from-file=config.json="$COPILOTKIT_CONFIG_DIR/auth/config.json"
# The Job reads it once. The server never holds it.
cliLoginSecret:
name: ""
key: config.json
# An Intelligence service token, which creates Learning containers on a CopilotKit local
# evaluation install only. Requires projectId: the numeric ID of the runtime key's project.
# Passed to the server too, so Admin → Automatic Learning can create the container again.
serviceTokenSecret:
name: ""
key: token
projectId: ""
# Memory sources and background research, on by default for each person and Bot (OpenBot turns
# them on when a person talks to a Bot, and never back on once the person turns one off or removes
# it). false stops new defaults for the whole deployment; existing settings are left as they are.
memory:
sourceDefaults: true
researchDefaults: true
# How far one Bot may hand work to another.
#
# A Bot addressing another is a grant an administrator makes, and these are the ceilings on what
# that grant can cost. Both are deliberately mean: a hop is a whole agent turn at the other end,
# several Bots asked in one turn cost several full runs rather than a fraction each, and with
# `computers.mode: sandbox` a hop to a Bot whose browser is asleep also pays a pod resume. A chatty
# Bot fanning out to four others wakes four machines.
#
# `maxDepth: 0` switches the capability off entirely: no Bot is offered the tool and the delivery
# loop does not run.
handoff:
maxDepth: 1
maxPerRun: 3
# Your own Bot, over AG-UI.
#
# OpenBot is a shell for somebody else's agent, so this is the seam that matters: point it at a
# service you run and coworkers created here reach it. Left empty, this deployment has only the
# Bots its tenant package declares as built-in, and a package entry whose endpoint resolves to
# nothing is dropped rather than registered as a coworker nobody can talk to.
#
# The address must be reachable from the server pod, so a Service in this cluster is named as
# `http://my-agent.my-namespace:8000/ag-ui`, not as localhost.
managedAgent:
url: ""
# The token travels in `secrets.managedAgentToken`. Required whenever a url is set: the server
# refuses to start with one and not the other, because an unauthenticated Bot endpoint is an
# open door to whatever that Bot can reach.
# Slack and Microsoft Teams, through the OpenTag pairing.
#
# `enabled` is the switch, rather than the secret's presence, because a secret held in
# `secrets.existingSecret` or a store is not readable at template time. The shared secret travels in
# `secrets.opentagSharedSecret`; the server refuses one shorter than 32 characters, and refuses a
# `url` or icon template with no secret at all.
opentag:
enabled: false
# OpenTag's base URL, for messages sent when no Slack turn is open. Without it those sends fail
# visibly in the outbox and Slack triggers are refused. Must be http(s).
url: ""
# Optional https PNG URL with `{seed}` or `{agentId}`, used as the Bot's Slack icon.
botIconUrlTemplate: ""
# Text messages, through Twilio. The server takes all four Twilio settings or none, so `enabled`
# needs the three below and `secrets.twilioAuthToken`.
sms:
enabled: false
accountSid: ""
verifyServiceSid: ""
fromNumber: ""
# Push notifications and sign-in from the native app, through Expo.
#
# Setting `projectId`, the app's EAS project UUID, switches both on; the server refuses anything
# that is not a UUID. `secrets.expoAccessToken` is optional and sent to Expo's push service when set.
push:
projectId: ""
# The public origin Twilio calls back on, when it is not `publicUrl`. Twilio signs each request over
# the URL it was given, so this has to be the address Twilio was configured with. Must be http(s).
deliveryPublicUrl: ""
# SCIM provisioning at `<publicUrl>/api/auth/scim/v2`.
#
# `enabled` needs `secrets.scimBearerToken`, the token the directory sends. A second token in
# `secrets.scimBearerTokenNext` is accepted beside it, so the directory can move to a new one before
# the old one is removed.
scim:
enabled: false
# The name of the directory connection. Empty means the server's default, `directory`.
connectionId: ""
# Inbound email triggers: an SES receipt rule delivering through SNS to
# `<publicUrl>/api/events/email/sns`. Both are needed; with either missing the route is not mounted.
inboundEmail:
# The domain the receipt rule covers, such as `in.example.com`.
domain: ""
# Comma-separated ARNs of the SNS topics allowed to deliver mail.
snsTopicArns: ""
# Every audit row as an OTLP log record over HTTP, for a SIEM or an OpenTelemetry Collector.
#
# Setting either endpoint switches export on. Headers, which usually carry a collector's API key,
# are secrets: `secrets.otelHeaders` and `secrets.otelLogsHeaders`, as `key=value` pairs separated
# by commas. With `networkPolicy.enabled`, a collector inside the cluster has to be named in
# `networkPolicy.extraEgress`.
otel:
# Collector base URL; the server appends `/v1/logs`.
endpoint: ""
# Where log records go, used exactly as written. Takes precedence over `endpoint`.
logsEndpoint: ""
# The `service.name` on every record. Empty means the server's default, `openbot`.
serviceName: ""
# Stops export while an endpoint is still set.
paused: false
logLevel: ""
# Free-form additions, for anything this chart has no opinion about.
extraEnv: []
extraEnvFrom: []
# Volumes, and where to mount them, on every pod that loads this deployment's configuration: the
# server and the routines and computer-culler CronJobs, the same pods `extraEnv` reaches. The usual
# reason is a tenant package of your own, from a ConfigMap, with `tenantPackageDir` pointed at its
# mount; every one of those pods reads the package, so mounting it on the server alone is not enough.
#
# extraVolumes:
# - name: tenant
# configMap: { name: my-tenant-package }
# extraVolumeMounts:
# - name: tenant
# mountPath: /tenant
# readOnly: true
extraVolumes: []
extraVolumeMounts: []
# How a Bot gets a computer.
#
# shared One browser for every Bot, run by this chart. Needs nothing installed in the cluster,
# and is what a first install should use. Each person's Bots keep their own logins
# and files, but a command one Bot runs can read another's files. For that reason a
# person's own OpenBot browser does not run here, and nobody records in a Bot's browser:
# the Browser page and the Bot's screen say so.
# sandbox A computer for each person, and for each Isolated Bot, as a `Sandbox` from
# kubernetes-sigs/agent-sandbox, suspended when idle and resumed with its logins
# intact. Needs that controller in the cluster. Each person's own OpenBot browser gets a
# computer of its own the same way.
# external Neither. `url` points at a computer somebody else runs, which is shared like the
# first, so it runs no person's browser and records in no Bot's browser either.
computers:
mode: shared
# Only for `mode: external`. The other modes derive the address from what they created.
url: ""
# Never a literal. See `secrets` below.
existingTokenSecret: ""
# gVisor or Kata, where the cluster has one. Unset means an ordinary pod, because the three clouds
# do not agree: GKE has managed gVisor, AKS offers Kata and gVisor, and on EKS it is bring your own
# node configuration. A chart that assumed a RuntimeClass would fail to install without one.
runtimeClassName: ""
# Who the browser and the Bot's shell run as.
#
# KUBERNETES ONLY, and that is the scope rather than the whole of #261. The chart runs the
# all-in-one image, whose `Dockerfile` creates `pwuser`, chowns `/workspace`, `/profiles` and
# `/app` to it, and drops to it through s6. A computer pod overrides the command to run the
# browser process alone, so it never reaches s6 and ran as uid 0. The Compose and supervisor
# paths run `agent-computer/Dockerfile`, which builds no such user and is still uid 0; that is
# the rest of #261's residual and is not this.
#
# WHAT IT BUYS, honestly. It is not a containment boundary against a Bot's own shell: the image
# grants `pwuser` passwordless sudo for apt-get/apt/dpkg, and those escalate to root by design
# (`-o APT::Update::Pre-Invoke=`). gVisor and a computer per Bot remain the actual boundary. What
# this does buy is real and separate: the org policies and admission rules that reject uid 0
# outright, root-owned data stops accumulating in the volumes, and any bug yielding a constrained
# primitive lands as 1001 rather than as root.
#
# It does NOT move the pod between Pod Security Standards. `runAsNonRoot` is a restricted control
# rather than a baseline one, and restricted also wants `allowPrivilegeEscalation: false`,
# `capabilities.drop: [ALL]` and a seccomp profile, none of which are set here. Baseline was
# already met; restricted still is not.
#
# 1001, not 1000, because the base is `ubuntu:24.04` and its own `ubuntu` user already holds 1000.
# Verified by creating the user the way the Dockerfile does:
# docker run --rm ubuntu:24.04 sh -c 'useradd -m pwuser; id pwuser' -> uid=1001(pwuser)
#
# `fsGroup` is what makes an existing volume usable: it is created root-owned and the kubelet
# applies the group on mount. `OnRootMismatch` is not a detail. Unset means `Always`, which walks
# every file on EVERY mount, and a real Chromium profile is tens of thousands of small ones: in
# `mode: sandbox` that pass would run again on every resume from idle, which is the latency
# agent-sandbox exists to avoid. `OnRootMismatch` runs it once, when the root still says root.
#
# A NOTE ON STORAGE. The kubelet applies fsGroup only where the volume plugin says it can.
# The EBS, PD and Azure Disk CSI drivers do. `hostPath` does not, and that is what
# rancher/local-path-provisioner hands out by default, which is the default StorageClass on k3s.
# There the computer now refuses to start with a message saying so, rather than coming up healthy
# with an empty profile.
#
# Set `computers.podSecurityContext: null` to go back to running as root.
#
# NOTHING ELSE IS SET HERE ON PURPOSE. A capability drop was proposed in #262 and declined,
# because gVisor is the sandbox boundary this ships and `apt-get` in a Bot's shell needs CHOWN,
# DAC_OVERRIDE, FOWNER, SETUID and SETGID. `allowPrivilegeEscalation: false` is the same question
# wearing a different hat: it is `no_new_privs`, which turns off the setuid bit `sudo apt-get`
# depends on. The supervisor path already makes that trade (`docker.ts` sets
# `no-new-privileges:true`), and can, because the image it runs installs no sudo at all. Add
# either here if your deployment wants it and your Bots never install packages.
podSecurityContext:
runAsNonRoot: true
runAsUser: 1001
runAsGroup: 1001
fsGroup: 1001
fsGroupChangePolicy: OnRootMismatch
# How many browsers one computer holds at once, and how long an untouched one is kept. Empty means
# the process default, which is a handful and thirty minutes.
maxBrowsers: ""
browserIdleMs: ""
# At what share of the pod's memory limit the computer starts closing browsers nobody is using,
# least recently used first, down to ten points under it. Measured as the kubelet measures it (the
# working set), before each launch and once a minute: it stops idle browsers filling the pod one
# launch at a time, and a page that grows between two checks can still run the pod out of memory.
# Empty means 85; 0 switches it off.
memoryHighPercent: ""
# How long a Bot's background tab (one it left behind, such as the page a sign-in popup opened from)
# is kept untouched before it is closed. The page the Bot is on is never closed. Empty means ten
# minutes; 0 keeps them.
tabIdleMs: ""
# Which Chromium a Bot's computer runs. `headed` is full Chromium drawing to the pod's own X server
# (Xvfb, started by the computer), behind the same streamed screen: it is what sites see from a
# person's browser, and Cloudflare's bot check challenges it far less than headless Chromium. Costs
# a little more memory and CPU than `headless`, which is still available.
browserMode: headed
# A residential or ISP proxy for every Bot's outbound traffic. OFF BY DEFAULT, and an operator's
# choice to make knowingly: through one, a Bot's traffic leaves from an address a consumer ISP owns,
# so a site sees what looks like a person at home rather than a datacenter. That is the point (a
# datacenter address is the other thing bot checks key on) and also the thing to be comfortable
# with. The credentialed URL (`http://user:[email protected]:8000`) is a secret:
# `secrets.egressProxyUrl`, or a key in a Secret of your own. It reaches every computer as
# `EGRESS_PROXY_DEFAULT`, behind the egress filter, so the network policy still decides what a Bot
# may reach. With `networkPolicy.enabled`, also name the proxy in
# `networkPolicy.computerExtraEgress`. One Bot's own proxy is still `EGRESS_PROXY_<BOT>` in
# `extraEnv` below.
egressProxy:
enabled: false
# Empty uses the chart's Secret (`secrets.egressProxyUrl`).
existingSecret: ""
existingSecretKey: egress-proxy-url
persistence:
# EMPTY MEANS THE CLUSTER'S DEFAULT CLASS. Naming `gp3` or `pd-balanced` is how a chart stops
# installing on a bare-metal cluster. Note that the ordinary block volume on every cloud is
# zonal, so a computer is pinned to the zone its profile was created in.
storageClass: ""
profilesSize: 10Gi
workspaceSize: 10Gi
# What happens to a Bot's logins when the release is deleted. `Retain` keeps them, which is the
# safe default; `Delete` is for a trial you want to leave no trace of.
whenDeleted: Retain
# SIZED FOR A PERSON, NOT A BOT. A computer is one person's and runs a browser for each of their
# Bots in use at once, up to `maxBrowsers` (8 when empty), closing each after `browserIdleMs`
# untouched (30 minutes when empty). Chromium is roughly 200-500MB per browser (a little more
# headed, plus a few MB for Xvfb) and up to 2GB with real pages open. Running out of memory takes
# down every one of that person's browsers at once, so size the limit to `maxBrowsers` times what
# one browser takes on your Bots' sites, plus headroom; on a small node, lower `maxBrowsers` (the
# least recently used browser closes first) rather than the limit.
resources:
requests:
cpu: 500m
memory: 2Gi
limits:
memory: 8Gi
nodeSelector: {}
tolerations: []
# Free-form additions, and where a Bot's outbound address is set. `EGRESS_PROXY_DEFAULT` covers
# every Bot and `EGRESS_PROXY_<BOT>` names one, upper-cased with anything unusual replaced, so
# `sales-bot` reads `EGRESS_PROXY_SALES_BOT`. Both reach the computer whichever mode it runs in.
# With `networkPolicy.enabled` the proxy also has to be named in
# `networkPolicy.computerExtraEgress`, or the computer cannot reach it.
extraEnv: []
# `mode: sandbox` only. Where the per-Bot computers are created and what may create them.
sandbox:
# Refuse to install when the cluster has no Sandbox CRD, rather than succeeding and failing at
# the first browser action. Turn it off only where the CRD arrives after this chart does, such as
# a GitOps run that applies both together.
requireController: true
namespace: ""
# Pre-warmed sandboxes, so a Bot's first action after lunch does not wait for Chromium to boot.
#
# Not usable yet, and the chart refuses to render with it on. A Bot reaches a warm sandbox by
# claiming it, and nothing in the server creates a SandboxClaim: `locate` posts a new Sandbox and
# waits for it, pool or no pool. Left here, with the template and the RBAC beside it, because the
# missing half is the claim rather than any of this.
warmPool:
enabled: false
replicas: 2
# Suspend a computer nobody has used for this long. The Sandbox CRD has an absolute expiry, which
# is not the same question, so the culler below asks this one.
idleAfter: 30m
culler:
# A ceiling on one sweep. `concurrencyPolicy: Forbid` means a sweep that hangs holds the lock
# for ever and culling stops silently, which is the failure this feature exists to prevent.
activeDeadlineSeconds: 600
enabled: true
schedule: "*/5 * * * *"
# Standing instructions a Bot runs on a schedule. The sweep offers due routines to the shared work
# queue and hands each firing to the API server, which runs the turn as the person who scheduled it.
routines:
# Off by default, because it needs a secret. Without `secrets.workerSharedSecret` the API server
# refuses every handoff, and a CronJob whose every run is a 401 is worse than no CronJob at all.
enabled: false
# Inside the 15-minute floor the tools enforce, so a firing waits at most one tick.
schedule: "*/5 * * * *"
# Deleting attachments somebody staged and then never sent. `attachedAt` stays null until an
# attachment is actually sent, and the upload endpoint counts exactly those null rows against two
# separate caps: eight per composer session, which is the per-message limit the composer's own screen
# enforces, and 32 per PERSON across every channel and every session at once, which is the one that
# makes this sweep load-bearing.
#
# The second cap is why never running this is worse than growth. The per-session eight is counted
# over a bucket the client names in its own request, so a new tab is a new bucket and it bounds a
# client that plays along and nothing else. The per-person 32 is not: it is every unsent row that
# person holds anywhere, and the refusal they see on the 33rd file tells them anything still unsent
# is cleared within a day, which is a promise made on this sweep's behalf. With the sweep off, a
# changed mind is a permanent dead end naming files that are no longer on anybody's screen, and
# anybody who reaches 32 can attach nothing, in any channel, for good.
attachments:
culler:
# On by default, unlike `routines` above: this needs nothing but the database, which every
# deployment already has, so there is no failure mode where enabling it does more harm than the
# rows it was written to remove. Nothing but the database is meant literally — the script reads
# `DATABASE_URL` and no other variable, which is why this CronJob carries no secret at all.
enabled: true
# Hourly, not the five-minute schedule the other two CronJobs use: nothing here is time-sensitive
# the way a due routine or an idle browser is.
schedule: "0 * * * *"
# How long a staged attachment is kept before the sweep deletes it. Matches the script's own
# fallback, so leaving this out and never running the CronJob behave alike.
#
# A fraction is a fraction of an hour: `0.5` is thirty minutes. Be sure that is what you want —
# this deletes files a person picked in the composer and has not sent, and a window shorter than
# somebody's train of thought deletes one out from under them while the tab is still open.
olderThanHours: 24
# A ceiling on one sweep, because `concurrencyPolicy: Forbid` turns a hung one into a permanent
# stop. A deployment arriving with a large backlog does not need it raised: the sweep deletes in
# bounded batches, each its own transaction, so a run stopped at the ceiling keeps what it
# committed and the next one carries on from there. Raising it drains that backlog in fewer runs.
activeDeadlineSeconds: 300
database:
# Used when `postgresql.enabled` is false. A URL, or a secret holding one.
#
# PUT `?sslmode=require` ON IT. Every managed database refuses an unencrypted connection: RDS has
# `rds.force_ssl` on by default, and Cloud SQL and Azure Database do the same. Without it the
# migration fails with `no pg_hba.conf entry for host ... no encryption`, which names the host and
# the user and not the actual problem.
#
# postgres://user:password@host:5432/openbot?sslmode=require
#
# Keep it in a Secret rather than here: `url` is readable by anybody who can read the release.
url: ""
existingSecret: ""
existingSecretKey: "database-url"
# The bundled database. Off by default in favour of a managed one.
# The bundled database.
#
# NOT PRODUCTION-GRADE, AND OFF FOR THAT REASON. A database on a pod is a database that goes away
# when the pod does: a rollout, a node drain or an evicted pod is a restart, and while the volume
# survives, nothing about this shape gives you backups, failover, point-in-time recovery or a
# connection that outlives the release. It exists so somebody can try OpenBot in one command.
#
# A REAL DEPLOYMENT POINTS `database` ABOVE AT A MANAGED DATABASE: RDS, Cloud SQL, Azure Database, or
# your own server. That is the same line the Intelligence chart draws, and for the same reason.
postgresql:
enabled: false
auth:
# THE SUPERUSER, DELIBERATELY, AND ONLY FOR THIS BUNDLED DATABASE.
#
# The first migration runs `CREATE EXTENSION vector` and a later one drops it again, and only a
# superuser can do either. An ordinary role fails the install at migration one with "permission
# denied to create extension", which reads like a broken chart rather than a database privilege.
#
# This is the shape `docker-compose.yml` already ships, where the app user is the cluster
# superuser, and it is safe for the same reason: this database exists for this release alone and
# nothing else can reach it.
#
# A MANAGED DATABASE IS NOT THIS. On RDS, Cloud SQL or Azure there is no superuser to hand out,
# so create the extension once as the administrative role and grant the migrating role ownership
# of it. `CREATE EXTENSION IF NOT EXISTS` then passes for an ordinary user.
username: postgres
database: openbot
# SET ONE, OR UPGRADES FAIL. The subchart generates a password on install and then refuses to
# render on upgrade unless it is given the current one, which turns the second `helm upgrade`
# into an error about credentials. A password you chose, or a Secret you made, makes the release
# repeatable. The chart refuses to install without one rather than letting you find out later.
password: ""
existingSecret: ""
image:
# Bitnami moved its unsupported images to this frozen mirror. Nothing new lands here, so the tag
# is named rather than inherited from the subchart: with it inherited, bumping the subchart
# silently asks for an image the mirror does not have, and the chart still renders perfectly.
repository: bitnamilegacy/postgresql
tag: 17.6.0-debian-12-r4
primary:
# PINNED, BECAUSE THE SHIPPED DEFAULT ADMITS EVERYTHING.
#
# The subchart renders its NetworkPolicy whether or not this chart's own is enabled, and with
# `allowExternal: true` its ingress rule carries no `from` at all: any pod in any namespace may
# open 5432. That includes a Bot's computer, the one pod running a browser on pages a person
# named and a shell on commands a model chose. Compose has kept the database off the Bot's
# network since the beginning; this is the same boundary in the other deployment's words.
#
# With this off, the database admits pods labelled `<release>-postgresql-client`, which the API
# server carries and nothing else does.
networkPolicy:
allowExternal: false
allowExternalEgress: false
persistence:
enabled: true
# EMPTY MEANS THE CLUSTER'S DEFAULT CLASS, and that is deliberate. Naming `gp3` or
# `pd-balanced` here is exactly how a chart stops installing on somebody's bare-metal cluster.
storageClass: ""
size: 20Gi
# Secrets, without picking a vendor.
#
# A plain Kubernetes Secret is the default because that is what a self-hosted cluster has.
# `externalSecrets` turns the same fields into an ExternalSecret instead, so Secrets Manager, Secret
# Manager and Key Vault are a values block rather than three code paths.
secrets:
# Point at a Secret you made yourself, and the chart creates none.
existingSecret: ""
# Created by the chart when `existingSecret` is empty. Pass with --set-string or a values file that
# is not in version control; `KEY_ENCRYPTION_KEY` and the model credential are the two that matter
# and neither should ever be a literal in a file anybody commits.
keyEncryptionKey: ""
betterAuthSecret: ""
modelApiKey: ""
computerToken: ""
supervisorToken: ""
# From the CopilotKit CLI: `npx --yes copilotkit@latest project select` prints the runtime key.
# The chart refuses to install without it, because there is no mode where this runs with
# Intelligence missing.
intelligenceApiKey: ""
# Optional. Managed Intelligence issues no licence token; set this only for a self-hosted
# Intelligence that has one, and it is passed to the server as COPILOTKIT_LICENSE_TOKEN. From a
# store, name `license-token` in `externalSecrets.data` instead; it is passed the same way. That
# Intelligence needs the licence on its own deployment too, or it refuses memory.
licenseToken: ""
# Optional. One key for the whole deployment, for Composio, the broker holding people's accounts for
# a few hundred apps (docs/plugins/composio.md). Passed to the server alone as COMPOSIO_API_KEY.
# From a store, name `composio-api-key` in `externalSecrets.data` instead.
composioApiKey: ""
# Sent to `config.managedAgent.url` on every call. Required when that url is set.
managedAgentToken: ""
# Required when `routines.enabled`: what the CronJob presents to the API server to be recognised
# as the worker rather than as an unauthenticated caller.
workerSharedSecret: ""
# The client secret for whichever provider is configured above.
googleClientSecret: ""
microsoftClientSecret: ""
oktaClientSecret: ""
# Required when `config.opentag.enabled`. At least 32 characters. Generate one with:
# openssl rand -hex 32
opentagSharedSecret: ""
# Required when `config.sms.enabled`.
twilioAuthToken: ""
# Optional, with `config.push.projectId`.
expoAccessToken: ""
# Required when `config.scim.enabled`; the next one is optional, for rotation.
scimBearerToken: ""
scimBearerTokenNext: ""
# Optional, with `config.otel`. Headers for the logs endpoint, and the general ones used when the
# logs ones are unset.
otelLogsHeaders: ""
otelHeaders: ""
# Optional, with `config.webBotAuth`. An Ed25519 private key as a JSON Web Key, to sign with instead
# of the one derived from `keyEncryptionKey`. Read from key `web-bot-auth-key` of whichever Secret
# this chart uses, when present.
webBotAuthKey: ""
# Required when `computers.egressProxy.enabled` and no `existingSecret` is named there.
egressProxyUrl: ""
externalSecrets:
enabled: false
# Whatever your cluster's ClusterSecretStore or SecretStore is called. Backend-agnostic on purpose.
secretStoreRef:
name: ""
kind: ClusterSecretStore
refreshInterval: 1h
# remoteRef keys, one per secret this chart reads.
data: []
ingress:
enabled: false
# The controller differs on every cluster and always will, so this is a value with no default.
className: ""
annotations: {}
hosts:
- host: openbot.example.com
paths:
- path: /
pathType: Prefix
tls: []
# Gateway API, as an alternative rather than a replacement. Plenty of self-hosted clusters still run
# an Ingress controller, so both are here and neither is assumed.
httpRoute:
enabled: false
parentRefs: []
hostnames: []
networkPolicy:
enabled: false
# Where the API may reach out to. A deployment with a managed database adds its CIDR here.
#
# It already reaches HTTP and HTTPS everywhere outside the cluster's private ranges, because that
# is where Intelligence, sign-in and the Bots are. This is for anything on the private side.
extraEgress: []
extraIngress: []
# `computers.mode: sandbox` only. The service range the Kubernetes API server answers on, so the
# rule that lets the API ask for a Bot's computer can name it.
#
# REQUIRED once `enabled` is true and `computers.mode` is sandbox, and empty here because the range
# is the cluster's rather than the release's, so there is nothing this chart could put in its place.
# `kubectl get svc kubernetes -o jsonpath='{.spec.clusterIP}'` shows which one yours is on; on EKS
# it is usually 172.20.0.0/16, on GKE and kubeadm 10.96.0.0/12.
#
# Empty USED to mean unscoped, and unscoped was not a looser version of this rule — it was the
# absence of one. An egress rule with ports and no `to` matches every destination in Kubernetes, so
# the default granted 443 and 6443 to all of `10/8`, `172.16/12`, `192.168/16` and `169.254/16`,
# which are the four ranges the rule beside it exists to cut out. It is refused rather than skipped
# because skipping it is an outage nobody is told about: on a cluster that enforces policy the API
# server can no longer ask for a computer and every Bot action fails. A `helm upgrade` that stops
# here has changed nothing in the cluster; set this and run it again.
kubernetesApiCidr: ""
# Where a Bot's computer may reach beyond the public internet. A deployment whose Bots must reach
# an internal site adds it here, one address at a time, rather than reopening the private ranges.
computerExtraEgress: []
# Extra egress for the culler. Empty falls back to `extraEgress`, where an external database is
# already named; set it to give the culler a narrower list.
cullerExtraEgress: []
# The same, for the routines sweep.
routinesExtraEgress: []
# The same, for the attachments culler.
attachmentsCullerExtraEgress: []
podSecurityContext:
runAsNonRoot: false
fsGroup: null
securityContext: {}
# Applied to every pod this chart creates.
commonLabels: {}
commonAnnotations: {}