Google Cloud Ships llm-d 1.0 With Cache-Aware Routing for TPU and GPU Fleets

Google team have released llm-d 1.0, the first stable version of its distributed inference stack. This open-source, Kubernetes-native layer turns vLLM or SGLang model servers into one coordinated pool. They released it at the PyTorch Conference North America. It targets self-hosted agent and RL workloads, where round-robin load balancing breaks down.

TL;DR

A serving stack: Google reports a published benchmark on a 17,000-node multi-region GKE deployment.

Runs on: Kubernetes with NVIDIA, AMD or Intel GPUs or Google TPUs, over vLLM or SGLang.

Performance: Vendor-reported gains come from cache-aware routing, tiered KV cache offload and prefill/decode disaggregation.

Best: Median TTFT cut by more than 85%, with 2.4x throughput, on an Ironwood TPU coding workload.

Worst: RL time-slicing lifts accelerator duty cycle only to above 70%, so roughly 30% idle time remains.

What is llm-d 1.0?

llm-d was founded in 2025 by Red Hat, IBM, Google Cloud, CoreWeave and NVIDIA. Red Hat, IBM and Google are the lead maintainers. The project counts more than 500 contributors from over 25 organizations. It is a CNCF Sandbox project, accepted on March 12, 2026, and is licensed under Apache 2.0.

Prefix-aware routing, KV cache offloading, prefill/decode disaggregation, wide expert parallelism and batch inference already shipped. Version 1.0 is about running them reliably in production, which IBM calls day 2 operations.

What is new in llm-d 1.0?

Multi-tenant quality of service: Priority and fairness-aware flow control stops bursty agents from starving latency-sensitive requests.

Stable foundation: v1 APIs and a hardened request path, validated on multiple clouds and accelerators.

Zero-downtime upgrades: Router high availability with hot standby, plus DisaggregatedSet, which rolls prefill and decode pools together.

Agent-aware serving: Session-aware routing, turn-priority scheduling and native Responses API state.

Async inference: llm-d-async-processor pulls jobs from Google Cloud Pub/Sub or Redis into slack capacity.

Expanded TPU support: TorchTPU runs PyTorch models natively inside upstream vLLM and SGLang.

How does llm-d route requests?

The llm-d router builds on the Kubernetes Gateway API Inference Extension. It tracks which replicas hold each cached prefix. It then weighs load and predicted latency before picking a replica. Agents call one endpoint, and each step lands where its context already lives.

When accelerator memory fills, KV cache moves to host memory, then SSD or Managed Lustre. It uses vLLM’s OffloadingConnector, Mooncake or SGLang’s HiCache for this. Prefill and decode run as separate pools, because prefill is compute-heavy and decode is memory-bound.

<div class="pn on">
<div class="flow">
<div class="node act"><span class="ic"></span><b>Agent request</b><small>1 endpoint</small></div>
<div class="node"><span class="ic"></span><b>llm-d router</b><small>prefix + load aware</small></div>
<div class="node"><span class="ic"></span><b>Prefill / decode</b><small>separate pools</small></div>
<div class="node"><span class="ic"></span><b>Tiered KV cache</b><small>HBM to Lustre</small></div>
</div>
<div class="pkt"><span></span></div>
<div class="exp" id="mtp-exp"></div>
<div class="tiers" id="mtp-tiers">
<div style="background:rgba(66,133,244,.15)">Accelerator HBM</div>
<div style="background:rgba(52,168,83,.15)">Host CPU RAM</div>
<div style="background:rgba(251,188,4,.15)">Local SSD</div>
<div style="background:rgba(234,67,53,.15)">Managed Lustre</div>
</div>
<div class="ctl">
<button class="btn gh" id="mtp-prev">Back</button>
<button class="btn" id="mtp-next">Next step</button>
<button class="btn gh" id="mtp-play">Auto-play</button>
<span class="st" id="mtp-st">Step 1 of 4</span>
</div>
</div>

