Ada-KV: From Equal KV Budgets to Per-Head Competition

Date: 2026-09-18
Rotating field: Efficiency and Systems (Long-Context Inference / KV-Cache Compression)
Core paper: Yuan Feng, Junlin Lv, Yukun Cao, Xike Xie, S. Kevin Zhou. Ada-KV: Optimizing KV Cache Eviction by Adaptive Budget Allocation for Efficient LLM Inference. NeurIPS 2025.
Core positioning: Ada-KV does not reinvent token selection. It reallocates a layer's total KV budget across heads—less for concentrated attention, more for diffuse attention—then applies existing SnapKV/Pyramid per-head Top-k selection.

Audit conclusion first. This is a small, reusable systems-algorithm contribution. On Llama-3.1-8B, question-agnostic LongBench with mean per-head budget 512, Ada-SnapKV improves the 16-task average 31.20→32.82: +1.62 pp / +5.19% relative, improving 14 of 16 datasets. It is not a lossless-compression theorem: theory minimizes an $L_1$ upper bound with a global constant, and the text admits a smaller bound need not mean smaller actual eviction loss. Safeguard formulas, appendix prose, and README defaults disagree in direction/value and need clarification before deployment.

0. Link verification table

All links were accessed 2026-09-18. OpenReview confirms NeurIPS 2025; numbers follow arXiv v5 PDF/HTML. Not found means no verifiable entry was located, not that authors never released one.

1. Candidate pool, deduplication, and random selection

The index excluded recently covered systems topics, especially 2026-09-04's Lumos(training-performance modeling) and 2026-09-11's ScaleSearch(NVFP4 scale search). Earlier QServe/DuoAttention lie outside the strict 14-day window but were still avoided as core topics. Searches covered arXiv, OpenReview, official NeurIPS/ICLR/MLSys/ACL proceedings, Hugging Face Daily Papers, Papers with Code, and Semantic Scholar. The latter two yielded no stable direct core-title record and were not evidence sources.

The 24-paper pool was frozen before sampling:

1. VeriCache: Turning Lossy KV Cache into Lossless LLM Inference（arXiv 2026）
2. Lynx: Progressive Speculative Quantization for Accelerating KV Transfer in Long-Context Inference（arXiv 2026）
3. SmartGen: Efficient LLM Serving via Selective KV Cache Transfer（arXiv 2026）
4. Pallas: Proactive KV Cache Migration for AI-RAN（arXiv 2026）
5. SwiftCache: Efficient LLM Serving for Multi-turn Conversations with Heterogeneous KV Cache Sharing（arXiv 2026）
6. Joint Encoding of KV-Cache Blocks for Scalable LLM Serving（arXiv 2026）
7. Robust KV Cache Management for LLM Serving under Output Token Length Uncertainty（arXiv 2026）
8. Kara: Efficient Reasoning LLM Serving via Sliding-Window KV Cache Compression（arXiv 2026）
9. KVComp: A High-Performance, LLM-Aware, Lossy Compression Framework for KV Cache（arXiv 2025）
10. LMCache: An Efficient KV Cache Layer for Enterprise-Scale LLM Inference（arXiv 2025）
11. Oaken: Fast and Efficient LLM Serving with Online-Offline Hybrid KV Cache Quantization（arXiv 2025）
12. Ada-KV: Optimizing KV Cache Eviction by Adaptive Budget Allocation for Efficient LLM Inference（NeurIPS 2025）
13. R-KV: Redundancy-aware KV Cache Compression for Reasoning Models（NeurIPS 2025）
14. FlashInfer: Efficient and Customizable Attention Engine for LLM Inference Serving（MLSys 2025）
15. NanoFlow: Towards Optimal Large Language Model Serving Throughput（OSDI 2025）
16. LoongServe: Efficiently Serving Long-context LLMs with Elastic Sequence Parallelism（SOSP 2025）
17. CacheBlend: Fast LLM Serving for RAG with Cached Knowledge Fusion（EuroSys 2025）
18. BlendServe: Optimizing Offline Inference with Resource-aware Batching（MLSys 2025）
19. ShadowKV: KV Cache in Shadows for High-Throughput Long-Context Inference（ICML 2025）
20. MiniKV: Pushing the Limits of 2-Bit KV Cache via Compression and System Co-design（ICLR 2025）
21. KIVI: A Tuning-Free Asymmetric 2-bit Quantization for KV Cache（ICML 2024）
22. Mooncake: A KVCache-centric Disaggregated Architecture for LLM Serving（FAST 2025）
23. CacheGen: KV Cache Compression and Streaming for Fast LLM Serving（SIGCOMM 2024）
24. vAttention: Dynamic Memory Management for Serving LLMs without PagedAttention（ASPLOS 2025）

