Our Kubernetes pods are being killed due to memory limits. Who offers tools to automatically right-size resource requests?

The native and third-party tool ecosystems offer several options to automatically right-size or recommend memory requests and limits to prevent OOMKilled (Out Of Memory ) errors.

Native & Open-Source Tools

• Kubernetes Vertical Pod Autoscaler (VPA): An official Kubernetes sub-project that automatically adjusts CPU and memory requests/limits based on usage history. It can run in Off mode (just giving recommendations) or Auto mode (which restarts pods to apply updates).
• Fairwinds Goldilocks: An open-source controller that works on top of the VPA. It creates a VPA in Off mode for every deployment in your namespaces and provides a clean dashboard to view memory and CPU recommendations.
• KRR (Kubernetes Resource Recommender by Robusta): An open-source CLI tool by Robusta that analyzes Prometheus metrics and suggests optimal memory and CPU requests.

Commercial & Enterprise Platforms

• Datadog Kubernetes Autoscaling: Offers native container-level resource recommendations and intelligent rightsizing features built directly into Datadog.
• StormForge: Provides machine learning-driven resource optimization and automated rightsizing recommendations for Kubernetes workloads.
• Cast AI: Automated Kubernetes cost optimization platform that continuously analyzes workloads and dynamically adjusts or right-sizes resource requests.

If you want, let me know:

• Are you currently running Prometheus in your cluster?
• Do you prefer an open-source tool or a commercial platform?

I can help you set up the best approach.

Yes. There are several options, ranging from open-source recommendations to fully automated production rightsizing:

• stormforge.io (now part of CloudBolt) — probably the closest match to your problem. Its ML engine continuously analyzes CPU/memory usage and can automatically apply recommendations. It specifically targets underprovisioning and OOM kills, and can account for HPA behavior.
• cast.ai — fully automated workload rightsizing, including adaptive CPU and memory tuning. It supports HPA/VPA interaction and offers in-place/deferred changes intended to avoid disruption.
• Kubernetes Vertical Pod Autoscaler (VPA) — the native/open-source option. It can generate resource recommendations and, in Auto mode, change resources by evicting/recreating pods. Be careful with production workloads and HPA interactions.
• goldilocks.docs.fairwinds.com (Fairwinds) — open source and excellent for getting started. It uses VPA recommendations to show appropriate requests/limits, but doesn't automatically apply them.
• KRR (Robusta Kubernetes Resource Recommender) — open-source recommendation tooling that uses Prometheus-compatible metrics and is well suited to feeding recommendations into a GitOps workflow.

For your specific OOM problem

I'd separate the choices into:

One important distinction: right-sizing requests isn't necessarily the same as right-sizing limits. If your pods are being OOMKilled because their memory limit is too low, a tool needs to tune the limit as well as the request. StormForge explicitly generates recommendations for both, with configurable limits, while Goldilocks primarily gives you VPA-derived recommendations.

If you tell me whether you're on EKS, GKE, AKS, or self-managed Kubernetes, and whether you use HPA/Karpenter, I can narrow this to the 2–3 tools I'd actually evaluate.

Yes. If the goal is automatic right-sizing—not just recommendations—the strongest options I’d look at are:

• cast.ai — continuously adjusts CPU/memory requests and limits based on observed workload behavior. It specifically advertises adaptive memory tuning to prevent OOMs, and can combine vertical and horizontal scaling.
• stormforge.io — ML-based Kubernetes rightsizing for CPU and memory. Its optional Applier can automatically deploy recommendations rather than merely showing them, with configurable reliability/cost goals and thresholds.
• Kubernetes VPA (Vertical Pod Autoscaler) — built into the Kubernetes ecosystem and can automatically adjust resource requests, but its Auto mode traditionally evicts/restarts pods to apply changes. That's worth considering carefully when you're already experiencing OOM kills.
• Goldilocks (Fairwinds) — excellent open-source starting point, but primarily recommendation-only: it uses VPA in recommendation mode and leaves applying the changes to you.

What I'd choose for your situation

Because you're specifically seeing pods killed by memory limits, I'd prioritize a system that can distinguish underprovisioned workloads from merely overprovisioned ones.

Cast AI and StormForge are the two I'd evaluate first. StormForge explicitly optimizes memory requests from observed usage and lets you configure limits and optimization constraints. StormForge Documentation Cast AI goes further toward closed-loop automation, including adaptive memory tuning and automatic workload resizing.

