AWS Builder Center

Cluster Autoscaler vs. Karpenter on Amazon EKS: Seven Claims Tested, and What Agent Workloads Change

How to choose autoscaler vs Karpenter for your EKS cluster

I am seasonal DevOps Engineer working on AWS Cloud
Ask five platform engineers whether to run Cluster Autoscaler or Karpenter and you will get the same short answer: "Karpenter, obviously." The reasons they give are usually a mix of true, half-true and outdated.
I run EKS clusters that started on node groups and Cluster Autoscaler, and I am moving them to Karpenter, so I have had to separate the claims that hold up from the ones that do not. This post goes through the seven I hear most, with a verdict on each, and then looks at what changes when the workloads are AI agents.

First, the mental model

Cluster Autoscaler scales node groups. On AWS those are Auto Scaling groups. When pods are pending, it picks a group that could fit them and raises its desired count. Everything it can do is bounded by the groups you defined ahead of time.
Karpenter scales nodes. It reads the requirements of pending pods (requests, affinities, topology spread, volumes) and asks EC2 for a node that fits, with no Auto Scaling group in between. A NodePool says what nodes are allowed and how they may be disrupted. An EC2NodeClass says how they are built.
EKS Auto Mode is Karpenter run for you. AWS operates the controller off-cluster and uses the same NodePool API. Keep that in mind for claim five.

Seven claims, tested

"Karpenter is faster." Mostly true

Karpenter calls EC2 directly. Cluster Autoscaler raises an Auto Scaling group's desired count and waits for the group to deliver. Removing that step helps, and most reports are of nodes appearing sooner.
But a pending pod waits for more than the launch call: node boot, add-on startup and image pulls all count, and neither tool controls those. Benchmark on your own cluster before you promise anyone a number.

"Karpenter is always cheaper." Only sometimes

Karpenter saves money in three ways: it sizes nodes to pending pods, it keeps repacking, and it makes Spot practical by spreading across many instance types. If your pods are uniform and your node groups are already well tuned, there is less to win.
It also sizes nodes from pod requests, so it cannot fix pods that ask for more than they use. Inflated requests become inflated nodes. And on Auto Mode you pay a management fee on top of EC2 for the nodes it manages.
AWS advertises Spot discounts of up to 90% below On-Demand, which is the ceiling, not the expectation. Compare Cost Explorer before and after, grouped by purchase option, instead of trusting anyone's percentage, including mine.

"Cluster Autoscaler is legacy." No

It is maintained by Kubernetes SIG Autoscaling, has been the default since 2016, and still runs most production clusters that never switched. It works across clouds and across node group types. For a small, steady cluster with similar pods and little Spot, it is a sound choice.
Its limits are real but specific. AWS's own guidance says instances in a mixed-instances policy should share the same CPU, memory and GPU shape, and that the first listed type is used to simulate scheduling, which makes it a poor fit for diversified Spot. Its scale-down only removes nodes, by default after they sit under 50% utilization for ten minutes. If neither of those hurts you, you may not need to move.

"Karpenter is AWS-only." Not any more, but check your platform

The vendor-neutral core now lives with Kubernetes SIG Autoscaling, and the AWS-specific code sits in a separate provider. Other providers exist, including Azure's Node Auto Provisioning on AKS. As of mid-2026 there is still no official GKE provider.
So "Karpenter everywhere" is not yet true. If you need one autoscaler across several clouds, confirm a provider exists for each before you plan around it.

"Auto Mode makes self-managed Karpenter pointless." No, it makes it optional

Auto Mode removes the controller from your list of things to run, and you still define NodePools. The trade-offs are:
  • Bottlerocket only, with no custom AMIs and no SSH or SSM access to nodes
  • A management fee on top of the EC2 price
  • Managed node groups can run alongside Auto Mode nodes in the same cluster, so adoption can be gradual
If you need AMI control, node access or a different cost model, self-managed Karpenter is still the answer. If you do not, Auto Mode is the lower-effort default for new clusters.

"Spot with Karpenter is set and forget." No

Karpenter handles Spot interruption through an SQS queue and EventBridge rules, cordoning and draining nodes ahead of a reclaim. That is a start, and it is not the whole job:
  • Spot-to-Spot consolidation needs at least 15 candidate instance types, so narrow NodePool requirements quietly disable it.
  • Services need at least two replicas, topology spread and a PodDisruptionBudget.
  • Pods must shut down cleanly inside the two-minute warning.
  • The  karpenter.sh/do-not-disrupt: "true"  annotation stops voluntary disruption, not a Spot reclaim.
  • Databases and singletons belong on On-Demand.

"Consolidation is free savings." It has a price

Consolidation moves pods. At small scale that is invisible. At larger scale unconstrained consolidation can trigger waves of rescheduling that hurt pod startup latency. Karpenter gives you the controls ( consolidateAfter , disruption budgets and schedules), and the defaults are not tuned for your workloads. Raise  consolidateAfter  for production and block disruption during peak hours.

