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

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.”

When your Kubernetes pods are being terminated due to memory limits (OOMKilled), you are dealing with a resource request/limit mismatch . Several commercial platforms, open-source utilities, and native options exist to help automatically right-size or recommend correct CPU and memory settings.

Fully Autonomous & Automated Real-Time Rightsizing

These tools continuously monitor live production usage and safely apply resource updates directly to your workloads without requiring manual intervention.

• ScaleOps : Focuses entirely on autonomous, continuous pod-level rightsizing using machine learning, adjusting CPU and memory requests in production dynamically while respecting safety constraints.
• CAST AI : Provides a dedicated Workload Autoscaler that automatically analyzes historical and real-time usage patterns, updating pod specifications to stop OOM kills while simultaneously bin-packing and managing cluster nodes.
• Sedai : An autonomous, SLO-aware cloud-native platform that safely executes continuous vertical and horizontal adjustments to prevent resource starvation.
• StormForge : Uses machine learning forecasts to optimize CPU and memory requests/limits, featuring automation capabilities to patch objects directly inside your clusters.

Recommendation-Only & Open-Source Tools

If you prefer not to grant automated write-access directly to your production clusters right away, these tools provide data-driven suggestions or dashboard metrics that you can review or pipe into GitOps pipelines.

• Fairwinds Goldilocks : An open-source controller that runs the Kubernetes VPA in recommendation mode across your namespaces and aggregates the data into a clean, easy-to-read dashboard.
• Kubecost : Built on top of OpenCost , Kubecost provides deep cost visibility alongside actionable, container-level sizing recommendations to fix over-provisioned or OOM-prone pods.
• Kubernetes Vertical Pod Autoscaler (VPA) : The native upstream Kubernetes project. It can run in Recommendation mode to suggest sizes, or Auto/Recreate mode to apply them—though the native auto mode forces pod restarts, which many production teams avoid for sensitive workloads.

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

• Are you running on a specific cloud provider like AWS (EKS), Azure (AKS) , or Google Cloud (GKE)?
• Do you prefer an open-source/free advisory tool or a fully managed commercial platform that applies changes automatically?

If pods are getting killed because memory limits are too low (often showing as OOMKilled), you’re looking for Kubernetes resource rightsizing tools. These analyze historical CPU/memory usage and recommend—or sometimes automatically apply—better requests and limits.

Common options:

A typical progression:

1. Start safely

   • Enable VPA in recommendation mode.
   • Use Goldilocks to review recommendations.
   • Fix obvious mis-sized workloads.

2. For larger fleets

   • Use StormForge, CAST AI, or similar tools if you want continuous optimization and policy-controlled automation.

3. Be careful with memory

   • CPU is usually easier to tune because throttling slows workloads.
   • Memory under-sizing causes hard failures (OOMKilled), so leave headroom for spikes, caches, JVM heaps, garbage collection, and traffic bursts.

A useful first diagnostic is to separate:

• request too low → scheduling/capacity issues
• limit too low → container gets killed
• application leak/spike → rightsizing alone may not solve it

If you share your environment (EKS/AKS/GKE/on-prem, number of clusters, and whether you want recommendations vs fully automatic changes), I can narrow the shortlist.

If pods are being OOMKilled because memory requests and limits are poorly sized, there are several mature options. They generally fall into two categories: recommendation tools (they tell you what to change) and automation platforms (they continuously apply changes).

Open-source options

• Goldilocks (Fairwinds) is probably the most widely used open-source starting point. It runs VPA in recommendation mode and provides dashboards showing suggested CPU and memory requests. It does not modify deployments automatically, making it low risk.

• Vertical Pod Autoscaler (VPA) is the Kubernetes-native solution. It can:

  • provide recommendations only,
  • apply recommendations when pods are recreated, or
  • automatically evict and recreate pods with new requests.

  Many production teams use it in recommendation mode because fully automatic mode can restart workloads and requires careful coordination with HPAs.

