Skip to main content

Overview

The Air-Gapped edition runs the full platform in your environment, no internet access required*: the web UI, the control plane services, a self-hosted Supabase stack (auth, storage, edge functions), and the data tier (PostgreSQL, Redis Stack, MongoDB). One Helm release, one namespace, zero connection to xpander Cloud. Nothing is sent to xpander: no heartbeats, no catalog sync, no telemetry. Entitlement is a signed Ed25519 license verified in-cluster. As in every self-hosted edition, MCP and external-system calls run from your cluster, and agent workspaces (the agents’ computers) run there too. It installs anywhere without an internet connection: a cloud VPC in private mode (no internet or NAT gateways), or any disconnected compute environment. *Except outbound traffic you choose to allow: LLM providers, plus MCP and connector calls to external systems.

Air-Gapped Security Architecture

Zero egress to xpander Cloud, signed Ed25519 license, local sign-in, and what stays in your environment. Diagrams live on that page. This guide does not repeat them.
Three things define an air-gapped install:
  1. The license file is the identity. It carries your organization id: there are no console IDs and no API key. The installer generates the environment id, and the first install’s seed pipeline creates everything else in-cluster, including your organization. Single-tenant: the license binds one organization.
  2. Images come from your own registry mirror. xpander delivers the artifact set through the gated xpanderaihub Docker Hub org with a per-customer read token; the installer mirrors it into a registry your cluster can reach, or you run the mirroring yourself on a sealed network.
  3. Image tags are pinned per release. The chart refuses to render against unpinned images, and upgrades require mirroring the new bundle first.
The install runs through xpander’s interactive installer wizard, invoked with --edition airgap. The flag selects the air-gap flow: a pre-install checklist, license validation, registry mirroring when needed, and a live watch over the chart’s install pipeline.
“Air-gapped” means air-gapped from xpander’s cloud, not necessarily from the internet. Internet-backed agent tools (web search, docs search, TTS) can stay enabled through the chart’s internet-posture setting, or be sealed off entirely. Ask your xpander contact about the sealed hardening profile.

What Talks to What

The network surface in both directions: the answers a security review needs. Outbound (from your cluster). Nothing is required; there is no connection to xpander at all. Inbound (from your users to your cluster). These are your network requirements for reaching the platform. All of them land on your ingress controller, over whatever path your network provides (internal DNS, VPN, private load balancer); see Domains, Ingress & DNS:

Prerequisites

To compare against the currently published requirements, see the chart’s requirements.json. Harness agents (Claude Code / Codex / OpenCode) are the default for every new agent and run on the executor fleet, which adds to these numbers and brings its own node prerequisites (privileged pods, cgroup v2, XFS with prjquota); see Harness Agents: Sizing and Requirements. The fleet is always rendered and starts warm with one executor. Its one storage prerequisite is a StorageClass that mounts XFS with prjquota for the 500 GiB per-executor volume: bring that class under the name in global.fleet.storage.className (fleet-xfs; createClass: false is the Air-Gapped default), or set global.fleet.storage.createClass: true on EKS to let the chart render it for the EBS CSI driver (ebs.csi.aws.com, gp3, encrypted). On a live cluster where that class is missing (or where the driver named in provisioner is not installed), the chart renders the executor idle at replicas: 0, annotated xpander.ai/fleet-idle-reason, so an --atomic install or upgrade never waits on a volume that cannot bind; create the class and the next upgrade brings the executor up.

Sizing Tiers

The Air-Gapped edition runs the whole platform in-cluster: the worker plane plus the control plane services, the web UI, the Supabase stack (its own PostgreSQL 15, auth, storage, edge functions), and MongoDB. Storage breakdown at the production tier: Supabase PostgreSQL 50 GiB, platform PostgreSQL 50 GiB, Supabase Storage 50 GiB+, MongoDB 20 GiB, Redis 8 GiB, registry ~50 GiB, mirror caches 50–100 GiB. All RWO, one StorageClass (the chart’s preflight verifies it exists). Most services default to a single replica; deployment-manager, actions, and the Supabase edge runtime ship at ×2 replicas with soft anti-affinity out of the box. For production, run the rest of the hot path at ×2 as well: agent-controller, agent-worker, api, agents, functions.

Scaling with Usage

The chart ships fixed replica counts and no autoscalers: scaling policy is yours. What actually grows with usage, and how to scale each: Node capacity: workspaces and code-execution Jobs create pods on demand, so the real ceiling on concurrent agent activity is how many nodes you have. Two workable postures:
  • Static capacity: size the node group for your peak concurrent workspaces and leave it fixed. Simplest, fully offline, and the recommended posture for sealed networks.
  • Cluster Autoscaler: adds nodes automatically when pods can’t schedule. It works in a no-internet VPC, but it talks to your cloud’s scaling API to do its job, so that API must be reachable from inside the network (on AWS: the autoscaling and ec2 VPC endpoints).
