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
- 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.
- Images come from your own registry mirror. xpander delivers the artifact set through the gated
xpanderaihubDocker 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. - Image tags are pinned per release. The chart refuses to render against unpinned images, and upgrades require mirroring the new bundle first.
--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.
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.Prerequisites
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.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:- 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
autoscalingandec2VPC endpoints).
Install in Three Steps
Receive the license and pull token by email
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).Run the one-liner
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.Sign in as the seeded admin
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).
FIX: line (the repair) and a RERUN: line (your personalized command to resume). Nothing needs diagnosing from scratch.Resolve: load the latest release
--release-manifest ./release-manifest.json. A missing or invalid manifest stops the operation. How release selection works.Checklist: preconditions verified before anything changes
/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.License: validated locally, applied as a Secret
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.Chart: pulled over OCI
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.Values: secrets never touch the command line
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.Pipeline: the cluster comes up, hook by hook (10–20 min)
Summary: URLs, password, logs
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:~/.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-manifestwhen running the installer or mirror tool on a connected machine. - Repeat one release: retain its JSON manifest and pass the same
--release-manifest FILEto 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.
Existing Helm and GitOps Pipelines
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
Useimage_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:
--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:
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:
Using Nexus, Artifactory, or Harbor
Using Nexus, Artifactory, or Harbor
--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:--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: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.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.- In-cluster (default)
- External (RDS / MemoryDB)
- 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)
--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: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.
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.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 theopenapi-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).
The License
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.xpander-license/v1 envelope, expiry) and creates the Secret for you, idempotently:
- 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-licenseSecret with the new file (the command above), then runhelm upgrade(orinstall.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:
<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 derivedchat.<domain>only; any other host is overridable per service viaglobal.hosts.<name>in values.--ingress-scheme https|http(defaulthttps) sets how the browser reaches those hosts: it feeds every derived URL. Usehttponly 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 viaglobal.ingress.className/global.ingress.annotations.
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
- Internal DNS zone
- VPN + internal load balancer
- Local test: port-forward + /etc/hosts
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:
-
Bootstrap password (default): open the UI (
https://chat.<domain>) at/login-passwordwith your--admin-emailand the password from the summary; read it again any time: -
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_DOMAINcontrols the From domain; the SMTP identity must be allowed to send as the agents’ mailbox subdomain). -
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-authcomponent, not by GoTrue’s external providers. Setup, IdP client settings, the Keycloakpreferred_usernamenote and troubleshooting: SSO with your identity provider. Google and GitHub social buttons remain GoTrue providers (supabase.auth.extraEnv).
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:Mirror the new bundle FIRST
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.Run the upgrade
--atomic, which rolls back workload changes on failure; database migrations remain forward-only.--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-keysSecret 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.
Automation & CI
The installer is built to be driven by scripts, CI pipelines, and coding agents:- Every prompt has a flag. With
--non-interactivenothing 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--yesand--on-probe-failure abort. - Stable progress output. Progress is one line per transition in a grep-friendly shape,
[3/8] license: ok, and--quietreduces output to phase lines and the outcome only. Color is emitted only when stdout is a terminal. statusis the poll target. A read-only health report: edition, chart, release status, hook jobs, workload readiness, and URLs.--jsonemits one JSON object.
--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
Jenkins (or any CI): watch the releases feed, mirror, upgrade
Jenkins (or any CI): watch the releases feed, mirror, upgrade
status. Run it on an agent with cluster access, Helm ≥ 3.13, skopeo, and Python 3.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.ArgoCD: the chart as Helm OCI from your registry
ArgoCD: the chart as Helm OCI from your registry
--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:- 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-licenseSecret (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.shremains 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
Mirror push fails: name unknown, 'The repository ... does not exist' (ECR)
Mirror push fails: name unknown, 'The repository ... does not exist' (ECR)
image_sync.sh creates each ECR repository automatically before pushing (it needs AWS CLI credentials on the machine running it). Refresh your copy:Mirror push fails: authentication required at the destination
Mirror push fails: authentication required at the destination
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:401 from Docker Hub when resolving or mirroring
401 from Docker Hub when resolving or mirroring
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.Pods can't pull: manifest unknown at your pinned tag
Pods can't pull: manifest unknown at your pinned tag
manifest unknown, or the installer’s checklist reports:image_sync.sh, safe to re-run), then verify the exact coordinate before retrying:Cluster and Network
Nodes time out pulling from docker.io (dial tcp ... i/o timeout)
Nodes time out pulling from docker.io (dial tcp ... i/o timeout)
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:Preflight: no node with a supported architecture (Graviton/ARM)
Preflight: no node with a supported architecture (Graviton/ARM)
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'.LoadBalancer Service stuck <pending>: could not find any suitable subnets
LoadBalancer Service stuck <pending>: could not find any suitable subnets
kubectl -n xpander port-forward svc/ui 8080:80.External data-tier probe fails: namespaces 'xpander' not found
External data-tier probe fails: namespaces 'xpander' not found
curl -fsSL https://charts.xpander.ai/install.sh), or create the namespace and re-run:Pods stuck in Pending
Pods stuck in Pending
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.UI loads blank: Missing or invalid environment variables
UI loads blank: Missing or invalid environment variables
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.Only the UI host resolves; other subdomains 404 or NXDOMAIN
Only the UI host resolves; other subdomains 404 or NXDOMAIN
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
Release stuck in pending-install / pending-upgrade / failed
Release stuck in pending-install / pending-upgrade / failed
install.sh upgrade requires deployed: operating on a stuck release would strand it. Recover first: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.'images are unpinned' / chart refuses to render
'images are unpinned' / chart refuses to render
License expired or rejected
License expired or rejected
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:install.sh upgrade: license consumers carry a checksum annotation over the Secret, so the upgrade rolls them onto the new file.A pipeline stage failed (preflight / keygen / migrations / org-seed / smoke)
A pipeline stage failed (preflight / keygen / migrations / org-seed / smoke)
--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.Services fail auth after an upgrade with a custom values file
Services fail auth after an upgrade with a custom values file
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).Create connector stops at "Generating the enriched spec", but the connector appears anyway
Create connector stops at "Generating the enriched spec", but the connector appears anyway
Pods in ImagePullBackOff after an upgrade
Pods in ImagePullBackOff after an upgrade
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.Edge-runtime crash-looping after upgrading with --reuse-values
Edge-runtime crash-looping after upgrading with --reuse-values
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:--edge-functions-tag).Release already runs the other edition's chart
Release already runs the other edition's chart
--release / --namespace), or remove the existing release first (helm uninstall xpander -n xpander).Piped run exits with 'these required flags are missing'
Piped run exits with 'these required flags are missing'
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