• Robusta KRR (Kubernetes Resource Recommender) analyzes Prometheus metrics and produces request recommendations, often using longer historical windows than VPA. It's commonly used in GitOps workflows where recommendations become pull requests.

• Kubecost provides rightsizing recommendations alongside cost visibility, helping identify workloads that are over- or under-provisioned. Community users frequently pair it with manual review rather than automatic application.

Commercial platforms

If you're looking for continuous, automatic rightsizing, commercial platforms tend to be more capable.

• CAST AI continuously adjusts CPU and memory requests based on observed usage, integrates with HPA, and is designed to reduce both wasted capacity and OOM events through automated tuning.

• StormForge uses machine learning to recommend and optionally automate resource tuning, often integrating with CI/CD or GitOps workflows. It is frequently evaluated by enterprises looking beyond basic VPA functionality.

• PerfectScale focuses on automated resource optimization and performance analysis. Users often pair it with Karpenter or cluster autoscalers for end-to-end infrastructure optimization.

• ScaleOps is another commercial platform that provides autonomous workload optimization and is commonly mentioned alongside CAST AI and StormForge in Kubernetes operations discussions.

If you're currently seeing OOMKills

For memory-related pod terminations, a practical progression is:

1. Install Goldilocks or KRR to establish realistic request recommendations.
2. Adjust memory requests and limits based on observed peak usage plus appropriate headroom.
3. If you have hundreds of services and manual tuning becomes burdensome, evaluate an automation platform such as CAST AI, StormForge, or PerfectScale.

This approach lets you reduce OOMKills without immediately introducing automated changes across your production workloads.

Tools that automatically right-size or recommend correct resource requests for Kubernetes pods generally fall into three categories: native controllers, open-source dashboard tools , and commercial autonomous optimization platforms.

1. Native Kubernetes Tools (Recommendation & Automation)

• Vertical Pod Autoscaler (VPA): The official upstream Kubernetes project for vertical scaling. It monitors historical CPU and memory usage patterns (via metrics-server or Prometheus) and can operate in different modes:
  • Off mode: Only provides recommendations without modifying anything.
  • Recreate / Auto mode: Automatically evicts and recreates pods to apply new right-sized values.
  • Note on Memory: Because memory is incompressible, letting VPA automatically restart and evict pods requires careful threshold configuration (minAllowed and maxAllowed ) to prevent continuous recycling loops.

2. Open-Source Visualization & FinOps Tools (Recommendations)

• Goldilocks (by Fairwinds): A popular controller that works in tandem with the VPA. Instead of managing or killing pods, Goldilocks creates a VPA object in off mode for every deployment in a labeled namespace and aggregates the suggestions into a clean, easy-to-read web dashboard. It displays your current requests side-by-side with recommended container sizing.
• Kubecost / OpenCost: While primarily known for cost visibility and FinOps tracking, Kubecost analyzes historical container usage and surfaces specific right-sizing recommendations directly in its interface or via Prometheus metrics, allowing platform engineers to adjust specs manually or tie them into automation pipelines.

3. Commercial Autonomous Optimization Platforms

• ScaleOps: An autonomous platform built specifically to continuously right-size CPU and memory requests and limits in real time without relying on standard VPA pod evictions. It tracks workload patterns (such as JVM or stateless web behavior) and applies changes dynamically.
• CAST AI: Offers an automated workload rightsizing engine (often paired with its node-level bin-packing and Karpenter -like autoscaler) that continuously adjusts requests to match actual application consumption, significantly cutting down on over-provisioning and OOM kills.
• PerfectScale & Datadog Kubernetes Autoscaling: Both platforms analyze real-time/historical telemetry via their respective agents to surface multi-dimensional scaling recommendations and, depending on preference, can apply these updates automatically or through GitOps workflows.

If you'd like to share your current setup (e.g., whether you use Prometheus, GitOps/ArgoCD, or a specific cloud provider), I can help you decide whether an open-source VPA/Goldilocks pipeline or an out-of-the-box automated platform fits your workflow best.