<div class="pn">
<div class="seg">
<button class="btn" data-g="lat">Latency and cache</button>
<button class="btn gh" data-g="thr">Throughput</button>
</div>
<div class="bars" id="mtp-bars"></div>
<div class="note">All figures self-reported by Google, Snap and Zenteiq. Source: Google Cloud blog, Oct 20, 2026.</div>
</div>

<div class="pn">
<div class="grid">
<div class="card"><span class="k">Multi-tenant QoS</span><b>Flow control</b><p>Priority and fairness-aware routing keeps bursty agent loops from starving interactive users.</p></div>
<div class="card"><span class="k">Upgrades</span><b>DisaggregatedSet</b><p>Built on LeaderWorkerSet. Rolls prefill and decode pools together on matching versions without dropping sessions.</p></div>
<div class="card"><span class="k">Reliability</span><b>Router HA</b><p>Hot standby and rolling updates keep traffic flowing through upgrades and maintenance.</p></div>
<div class="card"><span class="k">Agents</span><b>Session-aware routing</b><p>Turn-priority scheduling and native Responses API state help agents reuse context across turns.</p></div>
<div class="card"><span class="k">Background jobs</span><b>Async processor</b><p>Pulls requests from Google Cloud Pub/Sub or Redis and runs them in slack capacity.</p></div>
<div class="card"><span class="k">TPU</span><b>TorchTPU time-slicing</b><p>Interleaves inference into idle RL cycles. Duty cycle rises from about 40% to above 70%.</p></div>
</div>
<div class="note">Click a card to reveal details. Stable v1 APIs ship across all components.</div>
</div>

<div class="pn"><div class="tw">
<table>
<tr><th></th><th class="us">llm-d 1.0</th><th>NVIDIA Dynamo</th><th>AIBrix</th></tr>
<tr><td>Version</td><td>1.0 (Oct 2026)</td><td>v1.5.1 (Oct 2026)</td><td>v0.7.0 (Jun 2026)</td></tr>
<tr><td>Governance</td><td>CNCF Sandbox</td><td>NVIDIA-led</td><td>vLLM project org</td></tr>
<tr><td>Engines</td><td>vLLM, SGLang</td><td>SGLang, TRT-LLM, vLLM</td><td>vLLM, SGLang, TRT-LLM</td></tr>
<tr><td>Accelerators</td><td>NVIDIA, AMD, Intel, TPU</td><td>NVIDIA GPUs</td><td>Mixed GPUs</td></tr>
<tr><td>KV tiers</td><td>HBM, CPU, SSD, Lustre</td><td>GPU, CPU, SSD, remote</td><td>Distributed KV cache</td></tr>
<tr><td>License</td><td>Apache 2.0</td><td>Apache 2.0</td><td>Apache 2.0</td></tr>
<tr><td>GitHub stars</td><td>4.8k</td><td>8.3k</td><td>5.1k</td></tr>
</table></div>
<div class="note">Stars as of Oct 20, 2026. Sources: each project’s GitHub repo and docs.</div>
</div>

