Product Updates
November 3, 2026 • 11 min read

Observability Has Spent 20 Years Finding Problems. It's Time to Start Fixing Them.

Observability has spent decades finding problems. groundcover CEO Shahar Azulay explains why it's time for infrastructure to start fixing them.

Shahar Azulay
Shahar Azulay
November 3, 2026
11 min read
Product Updates

For the better part of two decades, the observability industry has been helping engineers answer the same question: what's wrong with my infrastructure?

We've gotten remarkably good at answering it. We can collect billions of events, reconstruct distributed transactions, correlate metrics with logs, and now use AI to investigate incidents in seconds. The amount of information available to engineers today would have been unimaginable ten years ago.

And yet, after all that investment, the outcome is often the same. An engineer gets an alert, opens a dashboard, figures out what needs to change, and goes off to change it.

I've been thinking about how absurd that is.

We built increasingly sophisticated systems to understand our infrastructure, but we still rely on people to manually act on much of what those systems discover. The industry has treated understanding the problem as the finish line, when it should have been the starting point.

I think that's about to change.

The Kubernetes problem everyone knows about

Take something as basic as allocating CPU and memory in Kubernetes.

When an engineer deploys an application, they have to decide how much of each resource it needs. The problem is that they're making this decision before they know how the application will behave in production. Even with good historical data, they're estimating future demand.

Most teams compensate by over-provisioning. It's the rational thing to do. Nobody wants to be responsible for a production incident because they tried to save a few dollars on compute.

But that safety margin has a cost. Kubernetes schedules workloads based on their resource requests, so over-provisioning can leave expensive capacity sitting unused. Across hundreds of nodes and thousands of workloads, those small inefficiencies add up.

Under-provisioning creates a different set of problems. Insufficient CPU requests can leave workloads competing for resources, while insufficient memory requests can increase the risk of eviction under node pressure. And when actual memory consumption exceeds a container's limit, the result can be an out-of-memory kill.

And even when teams have a Kubernetes node autoscaler in place, the underlying problem remains. Tools like Karpenter can adjust cluster capacity based on the resources workloads request, but they depend on those requests being accurate in the first place. If every application is asking for more CPU and memory than it needs, the autoscaler can end up provisioning more infrastructure than necessary.

What makes this particularly frustrating is that we already have the information needed to make better decisions.

An observability platform can see actual resource consumption, identify usage patterns, and distinguish workloads that consistently need more capacity from those that have been allocated far too much.

So why does an engineer still need to review that information and manually update resource requests?

And why should they have to keep doing it as application behavior changes?

The problem isn't that we lack the data. It's that we've built an artificial boundary between observing infrastructure and operating it.

Why we acquired Wand

In September, groundcover acquired Wand, a company focused on autonomous Kubernetes resource optimization.

The acquisition was driven by a fairly simple idea: if we already understand how infrastructure behaves in production, we should be able to use that understanding to continuously improve how it operates.

Wand had built technology to optimize Kubernetes resource allocation. groundcover already had an eBPF-based observability platform collecting detailed production telemetry across applications and infrastructure.

Putting the two together gives us something neither approach delivers as effectively on its own: a direct connection between understanding how infrastructure behaves and taking action to improve it.

Today, we're introducing the first result of that combination, groundcover Autonomous Infrastructure, available in beta.

It continuously optimizes Kubernetes CPU and memory requests based on actual workload behavior. When resources are over-provisioned, it can reduce unnecessary allocation. When workloads need more resources, it can increase requests within defined boundaries.

But this isn't simply a system that watches CPU utilization and adjusts requests up or down. That approach is inherently reactive, and by the time it responds to a spike, the application may already be experiencing problems.

Autonomous Infrastructure analyzes historical behavior and the wider Kubernetes environment to anticipate resource requirements. It considers not only how an individual workload behaves, but how other workloads on the same infrastructure affect it, including resource contention and noisy neighbors. The goal is to have the right capacity allocated before it's needed, rather than continually reacting after demand changes.

This is also what distinguishes it from traditional workload right-sizing. Looking at the historical peaks and averages of a single workload only tells part of the story. The same resource request can be perfectly adequate in one environment and create stability problems in another. Optimizing safely requires understanding the environment as a whole.

The system considers how workloads fit onto nodes, how much capacity remains available, and whether an adjustment could create resource pressure elsewhere.

It works alongside existing node autoscalers rather than replacing them. Autonomous Infrastructure determines the appropriate resource requests for workloads, while tools like Karpenter can use those requests to provision the necessary cluster capacity. That connection is how better workload allocation can translate into actual cloud infrastructure savings.

Because optimizing infrastructure isn't just about reducing cost. It's about finding the right balance between efficiency and reliability, and continuously maintaining that balance as conditions change.

The advantage of already being there

