EKS Auto Mode Resizes Pod Requests In Place From Observed Usage
Amazon EKS Auto Mode is the managed Kubernetes mode in which AWS owns the nodes and provisions EC2 instances to fit the resource requests declared by Pods, and resource optimization is the new preview feature that adjusts those requests from measured usage.
AWS published resource optimization on 17 November 2026 for clusters running Kubernetes 1.36 or later in seven regions, at no additional charge.
A ClusterResourceOptimizationPolicy selects the namespaces and workloads to manage and sets a mode:
- Recommend collects usage and writes recommendations
- Apply also resizes running Pods in place through the Pod resize subresource
The resize never edits the Deployment or StatefulSet Pod template, so Argo CD and Flux keep seeing the manifest their repository holds and have nothing to revert.
A CPU request is sized so that the 95th percentile of observed usage lands at about 87% of the request in the single Balanced profile, and a container needs about 12 hours of history before the first recommendation.
The feature covers CPU and memory on Deployments and StatefulSets; GPUs, ephemeral storage, replica counts, HPA and KEDA metrics, and workloads managed by the Vertical Pod Autoscaler all stay as they are.
The preview has no automatic rollback and no console page, so a production rollout depends on the policy scope and the opt-outs a platform team writes down.
Page capture of "Amazon EKS Auto Mode now rightsizes Pods to reduce compute costs (Preview)", posted 17 November 2026. Source: aws.amazon.com/about-aws/whats-new/2026/11/eks-auto-mode-pod-rightsizing-preview, captured 17 November 2026.
Node cost in EKS Auto Mode has always followed one number: the resource request written in a Pod template. Auto Mode bin-packs Pods onto instance types that fit the sum of those requests, replaces nodes when the same work fits on fewer of them, and never looks at what a container actually consumed. The requests themselves were the part nobody revisited after the first deploy, which is the gap AWS opened a preview against on 17 November 2026.
What resource optimization changes about a Pod request
The feature observes each container's CPU and memory usage and turns that into a recommended request for the workload. The scope is deliberately narrow: Deployments and StatefulSets, CPU and memory, and nothing else. Replica counts are untouched, GPUs are untouched, ephemeral storage is untouched, and the recommendation appears as a ResourceOptimization object in the workload's namespace, with the short name ro, which the cluster writes and deletes and nobody edits by hand.
AWS diagram from the Auto Mode documentation: the standard cluster model on one side, the Auto Mode cluster with EC2 managed instances and its load-balancing and NAT path on the other. Source: docs.aws.amazon.com/eks/latest/userguide/auto-mode, retrieved 17 November 2026.
That object model is the part worth reading twice, because it separates the recommendation from the workload definition. The recommendation exists beside the workload, records which policy supplied each setting, and disappears when no policy selects that workload any more. Nothing in that flow requires a manifest change.
How the Recommend and Apply modes differ
Two modes exist and the default is the cautious one. Recommend collects usage and produces recommendations without changing a single Pod, which makes it usable on a production cluster the day the policy is created. Apply performs the resize, and a policy that omits mode never reaches that state by accident.
The mechanism behind Apply is the interesting one. The resize goes through the Kubernetes Pod resize subresource, which changes the running Pod without recreating it. The Deployment or StatefulSet template keeps the value that a team originally wrote, so a GitOps controller compares the cluster against the repository, finds the manifest it expects, and has no drift to correct. New Pods created later by a scale-out, a node consolidation or a rollout start at the recommended size.
Netics visual, 17 November 2026: the two modes, the untouched Pod template and the twelve-hour history the first recommendation needs.
Why the request decides the bill
Auto Mode's cost machinery reads requests in three places. Bin-packing picks instance types that match the aggregate requests, consolidation replaces nodes when the same Pods fit on fewer or smaller instances, and right-sizing moves Pods onto smaller nodes as a workload scales down. Every one of those decisions takes the declared request as the truth, so a request set at double the real need produces a cluster that is consistently twice as large as the work requires, and consolidation cannot help because the Pods still claim the capacity.
The feature changes the input to that machinery. It does not change the machinery, does not add a separate cost control, and does not set a budget. A NodePool limits setting remains the only hard ceiling on provisioned capacity, and it keeps its behaviour: when the limit is reached, Auto Mode stops launching nodes for that pool even with Pods pending.
What the Balanced profile measures
One optimisation profile ships in the preview, named Balanced. For CPU it sizes the request so that the 95th percentile of the container's observed usage lands at about 87% of the request. That is a headroom rule expressed as a percentage, and it leaves the remaining 13% of the request as the buffer a burst consumes before the container is throttled or the node runs short.
Page capture of the user guide page "Rightsize workloads with resource optimization", which documents the policy, the two modes and the sizing profile. Source: docs.aws.amazon.com/eks/latest/userguide/auto-resource-optimization, captured 17 November 2026.
Timing matters as much as the target. A container needs about 12 hours of usage history before resource optimization produces its first recommendation, and until then it keeps the request from its Pod template. A workload deployed on Friday afternoon therefore has no recommendation until Saturday morning, which is a detail that decides whether a rollout plan can rely on the feature at all.
What stays outside the feature
The exclusions are stated and they are the ones that cause incidents when they are assumed away. GPUs and ephemeral storage keep their declared values, replica counts do not move, and the feature does not touch the CPU or memory that a Horizontal Pod Autoscaler or KEDA scales on, so an autoscaling policy built on utilisation keeps its own arithmetic. Workloads the Vertical Pod Autoscaler manages can be excluded, which matters for teams running both controllers on one cluster.
Two operational gaps belong on the same list. There is no automatic rollback, so a recommendation that degrades a workload stays applied until someone opts the workload out or switches its policy back to Recommend. And there is no resource optimization page in the EKS console: the policy and the recommendation objects show up in the Kubernetes resource viewer as read-only, which means the command line and the API are where this feature lives.
Netics visual, 17 November 2026: the 87% figure is the share of the request that sits above the 95th percentile of observed CPU usage.
How to run it as a preview in production
The cautious sequence is the one the documentation implies. Create the policy across the application namespaces in Recommend, let the 12 hours of history accumulate, then compare recommendations against what the templates declare and against what the dashboards show for the same containers. A recommendation far below a declared request is either the saving the team wanted or a signal that the request was covering a burst the sampler did not see. Apply then belongs on one namespace at a time, with the ordering namespaces get in real estates: a batch worker with retries tolerates a resize far better than an interactive API that holds a Java heap. AWS names the Java case directly, describing a platform team that rightsizes every application namespace under Argo CD while the feature keeps memory above each heap and raises memory after an out-of-memory kill.
Where Auto Mode still depends on the workload owner
Rightsizing does not overrule two things the workload owner configures. The karpenter.sh/do-not-disrupt annotation keeps a node alive for as long as the annotated Pod runs on it, so the node cannot be consolidated, replaced or terminated, and a request that shrinks on such a node produces no saving at all. Pod disruption budgets set to maxUnavailable: 0, or to a minimum equal to the current replica count, block consolidation in the same way.
Netics visual, 17 November 2026: the boundaries AWS states for the preview, from workload types to the missing rollback.
Teams that already run their cluster with DevOps pipelines and managed monitoring in place have the measurements this preview needs, which is the practical entry point: a usage series per container, a policy in Recommend, and a written decision about which namespaces may ever reach Apply. The preview's real contribution is narrower than a cost reduction claim. It moves the request out of the template and into a controller that reads usage, and it does so without breaking the manifest a repository holds. Whether that produces savings depends on the annotations, the budgets and the instance ceiling a team already chose.
Originally published on the Netics blog.
Comments
No comments yet. Start the discussion.