Then the native command executed was shuf -i 1-24 -n 1returned 12. Ada-KV's NeurIPS 2025 version was complete and within 24 months, so zero redraws。

2. Motivation: waste may come from equal budgets, not tokens themselves

KV memory grows linearly with context. An illustrative extreme is an 8B model processing one 2M-token sequence requiring KV cache up to 256 GB(p.2, near line 61). This does not generalize to every GQA/quantized implementation, but illustrates HBM limits. Existing eviction gives each head budget $B/h$and retains its highest-attention tokens, despite unequal attention concentration.

Figure 1's example reallocates uniform budgets through cross-head competition, raising aggregate retained attention mass from 2.26 to 2.48, +0.22 absolute or +9.73%relative (p.2, Figure 1). If a head's top 5% covers almost all mass, extra tokens are wasted; diffuse heads need more. Ada-KV completes budget allocation for existing scores rather than predicting future queries or training a compressor.

Two assumptions are hidden: observed head concentration remains useful for future generation, and retained attention mass proxies output fidelity. The first comes from SnapKV's observation window; the second is supported by an upper bound, not equivalence. Precisely:when the existing Top-k selector is valid, global cross-head Top-B is a more justified budget allocator than uniform local Top-k, rather than a theoretical solution to KV compression.

3. Method: local Top-k to global Top-B within a layer

3.1 Formalization

For attention head $i$ , the current-query output is

$$y=\sum_{i=1}^{h} A_iV_iW_i^O,\qquad A_i=\operatorname{softmax}(q_iK_i^\top).$$

After applying retention mask $\mathcal I_i\in\{0,1\}^{n}$ , evicted positions are set to $-\infty$ before softmax, yielding $\hat A_i$ with $\hat y$. Actual eviction loss is defined as

$$\mathcal L_{\mathrm{evict}}=\lVert y-\hat y\rVert_1.$$

Let $C=\max_i\lVert V_iW_i^O\rVert_\infty$, and Theorem 3.1 derives

$$\mathcal L_{\mathrm{evict}}\le \epsilon =2hC-2C\sum_{i=1}^{h}\sum_{j=1}^{n}\mathcal I_i^jA_i^j.$$

Given per-head budget $B_i$, minimizing the bound retains top-$B_i$ attention weights per head. If only total budget $\sum_iB_i=B$is constrained, concatenate all heads' weights and select global top-$B$; each head's selected count becomes $B_i^*$. Theorem 3.3 shows this is no worse under the bound than any allocation, including uniform $B/h$(pp.3–4, Eqs.7–8; proofs Appendices A.8–A.10).

Three qualifications define optimality: it applies to observed attention weights, within one layer, for this upper bound —not future tokens, cross-layer total memory, or end-to-end task scores.

3.2 Algorithm

Input: layer budget B, observation window Xwin, historical K/V, heads=1..h
1. Compute each head's attention from the observation window to historical cache
2. Max-pool(kernel=7), then average over window positions to score historical tokens
3. Reserve winsize × h from B, retaining all window tokens
4. Concatenate head scores and select global Top-B within the layer
5. Count selected entries fi per head; set adaptive budget Bi*=fi
6. Safeguard: Bi ← α·Bi* + (1−α)·(B/h); paper experiments use α=0.2
7. Apply SnapKV/Pyramid Top-k within each head using Bi
8. Restore window tokens and write flattened variable-length KV layout
9. Decode with flash_attn_varlen_func; within GQA, average query-head scores to select shared KV

3.3 Key mechanisms and engineering

4. Datasets, evaluation, and comparability

Ruler Contains 13 tasks at 16K length: single/multi-key NIAH, multi-value/query retrieval, variable tracking, word-frequency extraction, and single/multi-hop QA. The paper chooses 16K because official evaluation gives Mistral-7B-Instruct-v0.2 and Llama-3.1-8B-Instruct full-cache maximum effective length 16K (p.6). This tests lost needles, not 128K–2M scheduling, fragmentation, or long-generation pressure.