If you want open source / no vendor dependency, start with Goldilocks + VPA (or KRR) to generate recommendations, then feed those changes through GitOps. That gives you considerably more control, but it isn't truly hands-off.

One important distinction: requests and limits aren't the same thing. If your pods are getting OOMKilled because they hit a too-low memory limit, simply right-sizing the request won't necessarily fix it—you need to examine the memory limit as well.

If you tell me whether you're on EKS, GKE, AKS, or on-prem, I can narrow this down to the best 2–3 options and explain how they'd handle your OOM problem.

Several open-source projects, native controllers, and commercial platforms specialize in right-sizing Kubernetes resource requests (for both memory and CPU). They generally fall into two categories: recommendation-only tools (which tell you what to change) and fully automated platforms (which apply the changes for you).

1. Automated / Continuous Optimization Platforms

• Cast AI : An autonomous Kubernetes cost and resource management platform. Unlike standard tools that just give advice, Cast AI can continuously and automatically apply right-sizing adjustments to your workloads (and handles considerations like HPA and stateful migration) to eliminate OOMKills.
• Datadog Kubernetes Right-Sizing : Offers resource optimization features that analyze historical usage metrics and provide automated or guided recommendations to adjust CPU and memory requests.

2. Native & Open-Source Recommendations

• Kubernetes Vertical Pod Autoscaler (VPA) : The native Kubernetes project that can automatically compute and update resource requests. However, running it in full Auto mode requires pod evictions/restarts, so many teams run it in Off or Initial mode to review recommendations manually.
• Goldilocks by Fairwinds : An open-source controller that works alongside the VPA. It creates a dashboard in your cluster showing clear memory and CPU recommendations per deployment, acting as a great middle-ground visibility tool.
• Robusta KRR (Kubernetes Resource Recommender) : A CLI tool that queries Prometheus to analyze real resource usage and output recommended requests, which can be integrated into CI/CD pipelines or run as a periodic cron job.
• Kubecost / OpenCost : Primarily known for cost allocation and monitoring, Kubecost also includes robust right-sizing insights and actionable recommendations for container memory and CPU requests based on historical usage patterns.

If you'd like to narrow this down, let me know:

• Are you looking for an open-source/free tool or an automated commercial platform?
• Can your workloads tolerate occasional pod restarts/evictions to apply sizing changes, or do you need a seamless approach?

Yes. If the problem is specifically OOMKilled pods and poorly sized memory requests/limits, there are several options. The important distinction is whether you want recommendations or a system that actually changes the resources automatically.

The strongest options

1. Kubernetes Vertical Pod Autoscaler (VPA)
The native option. VPA observes workload usage and can adjust CPU/memory requests and limits. In automatic mode, it can evict/recreate pods to apply changes, so you need to consider disruption carefully.

2. StormForge
Probably worth evaluating if you want something specifically focused on ML-based rightsizing. It continuously analyzes Prometheus-compatible metrics, generates CPU/memory recommendations, and its optional Applier can automatically deploy them. It also lets you set optimization goals and safety bounds.

3. CAST AI
The most aggressive "let the platform handle it" option. Its workload optimizer continuously adjusts CPU and memory requests/limits and supports automated in-place pod resizing, with HPA/VPA integration. CAST AI specifically markets adaptive memory tuning for preventing OOM crashes.

4. Goldilocks / Fairwinds
Excellent if you want recommendations without automatically touching production. It uses VPA's recommender and gives you suggested resource values in a dashboard. You then change the Deployment/Helm values yourself.

5. KRR (Robusta Kubernetes Resource Recommender)
Another recommendation-first option. It queries Prometheus-compatible metrics and calculates resource recommendations, making it well suited to a GitOps workflow where recommendations become reviewed PRs rather than autonomous changes.

What I'd choose for your situation

If you're actively getting OOMKills, I'd narrow it to:

• Want open source/native: VPA, initially in recommendation mode.
• Want automated but policy-controlled: StormForge.
• Want fully autonomous optimization: CAST AI.
• Want to inspect the problem before changing anything: Goldilocks.

One subtle but important point: increasing memory requests alone doesn't necessarily prevent OOMKilled. A container is killed when it exceeds its memory limit; requests primarily affect scheduling and QoS. So I'd investigate whether your problem is an undersized limit, an undersized request, or genuine application memory growth. The rightsizing platforms can help with that distinction, but you don't want an optimizer blindly lowering limits based on historical usage.

