Cost

What your cluster costs, who uses it, and what could cost less: in the lists you already work in, on a Cost section of its own, in the Scale dialog, and as a PDF report. Everything is worked out on your computer; nothing is uploaded.

Free and Pro​

	Free	Pro
Cost card on the overview — the cluster's (or namespace's) cost a month	✓ at list prices, marked list-price estimate; a click shows Pro	✓ at your prices, with this month so far and the forecast; a click opens Explorer
Footer — the hourly burn rate	✓	✓
Settings → Show costs	✓	✓
COST and EFFICIENCY columns in the lists		✓
Scale dialog: what the scale costs, and whether it needs nodes		✓
Stats COST chart		✓
Your own prices, discount, currency, rates (Cost settings)		✓
The Cost section: Explorer, ranges, Timeline, Cost map, Why did it cost more?, Savings, Rightsize…, budgets, the report, OpenCost/Kubecost, Carbon		✓
Agents (MCP get_costs, compare_costs, get_cost_savings)		✓

Prices you set with Pro are kept if the licence lapses, and used again when it is back.

Where costs show up (Pro)​

Where	What you see
Lists	COST/MO and EFFICIENCY columns on Pods, Deployments, StatefulSets, DaemonSets, ReplicaSets, Jobs and Namespaces; Nodes get COST/MO (hover it to see where the price comes from, worked out); on Pods, hover COST/MO for the cost of each container — each charged the larger of what it requests and uses, adding up to the pod. They sort and export like any column, and hide from the column menu. Right-click the cost column's header to show it per hour, day, month or year (COST/H, COST/DAY, COST/MO, COST/YR), in every list and on the Cost pages.
Overview	A Cost card: the scope's cost per month and how much of what pods request they use; for the whole cluster, what it has cost this month so far and the forecast to the month's end (from Prometheus; ≈ when part of the month is before Prometheus's data and estimated at today's rate).
Footer	The scope's cost, per hour, day, month or year — right-click it to choose (the same setting as the cost column's). Hover for the price sources and exchange rate; click for Cost → Explorer.
Stats window	Drag one Stats window's title onto another to merge them: every chart then draws a line per object, in its own colour, named by the chips at the top; × on a chip takes it back out.
Stats charts	⋮ at the top right ticks charts on and off (CPU, memory, cost, network, disk space and speed, swap, processes). Drag a chart by its title to move it; right-click the title to hide it. The order is remembered. Memory reads in MB, and in GB with one decimal past 1000 MB (10.7 GB).
Stats window (single)	Stats on a namespace or workload row (its row menu, or the chart button on Cost → Explorer's rows) sums its pods: CPU, memory, network and cost, live from the kubelets and over time from Prometheus. A pod's Stats has a COST chart under CPU and memory too: what the container is charged an hour as it runs — Charged, and its CPU and Memory parts, each the larger of its request and its use.
Scale dialog	What the workload will cost after the scale, and whether the bill itself moves: new pods that fit on today's nodes cost nothing extra; past that, it says how many nodes they need and what those cost.

The Cost section (Pro)​

Cost in the sidebar has two pages, Explorer and Savings.

Explorer is one table, cut by Group by: Namespace (cost per month split into CPU, memory, storage and load balancers, efficiency, a 7-day trend and share of the bill, plus an Idle capacity row), Workload (each Deployment, StatefulSet, DaemonSet and Job), Node (instance type, on-demand or spot, cost, how much of it pods request and use, idle cost), or a label such as team or cost-center for showback. Click a namespace for its workloads.

Cards, graph and map​

The toolbar's view buttons work here too. Cards lead with each row's cost, large, then its split bar (CPU, memory, …), how much of what it requests is used, and its pods; the card filter's cost is a min–max slider. Graph shows what the rows stand for with their price under each node: a namespace over its workloads, a workload over its pods — a Deployment at $59 over four pods at $15 each — or a node over the pods on it. On Savings the graph shows what each saving is about — the workload with its pods, the node, the volume — with saves $X/mo on it in amber. Prices appear only on the Cost pages' graphs.

The card above the table switches between Timeline and Cost map: a tile per row, its area its cost, coloured by how much of what it requests it uses (red mostly unused, yellow half, green used), its price on it; click a tile to open it as its row. The map needs no Prometheus. Ticking namespaces in the namespace picker narrows every Cost page, its cards, its graph and its map.

Cost detail​

Clicking a row on a Cost page opens the drawer on its Cost tab: what it costs (per the cost column's unit) and its share of the bill, what that is made of, how much of what it requests is used, and the pods it is paid for — each with its CPU and memory (used / requested) and its own cost; click one to open it. A node lists the pods on it; a pod, its containers. Stats opens its pods' charts, and a saving's fix sits beside it. The object's own tabs (Overview, Manifest, …) follow.

Why did it cost more?​

Next to the range picker on Explorer, a chip says how the cost moved: ▲ +$212/mo vs last week (red up, green down) — or vs yesterday when the cluster's Prometheus keeps less than two weeks. Click it for the workloads whose cost moved most and what changed — 2 → 6 pods, CPU request 0.5 → 1 per pod, uses more memory than it requests, new, gone — and why, found on the cluster: Scaled by HPA api, Argo CD app shop synced a1b2c3d · Tue 14:02, Helm api upgraded to revision 7. Each line opens what it names: the workload, the HPA, the app's History, the Helm release. Both periods are priced at today's prices, so the change is what ran, not what the machines cost.

Chargeback​

Group by → Share idle cost across rows drops the Idle capacity line and shares it out over the rows, each by its part of what is allocated — so each namespace, workload or team (label) carries its share of what nobody uses. The split bar shows it as Idle; the total stays the same.

Spend timeline​

Above Explorer's table, Timeline shows a bar per hour, day, week, month or year (the right-hand dropdown). The left-hand dropdown splits each bar:

By usage, three ways:

• Used — the CPU and memory pods actually used.
• Reserved, unused — what pods requested but did not use. You pay for it all the same.
• Unreserved — node capacity no pod requested.

By namespace (or By workload, By node — whatever Group by is): the five biggest rows stacked, then Other — or, ticked in the same menu, up to six rows you pick. Idle capacity is no row's spend, so it is left out here (By usage shows it). Each legend figure is the row's total over the bars shown; names that do not fit are under +N.

In the Per month view, the month under way is drawn up to its forecast, dashed. Tick rows in the table to compare them instead: a line each for the rows you picked (up to six). Hover a bar for its figures. A bar Prometheus has only part of is drawn faded and says how much of it Prometheus has.

The timeline reads the cluster's Prometheus with kube-state-metrics, at today's prices. Without one it offers Install Prometheus….

Budgets​

Budgets are optional. In Settings… → Budgets, Add budget (at the right of the column headers) for a namespace or a workload (Deployment, StatefulSet, DaemonSet, Job, CronJob) and type the amount, in any currency, per hour, month or year. Nodes have no budget; what runs on them does.

Explorer then gets a BUDGET column on those rows: spent so far this month against the budget, and the forecast to the month's end at today's rate as a share of it — $540 of $750 · 108%. The bar fills with what is spent, a grey tick marks the forecast and a dark tick the budget; it turns yellow from 80% and red past 100%. Spent so far comes from Prometheus; without it, it is estimated from today's rate and marked ≈.

Savings​

Savings lists everything that could cost less, biggest first, each with its action:

Suggestion	When	Action
Lower requests	A workload requests much more CPU or memory than it uses	The wrench button cuts its requests to its use plus headroom. Argo CD-managed: committed to git or opened as a pull request. Otherwise patched on the cluster. Helm or another manager: you are told where to make it.
Empty node	One node's pods fit on the others by their requests	The drain button opens the Drain dialog with its safety checks.
Scale down	A workload used next to no CPU over the last 7 or 30 days	The arrow button scales it down.
Unused volume / Unused load balancer	A volume no pod mounts, or a LoadBalancer with no pod behind it	Detail opens it; delete it from there.

Every row also has Detail (ⓘ), which opens the object in the drawer.

Range​

The range picker (clock icon) on every Cost page: Live (what runs now) or 24h, 7d or 30d, read from the cluster's Prometheus. A range charges every pod that ran in it, including the ones gone since, for the share of the range it ran, at its average requests and use. Figures stay per month, so a range and Live read the same way.

A range needs Prometheus with kube-state-metrics. When the cluster has none, Install Prometheus… appears beside the range: the one Kubezilla installs keeps 31 days (capped at 7 GB).

Report…​

Report (the PDF icon in the title row) saves the page as a two-page A4 PDF: the totals, where the money goes and the cost by namespace (or group) on page one; top workloads, savings, machines and prices, and how the numbers were made on page two. It reports the list as you see it: the same rows in the same order — namespaces, workloads, nodes, a label grouping or savings — narrowed the same way (ticked namespaces, the search), with the totals, the split, top workloads and savings worked out for those rows, and a line under the title saying what it shows ("Showing 2 of 9 namespaces · "web""). Every figure is in the COST column's unit (per hour, day, month or year), at the page's range, prices and currency.

How prices work​

1. Each node is priced from its labels: node.kubernetes.io/instance-type, topology.kubernetes.io/region, and spec.providerID for the cloud (AWS, GCP, Azure), against a price sheet that ships with the app. A spot node (Karpenter, EKS, GKE and AKS spot labels) gets a typical spot discount, marked as an estimate. A machine the sheet does not know — on-prem, Hetzner, kind, k3s — is estimated from its size at typical cloud rates (about $23 a month per vCPU, $3 per GiB of memory and $694 per GPU) until you set a price.
2. The node's price is split into a CPU rate and a memory rate: one vCPU costs as much as 7.46 GiB. A pod costs the same on any machine family of the same price level, and less on spot.
3. Each pod is charged the larger of its requests and its use at its node's rates. Idle is what no pod on a node is charged for.
4. Volumes are their size at the cloud's default disk rate (gp3, pd-balanced, Premium SSD); load balancers an hourly rate each.

Settings…​

Settings (the gear icon in every Cost page's title row) has five tabs. They stay in view, as do a table's column headers, while long lists scroll under them:

• Nodes — two columns, Node and Price. An empty field shows our estimate in grey; type what you really pay to replace it, with its currency before the amount and its period (hour, month or year) after it. A price on a node type covers all its nodes; open the type to price one node on its own. The ⓘ beside a field works the estimate out.
• Adjustments — a discount on list prices (a savings plan, reserved instances), Storage, per GiB, Load balancer, each, and Network egress, per GiB: empty, network is not charged; with a price, every byte a pod sends (from Prometheus, over the range) is charged to its workload and namespace and shows as Net in the split. It is an upper bound — Kubernetes counts in-cluster traffic too, which clouds do not bill. And Carbon — see Carbon.
• Currency — what every figure is shown in. It lists what has to be converted (our estimates are in US dollars; a price typed in another currency), with a rate for each currency involved: the European Central Bank's daily reference rate, or Use my own. A price you type is used as typed, in its own currency.
• Budgets — see Budgets.
• Sources — Metrics: where history is read from — Auto (whatever the cluster has: Prometheus first, else VictoriaMetrics), Prometheus or VictoriaMetrics (single node, or a cluster's vmselect). A green ✓ says which one is used (hover it); a ⚠ that the one chosen is not in the cluster, with Install Prometheus… — and Save stays off until it is installed or Auto is picked, so a missing source is never saved. Without either, costs are still worked out for what runs now; only history needs one. Figures: whose figures Explorer shows — Auto (OpenCost or Kubecost when the cluster runs one set up right, else built-in), Built-in (worked out here), OpenCost or Kubecost. The same ✓ or ⚠ beside it: ⚠ with Fix… when the tool is there but set up wrong (under Auto, built-in figures are used meanwhile), or ⚠ when the tool chosen is not in the cluster — with Install — and Save stays off until it is there. Install shows the Helm values before anything happens: OpenCost asks the cluster's Prometheus (so it needs one first), is scraped by it and is priced at your prices; Kubecost 3 (kubecost chart, kubecost namespace) collects usage with its own agent, needs no Prometheus, gets your prices and a cluster id from the context name, and keeps its data on a 32 GiB volume. Kubecost's free tier is limited; the full product is a paid plan. See below.

Turning costs off. Settings → Show costs (the app's Settings, in the ⋮ menu) turns every cost off: the COST and EFFICIENCY columns, the Cost card (and from the widget picker), the footer, the Stats COST chart, the Scale dialog's cost rows and the Cost section. Nothing is worked out or fetched while it is off — no exchange rates, no cost queries to Prometheus — and agents asking get_costs, compare_costs or get_cost_savings are told costs are off. Your prices, budgets and other Cost settings are kept for when you turn it on again.

Everything in Settings is saved per cluster, in state.json: prices, discount, storage, network and load-balancer rates, budgets, the metrics database, Figures and Carbon. Only the currency shown and your own exchange rates are the same for every cluster.

Each window has its own view: a cluster window (right-click a cluster → Open in new window) prices its own cluster, and its Group by, range, unit, chart and table, card or graph view change there only.

Carbon​

Optional, off by default. Tick Show CO₂e beside cost in Settings → Adjustments and Explorer's namespace, workload and node tables get a CO₂ column beside COST (CO₂ equivalent: other greenhouse gases counted as CO₂), in the same unit (right-click either header for per hour, day, month or year). Hover a figure for how it was worked out.

It is an estimate, worked out the way OpenCost does it, from Cloud Carbon Footprint's power figures:

• Energy — every pod is charged for what it is charged money for (the larger of its requests and its use): a vCPU at half load (about 2.1 W on AWS, 2.5 W on Google Cloud, 2.3 W on Azure) and 0.42 W per GiB of memory.
• Data centre — times the PUE, the overhead of cooling and losses: AWS 1.135, Google Cloud 1.1, Azure 1.185, and 1.58 (the industry average) on your own servers.
• Grid — times the grams of CO₂e per kWh where the nodes run, from their cloud region (eu-central-1 → Germany, 338 g/kWh). No region — your own servers, a local cluster — reads as the world average, 475 g/kWh.

Your own figures: Grid and Data centre show the estimate in grey; type over it. Your electricity supplier's figure goes in Grid — 0 on a renewable contract. Both are saved per cluster.

The Idle capacity row is what the nodes emit running that no pod is charged for. For agents, get_costs adds co2e_kg_per_month (cluster, pods, idle, per namespace and workload) while Carbon is on.

OpenCost and Kubecost​

Neither is needed. Kubezilla works out every cost itself — from Kubernetes for what runs now, and from the cluster's Prometheus for ranges, the timeline, budgets, the forecast and network. OpenCost and Kubecost are a second source, when a cluster has one.

When the cluster runs OpenCost or Kubecost, Kubezilla finds it — OpenCost's opencost Service on port 9003; Kubecost 1–2's …cost-analyzer, or Kubecost 3's …-frontend (labelled app: kubecost), on 9090 — and reaches it through the API server, so it also works through an SSH tunnel. Their cost data is an HTTP API, not custom resources (Kubecost's one CRD, TurndownSchedule, is for turning clusters down), and OpenCost publishes its prices to Prometheus.

• Settings… → Sources → Figures: Auto, Built-in, OpenCost or Kubecost. With the tool's figures in use, the page title row then says OpenCost figures. With OpenCost, Explorer's namespaces and workloads are OpenCost's own figures for the range, including network cost and its Unallocated cost, and every node is priced at OpenCost's price (node_total_hourly_cost), so lists, the cost card, Scale, Savings, budgets and the timeline all follow it. A price you typed in Settings… still wins.

• Setup check. OpenCost's Helm chart needs three things its defaults often get wrong. Kubezilla checks them and Settings… → Sources says which is wrong. While OpenCost is chosen by name, a yellow dot on the gear says so, and the gear opens Settings on Sources — click for what is wrong, Fix…, or Hide (for this cluster). One at a time:

  1. OpenCost cannot reach Prometheus — it asks the chart's default prometheus-server.prometheus-system; Fix points it at the Prometheus the cluster has.
  2. Prometheus does not collect OpenCost's metrics — Fix annotates its Service for scraping (or enables its ServiceMonitor with the Prometheus Operator).
  3. OpenCost has no prices — it cannot save its default pricing (/var/configs is read-only), so every node is $0 and there is no idle; Fix gives it its own default prices as a ConfigMap.

  Fix… shows the exact Helm values before it runs a Helm upgrade of OpenCost's release, keeping its chart version and the values it has. Each check runs again a minute later until it passes.

• Install (optional, in Settings… → Sources → Figures with OpenCost chosen, when the cluster has Prometheus but no OpenCost) installs OpenCost set up right from the start: asking that Prometheus, scraped by it, and priced at Kubezilla's prices. Kubezilla, a desktop app, cannot publish cost metrics itself; with OpenCost they reach Prometheus — and Grafana and alerts — saying what Kubezilla says.

For agents​

The MCP server's get_costs tool returns the same figures for a cluster or a namespace: totals, namespaces and workloads by cost, nodes with their price sources, idle capacity, efficiency, and unmounted volumes and load balancers with nothing behind them — now, or over the last 24h, 7d or 30d (range).

compare_costs answers "why did the bill go up?": the last 24h, 7d or 30d against the same length just before it, both at today's prices, with every namespace and workload whose cost moved — biggest change first — and what drove it (CPU and memory requested and used, pods that ran, new or gone). It needs Prometheus to keep at least twice the range. get_cost_savings returns the Savings page: each suggestion, why, and what it saves a month.

Ask an agent, for example: "Why did atlas cost more this week?" or "What can we save in the shop namespace?"