LongBench Contains 16 datasets grouped into six domains: single-document QA, multi-document QA, summarization, few-shot, synthetic, and code; average input length 6,711(Appendix A.7, p.17). Dataset metrics differ, so arithmetic-average pp changes describe a heterogeneous aggregate, not unified probabilistic accuracy.

Two scenarios: question-aware compression sees context+question first; question-agnostic compresses context before receiving questions, closer to reusable prompt caches/multiturn dialogue. This is the most valuable evaluation extension because query-based eviction loses its target when questions are unknown.

Models/settings: Llama-3.1-8B-Instruct, Mistral-7B-Instruct-v0.2, plus domain-level Llama-3.1-70B tables. Compression follows each layer's prefill. Budgets are 20/40/60/80% of original cache or fixed mean per-head 128/256/512/1024/2048; window=32, pool=7, paper α=0.2 (§4.1, p.6).

5. Main results: real quality gains, but not universal dominance

5.1 Complete six-domain × three-budget matrix

The following transcribes Table 1（p.7）for Llama-3.1-8B, question-agnostic LongBench. Bold marks the better SnapKV/Ada-SnapKV value at equal budget; parentheses are recomputed Ada−base pp.

Mean relative improvement at 20% budget is $(42.87-41.29)/41.29=3.83\%$. Not all 18 domain×budget pairs improve: three cells decline, consistent with the paper's 15/18 statement (p.8). The contribution is a better average Pareto tradeoff, not monotonic domination.

5.2 Five budgets × five methods: question-aware versus unknown-query

From Appendix Table 5（p.19） with Table 7（p.20）; all are Llama-3.1-8B averages across 16 LongBench datasets.SLM denotes StreamingLLM. Values are reported, without invented standard deviations.

Wider budgets and earlier question visibility reduce reallocation's marginal value. Aware/2048 gains only 0.06 pp, near saturation; agnostic/512 is the most convincing intermediate-budget point. Auditing Table 7 at B=512, Ada-SnapKV versus SnapKV gives 14/16 improvements, 2/16 declines, averaging +1.62. One clear large gain is TREC 35.00→43.00（+8.00 pp，+22.86%）, while LCC 66.79→66.12（−0.67）. The average does not erase failures, but the main text does not emphasize declining tasks.

5.3 70B and follow-up methods

On Llama-3.1-70B, question-agnostic, Ada-SnapKV averages at 20% budget 44.95→46.08（+1.13 pp，+2.51%）and at 40% 48.91→49.64（+0.73 pp，+1.49%）(Table 2, p.9). Yet Code at 40% falls 51.90→49.23 (−2.67 pp, −5.14%), so larger-model benefits do not mean domain-wide robustness.

Updated Table 3 (p.9) summarizes follow-ups: at 20% cache, CriticalKV 42.99→43.77 (+0.78), DefensiveKV 43.78→46.68 (+2.90); at 40%, +0.71/+1.45. These are secondary summaries from later methods, not synchronized fair reruns. They support allocator portability, not dominance over every newer method in one stack.

6. Ablations, sensitivity, transitions, and statistics

6.1 Layered ablations

There is no four-factor remove-global-allocation/safeguard/flattened-kernel/GQA-fix table. Identifiable levels are:

1. Algorithm: SnapKV→Ada-SnapKV and Pyramid→Ada-Pyramid isolate average allocation gains;
2. Model scale: 8B main tables versus 70B Table 2 show transferable but not universally positive gains;
3. Scenario: aware→agnostic shows larger gains for unknown queries;
4. Engineering: Figure 6 plots Full/Snap/Ada-Snap peak memory and ms/token without reusable numerical tables, error bars, batch sizes, concurrency, or request traces, preventing end-to-end throughput recomputation.

Without factorial ablation, gains cannot be split among GQA deduplication, head reallocation, and flattened layout. All methods reportedly receive GQA compatibility, improving fairness while preventing direct system comparison with originally released SnapKV/Pyramid implementations.

6.2 α sensitivity and small-budget transitions

Appendix Table 4 (p.15) tests only Mistral-7B, question-aware LongBench, α∈{0,0.2,0.5}:

Numerically, α=0 wins at low budgets and α=0.5 slightly at high budgets, with maximum 0.49 pp difference—smaller than task/budget effects. Yet the formula is $\alpha B_i^*+(1-\alpha)B/h$, implying smaller α is closer to uniform and less aggressive, while appendix prose says smaller α permits more aggressive allocation, the opposite. The public README's floor_alpha also defaults to 0.5, while the main text fixes all experiments at 0.2. This is actionable, not cosmetic: tuning under the smaller-is-more-aggressive description would produce the opposite operation.

The matrix also shows an empirical transition: aware Ada-Snap gains shrink from +0.78 at 128 to +0.06 at 2048; agnostic gains peak at +1.62 at 512 then shrink to +0.43 at 1024. Without fitted breakpoints or denser budgets, this is a pattern of strongest marginal gains at low/intermediate budgets, not a rigorous phase transition.

6.3 Statistical significance

not reported by the paperseeds, standard deviations, CIs, significance tests, or bootstrap. Most LongBench settings decode deterministically, but kernels, sample selection, and implementations can vary. Small 0.06–0.39 pp gaps lack uncertainty ranges. Large changes such as TREC +8.00 merit verification; aware/2048 +0.06 cannot establish a stable improvement.

7. Related work: problem origins, gaps, responses, and transferred design

7.1 SnapKV

Problem addressed: Uses a prompt-ending observation window to predict persistently important generation tokens, with per-head clustering/Top-k. The original reports up to 3.6× generation speed and 8.2× memory efficiency at 16K input.Remaining gap: Equal token counts per head ignore concentration heterogeneity.Ada-KV's response: retain SnapKV scores, windows, and pooling, replacing budget $B/h$ with global Top-B selection counts.Transferred design: Algorithm 2 essentially prepends an allocator to SnapKV, enabling reuse while inheriting observation-window stability assumptions.

7.2 PyramidInfer / PyramidKV

Problem addressed: Finds shallow layers need longer caches and deep layers tolerate greater compression; pyramid layer budgets achieve 2.2× throughput over Accelerate and over 54% KV-memory reduction in the ACL paper.Remaining gap: Heads remain uniform within layers, leaving waste even with smart layer budgets.Ada-KV's response: Reallocate each predetermined layer budget among heads.Transferred design: Creates a composable layer-allocator × head-allocator × token-selector hierarchy; joint cross-layer optimality remains open.

7.3 DuoAttention

Problem addressed: Optimization/synthetic data divide heads into few retrieval heads and many streaming heads retaining only sinks/recent tokens. The ICLR abstract reports MHA memory/decode gains up to 2.55×/2.18× and GQA 1.67×/1.50×.Remaining gap: Binary head types and offline profiling may mismatch prompts/tasks, with nonzero training/optimization costs.Ada-KV's response: Generate continuous per-input, per-layer budgets without training.Transferred design: Both observe heterogeneous head functions; DuoAttention discretizes types, Ada-KV continuously allocates token counts.

7.4 HeadKV

Problem addressed: Retrieval–reasoning examples estimate head importance for global allocation; the paper claims 97% of full-cache contextual-QA performance with only 1.5% KV retained.Remaining gap: Importance depends on offline examples/task proxies and may drift.Ada-KV's response: Use current-context attention concentration without offline profiling.Transferred design: HeadKV's repository explicitly builds on Ada-KV/PyramidKV, suggesting the allocation interface may matter more than one score.

7.5 KV-Compress

Problem addressed: Variable compression ratios remain theoretical unless PagedAttention can release whole blocks. Continuous KV-block eviction integrated with vLLM reports up to 5.18× throughput.Remaining gap: Block granularity constrains fine-grained optimality; workload results are not directly Ada-KV results.Ada-KV's response: Flattened variable-length layouts run unequal heads, but lack PagedAttention serving evaluation.Transferred design: Turning logical budgets into physically reclaimable memory is the critical next step toward production.

Nonlinear technical evolution

Full KV cache
├─ Fixed structure, local retention
│  └─ StreamingLLM: attention sinks + recent window
├─ Token-importance eviction
│  ├─ H2O: accumulated heavy hitters
│  └─ SnapKV: observation-window scores
│     ├─ PyramidInfer: layer-wise budgets
│     │  └─ Ada-Pyramid: head-wise budgets
│     └─ Ada-SnapKV: global Top-B → per-head counts
│        ├─ CriticalKV: attention + value/output perturbation
│        ├─ DefensiveKV: risk/vulnerability protection
│        └─ KVzip: context-reconstruction query-agnostic scores
├─ Head-function profiling
│  ├─ DuoAttention: retrieval versus streaming (binary)
│  └─ HeadKV: retrieval–reasoning importance (continuous)
└─ Physical systems integration
   ├─ Ada-KV flattened varlen + custom CUDA
   └─ KV-Compress: PagedAttention block reclamation + vLLM throughput

