A Better Newspaper

## Overview The key-value (KV) cache is a core memory bottleneck in transformer inference, particularly for long-context and multimodal generation. Optimizing cache size and access patterns is a primary lever for reducing LLM inference cost. Beyond compression, KV cache reuse across requests has emerged as a distinct optimization axis, introducing new efficiency gains but also new security and quality risks. A related but distinct bottleneck — prefill cost, as opposed to decode-time cache size — has also emerged as a target for sparse-attention optimization. A further emerging approach compresses context into query-aligned soft memory embeddings rather than pruning or quantizing the raw KV cache. A new empirical study also questions how much sophisticated cache-eviction research actually matters in real production agentic workloads. A new system-level report demonstrates that persisting KV state to disk rather than recomputing it can extend usable context to tens of millions of tokens at lower cost than recompute. A new methodological report separately raises a cautionary note about how parameter-efficient fine-tuning recipes for SVD-based KV-cache compression are evaluated and compared. A separate new report reframes the field's core design problem as an "impossible triangle" among KV cache size, training/prefill FLOPs, and model quality, arguing existing architectures (GQA, MLA, MFA) each sacrifice at least one vertex. Several further new reports target head-wise/learned budget and rank allocation, vector-quantized low-bit key compression, cross-model cache transport, and non-prefix cache reuse in multi-agent systems. Two further new reports extend the head-wise granularity trend: one applies multi-objective neural architecture search to per-layer (rather than per-head) budget allocation, and another investigates why existing head-wise eviction methods are unstable across workloads. ## Sub-Token Routing Sub-token routing introduces a finer control axis within retained tokens (arXiv:2604.21335). Rather than selecting or evicting whole tokens, it splits each retained value vector into groups and keeps only selected groups while leaving query and key statistics intact. This allows more granular cache compression without the quality degradation associated with aggressive token eviction. The method is complementary to existing token-level selection and quantization approaches. ## Lookahead Sparse Attention (LSA) A report proposes Lookahead Sparse Attention, a KV cache management paradigm built on the DeepSeek-V4 architecture, intended to address the GPU memory bottleneck of keeping the full KV cache loaded during decoding for ultra-long context serving (arXiv:2606.09079, June 9). Rather than passively attending to all historical tokens, LSA reportedly uses a "Neural Memory Indexer" to proactively predict future context demands and preserve only query-critical KV chunks in GPU memory, discarding the rest. The architecture is described as instantiated via a "backbone-free decoupled" training approach, though full technical details of this decoupling were not specified in the abstract. This represents a proactive/predictive alternative to the reactive selection or grouping strategies of sub-token routing and prior token-eviction methods. ## Virtual Head Attention and the KV "Impossible Triangle" A new report, Virtual Head Attention (VHA), frames long-context attention-mechanism design as facing an "impossible triangle" among KV cache size, training/prefill FLOPs, and model quality (arXiv:2610.17959, published Oct 14). The paper characterizes existing approaches as each sacrificing one vertex: Grouped-Query Attention (GQA) reportedly achieves strong quality but incurs high KV cache overhead, Multi-head Latent Attention (MLA) compresses the cache but reportedly suffers quality loss, and Multi-head Factorized Attention (MFA) compresses the cache but reportedly substantially increases training and prefill compute. VHA proposes to improve all three dimensions simultaneously via two lightweight linear operations, including a "Q Premix" step (further mechanism details not specified in the abstract excerpt). This is a distinct contribution from the compression/eviction/reuse methods elsewhere on this page in that it proposes a new attention architecture rather than a post-hoc compression or reuse strategy for an existing architecture's cache, and it offers an explicit comparative framework (GQA vs. MLA vs. MFA) for situating architectural cache-efficiency tradeoffs. ## Low-Bit KV-Cache Quantization Quality Degradation A new report directly quantifies the accuracy cost of aggressive KV-cache quantization: one-bit quantization reportedly reduces accuracy from 84.2% to 47.8% on Llama-3.1-8B under the RULER long-context benchmark (arXiv:2607.16248, July 21). The paper identifies the root cause not as absolute logit error, as commonly assumed, but as "structured local misranking," where the distribution of logits within the top-K region drifts under quantization. To address this, the authors propose a "local distribution restoration" method aimed at preserving high accuracy at low bit-widths. This work provides a concrete accuracy benchmark and a specific failure mechanism for low-bit KV-cache quantization, complementing the more general outlier-distortion findings from FP4 weight/activation quantization research (arXiv:2603.10444). A separate new report, "E8 Lattice Key Quantization," reportedly addresses the quality-fidelity trade-off in current scalar KV quantization methods, which the authors say suffer performance instability at 2-bit precision or require 3-bit keys to maintain quality (arXiv:2610.15384, published Oct 14). The paper reportedly demonstrates that a uniform k2v2 configuration (2-bit keys, 2-bit values) can preserve near-baseline quality by applying vector quantization (VQ), based on an E8 lattice structure, to keys specifically rather than relying on scalar quantization. This offers a more specific technical route — lattice-based VQ — to the general 2-bit-quantization instability problem also implicated in the "structured local misranking" findings above. A further new report, KV4-RL, examines INT4 KV cache quantization in a reinforcement-learning-with-verifiable-rewards (RLVR) training context rather than pure inference serving: the authors reportedly find that sustained concurrency in asynchronous rollouts concentrates context processing into fewer decode steps ("KV concentration"), and that KV cache quantization delivers substantially greater acceleration than weight-only or weight-activation quantization under matched-workload comparisons — but reportedly note that INT4 KV rollout can degrade learning (arXiv:2610.14448, published Oct 14). This extends the quantization-quality-tradeoff discussion from inference serving into RL training workloads specifically. ## Relationship to Quantization FP4 quantization research identifies that blockwise quantization is distorted by extreme activation outliers driven by a coherent rank-one mean bias component (arXiv:2603.10444). This finding is relevant to KV cache quantization strategies, as the same outlier dynamics that destabilize weight quantization affect activation caching. The newly reported "structured local misranking" mechanism (arXiv:2607.16248, July 21) offers a more specific, KV-cache-targeted account of how quantization degrades quality, distinct from the outlier-driven distortion described for weight quantization. The E8 lattice VQ approach (arXiv:2610.15384) and KV4-RL's RL-specific findings (arXiv:2610.14448) further diversify this literature along the bit-width and workload-type axes. ## UltraSketchLLM and Sub-1-Bit Compression UltraSketchLLM reportedly achieves compression down to 0.5 bits per weight using data sketch methods combined with hardware-friendly operators, reducing peak GPU memory footprint substantially (arXiv:2506.17255). While primarily a weight compression technique, the memory savings directly reduce competition for GPU memory between weights and KV cache. ## KV Cache Reuse: Efficiency Gains and Security Risks A cluster of new reports addresses KV cache reuse across inference requests as a distinct optimization strategy from compression. Position-independent KV reuse allows cached key-value pairs to be reused whenever identical text chunks appear, regardless of sequence position, improving on traditional prefix-based reuse which requires exact token-and-position matches (arXiv:2607.19957, published Aug 3). However, a report identifies this design as introducing a new security threat termed "KV Cache Hijacking": because caches are retrieved by token match but reportedly not properly bound to their original context, this creates an exploitable vulnerability (arXiv:2607.19957, published Aug 3). Separately, for retrieval-augmented generation (RAG), reusing pre-computed document KV caches reduces time-to-first-token latency but reportedly introduces a distribution mismatch, since offline caches lack the inter-document attention patterns needed for coherent reasoning; the existing CacheBlend method reduces recomputation via selective attention but reportedly suffers severe accuracy degradation at longer contexts, which a new "Decoupled Attention Fusion" method aims to address (arXiv:2607.21599, published July 27). A further report proposes CoinRAG, which reportedly targets a related inefficiency in chunk-level KV cache reuse for RAG: coarse-grained chunks retain significant redundancy and noise even after reuse, and CoinRAG instead reuses cache at the level of finer-grained "contextualized information nuggets," aiming to optimize the accuracy/prefill-latency tradeoff (arXiv:2608.07458, published Aug 10). A new report, CacheLink, addresses a distinct reuse problem: cross-model context handoff, where switching between models breaks KV reuse and forces the receiving model to re-prefill the same context (arXiv:2610.15509, published Oct 14). The paper studies "zero-prefill cross-model context handoff" — translating a sender model's cache into a receiver-compatible state so the receiver can continue without reprocessing the context. It reportedly builds on existing affine transport methods, which show receiver KV states can be substantially reconstructed from sender caches, but finds that reconstruction fidelity degrades under conditions not fully specified in the abstract. This introduces a new reuse axis — cross-model rather than cross-request same-model reuse — distinct from the position-independent and RAG-document reuse methods above. A further new report, LatentRemedy, identifies a quality risk specific to non-prefix KV cache reuse in multi-agent systems: when agents sharing context blocks have conflicting tasks, directly reusing non-prefix KV caches across agents can reportedly degrade model performance by up to 90% (arXiv:2610.18014, published Oct 14). The paper reportedly finds that existing remedies — selective recomputation and offset-based calibration — recover only a limited fraction of this loss, and attributes the problem not only to contaminated KV representations but also to the agent's difficulty interpreting the reused context (details not fully specified in the abstract). This is a distinct, multi-agent-specific quality-degradation risk, separate from the KV Cache Hijacking security vulnerability (arXiv:2607.19957) identified for position-independent reuse. A new empirical study of production prefix-caching traces from two (unnamed) companies complicates the case for sophisticated eviction research: evaluating 14 eviction algorithms across both HBM-constrained and large memory-pool settings, the study reportedly finds that despite a large gap to the theoretical optimum (Belady's algorithm), sophisticated policies designed for traditional caches provide little benefit over simple LRU under real agentic workloads (arXiv:2609.28870, published Sept 25). The paper attributes this to a structural property of agentic traffic: prefix reuse is reportedly dominated by the regular pacing of active sessions rather than the content-similarity patterns that sophisticated eviction policies are designed to exploit (arXiv:2609.28870, published Sept 25). This finding is specific to prefix-level cache reuse/eviction (prefill-cost reduction) and does not directly address decode-time KV compression, cross-model handoff, multi-agent reuse, or the position-independent reuse security concerns raised elsewhere on this page. A separate new report tests an alternative to in-memory cache reuse entirely: a memory layer called galahad-kv reportedly saves the KV state of each ~16,000-token block to encrypted local NVMe disk and reloads it later "byte-exact," without recomputation (arXiv:2610.10845, published Oct 9). The authors reportedly tested this on 50 million tokens of real public text served via vLLM on a single NVIDIA H100, using Gemma 4 12B and Gemma 4 31B, and report that every probed block was loaded back correctly. The abstract frames this disk-backed persistence as faster and cheaper than recomputing KV state, positioning it as a long-term-memory mechanism distinct from the in-GPU-memory cache reuse, eviction, and compression strategies described elsewhere on this page. ## Structured Pruning and RoPE Compatibility A new report identifies a specific technical obstacle for structured KV-cache pruning: dropping channels from W_k/W_v projection weights directly shrinks cache size, but modern LLMs apply Rotary Position Embedding (RoPE) after QK projection, which rotates feature dimensions in pairs — meaning naive channel removal breaks these pairs and corrupts positional semantics, rendering pruned models reportedly unusable without RoPE-aware alignment (arXiv:2602.02599, published Aug 4, RoPE-Aligned Pruning/RAP). ## Head and Layer Grouping, and Adaptive Rank/Budget Allocation A new low-rank compression method, DynaCalKV, reportedly treats Key and Value caches differently (rather than applying uniform compression) via head grouping and adaptive rank allocation, addressing a gap in prior low-rank KV compression methods that use fixed attention-rank allocation regardless of the distinct roles Keys and Values play (arXiv:2607.24331, published July 28). A separate new report, ChampionKV, addresses a related but distinct gap in observation-window-based KV cache compressors: such methods reportedly use prompt attention to identify important tokens but allocate uniform or predefined budgets across attention heads, overlooking input-dependent differences in per-head budget demand (arXiv:2610.18026, published Oct 14). ChampionKV proposes an input-adaptive, head-wise budget allocator that uses the maximum aggregated observation-window attention score as a lightweight empirical proxy for attention concentration, assigning larger token budgets to heads with dispersed attention and smaller budgets to heads with concentrated attention. Unlike DynaCalKV's Key/Value-differentiated rank allocation, ChampionKV operates on token budget allocation across heads within observation-window-based eviction methods, representing a further refinement of the head-level granularity trend in KV cache compression. A further new report, BELT ("BEhavior-Aligned Low-Rank KV Cache Compression with Learned Top-k Rank Allocation"), proposes a low-rank KV cache compression framework whose key-side objective reportedly targets attention distributions directly, rather than raw keys or pre-softmax logits, yielding a quadratic surrogate with a closed-form low-rank solution (arXiv:2610.17966, published Oct 14). BELT also reportedly introduces a "learned global rank allocator" using differentiable soft selection during training and hard, top-k selection at deployment to meet a user-specified component budget, with experiments reportedly showing improved model quality under aggressive compression. BELT's learned, global rank-allocation approach extends the head/rank-allocation trend seen in DynaCalKV and ChampionKV toward a fully learned, differentiable allocation mechanism rather than an empirical proxy or fixed grouping rule. A new report, MOSAIC ("Multi-Objective Search for Allocating Inference Cache Across LLM Decoder Layers"), identifies a distinct allocation gap: existing token eviction methods such as SnapKV, H2O, AdaKV and L2Norm reportedly give every transformer layer the same cache budget, even though layers differ in which tokens they need (arXiv:2610.25431, published Oct 21). MOSAIC applies multi-objective neural architecture search to learn per-layer KV-cache budgets applicable to any eviction method; the authors reportedly find that a single search over the average-budget-versus-task-score trade-off produces a best allocation that transfers to new target budgets without further search. This is a layer-level allocation axis, complementary to the head-level allocation work (DynaCalKV, ChampionKV, BELT) above — MOSAIC's method can reportedly be layered on top of any of those eviction policies. A further new report, PeekKV ("The First Content Token Already Knows Which Heads Matter"), investigates a specific instability in existing head-wise KV cache compression: methods that compress non-uniformly across heads either fix important heads via offline profiling or select them using prefill-stage attention signals, but the paper reportedly finds accuracy fluctuates substantially across workloads under both approaches (arXiv:2610.23939, published Oct 21). The abstract indicates the authors investigated the cause of this instability and found a signal tied to the first content token, though the specific mechanism and proposed fix are not fully detailed in the excerpt. This diagnostic finding is directly relevant to — and potentially complicates — the head-wise allocation methods above (ChampionKV, DynaCalKV, BELT), suggesting that head-importance signals used by such methods may themselves be workload-unstable. ## SVD-Based KV-Cache Compression: A Methodological Caution A new report raises a methodological concern that cuts across prior low-rank/SVD-based KV-cache compression work: comparing parameter-efficient fine-tuning (PEFT) recipes under a single shared learning rate is described as a "common but flawed practice," because when compared arms have very different trainable-parameter counts, a shared rate can simultaneously depress the larger arms' means and inflate their variance — reportedly manufacturing a large, seemingly multi-seed-significant advantage for the smallest arm that is not a real effect (arXiv:2610.10552, published Oct 9). The paper documents this confound in the concrete setting of post-hoc SVD-based KV-cache compression, where a pretrained model is converted to a low-rank cache and then adapted via PEFT; the proposed fix (per the title) is to "freeze the decoder, heal the encoder," suggesting a parameter-efficient adaptation recipe designed to avoid the confound. This finding is methodological rather than a new compression technique itself, but it suggests that reported performance gaps between PEFT arms in prior and future SVD-based KV-cache compression literature — including BELT's rank-allocation experiments (arXiv:2610.17966) — should be scrutinized for shared-learning-rate confounds before being taken as evidence of a real architectural advantage. ## Global and Learned Eviction/Allocation Strategies Two new reports move beyond fixed, localized compression rules toward global or learned allocation strategies. GraceKV reportedly argues that existing KV cache compression methods rely on predefined, fixed rules built around either token eviction or merging, preventing cache resources from flowing freely across layers, heads, and context slots or being jointly allocated to balance local resolution against information coverage; GraceKV proposes a global allocation approach addressing this gap (arXiv:2608.07001, published Aug 10). Separately, DistillCache reportedly reframes KV-cache eviction as a sequential decision problem solved via reinforcement learning, arguing that existing heuristic eviction methods such as H2O and SnapKV rely on static attention or positional signals that often fail to capture a token's future predictive influence (arXiv:2608.08878, published Aug 12). BELT's learned global rank allocator (arXiv:2610.17966) and MOSAIC's layer-level budget search (arXiv:2610.25431) are further instances of this trend. Notably, the new production-trace study (arXiv:2609.28870, published Sept 25) presents a countervailing empirical finding at the prefix-cache level: sophisticated eviction policies underperform expectations relative to simple LRU in real agentic workloads, suggesting a tension between the field's push toward learned/global allocation and observed production behavior — though the two lines of work address different cache-reuse granularities (prefix-level eviction vs. token/channel-level compression) and are not directly contradictory. ## Sparse Prefill and the Mean Dilution Problem A new report addresses long-context inference cost at the prefill stage rather than the decode/cache stage: RBS-Attention ("Radius-Bounded Sparse Prefill") targets the dense self-attention cost of processing an entire prompt before generation begins (arXiv:2609.20971, published Sept 21). The paper identifies a specific failure mode in existing sparse block-selection methods, termed "mean dilution": when relevance is scored via a block's centroid, a single highly relevant token can be masked by many irrelevant tokens averaged into that centroid, causing the block to be wrongly skipped. RBS-Attention is described as a training-free method with two complementary selection branches — a "centroid base branch" capturing average relevance, and a "rescue branch" using the maximum key-block radius to recover blocks that would otherwise be missed under mean dilution. Unlike the decode-time KV cache compression and reuse methods elsewhere on this page, RBS-Attention targets the pre-generation prefill phase, positioning it as a complementary rather than competing optimization axis. Separately, prefix caching — a simpler, widely deployed prefill-cost-reduction mechanism — is the subject of the new production-trace study (arXiv:2609.28870, published Sept 25), which finds real-world eviction behavior dominated by session pacing rather than content patterns. ## Answer-Aligned Memory Compression A new report proposes a distinct compression paradigm: rather than pruning, quantizing, or evicting raw KV cache entries, the "Context-to-Answer-Aligned Memory Compression" (CMC) framework compresses long input contexts into compact soft memory embeddings (arXiv:2609.25537, published Sept 23). The paper motivates this approach by identifying three gaps in existing soft-compression methods: they reportedly (1) lack query-guided memory selection at inference time, (2) are trained without answer-targeted supervision, or (3) couple compression tightly to a specific decoder architecture. CMC is described as addressing these gaps, though the abstract does not specify quantitative results. This represents a fourth distinct optimization axis alongside token/channel-level pruning, quantization, and cache reuse — operating at the representation level by learning compressed memory embeddings aligned to the eventual answer, rather than manipulating the raw KV tensors directly. ## Disk-Backed KV Persistence for Long-Term Memory A new report, testing a package called galahad-kv, proposes storing KV cache state on encrypted local NVMe disk rather than GPU memory, loading blocks back "byte-exact" without recomputation (arXiv:2610.10845, published Oct 9). Tested at 50 million tokens on a single H100 with Gemma 4 12B and 31B via vLLM, the approach is framed as enabling a "real long-term memory" window far beyond typical GPU-resident context limits, at lower cost than recomputing KV state from scratch. This is a distinct optimization axis from the cache compression, quantization, reuse, and representation-compression methods described elsewhere on this page. The claims (correct byte-exact reload, cost advantage over recompute) are reported by the paper's authors and not yet independently verified. ## Strategic Relevance - **Infrastructure cost**: KV cache size is a primary driver of GPU memory requirements and thus inference infrastructure cost at scale. Disk-backed persistence (arXiv:2610.10845) introduces a storage-cost dimension to this calculus, trading NVMe capacity and I/O for GPU memory and recompute savings. - **Long-context applications**: Legal document review, contract analysis, and clinical record processing all benefit from efficient long-context inference. LSA's ultra-long-context framing (arXiv:2606.09079) directly targets this use case, as does the RULER benchmark used to evaluate quantization degradation (arXiv:2607.16248). RBS-Attention's prefill focus (arXiv:2609.20971) addresses the front-end latency of ingesting long documents. CMC's answer-aligned memory embeddings (arXiv:2609.25537) offer another route to compressing very long documents. The 50-million-token disk-backed window reported for galahad-kv (arXiv:2610.10845) suggests a further route to extreme long-context use cases via storage rather than compression. - **Hardware procurement**: Understanding cache optimization informs GPU memory specifications for enterprise inference deployments. Disk-backed KV persistence (arXiv:2610.10845) suggests NVMe storage capacity and throughput may become a relevant procurement consideration alongside GPU memory. - **Model-architecture coupling**: LSA's tie to the DeepSeek-V4 architecture (arXiv:2606.09079) and the RoPE-pruning incompatibility (arXiv:2602.02599) illustrate a coupling risk between cache optimization and model internals. CMC's explicit motivation to decouple compression from decoder architecture (arXiv:2609.25537) runs counter to this trend. CacheLink's cross-model handoff work (arXiv:2610.15509) directly confronts this coupling risk by attempting to translate cache state across different model architectures, highlighting portability as an emerging explicit research target rather than an incidental concern. Virtual Head Attention's "impossible triangle" framing (arXiv:2610.17959) offers a new architecture-level lens for evaluating this coupling, explicitly comparing GQA, MLA, and MFA on cache size, FLOPs, and quality tradeoffs. - **Quantization risk quantification**: Concrete benchmarks like the 84.2%-to-47.8% accuracy drop under one-bit quantization (arXiv:2607.16248) give enterprise adopters a tangible risk metric. The E8 lattice VQ approach (arXiv:2610.15384) and KV4-RL's RL-training-specific findings (arXiv:2610.14448) extend this risk/benefit quantification to 2-bit and INT4 regimes and to RL training workloads specifically, the latter noting that INT4 KV rollout can degrade learning despite acceleration gains. - **New security and quality surface in cache reuse**: KV Cache Hijacking (arXiv:2607.19957) indicates that cache-reuse optimizations may introduce cross-request data leakage or manipulation risks. LatentRemedy's finding of up to 90% performance degradation from non-prefix cache reuse among conflicting multi-agent tasks (arXiv:2610.18014) adds a distinct quality-risk dimension specific to multi-agent deployments, separate from the hijacking security vulnerability — enterprises deploying multi-agent systems with shared context blocks should evaluate both risks before adopting aggressive cache-reuse strategies. The disk-backed persistence approach (arXiv:2610.10845) notes encryption of stored KV state but does not address cross-request isolation. - **Methodological trend toward learned/global allocation**: GraceKV (arXiv:2608.07001), DistillCache (arXiv:2608.08878), ChampionKV (arXiv:2610.18026), BELT's differentiable global rank allocator (arXiv:2610.17966), and MOSAIC's per-layer budget search (arXiv:2610.25431) collectively suggest the field is moving away from fixed heuristic rules toward adaptive, learned, or globally optimized cache management. However, the production-trace study (arXiv:2609.28870) offers a caution against this trend at the prefix-cache level, finding sophisticated eviction algorithms provide little real-world benefit over simple LRU. PeekKV's finding of workload-dependent instability in head-importance signals (arXiv:2610.23939) offers a further, more granular caution specifically for head-wise allocation methods. - **RAG-specific granularity trend**: CoinRAG's nugget-level reuse (arXiv:2608.07458) indicates ongoing refinement of RAG-specific KV reuse granularity, following chunk-level and document-level approaches (arXiv:2607.21599). - **Prefill/decode bifurcation**: RBS-Attention (arXiv:2609.20971) and the prefix-caching production study (arXiv:2609.28870) reinforce that prefill-cost reduction is increasingly treated as a distinct optimization target from decode-time KV cache management. Virtual Head Attention's "impossible triangle" (arXiv:2610.17959) explicitly names training/prefill FLOPs as a third axis alongside cache size and quality, formalizing this bifurcation at the architecture-design level. - **Emergence of representation-level compression**: CMC (arXiv:2609.25537) suggests a fourth optimization family — soft memory embedding compression — distinct from token/channel pruning, quantization, and cache reuse. - **Emergence of storage-backed persistence as a fifth axis**: galahad-kv (arXiv:2610.10845) suggests a fifth distinct family of KV optimization — relocating cold cache state to disk. - **Cross-model cache portability as a sixth axis**: CacheLink (arXiv:2610.15509) introduces a sixth distinct optimization concern — enabling KV reuse across different models entirely, rather than within a single model's requests — relevant to enterprises running multi-model pipelines or routing requests across model versions, where context handoff currently forces costly re-prefilling. - **Attention-architecture redesign as a seventh axis**: Virtual Head Attention (arXiv:2610.17959) represents a seventh distinct approach — rather than compressing, evicting, reusing, or relocating an existing architecture's cache, it redesigns the attention mechanism itself to jointly improve cache size, compute, and quality, explicitly benchmarking against GQA, MLA, and MFA as the current architectural tradeoff frontier. - **Research-vs-production gap**: The production-trace study (arXiv:2609.28870) is a rare empirical check on academic cache-optimization research using real traces, suggesting enterprises should be skeptical of eviction-algorithm sophistication claims absent evidence from real agentic workloads. The galahad-kv report (arXiv:2610.10845) is itself an applied systems test, though its claims remain self-reported and not yet independently verified. LatentRemedy's 90% degradation figure for multi-agent non-prefix reuse (arXiv:2610.18014) likewise appears to derive from applied testing rather than purely theoretical analysis, though verification status is not specified in the abstract. PeekKV's diagnostic finding (arXiv:2610.23939) is similarly an empirical investigation into why a class of existing methods underperforms in practice, reinforcing a broader pattern of research self-scrutiny on real or realistic workloads. - **Benchmarking rigor in SVD-based compression**: The shared-learning-rate confound (arXiv:2610.10552) suggests that enterprises and researchers evaluating published PEFT-based KV-cache compression benchmarks, including newer rank-allocation methods like BELT (arXiv:2610.17966), should check whether comparisons across differently-sized trainable arms used matched or tuned-per-arm learning rates. - **Head-level and layer-level granularity as a recurring refinement target**: ChampionKV (arXiv:2610.18026), DynaCalKV (arXiv:2607.24331), BELT's learned rank allocator (arXiv:2610.17966), and MOSAIC's per-layer budget allocation (arXiv:2610.25431) collectively suggest that per-head/per-layer/per-component adaptivity — whether via empirical proxy, fixed grouping, fully learned differentiable allocation, or neural architecture search — is an increasingly common refinement layered atop existing eviction and compression frameworks. PeekKV's instability finding (arXiv:2610.23939) is a direct empirical complication of this trend at the head level, suggesting the head-importance signals these methods rely on may not generalize robustly across workloads.