Karpenter is not a good fit for sealed networks: it fetches instance pricing data from the internet.

Install in Three Steps

1

Receive the license and pull token by email

The xpander.ai team issues and emails you two things: license.json, the signed xpander-license/v1 envelope that is both your entitlement and your identity (it carries your organization id; preflight validates its shape, expiry, and Ed25519 signature), and a registry pull token for the gated xpanderaihub Docker Hub org (read-only, scoped to your account, individually revocable; it gates delivery only, the license is the enforcement).
2

Run the one-liner

The license file is the identity. Nothing else needs to be filled in up front:
The command downloads the installer from charts.xpander.ai and runs an interactive wizard: preflight checks, configuration, Helm install, and a seeded admin login to sign in with when it finishes. Run it from a terminal with kubectl access to the target cluster.The wizard prompts for the rest: registry, chart source (OCI pull or local path), data tier, admin email, organization display name, StorageClass, whether to enable agent code execution (--code-execution / --no-code-execution; the runner embeds dockerd, so its pod must be privileged, and a restricted PodSecurity policy refuses it), and a base domain for the public hosts, then the LLM provider keys, for any hosted providers your egress policy allows. Image tags are not typed in: they are read from the release.If your registry has no xpander images yet, the wizard detects it and offers to mirror them right there: it asks for the pull token from step 1, copies every image with per-image progress, and creates ECR repositories automatically. On a sealed network, choose the runbook option instead and see Sealed / manual mirroring.
3

Sign in as the seeded admin

The first install’s seed pipeline creates your organization and a bootstrap admin user in your own in-cluster Supabase. The closing summary prints the sign-in commands: see Signing In.
A complete non-interactive invocation (image tags resolve from the mirror unless pinned):
Prefer to see every command before anything runs? bash install.sh --edition airgap --manual prints the whole install as a personalized, copy-pasteable runbook and executes nothing: see Advanced: review-first / manual install.

What Happens When You Run the Installer

The full anatomy of an install, in order. Steps 1–6 take a few minutes altogether; step 7, the cluster actually coming up, is the long one, typically 10–20 minutes. Each phase is announced as a stable [N/8] name: ... progress line (the shape scripts grep, see Automation & CI).
Wherever a step can fail, the failure is specific: every hook failure names the Job, prints its last 30 log lines, and closes with a FIX: line (the repair) and a RERUN: line (your personalized command to resume). Nothing needs diagnosing from scratch.
1

Resolve: load the latest release

Each xpander image has its own version. The installer loads one release manifest that lists the matching version and SHA-256 digest for all 27 xpander images. It writes those pins into the values passed to Helm.The default is the latest release. To repeat a release or install offline, pass --release-manifest ./release-manifest.json. A missing or invalid manifest stops the operation. How release selection works.
2

Checklist: preconditions verified before anything changes

Every requirement is checked and printed with the reason it matters: the registry answers /v2/ (a 401 counts as up), representative images (agent-controller, deployment-manager) exist in the mirror, each probed at its own pinned tag, a usable RWO StorageClass exists, the image pins are in place (N images pinned, each at its own version), the org seed has its inputs (--org-name + --admin-email), and a chart source exists. Any failed item stops the run here, with nothing to clean up.
3

License: validated locally, applied as a Secret

The license file is checked (JSON shape, the xpander-license/v1 envelope, expiry, the org id it is bound to), then applied idempotently as the xpander-license Secret. The chart wires it to every license-consuming service and verifies the Ed25519 signature against xpander’s issuer public key: in the preflight hook, and again at deployment-manager boot.
4

Chart: pulled over OCI

The xpander-airgap chart is pulled from the gated OCI registry with your read token, or from your own mirror if you mirrored the chart next to the images, or from a hand-carried .tgz via --chart-path.
5

Values: secrets never touch the command line

Your configuration is written to a temporary values file (mode 600, removed on exit) together with the pinned image manifest. Secrets never appear on the helm command line, in shell history, or in process listings.
6

Install: helm, without --atomic on purpose

helm upgrade --install runs in the background (its log path is printed). The first install deliberately runs without --atomic: --atomic implies --wait, which would hold the post-install seed hooks until every pod is Ready, while the api and agent-controller pods are themselves waiting on that seed. The smoke hook (step 7) is the real readiness gate. Upgrades always run with --atomic: a failed upgrade rolls back automatically and the previous revision keeps serving.
7

Pipeline: the cluster comes up, hook by hook (10–20 min)

The chart installs through an ordered hook pipeline; the installer watches it live and reports each stage as it starts and completes:
8