Drivers and turning points: The first stage asks which tokens matter; the second treats budgets as multidimensional layer/head/token allocation; the third replaces immediate query-aware scores with reusable query-agnostic scores. The systems turning point recognizes that logical deletion is not physical memory release and requires block allocators, kernels, and schedulers together.

Cross-paper comparison

8. Genuine contributions, reusable design, and transfer potential

1. The core contribution is decomposition. Split compression into total, layer, head, and within-head token budgets; prove global Top-B gives optimal single-layer head budgets under the bound. This interface is more reusable than one Ada-SnapKV score.
2. Question-agnostic evaluation is an independent contribution. Prompt caches, multiturn dialogue, and RAG prefix reuse cannot inspect future queries during compression. Separating context/questions exposes Top-k fragility.
3. Flattened variable-length layout is minimum necessary engineering. Padding every head to the longest would erase memory savings. Custom CUDA plus variable-length FlashAttention at least establishes executable unequal-length heads.
4. Direct transfer to VLMs/video generation is possible. Heterogeneous attention concentration and available scores permit global budget selection, but visual locality/cross-modal heads may need modality/group safeguards.
5. Quantization is complementary. Eviction reduces tokens; KV quantization reduces bits per token. Joint budgets must optimize accuracy, dequantization cost, and packing rather than multiply theoretical compression ratios.

9. Limitations and independent critique

9.1 Stated limitations / explicit future scope

1. Formal limitation: allocation within one layer only. Appendix A.6 (p.17) leaves cross-layer extensions/theory for future work.
2. No joint quantization/sparse-attention optimization. Appendix A.1 (around p.14) lists those combinations as future work, so composite compression/stability cannot be inferred.
3. Limited advanced-selector coverage. Appendix A.1 proposes newer eviction methods; v5 Table 3 summarizes a few follow-ups rather than unified reruns.

9.2 Independent critique: evidence → inference

1. [Theoretical validity] Because Theorem 3.1 uses a cross-head $C=\max_i\|V_iW_i^O\|_\infty$ global worst-case constant for value/output-projection differences, and p.4 explicitly says smaller bounds need not imply smaller eviction loss,therefore the proof optimizes an attention-mass surrogate, not actual output perturbation or task quality.
2. [Parameter semantics/reproduction] Because Algorithm 2 defines $\alpha B_i^*+(1-\alpha)B/h$, algebra makes smaller α more uniform, while Appendix A.3 says more aggressive and README defaults to floor_alpha=0.5 instead of the main text's fixed 0.2,therefore safeguard semantics/configurations conflict operationally, potentially reversing tuning directions.
3. [System evidence] Because Figure 6 gives only B=1024 memory/latency curves without numerical tables, batch, concurrency, request distributions, TTFT/ITL/P99, or goodput,thereforeit suggests little allocator slowdown in a microbenchmark, not validated production throughput.
4. [External validity] Because main evaluation covers two 7–8B GQA dense models, 70B only domain tables, Ruler only 16K, and LongBench mean length 6,711,thereforeresults do not extend directly to 128K–2M, MoE/MLA, long reasoning outputs, or multi-tenant prefix caches.
5. [Statistics] Because seeds, deviations, CIs, and significance are absent, while aware/2048 gains only 0.06 pp,thereforesmall gains may be below evaluation noise; strong conclusions require larger, consistent differences.
6. [Averages conceal regressions] Because Table 1 declines on 3/18 pairs and 70B Code at 40% falls 51.90→49.23 (−2.67 pp),thereforeconsistent improvement means averages/most conditions, not per-task dominance. Code workloads need specific guardrails.
7. [Physical memory] Because flattened layouts demonstrate computation but not PagedAttention fragmentation, continuous batching, or reclaimed-page counts—the gap KV-Compress addresses—thereforelogical cache fractions cannot be treated as available serving HBM fractions.
8. [Dynamic generation] Because compression occurs once after each layer's prefill, without long-CoT growth, periodic recompression, or score-drift evaluation,thereforeresults fit long prompts/short answers better than long reasoning generations.