<div class="ft"><span>Sources: Google Cloud, IBM Research, Red Hat, GitHub</span><a href="https://www.marktechpost.com" target="_blank" rel="noopener">© Marktechpost</a></div>
</div>
<script>
(function(){
var R=document.getElementById(‘mtp-llmd1’);
var tabs=R.querySelectorAll(‘.tabs button’),pns=R.querySelectorAll(‘.pn’);
tabs.forEach(function(b){b.onclick=function(){tabs.forEach(function(x){x.classList.remove(‘on’)});pns.forEach(function(x){x.classList.remove(‘on’)});b.classList.add(‘on’);pns[+b.dataset.t].classList.add(‘on’);if(+b.dataset.t===1)draw(cur);rs();};});
var steps=[
‘An agent sends one step of a multi-turn task to a single llm-d endpoint. TPU and GPU pools sit behind it, running vLLM or SGLang.’,
‘The router tracks which replicas already hold each cached prefix. It weighs load and predicted latency, then sends the step where its context lives.’,
‘Prefill (compute-heavy) and decode (memory-bound) run in separate pools. DisaggregatedSet upgrades both together without dropping sessions.’,
‘When accelerator memory fills, KV cache moves to host RAM, then SSD or Google Cloud Managed Lustre instead of being evicted.’];
var s=0,nodes=R.querySelectorAll(‘.node’),pk=R.querySelector(‘.pkt span’),ex=document.getElementById(‘mtp-exp’),st=document.getElementById(‘mtp-st’),ti=R.querySelectorAll(‘#mtp-tiers div’),timer=null;
function show(){nodes.forEach(function(n,i){n.classList.toggle(‘act’,i===s)});pk.style.left=(s*25)+’%’;ex.textContent=steps[s];st.textContent=”Step “+(s+1)+’ of 4′;
ti.forEach(function(t,i){t.classList.remove(‘lit’);if(s===3)setTimeout(function(){t.classList.add(‘lit’)},i*350);else if(i===0)t.classList.add(‘lit’)});}
document.getElementById(‘mtp-next’).onclick=function(){s=(s+1)%4;show()};
document.getElementById(‘mtp-prev’).onclick=function(){s=(s+3)%4;show()};
document.getElementById(‘mtp-play’).onclick=function(){var b=this;if(timer){clearInterval(timer);timer=null;b.textContent=”Auto-play”;return}b.textContent=”Pause”;timer=setInterval(function(){s=(s+1)%4;show()},2600)};
show();
var data={lat:[
[‘Ironwood TPU: median TTFT cut’,’>85%’,85,’#4285F4′,’agentic coding vs plain K8s Service’],
[‘Gemini: P95 TTFT cut (bursty chat)’,’>50%’,50,’#34A853′,’GKE Inference Gateway’],
[‘A3 Mega 70B: TTFT improvement’,’~40%’,40,’#FBBC04′,’Lustre + CPU offload, 50k-token prompts’],
[‘Gemini: TTFT cut (coding agents)’,’>35%’,35,’#EA4335′,’production traffic’],
[‘Gemini: prefix cache hit rate’,’35% to 70%’,70,’#4285F4′,’doubled’]],
thr:[
[‘Zenteiq: aggregate throughput’,’>4x’,4,’#34A853′,’1.47B to 5.97B tokens/day per 1,000 TPU v6e’],
[‘17,000-node GKE: throughput’,’2.9x’,2.9,’#4285F4′,’3 clusters, 99.9% success’],
[‘Ironwood TPU: total throughput’,’2.4x’,2.4,’#FBBC04′,’vs plain K8s Service’]]};
var cur=”lat”;
function draw(g){cur=g;var box=document.getElementById(‘mtp-bars’),mx=g===’thr’?4:100;box.innerHTML=”;
data[g].forEach(function(d){var r=document.createElement(‘div’);r.className=”row”;r.innerHTML='<div class="lb"><span>’+d[0]+’ <em>’+d[4]+'</em></span><b>’+d[1]+'</b></div><div class="tr"><div class="fl" style="background:’+d[3]+’"></div></div>’;box.appendChild(r);
var f=r.querySelector(‘.fl’);setTimeout(function(){f.style.width=(d[2]/mx*100)+’%’},60);});rs();}
R.querySelectorAll(‘[data-g]’).forEach(function(b){b.onclick=function(){R.querySelectorAll(‘[data-g]’).forEach(function(x){x.classList.add(‘gh’)});b.classList.remove(‘gh’);draw(b.dataset.g)}});
R.querySelectorAll(‘.card’).forEach(function(c){c.onclick=function(){c.classList.toggle(‘open’);setTimeout(rs,380)}});
function rs(){try{parent.postMessage({mtpH:R.offsetHeight+40,id:’mtp-llmd1′},’*’)}catch(e){}}
window.addEventListener(‘load’,rs);window.addEventListener(‘resize’,rs);setTimeout(rs,300);
})();
</script>
</body></html>
” style=”width:100%;max-width:880px;height:600px;border:0;display:block;margin:0 auto;” loading=”lazy”>
window.addEventListener(‘message’,function(e){if(e.data&&e.data.id===’mtp-llmd1’&&e.data.mtpH){document.getElementById(‘mtp-llmd1-frame’).style.height=e.data.mtpH+’px’;}});

What do the llm-d 1.0 benchmarks show?

All figures below are self-reported by Google and llm-d adopters.

Ironwood TPU (TPU 7x): prefix-aware routing plus host memory offload cut median TTFT by more than 85%. Throughput rose 2.4x versus a plain Kubernetes Service.

Gemini platform: prefix cache hit rate doubled from 35% to 70%. TTFT fell more than 35% for coding agents. P95 TTFT fell more than 50% under bursty chat.

17,000-node GKE benchmark: throughput scaled 2.9x across 3 clusters, with 99.9% success and under 1% overhead.

A3 Mega, 70B model: Lustre plus CPU RAM offload improved TTFT by about 40% on 50k-token prompts. End-to-end latency fell 30% and GPU-hours fell nearly 60%.

RL time-slicing: accelerator duty cycle rose from about 40% to above 70%.

Adopters report similar patterns. Snap reports prefix cache hit rates of up to 75 to 80%. Zenteiq reports over 4x throughput, from 1.47 billion to 5.97 billion daily tokens per 1,000 TPU v6e chips. An IBM demo served 3,000 concurrent coding agents at 5 to 10 times below API pricing.

How does llm-d compare with NVIDIA Dynamo and AIBrix?

Featurellm-d 1.0NVIDIA DynamoAIBrixLatest version1.0 (Oct 20, 2026)v1.5.1 (Oct 6, 2026)v0.7.0 (Jun 16, 2026)LicenseApache 2.0Apache 2.0Apache 2.0GovernanceCNCF SandboxNVIDIA-led (ai-dynamo org)vLLM project org, ByteDance originEnginesvLLM, SGLangSGLang, TensorRT-LLM, vLLMvLLM, SGLang, TensorRT-LLMAcceleratorsNVIDIA, AMD, Intel GPUs, Google TPUNVIDIA GPUs (Blackwell, Hopper, Ada, Ampere)Mixed GPUs (heterogeneous serving)Cache-aware routingYes, prefix and load-awareYes, KV-awareYes, gateway routingKV cache tiersHBM, CPU, SSD, Managed LustreGPU, CPU, SSD, remote storage (KVBM)Distributed KV cacheP/D disaggregationYes, DisaggregatedSetYesYesHeadline result2.9x throughput, 17,000 nodes (self-reported)2x faster TTFT, Qwen3-Coder 480B (Baseten)Not disclosed

These are not strict rivals. CoreWeave runs llm-d alongside Dynamo, and NVIDIA contributes Dynamo components to llm-d.

How do you deploy llm-d 1.0?

On Google Cloud, GKE Inference Gateway runs the llm-d router as a managed service. It can also span clusters and regions with global failover. KEDA and HPA scale pools on queue depth and predicted latency. Kueue enforces per-model quotas. Verified Helm charts deploy TPU and GPU pools behind one endpoint.

Google team suggests a staged path. Start with prefix-aware routing in front of an existing vLLM deployment. Then add flow control, tiered KV offload and disaggregation. Published runs can be compared on Prism.

Key Takeaways

llm-d 1.0 is the first stable release, with v1 APIs.

New: flow control, router HA, DisaggregatedSet and agent-aware routing.

Gemini doubled prefix cache hits from 35% to 70%.

A 17,000-node GKE benchmark scaled throughput 2.9x.

Check out the Google Cloud announcement, the IBM Research post, the GitHub repo and the GKE docs. All credit goes to the researcher of this project. Also, feel free to follow us on Twitter and don’t forget to join our 150k+ML SubReddit and Subscribe to our Newsletter. Wait! are you on telegram? now you can join us on telegram as well.

The post Google Cloud Ships llm-d 1.0 With Cache-Aware Routing for TPU and GPU Fleets appeared first on MarkTechPost.

Source link