Summary: URLs, password, logs

A closing box prints the release facts, the derived URLs (with a base domain set: the UI at https://chat.<domain>, the API at https://api.<domain>, Supabase at https://supabase.<domain>), and the bootstrap admin password itself, plus the command to read it again later:
The full session log (secret-scrubbed, mode 600) is saved under ~/.xpander/logs/: latest.log always points at the most recent run, ready to review and share with support if you need help.

Releases

Helm remains the deployment mechanism. The release manifest supplies the xpander image versions and digests to Helm; it does not install workloads itself. The installer and mirror tool default to the release manifest in the latest release. Each manifest identifies one complete set of 27 xpander images, including the UI, services, migrations, edge functions, agent runtime images, skills, catalog, and icons. A newer tag in a registry does not change this set.
  • Use the latest release: omit --release-manifest when running the installer or mirror tool on a connected machine.
  • Repeat one release: retain its JSON manifest and pass the same --release-manifest FILE to both tools. This also prevents a new release between mirroring and installation from changing the selected images.
  • Stop on an invalid release: a missing, incomplete, or invalid manifest stops the operation. It does not fall back to latest, guess individual tags, or silently omit missing artifact images.
  • Keep the release consistent: explicit image tag flags must match the manifest. The installer applies the release image pins over conflicting image values. Customer configuration such as registry addresses, infrastructure settings, and secrets remains separate.
The manifest covers xpander images. The chart continues to define third-party image versions. Keep the matching chart package with your release; the image manifest alone does not select a chart version. Publishing a release does not upgrade customer clusters. Your Helm invocation, GitOps reconciliation policy, or upgrade schedule determines when it is installed. Updating a Helm repository index only refreshes the available chart list.

Existing Helm and GitOps Pipelines

Pipelines that keep old script copies or select image tags themselves need a one-time adaptation. See CI/CD & GitOps for an example that downloads the manifest once and uses it throughout the upgrade.

When the Mirror Is Empty, the Wizard Offers to Fill It

The wizard can mirror the selected release from a connected machine. Choose Mirror them now, provide the xpander registry pull credentials and any destination credentials, and let the copy finish before installation. ECR repositories are created automatically when the configured AWS credentials allow it. For a sealed network, use the archive flow below. Non-interactively, --mirror now|guide|skip chooses the mirroring behavior; --mirror now needs the registry credentials. Skipping mirroring does not make missing release images available.

Sealed / Manual Mirroring

Use image_sync.sh to mirror the release before installing it. Mirroring requires skopeo and Python 3; the Docker pull/tag/push fallback does not preserve the release digests. On a connected workstation, download the manifest once and use that exact file for the copy and upgrade:
Supply your registry credentials using the tool’s source/destination credential flags or configured registry authentication. --dry-run prints the copy plan. Keep the release JSON manifest; a single --tag or a legacy platform-only manifest does not describe the complete release. Fully sealed network? Archive on the connected side, transfer the entire directory, and import it inside:
Carry install.sh, image_sync.sh, and their matching release_manifest.py alongside the bundle. Obtain the validator from the immutable release_manifest-<sha256>.py URL embedded in those scripts and save it as release_manifest.py beside them. The scripts verify its checksum before executing it. Connected runs download the matching validator automatically. The archive includes a release manifest and an image index. Import validates the complete xpander image set and digests before copying. An incomplete archive must be completed on the connected side. Legacy archives require the previous importer and do not establish an release. The chart itself is an OCI artifact. Either mirror it next to the images (--chart-version <X.Y.Z> --chart-source registry-1.docker.io/xpanderaihub/xpander-airgap, it lands at oci://<your-registry>/xpander/charts/xpander-airgap), or pull and hand-carry the .tgz:
A registry manager fits either of two patterns:Hosted repository: mirror into it. The registry manager is the --registry target. Create a hosted Docker repository and fill it with the wizard’s mirror-now step, or with image_sync.sh directly; --dest-user / --dest-token cover repositories behind Basic auth:
Then install with --registry nexus.corp.example:5000/xpander.Pull-through proxy, no mirror step. Create a Docker proxy repository with Docker Hub (https://registry-1.docker.io) as the upstream, and set the xpander-issued read token as the proxy’s upstream credentials. Install with the org path kept inside the registry value:
Images cache lazily in the proxy on their first pull: nothing to mirror. The xpanderaihub path segment must remain: the chart composes every image reference as <registry>/<name>, so the cluster asks the proxy for <proxy-repo>/xpanderaihub/agent-controller, which maps to xpanderaihub/agent-controller upstream. The installer’s tag resolution works against the proxy the same way (Docker Registry v2 API, Basic or bearer auth).A fully sealed network can’t use a proxy: it needs upstream reachability. Keep the two-hop archive flow above, landing in a hosted repository.
The installer prints this entire runbook, personalized with your registry and namespace, with bash install.sh --edition airgap --guide, and prints it automatically when it detects no reachable cluster. --manual goes further: the whole install as copy-pasteable commands, executing nothing.

Data Tier: In-Cluster or External

The data tier is the one choice that is expensive to change later: the chart-managed StatefulSets own their PVCs, and moving to a managed service afterwards is a migration. The wizard asks per store; the default is both in-cluster.
Chart-managed StatefulSets on your StorageClass:
  • PostgreSQL 16: durable history/memory tier and per-agent database provisioning
  • Redis Stack (redis-stack-server): queues, cache, and knowledge-base vectors. Deliberately not plain Redis: knowledge bases are RediSearch (FT.*) indexes
  • MongoDB: catalog and monitoring stores
  • The Supabase stack ships its own pinned PostgreSQL 15 (it requires extensions managed services don’t offer)
No flags needed. Set --storage-class <name> if you don’t want the cluster default.

Local LLM Inference

An air-gapped install needs an LLM endpoint reachable in-network. The platform speaks the OpenAI-compatible API, so any local runtime that exposes it plugs in directly: Size your inference pool separately by model; it is your own infrastructure, not part of the chart’s footprint. Hosted providers (OpenAI, Anthropic, Google, Bedrock) also work when your egress policy allows them: the same LLM provider keys apply. Two models are declared at install level: the agents’ default model, and the gateway model that runs entry filtering ahead of it, global.llm.gateway.{provider,model,apiBase} in values. LLM defaults follow values-as-truth with snapshot convergence: every install and upgrade converges the organization’s LLM defaults to the chart’s declaration, but only when the declaration itself changed: defaults an admin has edited in the UI survive upgrades until you deliberately change the declared value.
Amazon Bedrock without a key. Chat, agent task executions and the summaries around them all work on the pods’ own AWS identity (EKS Pod Identity or IRSA) since xpander-sdk 2.0.503 (images built after 27 August 2026): leave global.llm.bedrock.bearerTokenSecret empty and set global.llm.bedrock.region. The role bound to the pods needs the Bedrock permissions itself (bedrock:InvokeModel, bedrock:InvokeModelWithResponseStream, bedrock:Converse, bedrock:ConverseStream on *, because the global.* inference profiles route across regions), and it must be bound to both ServiceAccounts the LLM services run as in the release namespace: default and agent-controller. The chat and task paths use those credentials directly and do not assume a second role. The account must be opted in to Bedrock’s data retention mode for the models in every region a global. profile can route to, and a sealed network needs VPC endpoints for bedrock-runtime, sts and eks-auth. A Bedrock API key (bearer token) in bearerTokenSecret is the alternative. An organization can also store an IAM role ARN as a Bedrock provider credential under Settings, LLM settings, Providers (“IAM role” method): the runtime assumes it with its pod identity for chat and tasks.
Harness agents take their own path: Claude Code on Bedrock reaches Bedrock through the Agent Controller’s LLM proxy, which resolves AWS auth on the controller itself. There too a bearer token is optional: global.llm.bedrock.assumeRoleArn (plus assumeRoleExternalId) takes the STS assume-role path, and with both the token and the role empty the controller signs with the pod’s own credential chain (EKS Pod Identity or IRSA). global.llm.bedrock.baseUrl points that leg at your VPC endpoint on a sealed install. Fable- and Mythos-class Anthropic models additionally need the account’s Bedrock data-retention opt-in, per region; the exact call is on Harness Agents: Sizing and Requirements. The summaries the platform writes around agent work (thread titles, context compaction, evaluation judges) follow the organization’s LLM settings: the org default model leads, and the install’s other configured providers back it up. Nothing in that chain dials a public endpoint on a sealed install.

Harness Agents on Air-Gap

Harness agents (Claude Code / Codex / OpenCode) ship enabled on every Air-Gapped install and are the default runtime of every new agent. Their turns run on the executor fleet the chart always renders; sizing and node prerequisites are on Harness Agents: Sizing and Requirements. What an Air-Gapped operator configures beyond that:

AI Connector Generation

Air-gapped installs include the connector-generation pipeline: upload an OpenAPI spec in the UI (Connectors → Create connector) and the openapi-spec-generator service enriches it into a full connector (operation grouping, naming, descriptions, summaries, and validation) through a multi-step LLM pipeline. Runs execute in the background; connectors can be deleted, and a new spec version can be uploaded over an existing connector. The air-gap license carries the custom-connectors entitlement, and the generator’s image is part of the standard mirrored set. The generator runs on exactly one LLM provider, decided at install time: Bedrock when the install has Bedrock configured, otherwise OpenAI when an OpenAI key was provided. That one provider powers every pipeline step and the embeddings, and the service refuses runs when its provider’s credentials are absent rather than degrading quietly. With neither provider, the generator is not installed at all and connector creation in the UI is spec-only: the spec is ingested as-is, with no AI enrichment (the UI flag VITE_CONNECTOR_AI_ENRICHMENT is set for you).
On Bedrock, the generator follows global.llm.bedrock.region and falls back to us-west-2 when it is unset. Its default model IDs are US cross-region inference profiles, so the region it lands on must be a US one, and the IAM policy / PrivateLink endpoint must cover Bedrock there.

The License

New air-gap installs are licensed with two sealed files (install.json + activation.json, the xpander-license/v2 format), which enables renewal without a reinstall and enforces seat/agent caps. See Two-File Licensing. The single-file flow below (xpander-license/v1) still works for installs issued that way.
The installer validates the license file locally (JSON shape, the xpander-license/v1 envelope, expiry) and creates the Secret for you, idempotently:
The chart’s preflight hook then verifies the Ed25519 signature, and deployment-manager re-verifies at boot: it refuses to start on a bad signature.
  • Expired license: the installer warns at the license phase and the chart’s preflight refuses the install. A running install whose license expires needs a renewed license file: the xpander.ai team issues one and delivers it over email.
  • Renewing / replacing: recreate the xpander-license Secret with the new file (the command above), then run helm upgrade (or install.sh upgrade). License consumers carry a checksum annotation over the Secret, so the upgrade rolls them onto the new file.
  • Single-tenant: the license binds one organization; the org seed creates exactly that org.

Domains, Ingress & DNS

One --domain names every public host. Give the installer a base domain, xpander.acme.internal, and the chart derives the whole browser-facing set from it: Setting the domain is the publish decision: an Ingress renders for each of these services (an explicit <name>.ingress.enabled: false keeps one private; global.ingress.enabled: false suppresses all of them for clusters that manage their own ingress objects). The base domain also derives the UI’s runtime configuration: the app needs to know its Supabase, API, and chat-backend origins at boot, and without a domain (or explicit ui.env overrides) a browser on a sealed network would be pointed at origins it cannot reach. Overrides and knobs:
  • --ui-host <host> replaces the derived chat.<domain> only; any other host is overridable per service via global.hosts.<name> in values.
  • --ingress-scheme https|http (default https) sets how the browser reaches those hosts: it feeds every derived URL. Use http only for rigs without certificates.
  • No ingress controller is assumed. Set the class and annotations per component (<name>.ingress.className / annotations) or once for all of them via global.ingress.className / global.ingress.annotations.
TLS is the standard Kubernetes Ingress tls: block, passed through verbatim, per component (<name>.ingress.tls) or once via global.ingress.tls. Terminate at your controller with certificates that cover the seven hosts (a wildcard *.xpander.acme.internal covers them all):

Making the Hosts Resolve

Create records in the DNS zone your users’ machines resolve. A wildcard is simplest:
Or seven explicit records (the table above) when a wildcard is not allowed.
Sealed networks: public DNS records for these hosts are pointless without a path in: resolution has to happen where your users are (the internal zone, or VPN-side DNS). The domain itself never needs to exist on the public internet.

Signing In

The install ends with the summary box printing the derived URLs and the bootstrap admin password; the release NOTES (helm get notes xpander -n xpander) repeat the commands. With no external dependency configured, sign-in still works:
  1. Bootstrap password (default): open the UI (https://chat.<domain>) at /login-password with your --admin-email and the password from the summary; read it again any time:
  2. Email OTP without SMTP: the login page’s email flow works with no mailer. The code is generated and stored, just not sent. Print it with the chart’s scripts/get_login_code.sh <email> <namespace>. With SMTP configured (global.smtp.* in values), the same codes arrive by email, and on installs with inbound agent mailboxes, agents’ email replies deliver through the same relay (INBOUND_EMAIL_REPLY_DOMAIN controls the From domain; the SMTP identity must be allowed to send as the agents’ mailbox subdomain).
  3. SSO with your identity provider (OIDC): the SSO button is driven by the OIDC configuration an administrator enters in the app (Settings, OIDC), served by the client-auth component, not by GoTrue’s external providers. Setup, IdP client settings, the Keycloak preferred_username note and troubleshooting: SSO with your identity provider. Google and GitHub social buttons remain GoTrue providers (supabase.auth.extraEnv).
No domain set yet? Port-forward to the UI first:
Access tokens live one day. supabase.db.jwtExpiry defaults to 86400: a signed-in user’s access token stays valid for a day and the session renews through the rotating refresh token. One value feeds GoTrue, PostgREST and the database setting, so an override moves all three together. Tokens minted before an upgrade keep their old expiry until they refresh, and the migrations hook re-applies the database side on every upgrade, so an install born with the older one-hour default converges too.

Upgrading an Air-Gapped Install

Check the latest release for updates. An air-gap upgrade is two steps, in this order:
1

Mirror the new bundle FIRST

The release pins image digests, so upgrading before mirroring can leave pods in ImagePullBackOff. Re-run the mirroring for the target release (curl -fsSLO https://charts.xpander.ai/image_sync.sh and run it against your registry as in Sealed / manual mirroring), and hand-carry the new chart .tgz if your install host can’t pull it over OCI.
2

Run the upgrade

The upgrade subcommand infers the edition from the installed chart and reuses your installed configuration. It loads the release pins over the previous image values. Pass the same manifest used for mirroring; if the manifest cannot be loaded or validated, the upgrade stops. Upgrades run with --atomic, which rolls back workload changes on failure; database migrations remain forward-only.
The fleet and --atomic. --atomic waits for the executor fleet like any other workload, with two consequences. A running harness turn holds the roll: on SIGTERM an executor drains for up to global.fleet.executor.drainSeconds (3600 s) before the replacement pod appears, so a roll during a long turn takes as long as that turn; the installer’s timeout covers it, and on a hand-driven helm upgrade give --timeout at least the drain window or upgrade in a quiet period. A turn still running at the deadline is stopped with “The executor is restarting; send the message again to continue where it left off.” and resumes on the new pod when the user sends again. And an idle executor never stalls an upgrade: on a live cluster without the fleet’s StorageClass the chart renders the executor at zero replicas (annotation xpander.ai/fleet-idle-reason), and the installer skips zero-replica workloads when it verifies. A first install runs without --wait/--atomic on purpose (the post-install smoke hook is its readiness gate). What survives what:
  • Generated keys survive every upgrade: the keygen hook is lookup-preserve, the xpander-generated-keys Secret is Job-created (never Helm-rendered), and rollback never rewinds it.
  • helm rollback xpander <N> restores any prior revision: everything the chart owns is release-versioned.
  • Except the database schema. Migrations run as a versioned Job per revision (kept as the audit trail) and are forward-only: a schema rollback means restore-from-backup, never an automatic down-migration.
  • Settings that converge on every upgrade: the one-day access-token lifetime (supabase.db.jwtExpiry) is re-applied on the database side by the migrations hook, so an install born before that default cannot drift back to one hour.
Avoid --reuse-values on air-gap upgrades (the installer’s upgrade flow does the right thing; this applies to hand-driven helm upgrade). --reuse-values replays the previous release’s computed values, which can resurrect settings the new chart version deliberately removed: the known case is a stale edge-runtime placeholder image pin that leaves a crash-looping Deployment failing every --atomic upgrade. Re-supply your values files instead, or clear the stale pin once with --set supabase.edgeRuntime.image.repository=null --set supabase.edgeRuntime.image.tag=null.

Automation & CI

The installer is built to be driven by scripts, CI pipelines, and coding agents:
  • Every prompt has a flag. With --non-interactive nothing is read from the terminal, even when one exists: missing required values exit 2 with the usage and a completed rerun line rather than blocking. It implies --yes and --on-probe-failure abort.
  • Stable progress output. Progress is one line per transition in a grep-friendly shape, [3/8] license: ok, and --quiet reduces output to phase lines and the outcome only. Color is emitted only when stdout is a terminal.
  • status is the poll target. A read-only health report: edition, chart, release status, hook jobs, workload readiness, and URLs. --json emits one JSON object.
Exit codes: Air-gap, end to end, no terminal (use the release manifest already mirrored):
If the registry might not be mirrored yet, add --mirror now --xpander-registry-token <token>. Without a --mirror answer, a non-interactive run against an empty mirror exits 2 with the options spelled out. Poll until healthy:

CI/CD & GitOps

The pattern: fetch the release manifest once, mirror its image set with credentials from the CI secret store, then upgrade using that same file and gate on status. Run it on an agent with cluster access, Helm ≥ 3.13, skopeo, and Python 3.
Exit codes do the gating (the table above): the upgrade step fails the build on 1 (already rolled back, since upgrades run --atomic), 2 (usage), or 4 (preflight); status fails on 1 (degraded, with reasons) or 3 (not installed). status --json emits one JSON object if you’d rather parse than gate on the exit code.
The air-gap chart is standard Helm OCI. Mirror it next to the images, keep your configuration and generated release values in Git, and point an Application at both. Chart versions and image versions are separate: selecting a newer chart alone does not fetch the release manifest.Generate the Helm values with the manifest-aware installer using your usual install arguments plus --release-manifest ./release-manifest.json --values-out xpander/values.yaml. It exports xpander/values.yaml and xpander/values.yaml.release.json. The second file contains Helm values, not the original release metadata. Keep the original manifest for your release record and pass both generated values files, with release values last:
For Argo CD:
  • Values: regenerate the release values for each release and review them together with the chart version. Do not add image overrides after the release values; direct Helm/GitOps does not enforce the installer’s manifest checks. The generated file can carry secrets (LLM keys, external DSNs): strip those into your secret manager before committing.
  • Bootstrap secrets: the xpander-license Secret (and the registry pull secret, when one is needed) are created once out-of-band (kubectl create secret ... as shown in The License), or managed via SealedSecrets / External Secrets Operator.
  • Hooks: Argo CD maps Helm hooks (the chart’s preflight → keygen → migrations → org-seed → smoke pipeline) onto its own sync phases, and hook weights onto sync waves. This mapping is supported by Argo, but we have not certified the chart under Argo CD: verify the hook ordering on your Argo version before relying on it for upgrades; install.sh remains the certified path.

Troubleshooting

Every installer failure prints two lines: FIX:, the action that repairs the condition, and RERUN:, your personalized non-interactive one-liner (secrets typed at prompts are shown as placeholders). The installer is idempotent: fix the condition, paste the rerun line, and it picks up where the failure left off. The air-gap checklist verifies preconditions before anything changes, so most problems stop the run with nothing to clean up. For scripted runs, the exit code names the failure class (Automation & CI), and bash install.sh status gives a read-only health verdict.

Mirroring and Registries

Symptom:
Cause: ECR refuses a push to a repository that does not exist yet, and there is no push-time flag to create one.Fix: the current image_sync.sh creates each ECR repository automatically before pushing (it needs AWS CLI credentials on the machine running it). Refresh your copy:
On an older copy, pre-create the repository and re-run (already-landed copies are skipped fast):
Symptom: authentication required writing to your registry, even though docker login to it succeeds.Cause: skopeo cannot read logins kept in Docker Desktop’s credential store, so the docker login is invisible to the copy.Fix: the current image_sync.sh logs in itself for ECR destinations (aws ecr get-login-password | skopeo login --username AWS --password-stdin). For other registries, pass the credentials explicitly:
Symptom: 401 from auth.docker.io (incorrect username or password). The installer surfaces the registry’s own reason.Cause: the pull credential is the organization username xpanderaihub plus the read token from your delivery email. A personal Docker Hub username returns 401, and so does a token missing its read scopes.Fix: re-run with the exact pair from the email (--xpander-registry-user xpanderaihub --xpander-registry-token <token>). If it still refuses, ask xpander to re-issue the token: it needs repository-read and image-pull access to the gated repos.
Symptom: pod events show manifest unknown, or the installer’s checklist reports:
Cause: the mirror does not hold that repository at the pinned tag. A partial mirror, or an upgrade that pinned newer versions than were copied. Tags differ per image (each service versions independently), so one stale repo is enough.Fix: re-run the mirroring for the release (in-wizard, or image_sync.sh, safe to re-run), then verify the exact coordinate before retrying:

Cluster and Network

Symptom:
Cause: a sealed cluster has no route to Docker Hub, which is expected. Some image reference is still pointing at docker.io instead of your mirror.Fix: install with --registry <your-mirror>/<path> so every platform image resolves in-network, and make sure the mirror itself is reachable from the nodes (on an ECR-only sealed VPC that means the ecr.api + ecr.dkr interface endpoints plus the S3 gateway endpoint, and ECR read on the node role). Find the offending reference with:
Symptom:
(Or, past preflight on a mixed cluster: pods crash with exec format error.)Cause: xpander images are amd64-only; ARM/Graviton nodes (t4g, m7g, c7g, …) cannot run them. The installer’s preflight and the chart’s preflight hook both check before anything deploys.Fix: add an amd64 node group (x86 instance types) and re-run. Only if you have genuinely arm64 images should you override the chart’s check: --set 'preflight.allowedArchitectures[0]=arm64'.
Symptom: the ingress controller’s Service never gets an address; its events show:
Cause: in a sealed VPC there are no public subnets, and the private subnets are missing the ELB role tags, so AWS has nowhere to put the load balancer.Fix: for an internal load balancer, tag the private subnets and annotate the Service:
Or skip the load balancer entirely: reach the UI over your VPN, or with kubectl -n xpander port-forward svc/ui 8080:80.
Symptom:
Cause: the connectivity probe pod was launched before the install had created the namespace. Fixed in current installer versions.Fix: refresh your installer copy (curl -fsSL https://charts.xpander.ai/install.sh), or create the namespace and re-run:
Symptom: data-tier pods stay Pending; kubectl -n xpander describe pvc shows unbound claims.Cause: no usable RWO StorageClass (or the wrong one), or the cluster is under capacity for the footprint.Fix: kubectl get storageclass, pass --storage-class <name> if the default isn’t right; check kubectl -n xpander get events --sort-by=.lastTimestamp for FailedScheduling and add nodes if capacity is the constraint.
Symptom: the UI serves but renders a blank page; the browser console shows:
Cause: the app validates its runtime origins (Supabase, chat backend) at boot and refuses to start without them. Chart versions before 0.6.0 did not derive the UI’s runtime config from the base domain.Fix: upgrade with bash install.sh upgrade (chart ≥ 0.6.0 injects the config from --domain). Staying on an older chart, set the origins yourself via ui.env (VITE_SUPABASE_URL, VITE_CHAT_BACKEND_URL, …) in your values.
Symptom: chat.<domain> opens, but sign-in or API calls fail, supabase.<domain> / api.<domain> don’t resolve, or land on a default-backend 404.Cause: the install publishes seven hosts, and only one got a DNS record (or an /etc/hosts entry).Fix: create a wildcard record (*.<domain>) pointing at the ingress controller, or one record per host: chat, api, agent-controller, supabase, webhook, client-auth, actions. Verify what the cluster actually publishes:

Install and Upgrade

The installer refuses to install over a release in a stuck status, and install.sh upgrade requires deployed: operating on a stuck release would strand it. Recover first:
Then paste your RERUN: line. pending-install usually means an interrupted or timed-out first install: helm uninstall is the right recovery. The xpander-generated-keys Secret survives the uninstall (Job-created, not Helm-rendered), so a reinstall keeps the same keys.
The chart refuses to render against unpinned platform images. Load a complete latest release, mirror its images, and retry with that same manifest. For direct Helm, pass both generated values files, with the release values last. Do not repair a missing release by guessing a shared image tag.
The installer validates the file locally (JSON shape, xpander-license/v1 envelope, expiry, org id); the chart’s preflight hook re-verifies including the Ed25519 signature, and deployment-manager verifies again at boot.Expired: the installer warns License expired on <date> - preflight will refuse the install. Get a renewed license.json from the xpander.ai team (delivered over email), recreate the secret, and re-run:
On a running install, follow with install.sh upgrade: license consumers carry a checksum annotation over the Secret, so the upgrade rolls them onto the new file.
The installer already printed the failing Job’s last 30 log lines. Dig deeper:
The org-seed stage requires --org-name and --admin-email whenever the Supabase stack is on: the checklist catches this before install; a hand-driven helm upgrade that drops them fails at render time.
A values file that sets a username but leaves password: "" beside it overrides the generated password with the empty string. Helm merges the explicit empty value over the keygen Secret’s. The installer warns when it sees this shape; the fix is to drop the empty password: key from your values file entirely (a key that is absent is preserved, a key that is "" wins).
On releases older than the single-provider generator, the operation-clustering step needed an OpenAI key for embeddings; without one it fell back to simpler grouping, and that fallback transiently reported the run as failed: the creation dialog stopped with “The AI enrichment pipeline reported a failure” even though the pipeline finished seconds later. Check the connector list before retrying: the connector typically completed and is fully usable. Current releases run the embeddings on the install’s own provider and the false failure is fixed, so upgrading resolves it.
The chart pins image tags per release, so upgrading before mirroring the new bundle leaves pods unable to pull (typically with manifest unknown). Re-run the mirroring for the target release, then re-run the upgrade: it runs with --atomic, so the failed attempt already rolled back and the previous revision kept serving.
helm upgrade --reuse-values replays the previous release’s computed values, which can resurrect a stale edge-runtime placeholder image pin that newer chart versions removed. Upgrade with your real values files instead (what install.sh upgrade does), or clear the stale pin once:
Better: pin the real mirrored edge-functions build (--edge-functions-tag).
The two editions share nothing and cannot be upgraded into each other. Install under a different release or namespace (--release / --namespace), or remove the existing release first (helm uninstall xpander -n xpander).
Piping into bash leaves no stdin to prompt on, so the run is non-interactive: Air-Gapped requires only --license-file. Missing flags exit with code 2 and a completed rerun line. Download the script and run bash install.sh --edition airgap from a terminal for the interactive wizard.

Next Steps

  • Air-Gapped Security Architecture: zero egress to xpander Cloud, signed Ed25519 license, local sign-in
  • Advanced: review-first / manual install: read the installer before running it, plus --manual, --values-out, and --dry-run
  • The chart’s own README (inside the .tgz) covers advanced topics: bring-your-own ingress for the UI/API/Supabase gateway hosts, private CA and corporate proxy support, SMTP, internet posture and tool offering, builtin-skills seeding, and Bedrock region pinning