10. Open challenges: executable head-to-head gaps

Theory

• Attention-only vs value-aware。 At equal budgets/variable-length kernels, compare global attention mass, CriticalKV value/output perturbation scores, and a joint Lagrangian objective. Record per-layer actual $\|y-\hat y\|_1$, bound-to-actual ratios, and task scores to test tightness rather than only average quality.
• Layer-local greediness versus cross-layer optimization. At equal model-wide KV bytes, compare Ada-KV fixed layer totals, Pyramid×Ada preset totals, and learned/dynamic cross-layer knapsack. Plot quality–bytes Pareto curves for 8B/70B and 16K/128K, including solver cost.

Engineering applications

• Flattened vs paged physical memory。 Integrate official Ada-KV CUDA, NVIDIA kvpress hooks, and KV-Compress into one vLLM version with identical models/workloads. Measure logical compression, actual HBM, fragmentation, TTFT, ITL, P50/P99, and goodput under fixed arrival traces rather than separate peak claims.
• Static prefill eviction versus periodic recompression. For 32K prompts plus 32K CoT, compare one-time, every-1K-token, and drift-triggered compression. Measure correctness, recompression cost, and tail latency to assess reasoning serving.
• Match quality, not just budgets. For SnapKV/Ada-Snap/KVzip/HeadKV, find minimum real HBM subject to ≤1 pp LongBench mean loss, then compare throughput—a more practical capacity-planning comparison than fixed 20% budgets.

Emerging directions

• Cross-modal heads. On long-video/document VLMs, compare global cross-modal Top-B, modality-partitioned Top-B, and modality-safeguarded Ada-KV. Measure text QA, temporal localization, OCR, and video consistency to detect visual-head starvation.
• Query-agnostic multi-tenant caches. Reuse one compressed 64K prefix across 100 heterogeneous queries with Ada-KV, KVzip reconstruction, and DuoAttention profiles. Report first/100th-query worst accuracy, reuse hit rates, and amortized compression cost.

11. Seven recent works to track

1. KVzip, NeurIPS 2025: context reconstruction produces query-agnostic importance, reporting 3–4× memory reduction and about 2× FlashAttention latency reduction—a direct unknown-query comparator.
2. CriticalKV / Output Perturbation: includes value states/output projections in importance, reporting reduced perturbation in over 92% of Llama heads, directly challenging Ada-KV's loose bound.
3. The Sparse Frontier, ACL Findings 2026: finds no universally optimal sparse-attention strategy across tasks/phases and analyzes isoFLOPS/scaling, cautioning against deployment decisions from one LongBench average.
4. KV-Compress: aligns variable per-head rates with PagedAttention blocks, achieving up to 5.18× vLLM throughput by making compression reclaim physical pages.
5. KVComp: an algorithm–system lossy-compression framework reporting average 47%, maximum 83% greater memory reduction, suited to equal-HBM/quality eviction comparisons.
6. CompressKV: uses semantically retrieval-capable heads for token importance and layer-adaptive allocation, further separating reliable heads from budget quantities.
7. VeriCache: drafts with compressed KV and verifies with full KV for token-identical outputs, reporting up to 4× throughput. Compression becomes speculative acceleration rather than accepted approximation.

12. Final assessment

Ada-KV matters for extracting an overlooked compression degree of freedom—head budget—into a few global-selection operations, with minimum engineering for variable-length heads. Its strongest conclusion is that uniform allocation is suboptimal for unknown queries at low/intermediate budgets: B=512 Llama-3.1-8B LongBench gains 1.62 pp with 14/16 datasets improving.

Deployment conclusions should be narrower: no serving throughput/P99, uncertainty intervals, or dynamic long generation, and conflicting α formula/prose/README. Ada-KV is a reusable allocator, not yet a proven lossless, faster production compression system.

Evidence and production notes. Numbers come from the read Ada-KV arXiv v5 text/appendices or explicit table-based recomputations; unreadable curve values were not invented. Warm Editorial HTML uses inline CSS/JS, dual themes, and responsive tables. No executable Chromium was found under /usr/bin/chromium、chromium-browser or /opt/pw-browsers , so the constrained command playwright installwas not run and screenshot completion was not claimed. Template/structure validation, static responsiveness, and overflow auditing were used. The index entry was synchronized to ml-report-index.md。