There's another reason this combination is interesting, and it comes down to architecture.

Most Kubernetes optimization products need to install their own components, collect workload data, and build enough history before they can make meaningful recommendations.

For groundcover customers, that information already exists.

Our eBPF sensor is already running in their Kubernetes environments, collecting the production telemetry needed to understand resource consumption. The data is already stored in their own cloud, through our BYOC architecture.

And that data goes beyond basic CPU and memory utilization. groundcover already collects infrastructure metrics, application performance data, traces, and logs. Bringing optimization into the same platform gives us a much richer understanding of how workloads behave and how resource allocation relates to application performance.

This is particularly important because the cheapest resource configuration isn't necessarily the right one. Reducing CPU requests might save money, but not if it introduces contention or compromises application stability. The broader observability context helps us make more informed optimization decisions, and gives engineers the information they need to understand and evaluate them.

That changes the experience considerably.

When a customer opens Autonomous Infrastructure, they can immediately see which workloads are over-provisioned, which are running short of resources, and what their estimated savings could be. They can evaluate the opportunity before allowing the system to make a single change.

This is available as a dry run, without enabling autonomous changes. Customers can explore the potential savings, inspect recommendations, and understand why particular adjustments are being suggested. They can also see the impact of optimizations that have already been applied.

There's no separate optimization product to deploy just to discover the opportunity, and no additional observability dataset to build.

This is an important distinction. We aren't introducing another disconnected infrastructure tool that needs to learn about your environment. We're extending the observability platform that's already there.

And while we're calling it autonomous, that doesn't mean we're asking engineers to surrender control.

The system is off by default. Customers decide which workloads, namespaces, or clusters to optimize, and define the boundaries within which changes can happen. Policy changes are tracked, and during the beta, optimization is limited to CPU and memory requests rather than resource limits.

The system continuously evaluates workload behavior and updates its desired resource allocations. But that doesn't mean it restarts applications every time utilization changes. When supported by the Kubernetes environment, it can apply resource adjustments in place without restarting pods. When a rollout is necessary, changes are governed by thresholds designed to avoid unnecessary disruption.

And if a customer decides to stop optimizing a workload, the system restores its original resource request values.

Autonomy should remove repetitive operational work, not remove engineers from decisions that matter.

From understanding infrastructure to operating it

I believe we're approaching a fundamental shift in what an observability platform is supposed to be.

The first generation of monitoring tools told us when something was broken. The next generation helped us understand why. More recently, AI has made it possible to investigate complex production problems without requiring engineers to manually search through every signal.

Each step has reduced the amount of work required to understand what's happening.

But understanding isn't the same as solving.

If a system can reliably identify an inefficient resource allocation, determine a better configuration, and make that change within clearly defined safety boundaries, what value is there in requiring an engineer to perform those steps manually?

The answer, increasingly, is none.

That doesn't mean every infrastructure decision should be automated. Production environments are complicated, and there will always be situations that require human judgment. But a surprising amount of infrastructure management consists of repeatable decisions based on information we already collect.

Those decisions are good candidates for autonomy.

Kubernetes resource optimization is where we're starting because it offers a clear way to measure the results. We can quantify wasted resources, identify stability risks, and evaluate the impact of adjustments over time.

And we're starting with CPU and memory requests for Kubernetes Deployments, which represent a significant portion of the resource allocation decisions engineers make every day. Over time, the opportunity is much broader. Imagine resource optimization that can account for application latency, service-level objectives, and other performance signals, rather than relying primarily on infrastructure utilization. That's the direction we're building toward.

But the larger opportunity is to make observability an active part of infrastructure operations rather than a separate system that reports on them.

This is also how I think about the future of groundcover. Our investment in eBPF, BYOC, and AI-driven investigations has been about giving engineers complete access to what's happening in their environments, without forcing them to compromise on data, cost, or control.

Autonomous Infrastructure builds on that foundation. It turns information we're already collecting into improvements the platform can make on its own, under the customer's direction.

Starting with this beta, groundcover customers running our Kubernetes sensor can explore optimization opportunities and estimated savings at no additional charge. Customers who want to enable autonomous changes can opt in by upgrading their installation and enabling the optimization components. The beta is free to try, with commercial pricing to be determined ahead of general availability.

For years, observability vendors have competed to show engineers more information, faster.

I think the next competition will be about how much work that information can eliminate.

The future of observability isn't another dashboard telling you what to fix. It's infrastructure that knows how to improve itself.

Shahar Azulay
Shahar Azulay
 
CEO

8 min read |
Published on: Nov 03, 2026

Latest posts

Explore related posts

Sign up for Updates

Keep up with all things cloud-native observability.

We care about data. Check out our privacy policy.

No items found.
No items found.
No items found.
No items found.
No items found.
No items found.
No items found.