Get started
Deploy on GKE or EKS in ~15 minutes.
See how it works
The four-system optimization loop, end to end.
In place — no restart
Resizes apply live via KEP-1287. No rollout, no cold start, no dropped requests.
~73% of HPAs untouched
It only changes what pays off — the majority that are already fine are left alone.
A flat cost
A small, fixed footprint — never a percentage of your savings.
Your data never leaves
Every metric and decision stays in your cluster. Nothing is sent to a SaaS platform.
Why we built Autopilot
We ran a leading SaaS Kubernetes optimizer across our own production for a year. The optimization worked — but every cluster’s metrics left for their cloud, and the bill scaled with our savings: the better it worked, the more it cost. So we built Autopilot to deliver that same class of optimization on better terms — running entirely inside your cluster, at a flat cost, with every decision visible. It’s the tool we wanted to run on our own fleet.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 brings
that same optimization 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:Right-size every pod
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.
Provision the right nodes
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.
Tune every autoscaler
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.Consolidate safely
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.No restarts
Resizes are applied in place via KEP-1287 — workloads shrink while they keep serving.
No rollout, no cold start, no dropped requests.
Proves it before it acts
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.
Leaves what works alone
~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.
Every decision is visible
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
1
Connect
Deploy on GKE or EKS in ~15 minutes. Start in observe-only mode — no changes to your
workloads until you’re ready.
2
Observe
Autopilot learns each workload’s real behavior from your existing Prometheus metrics and
surfaces exactly what it would change — and why.
3
Optimize
Turn it on. Autopilot right-sizes pods, scales nodes, and tunes autoscalers continuously
— in place, proving every move safe first.
See the full walkthrough
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.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.Autopilot vs CAST AI
A feature-by-feature comparison — transparency, cost model, and where your data lives.
Migration runbook
The exact steps to migrate a cluster in under half an hour.
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), per-package cost attribution, and a fleet-wide command center across every cluster.Pod Resizing
In-place CPU/memory right-sizing.
Node Scaling
Per-pod machine selection.
Rebalancing
Consolidate onto fewer nodes.
Scheduled Scaling
Pre-warm for predictable bursts.
Observability & Cost
Managed-service health + cost.
How it works
The full four-system loop.
Ready in 15 minutes
Getting Started
Bootstrap a cluster and deploy Autopilot.
Verify it's working
Confirm each engine is healthy.
Operations Runbook
Run it day to day.