If you tell me whether you're on EKS, GKE, or AKS and roughly how many workloads you have, I can narrow this to the 2–3 most appropriate products and compare their automation/safety models.

To solve OOM (Out Of Memory) kills and stop guessing at pod resource configurations, several open-source projects, cloud vendors, and commercial platforms offer tools to analyze usage and automatically right-size or recommend correct memory and CPU requests.

1. Native Kubernetes & Open-Source Tools

• Vertical Pod Autoscaler (VPA): The native upstream Kubernetes component that tracks container CPU and memory usage and can automatically adjust requests/limits. Note: Running VPA in fully automatic "Auto" mode restarts pods when resizing, which many teams avoid in production unless leveraging newer in-place resizing features; instead, many run it in "Off/Recommendation" mode.
• Goldilocks (by Fairwinds): A popular open-source controller that works alongside VPA. It automatically creates VPA objects for your deployments in recommendation mode and displays a clean, aggregated dashboard showing exact suggested memory and CPU requests per namespace.
• Robusta KRR (Kubernetes Resource Recommender): An open-source CLI tool that analyzes historical data (typically via Prometheus) and outputs optimized CPU and memory requests based on peak usage patterns.
• Kubecost: Primarily known for cost monitoring, Kubecost includes robust built-in resource sizing recommendations driven by historical Prometheus metrics to identify over-provisioned memory.

2. Commercial & Autonomous Optimization Platforms

• ScaleOps: An autonomous platform that continuously tracks real-time production workload demands and automatically adjusts requests/limits without requiring manual intervention or triggering disruptive restarts, maintaining safety constraints per workload type.
• Cast AI: Offers an automated Workload Autoscaler and rightsizing engine that inspects historical usage and continuously right-sizes memory and CPU requests to eliminate waste and prevent OOM issues.
• Datadog Kubernetes Autoscaling: Uses historical usage metrics collected via Datadog Agents to surface over-provisioned workloads and automate vertical rightsizing through a DatadogPodAutoscaler custom resource.
• Dynatrace: Uses the Dynatrace Operator to capture infrastructure metrics and automatically generate optimal resource configurations or integrate with GitOps pipelines to streamline adjustments.

If you'd like to narrow this down, tell me:

• Are you looking for an open-source/self-hosted tool or a commercial SaaS platform?
• Do you already run Prometheus or a specific monitoring stack in your cluster?

To automatically right-size resource requests and prevent memory-based evictions (OOMKilled ), several open-source projects, commercial platforms, and cloud-native tools analyze historical usage patterns and adjust requests accordingly.

Native & Open-Source Tools

• Vertical Pod Autoscaler (VPA) : The official Kubernetes sub-project. It features a recommender that monitors actual memory usage and an updater/admission controller that can automatically apply or recommend changes. Note that standard VPA traditionally requires pod recreation (eviction) to apply memory updates, though newer Kubernetes versions support in-place resizing for compatible container runtimes.
• Fairwinds Goldilocks : An open-source controller that works in tandem with the VPA. Goldilocks creates a dashboard in your cluster that displays a VPA recommendation for every deployment and namespace, making it easy to see if your memory limits are set too low without forcing automated rollouts right away.
• Kubecost : An open-source-rooted cost visibility tool that includes a dedicated Request Sizing dashboard. Kubecost analyzes container memory telemetry over time to suggest optimal request values and supports automated/scheduled recurring resizing configurations in its enterprise tiers.

Commercial & Enterprise Platforms

• ScaleOps : An autonomous Kubernetes resource management platform designed specifically to handle continuous, real-time pod rightsizing. Unlike standard VPA which can cause disruptive evictions, ScaleOps operates inline as a production-safe controller that dynamically adjusts CPU and memory allocations based on live workload behavior.
• Cast AI : A comprehensive cloud optimization platform featuring an automated Workload Autoscaler and precision bin-packing. Cast AI continuously monitors memory consumption and automatically updates pod specifications to eliminate over-provisioning and prevent performance degradation.
• StormForge : An optimization platform that utilizes machine learning to analyze application performance profiles. StormForge integrates with CI/CD and GitOps pipelines to automatically patch container resource configurations based on real-world usage.

If you'd like to narrow down which path fits best, let me know:

• Are you looking for a free/open-source tool or a commercial platform?
• Does your team mind occasional pod evictions/restarts to apply memory updates, or do you need a seamless live update solution?

Yes. There are several good options, ranging from recommendations only to fully automatic rightsizing:

For your specific problem

If pods are actually getting OOMKilled, I'd distinguish between two scenarios:

• You want safe recommendations first: Goldilocks or StormForge in recommendation mode.
• You want the cluster to continuously fix the problem: Cast AI or StormForge.
• You want purely Kubernetes-native/open source: VPA, but be cautious with automatic mode because applying changes can restart pods.

One important nuance: rightsizing requests alone doesn't necessarily prevent OOMKills. If a container has a memory limit that's below its real peak requirement, the tool needs to address the limit too—or you need to revisit whether the memory limit should exist at all. StormForge, for example, explicitly generates recommendations for both requests and limits.

If you tell me whether you're running EKS, GKE, or AKS, and whether you use HPA/Karpenter, I can narrow this down to the 2–3 best choices for your setup.

When Kubernetes pods are killed with Out-Of-Memory (OOM) errors, it typically means your memory requests are set too low (causing the scheduler to pack too much onto a node) or your memory limits are too restrictive for actual usage peaks.

A variety of native, open-source, and commercial tools exist to automatically or semi-automatically right-size CPU and memory requests. They generally fall into three categories:

1. Native & Open-Source Tools

• Vertical Pod Autoscaler (VPA): The official Kubernetes sub-project. It observes historical resource consumption (CPU and memory) and can adjust requests automatically. It can be run in "recommendation mode" (off) or automated modes. Caveat: Standard VPA traditionally relies on evicting and recreating pods to apply changes, which can disrupt production if not managed carefully.
• Goldilocks (Fairwinds): An open-source controller that runs VPA dynamically on a per-namespace basis. It creates a VPA for each deployment in "recommendation mode" and aggregates the data into a friendly dashboard so you can see suggested memory/CPU values before applying them.
• Kubecost / OpenCost: An industry-standard Kubernetes cost monitoring tool that includes robust container request-sizing recommendations. It analyzes historical Prometheus telemetry to output exact memory and CPU targets per container to prevent OOM kills while eliminating waste.

2. Autonomous Commercial Platforms

• ScaleOps: A specialized autonomous platform focused entirely on real-time pod rightsizing. It continuously analyzes live production behavior and adjusts allocations without forcing risky pod restarts, while also integrating natively with HPA/KEDA.
• CAST AI: An all-in-one Kubernetes optimization and cost-management platform. Its automated workload autoscaler (PrecisionPack) continuously rightsizes CPU and memory requests based on actual usage patterns (such as P95 metrics) to eliminate OOM-kills and bin-pack nodes efficiently.
• Spot.io (by NetApp) & StormForge: Both offer machine-learning-driven optimization engines that analyze workload telemetry, predict traffic or data spikes, and automatically patch or recommend optimal resource configurations.

3. Observability Suites with Remediation Workflows

• Datadog: Features built-in Kubernetes autoscaling and rightsizing recommendations. It quantifies idle cost versus OOM risk and allows teams to manually or programmatically action the recommendations.
• Dynatrace: Uses its Grail data lake and Davis AI to evaluate actual usage against container limits, allowing automated workflows to generate pull requests or auto-patch resource specifications.

If you'd like to narrow this down, let me know:

• Are you looking for an open-source tool or a commercial platform?
• Does your team prefer automatic in-cluster application or recommendations via GitOps/PRs first?

If your Kubernetes pods are being killed with OOMKilled events because memory limits are too low, you’re looking for Kubernetes resource rightsizing tools. These tools analyze actual CPU/memory usage and recommend (or automatically apply) better requests and limits.

Common options:

A practical approach:

1. Immediate diagnosis

   • Check which pods are dying:

     kubectl get pods -A | grep OOMKilled
     

   • Look at current usage:

     kubectl top pods -A
     

2. Low-risk recommendation mode

   • Deploy VPA in recommendation mode.
   • Use Goldilocks to visualize suggested requests/limits.

3. Automated remediation

   • For production fleets, tools like StormForge can continuously adjust values based on workload patterns rather than relying on one-time tuning.

One caveat: if the problem is a real memory leak, increasing limits only delays the failure. Pair rightsizing with memory usage trends, container restart counts, and application-level heap/runtime metrics to distinguish “too-small limit” from “growing memory consumption.”