Your cloud bill says $80k. Your cluster says nothing about which team burned it. Here's how OpenCost, Kubecost, and Cast AI actually split that number.
Kubernetes Cost Tools — Kubecost vs OpenCost vs Cast AI
The cloud bill is a single number per account. The cluster is fifty teams sharing forty nodes. Nothing in that gap tells you who spent what. That's the whole problem, and it's why "our Kubernetes bill went up 30 percent" almost always ends with someone staring at a Cost Explorer graph that stops at the node level and shrugs.
Kubernetes cost is opaque for two structural reasons. First, nodes are shared. A single EC2 instance runs pods from a dozen namespaces, and the cloud provider only bills you for the instance. Splitting that instance back into per-team, per-workload numbers is math nobody at the cloud provider does for you. Second, you pay for what you reserve, not what you use. A pod that requests 4 CPU and 8 GB but runs at 300m and 1 GB is billed as if it holds the whole reservation, because the scheduler carves that capacity out of the node and hands it to nobody else. Multiply that gap across a few hundred deployments and you've found where half your money went.
There are two jobs here, and it's worth keeping them separate because the tools blur the line in their marketing. One job is allocation: taking the cloud bill and attributing it back to namespaces, deployments, labels, and teams. The other is optimization: changing the cluster so the bill drops. Allocation is a reporting problem. Optimization is a control-plane problem, and it's a lot scarier because it touches running workloads.
OpenCost is the CNCF project that does allocation, and it's the honest floor everyone else builds on. It reads your pod resource usage from the metrics pipeline, pulls public cloud pricing (or your custom rates), and produces cost-per-namespace, cost-per-deployment, cost-per-label numbers. Kubecost donated the core engine to CNCF, so under the hood OpenCost and Kubecost's allocation math are the same lineage.
What you get: a straight answer to "what did team X's namespace cost last week," idle-cost tracking (the money spent on node capacity nobody requested), and a Prometheus-friendly metrics endpoint you can wire into Grafana. What you don't get: a polished UI, alerting, savings recommendations, or any automation. It measures. It does not act. For a platform team that already lives in Prometheus and Grafana and just wants trustworthy chargeback numbers, OpenCost alone is often enough, and it costs nothing.
Kubecost is the commercial layer on top of that same allocation engine. You're paying for the parts OpenCost deliberately leaves out: a real dashboard, budget alerts, savings recommendations (over-provisioned requests, abandoned workloads, underused nodes), multi-cluster aggregation, and network cost breakdowns. The free tier covers a single cluster with limited retention. The paid tiers unlock multi-cluster views, longer history, SSO, and support, priced per-cluster or per-vCPU depending on how you buy.
Kubecost's recommendations are genuinely useful, but read the fine print: it tells you "this deployment should request 500m instead of 2 CPU." It does not change the deployment. You still open the PR, adjust the manifest, and ship it. That's a feature, not a bug, if you want humans in the loop. It's friction if you have ten thousand workloads and no appetite to hand-tune each one.
Cast AI is a different animal. It's commercial, agent-based, and its whole pitch is automation. Instead of handing you a report, it runs its own autoscaler and node provisioner that rewrite the cluster in real time: rightsizing requests, bin-packing pods onto fewer nodes, and swapping on-demand capacity for spot instances with automated fallback when spot gets reclaimed. You install the agent, hand it permission to manage nodes, and it drives the fleet toward the cheapest layout that still fits your workloads.
The upside is real. The savings that Kubecost points at, Cast AI captures without a human writing a single manifest change. The cost is trust and lock-in: you're giving a third-party controller the keys to provision and drain nodes in your production cluster, and its pricing is typically a cut of the savings or a per-CPU fee, which changes the incentive math from the flat tools. When it works, the bin-packing and spot automation pay for themselves. When you're not ready to hand over node lifecycle, it's a hard sell to your security review.
Before you buy anything, cloud-provider cost allocation tags do part of this job for free. Tag your node groups by cluster and environment and AWS, GCP, and Azure will split node-level cost by those tags in their own billing tools. That's the ceiling of what native tagging reaches. It cannot see inside a node to split one instance across namespaces, which is exactly the gap OpenCost exists to fill. Native tags answer "how much did the prod cluster cost." They never answer "which team inside it."
Strip away the branding and every one of these tools is surfacing the same four levers:
- Right-size requests. Close the gap between what pods reserve and what they use. Biggest single win in most clusters.
- Bin-pack. Schedule pods densely so you run fewer, fuller nodes instead of many half-empty ones.
- Spot. Move fault-tolerant workloads onto spot or preemptible capacity for a 60-to-90 percent discount, with fallback.
- Autoscaling. Scale nodes and pods to demand so you stop paying for idle capacity overnight and on weekends.
OpenCost and Kubecost show you these levers. Cast AI pulls them for you. That's the entire distinction.
|
OpenCost |
Kubecost |
Cast AI |
| Type |
CNCF OSS |
Commercial (OSS core) |
Commercial |
| Primary job |
Allocation |
Allocation + recommendations |
Automation |
| UI / alerts |
No |
Yes |
Yes |
| Savings advice |
No |
Yes (read-only) |
Yes (acts on it) |
| Changes the cluster |
No |
No |
Yes |
| Spot automation |
No |
No |
Yes |
| Pricing |
Free |
Free tier + per-cluster/vCPU |
Cut of savings / per-CPU |
| Lock-in risk |
None |
Low |
Higher (runs your autoscaler) |
This wider question of where the money leaks connects to the broader work of cloud cost optimization, which reaches past the cluster into storage, egress, and reserved capacity.
Start with OpenCost. Get honest allocation numbers into Grafana and find out who's actually spending before you spend anything on tooling. If you need the dashboard, alerts, and someone to yell at when a budget blows, Kubecost's paid tier earns it, especially across many clusters. Reach for Cast AI only once you've already right-sized the obvious offenders by hand and you're confident enough in your workloads' fault tolerance to let a controller drive spot and node lifecycle for you. Buying automation before you understand your own allocation is how you end up paying a percentage of savings on a cluster you could've fixed with three PRs.