What other teams have reported

Published numbers vary a lot, and that spread is the point. All of these are self-reported, from different starting points, so read them as a range, not a forecast.
  • Salesforce moved more than 1,000 EKS clusters from Cluster Autoscaler to Karpenter. It reported scaling latency falling from minutes to seconds and cost savings of about 5% in the first fiscal year, with another 5–10% expected the year after.
  • Slack adopted Karpenter on its internal EKS platform and reported about 12% cost savings, plus better bin packing and faster node provisioning.
  • Audi reported saving more than 60% on compute for its car-configurator backend after adopting Karpenter, according to an AWS case study.
  • Anthropic engineers were reported to have said at re:Invent that Karpenter helped cut their AWS bill by around 40%. The same coverage quotes a team describing Cluster Autoscaler getting stuck when Spot capacity ran out, because it could not fall back to On-Demand.
  • Speed: vendor benchmarks commonly put Karpenter at roughly 45 to 90 seconds to a ready node against 3 to 5 minutes for Cluster Autoscaler, and the same vendor notes that AMI caching, region and instance type change the result.
  • Performance can also go the wrong way. One vendor warns that on clusters around 500 nodes, unconstrained consolidation can create waves of rescheduling that slow pod startup.
My reading: teams whose clusters were already reasonably tuned saw single-digit to low-double-digit savings, and teams with a lot of idle capacity or unused Spot saw far more. Scale-up speed improved in nearly every account, and stability depended on how carefully disruption was configured. Your own before-and-after numbers are worth more than any of these.

Where agent workloads change the picture

For ordinary web services, a slow or clumsy autoscaler is an annoyance. Agent platforms turn it into a product problem.
Bursts have a person waiting. One request can fan out into many tool calls and sandbox pods at once, so node provisioning time lands directly in someone's wait.
Pod shapes are wildly uneven. A small tool server, a code sandbox and a GPU inference pod have nothing in common. Under Cluster Autoscaler that becomes a growing list of node groups. Under Karpenter it becomes a few NodePools with requirements.
GPU capacity is a purchasing problem. EKS documentation lists On-Demand, Spot, On-Demand Capacity Reservations and Capacity Blocks for ML as supported options for Auto Mode and Karpenter, using reserved capacity first. For accelerated nodes, the question is often which kind of capacity you hold, not how fast you can scale.
Idle time is expensive, and so is interruption. Agent sessions spend most of their time waiting on model responses, which makes consolidation attractive. But an evicted pod can mean a lost session. Put long-lived session pods in their own NodePool with a conservative disruption policy, mark runs that must not move with  do-not-disrupt , keep fragile agents on On-Demand, and store session state outside the pod.
Untrusted code needs its own nodes. If an agent runs generated code, that pod should not share a node with your platform services. A dedicated NodePool with a taint, a short node lifetime and a CPU limit gives you a boundary and an easy cleanup:
apiVersion: karpenter.sh/v1
kind: NodePool
metadata:
name: agent-sandbox
spec:
template:
metadata:
labels:
workload: agent-sandbox
spec:
nodeClassRef:
group: karpenter.k8s.aws
kind: EC2NodeClass
name: default
taints:
- key: workload
value: agent-sandbox
effect: NoSchedule
expireAfter: 24h
requirements:
- key: karpenter.sh/capacity-type
operator: In
values: ["spot", "on-demand"]
limits:
cpu: "100"
disruption:
consolidationPolicy: WhenEmpty
consolidateAfter: 2m
Sandbox pods then carry a matching toleration and node selector.  WhenEmpty  removes nodes only when no pods remain, so nothing is repacked underneath a running sandbox. On Auto Mode,  nodeClassRef  points at its  NodeClass  instead.
A taint and a separate pool do not make untrusted code safe on their own. They stop a mistake from spreading to your platform nodes, and you still want stronger isolation such as a sandboxed runtime.

What I would do

  • Small, steady cluster with uniform pods and little Spot: stay on Cluster Autoscaler and spend the effort on pod requests.
  • Varied pods, meaningful Spot use or bursty demand: move to Karpenter. Start with Auto Mode if Bottlerocket and no node access are acceptable, and self-manage when you need AMI or node control.
  • An agent platform: Karpenter with separate NodePools for sandboxes, session pods and GPU work, with disruption settings treated as part of the design.
If you do move, the two tools can run side by side. Add Karpenter next to your node groups, remove Cluster Autoscaler before you drain anything because two autoscalers on one cluster fight each other, keep a small managed node group for Karpenter and core add-ons, shrink the old groups gradually behind PodDisruptionBudgets, and put a CPU limit on every NodePool.
Karpenter is the better default for new AWS clusters in 2026, but "better default" is not "mandatory."
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article