Skip to content
NewKubeOn AI: a managed LLM gateway with cost per 1M tokens for every model
All articles

AI

Idle GPUs: the most expensive capacity you don't use

GPU spend is growing fastest of any compute, and published research from Microsoft and Alibaba shows how little of it does work. Why GPUs sit idle in Kubernetes, how to measure it, and what sharing, sizing and pricing change.

KubeOn Engineering

October 14, 20266 min read

GPUs are the fastest-growing line in most cloud bills. Across Datadog's customers, spend on GPU instances rose from 10% to 14% of EC2 compute costs in a single year, a 40% increase (Datadog, State of Cloud Costs 2024). Gartner forecast worldwide generative AI spending of $644 billion in 2025, up 76.4%, with about 80% of it going to hardware (Gartner, GenAI spending forecast (31 March 2025)).

Each GPU node costs many times what a general-purpose node does, so every idle hour on one costs as much as many idle hours elsewhere. And the published research on how GPUs are actually used in shared clusters is sobering.

14%

of EC2 compute spend went to GPU instances, up from 10% a year earlier

Source: Datadog, State of Cloud Costs 2024

~52%

average utilization of GPUs in use, in a large multi-tenant training cluster at Microsoft

Source: Jeon et al., Analysis of Large-Scale Multi-Tenant GPU Clusters for DNN Training Workloads, USENIX ATC 2019

0.042

of a GPU: the median streaming-multiprocessor use of a task in Alibaba's production cluster of over 6,000 GPUs

Source: Weng et al., MLaaS in the Wild: Workload Analysis and Scheduling in Large-Scale Heterogeneous GPU Clusters, USENIX NSDI 2022

18%

average GPU utilization on one group of Alibaba machines where 74% of GPUs were allocated

Source: Weng et al., MLaaS in the Wild: Workload Analysis and Scheduling in Large-Scale Heterogeneous GPU Clusters, USENIX NSDI 2022

What the research found

Microsoft's analysis of a two-month trace from a large multi-tenant GPU cluster used for deep learning training found that "the hardware utilization of GPUs in use is only around 52% on average" (Jeon et al., Analysis of Large-Scale Multi-Tenant GPU Clusters for DNN Training Workloads, USENIX ATC 2019). The causes were not lazy users: jobs waited for GPUs on the same machine, placement across servers slowed communication, and failed or killed jobs consumed GPU time without finishing.

Alibaba's study of a production machine-learning platform with over 6,000 GPUs found the gap is wider for inference-heavy work. A typical task used only a fraction of a GPU: the median was 0.042 GPUs of streaming-multiprocessor capacity, and over 75% of the click-through-rate prediction instances used less than 0.1 GPUs. On one group of machines, 74% of GPUs were allocated while average GPU utilization was 18% (Weng et al., MLaaS in the Wild: Workload Analysis and Scheduling in Large-Scale Heterogeneous GPU Clusters, USENIX NSDI 2022). The authors' conclusion was that allocating whole GPUs to tasks like these "would result in extremely low utilization", and they shared GPUs between tasks instead.

Allocated is not used: two published measurements

  • Alibaba, one machine group: GPUs allocated74%
  • Alibaba, same machines: average GPU utilization18%
  • Microsoft: utilization of GPUs in use~52%
Different clusters, workloads and years; shown side by side for scale, not as a benchmark. Sources: Weng et al., MLaaS in the Wild: Workload Analysis and Scheduling in Large-Scale Heterogeneous GPU Clusters, USENIX NSDI 2022; Jeon et al., Analysis of Large-Scale Multi-Tenant GPU Clusters for DNN Training Workloads, USENIX ATC 2019.

Why GPUs sit idle in Kubernetes

  • Whole-device allocation. GPUs are requested in a container's limits, and requests must equal limits (Kubernetes, Schedule GPUs). Unless you enable sharing, the device plugin hands each GPU to one container, so a small inference service that needs a fraction of a card holds all of it.
  • Provisioned for the peak. Inference replicas are sized for the busiest minute and then run all day, including nights and weekends.
  • Notebooks and experiments. An interactive session holds a GPU while someone reads, thinks or goes to lunch.
  • Waiting to start. Distributed training jobs need several GPUs at once, sometimes on the same machine; GPUs held while a job assembles do no work.
  • Nobody sees the bill. GPU nodes are often shared by several teams, so the most expensive idle hours belong to nobody.

