> ## Documentation Index > Fetch the complete documentation index at: https://autopilot.docs.xano.com/llms.txt > Use this file to discover all available pages before exploring further. # Right-size your entire Kubernetes cluster — without a single restart > Autopilot by Xano continuously tunes every pod, node, and autoscaler to real usage. Safely. In place. Entirely inside your cluster. Most Kubernetes clusters run far below the capacity they reserve — every workload is provisioned for its worst day, HPAs are set once and forgotten, and nodes fragment as workloads come and go. **Autopilot by Xano** closes that gap continuously: it right-sizes pods, scales nodes to real demand, tunes every autoscaler, and consolidates fragmented nodes — all from inside your cluster, and all **without restarting your workloads**. **Zero-downtime by design.** Every pod resize is applied **in place** (Kubernetes KEP-1287, 1.33+) and every node drain is **proven safe** before a single pod is touched. Your cluster shrinks to fit while it keeps serving traffic. Deploy on GKE or EKS in \~15 minutes. The four-system optimization loop, end to end. Resizes apply live via KEP-1287. No rollout, no cold start, no dropped requests. It only changes what pays off — the majority that are already fine are left alone. A small, fixed footprint — never a percentage of your savings. Every metric and decision stays in your cluster. Nothing is sent to a SaaS platform. ## Why we built Autopilot We run production Kubernetes at scale, every day. As our footprint grew, optimization stopped being a nice-to-have — the cost and reliability of the cluster became something we had to master, not delegate. So we went deep: we spent a long time paying close attention to how workloads actually behave, where right-sizing goes wrong, and how autoscalers drift over time — until we knew this problem cold. **Autopilot is what that expertise built.** Not a generic optimizer bolted onto your cluster, but a bespoke solution we engineered for our own production reality — in-place resizing with no restarts, autoscaler tuning that only touches what pays off, and consolidation that proves every move safe before it makes it. It's the tool we wanted to run on our own clusters, so it's the one we built. We evaluated the SaaS route, too. It works — but your cluster's metrics leave for someone else's cloud, and the pricing takes a cut of every dollar it saves, so the better it works the more it costs. Autopilot keeps the optimization **in your cluster, at a flat cost, with every decision open to inspection**. Kubernetes cost automation is a proven category — teams routinely report large savings from it (CAST AI, for instance, publishes **40–70% cloud savings at Akamai**). Autopilot delivers that same class of optimization on better terms: in-cluster, at a fixed cost, with the algorithm open to inspection. ## The waste is invisible — until you measure it Every request is a promise your cluster reserves whether the pod uses it or not. Teams over-provision for safety, HPAs are set once and forgotten, and nodes fragment as workloads come and go. The result is a cluster that's *busy reserving* capacity while sitting nearly idle — and a cloud bill sized to the reservation, not the usage. Autopilot closes that gap continuously, on four fronts: CPU and memory requests are recomputed from real usage every 5 minutes and applied **in place — no restart**. An over-provisioned request drops to what the workload actually needs, while it keeps serving. When pods can't fit, Autopilot provisions the **cheapest node that fits the pending work** — per-pod machine selection, not a one-size pool. When demand drops, it drains the empties. Autopilot makes HPAs turnkey — it right-sizes over-committed `minReplicas`, damps flapping, and floors undersized workloads — while leaving the majority that are already fine **alone**. During maintenance windows it bin-packs workloads onto fewer, cheaper nodes and drains the rest — **proving every pod has a home before it cordons anything**. ## Safe enough to run in production — because it proves every move first The reason autonomous optimizers don't get turned on is fear they'll break prod. Autopilot is built the opposite way: it earns each change before it makes it, and every change is reversible. Start in **observe-only mode** and watch what it would do before it does anything. Resizes are applied in place via KEP-1287 — workloads shrink while they keep serving. No rollout, no cold start, no dropped requests. Before any drain, Autopilot simulates placement — taints, affinity, and CPU/memory/pod fit — and cordons **nothing** until every evicted pod has a proven landing spot. \~73% of HPAs need nothing, so Autopilot touches nothing. It changes only where the math says it pays off — and any explicit operator setting always wins. No black box. Each recommendation shows the percentiles, buffer, and reasoning behind it — and every automated move is explained on the workload card. ## From connect to optimizing — in minutes Deploy on GKE or EKS in \~15 minutes. Start in **observe-only mode** — no changes to your workloads until you're ready. Autopilot learns each workload's real behavior from your existing Prometheus metrics and surfaces exactly what it would change — and why. Turn it on. Autopilot right-sizes pods, scales nodes, and tunes autoscalers continuously — in place, proving every move safe first. How Autopilot provisions the right nodes, tunes every autoscaler, resizes pods in place, and consolidates safely — the complete four-system loop. ## A cost model that doesn't punish success Savings-based pricing charges you *more* the better it works. Autopilot is software you run in your own cluster — its cost is a small, fixed footprint that doesn't grow with your savings or your cluster. | On a cluster spending **\$5,000/mo** | Autopilot | Savings-based tools | | ------------------------------------ | -------------------------------------------- | ---------------------------- | | Optimizer cost | **\~\$48/mo** flat (Prometheus + controller) | \~20–30% of realized savings | | *If* it saves 40% (\$2,000/mo) | still **\~\$48/mo** | **\~\$400–600/mo** | | As your savings grow | unchanged | you pay more | | Where your data lives | **in-cluster** | sent to a SaaS platform | The optimization is the same either way — Autopilot just doesn't take a cut of it. Every dollar it saves is a dollar you keep. ## Switching from CAST AI? Autopilot ships a **fully automated, zero-downtime migration** — it removes CAST AI, adopts your existing nodes in place (no reprovisioning), and right-sizes the fleet. Typical migration: **15–30 minutes per cluster** with no workload downtime. A feature-by-feature comparison — transparency, cost model, and where your data lives. ## Everything it does Beyond the four optimization engines, Autopilot gives you observability for the GCP managed services around your cluster (Cloud SQL, Redis, Cloud NAT, and more) and per-package cost attribution. In-place CPU/memory right-sizing. Per-pod machine selection. Consolidate onto fewer nodes. Turnkey autoscaler tuning + idle parking. Pre-warm for predictable bursts. Per-workload floors and ceilings. Managed-service health + cost. In-browser terminal, logs, and files. The full four-system loop. ## Ready in 15 minutes Bootstrap a cluster and deploy Autopilot. Confirm each engine is healthy. Run it day to day.