Skip to main content
Search

# KV Cache

36 related articles

Subscribe to updates
  1. arXiv

    VerKV keeps just 3.13% of the KV cache on GPU: it bounds attention error first, then fetches only what it needs

    Long-context inference makes the KV cache grow linearly with sequence length and often exceed GPU memory. VerKV keeps the full cache in CPU memory and only a Poisson sample of tokens, drawn from importance scores, on the GPU; at each decode step a certificate estimates the attention error and extra entries are fetched from CPU only when the bound exceeds tolerance. Across Qwen3-4B, Qwen3.5-9B and Ministral-3-8B on RULER and LOFT at 32K and 128K context, with 3.13% of the cache resident on GPU, the three retain 94.6%, 84.6% and 79.6% of dense quality, where Fast KVzip and KVzip at the same 3.13% retain only 1.9% to 11.9%.

  2. Coding agents stop rewriting history: ObsDrop drops stale KV instead, reaching 5.37× throughput at 16 concurrent agents

    Coding agents mostly append to their history, so prefix-cache reuse reaches 98–99%, yet text-level context compaction rewrites earlier tokens and forces the whole suffix to be recomputed. ObsDrop moves compaction from the prompt into the KV cache: it keeps the logical token prefix unchanged while releasing the KV of stale tool observations and excluding those positions from attention, implemented in SGLang and Sparse-vLLM. At 16 concurrent agents it reaches 2.45–2.85× throughput with FlashInfer and a 5.37× peak with Triton relative to no compaction, with task quality close to no compaction.

  3. PyTorch

    Meta's 816B sparse model now runs on one four-chip TPU host: a single whole-step kernel cuts per-token time 1.94× for one request

    Meta's open-weights mixture-of-experts model Muse Spark Open has 816B total parameters and about 42B active per token; serving it on TPU v7 previously took 2.9× the time needed just to stream its weights from HBM for one verify step. SGLang-TorchTPU now writes all 62 layers of a decode or verify step as one Pallas program, issuing weight, KV and cross-device transfers ahead of the compute that needs them. Per output token, a single request drops from 3.78 ms to 1.95 ms, two concurrent requests gain 1.85×, and the gain narrows as concurrency grows.

  4. NVIDIA prices agentic inference per byte: Vera Rubin NVL72 reaches up to 30x GB300 NVL72's throughput per megawatt

    NVIDIA reframes AI-factory memory from how much capacity a GPU has to how many useful tokens each byte produces, combining NVFP4 weight and KV-cache compression, wide expert parallelism for MoE weights, Dynamo KV-cache reuse, Vera CPU staging of context during tool calls, and CMX pod-level context storage. On SemiAnalysis AgentX, which replays recorded coding-agent sessions, Vera Rubin NVL72 delivers up to 30x the throughput per megawatt of GB300 NVL72 at 160 tokens per second per user, with both at 288 GB per GPU.

  5. arXiv

    Agent serving stops restarting nodes to rebalance: Evolving Infra switches prefill and decode in place, cutting a switch from 754 seconds to 6.2

    For coding, math and computer-use agent workloads, Evolving Infra decouples compute allocation between prefill and decode from KV cache management: a node switches phase without a restart, and its KV stays readable from a shared pool. On up to 256 GB300 GPUs it cuts mean end-to-end latency and P95 time to first token by up to 4.1 and 14 relative to NVIDIA Dynamo, and a phase switch takes 6.2 seconds on average against 754 seconds for a Dynamo relaunch.

  6. arXiv

    JSSA makes token-level sparse decoding gather-free, reaching up to full-KV throughput at 128K context

    Long-context decoding is bottlenecked by repeatedly reading a growing KV cache, and sparse attention reads only part of it, yet token-level selection has not reliably delivered both accuracy and lower latency. JSSA scores candidate tokens in a shared low-dimensional query–key subspace and pairs it with a gather-free indexed-attention kernel that keeps a distinct selected token set for each KV head. Across GQA, hybrid sliding-window/global attention and MLA models it stays closest to full-KV accuracy, and on a B200 at 128K context its decoding throughput reaches up to that of full-KV attention.

  7. LMSYS Org

    SGLang stores KV cache in 4 bits: long-context decode throughput rises 26–30%, and FP8 stalls first under agent concurrency

    SGLang adds NVFP4 storage to its paged KV cache, cutting per-token key-value bytes to about 56% of FP8. On Qwen3.8-27B at 32K, 160K and 1M input lengths with matched decode concurrency, peak-batch decode throughput rises about 26–30%; on agentic load beyond concurrency 12, FP8 throughput collapses while NVFP4 keeps climbing. Accuracy gaps vary by task, reaching 1.60 points on SWE-bench Verified.

  8. LMSYS Org

    XM-Sparse moves sparse-attention KV cache off HBM: 49.25% lower time per token at 16K context and matched batch

    Netpreme attaches its X-Mem™ memory tier to SGLang HiSparse so decode GPUs fetch missed KV entries from high-bandwidth external memory instead of host DRAM over PCIe. At 16K context, batch 192 per GPU and a 20% top-k miss rate, average time per output token falls from 167.48 ms to 84.99 ms, a 49.25% reduction; at a 40% miss rate the reduction is 63.58%. At 20% misses, peak decode throughput is 2.09–3.04× that of host DRAM across 16K to 1M contexts.

  9. KV selection stops waiting for the target-layer query: EarlySelectKV precomputes indices from proxy queries, lifting long-output throughput by up to 12.4%

    Query-conditioned sparse KV selection must wait for the target-layer query before scoring candidates and generating indices, so routing sits on the immediate pre-attention path. EarlySelectKV replaces the routing query with a proxy built from an earlier hidden state, precomputing the KV indices the next layer will access while final attention still uses the real query. On RocketKV it differs by +0.018 points on LongBench, about −0.01 points on RULER and +0.25 percentage points on representative NIAH/Passkey settings; in a TensorRT-LLM deployment with CPU-offloaded routing, end-to-end output throughput rises by up to 12.4% and GPU-resident memory falls by 11.1% of the combined KV/K-summary pool.

  10. PFN's PLaMo 3.1 Prime puts reasoning and fast answers in one model, so serving no longer needs double the compute

    PFN has released PLaMo 3.1 Prime, a domestically developed foundation model that folds reasoning and non-reasoning modes into one model and adds web search plus a Deep Research feature. PLaMo 3.0 Prime trained and served the two modes separately; under the configuration reported at the time, offering both took twice the compute of serving one single-mode model (PLaMo 2.2 Prime or PLaMo 3.0 Prime Beta). The new model is instruction-tuned in two stages, the second mixing in examples with the reasoning traces removed so one model switches per request. Against PLaMo 3.0 Prime it averages 2.4 points higher on reasoning-mode web-search QA and 11.1 points higher on search reports.