Measure three numbers per GPU node

MetricWhat it tells youWhere it comes from
Allocated GPU-hoursHow many GPUs pods held, and for how longPod GPU requests from the Kubernetes API
Idle GPU-hoursGPU capacity on the node that no pod heldNode GPU capacity minus allocated GPUs
Utilization of allocated GPUsWhether the GPUs pods hold are doing workGPU metrics such as NVIDIA's NVIDIA, DCGM Exporter
Idle GPU-hours is a scheduling problem; low utilization of allocated GPUs is a sizing or sharing problem. They have different fixes.

Price each of them at the GPU node's real, billed rate. A node billed several dollars an hour turns a 30% idle rate into a number that gets a conversation started.

Options, from simplest to most involved

OptionWhat it doesTrade-off
Right-size replicas and nodesFewer inference replicas off-peak; a smaller GPU type where the model fitsNeeds utilization history, and a latency target to protect
Scale non-production to zeroDevelopment and test GPU workloads stop outside working hoursStart-up time when people come back
Multi-Instance GPU (MIG)Partitions a supported GPU into multiple isolated instances, with memory and fault isolation in hardware (NVIDIA, Multi-Instance GPU user guide)Fixed partition sizes; only on supported GPUs
Time-slicingLets several pods take turns on one GPU (NVIDIA GPU Operator, Time-slicing GPUs in Kubernetes)No memory or fault isolation between the pods sharing it
Move bursty work to a hosted modelPay per token instead of per GPU-hour for spiky, low-volume inferenceCompare effective cost per 1M tokens first

The right answer differs per workload, which is why the measurement comes first: a training job that runs at 90% utilization on 8 GPUs needs nothing, while an inference service holding one GPU at 6% is a sharing or hosting candidate. For the hosted-model comparison, see what a million tokens really costs.

GPUs in your own data center

On-premises GPU servers have no hourly bill, so their idle time is invisible. Give them a GPU-hour rate from the hardware's purchase price over its depreciation period, plus power, space and support, and the same three numbers appear. See pricing Kubernetes in your own data center.

Who does what

Turn measured waste into a review queue

  1. 01

    Gather history

    Confirm billing and the usage window required by each finding.

    Diagnostics

  2. 02

    Apply rules

    Evaluate request sizing, node capacity, storage and off-hours opportunities.

    Savings engine

  3. 03

    Price the change

    Estimate monthly savings against the applicable billing data.

    KubeOn hub

  4. 04

    Prioritize

    Review evidence and risk before taking a proposal into your pipeline.

    Platform team

KubeOn reads and recommends. Your team and pipeline change the cluster.

Read the workflow
In KubeOn, idle and under-used GPU nodes and GPU requests are priced at the GPU node's rate and reviewed like any other saving.
Is 50% GPU utilization bad?

Not necessarily: a latency-sensitive inference service may need headroom, and some training phases are input-bound. What matters is whether the idle capacity is deliberate, priced and owned.

Should we turn on time-slicing everywhere?

No. Without memory isolation, one workload can exhaust GPU memory for the others sharing the card. Use it for development and for small, well-understood inference services; prefer MIG where isolation matters.

How do we attribute a shared GPU node's cost to teams?

Split it by GPU requests, the same way CPU and memory are split, and report the GPUs no pod requested as idle GPU time with its own cost.

What does KubeOn measure?

GPU node cost split by GPU requests, with idle GPU time reported on its own, GPU utilization, and idle or under-used GPU nodes and requests priced at the node's billed rate. Self-hosted model GPUs appear in KubeOn AI next to hosted model spend.

See your AI spend per team, model and request.

A 30-minute walkthrough on your own Azure OpenAI, Bedrock or Vertex AI usage.