Pith. sign in

REVIEW 4 major objections 6 minor 22 references

Accelerating Prefilling for Long-Context LLMs via Sparse Pattern Sharing

T0 review · 4 major / 6 minor · reviewed 2026-08-07 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read SharePrefill accelerates long-context prefill by computing full attention on a small subset of heads and sharing those exact block-sparse patterns with other heads whose attention is similar—and stably similar across inputs.

desk verdict SharePrefill's pattern-sharing idea is genuinely new and the paper shows it can tie or beat MInference on some models, but the gate that decides when sharing is safe only checks the last query block, and the 'best accuracy' claim depends on a slower ablation variant. read the letter →

arxiv 2505.19578 v1 pith:OBZQPH44 submitted 2025-05-26 cs.LG cs.AIcs.CL

Dan Peng , Zhihui Fu , Zewen Ye , Zhuoran Song , Jun Wang This is my paper · ORCID
classification cs.LGcs.AIcs.CL
keywords sparseattentionlong-contextLLMprefillingaccelerationpatternsharingheadclusteringblock-sparseinferenceoptimization
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

Long-context language models pay a quadratic cost during the prefilling phase, when every token in the prompt attends to every earlier token. Sparse attention tries to skip irrelevant blocks, but existing methods either impose fixed patterns that miss genuine structure or estimate block importance from pooled queries, which is unreliable. This paper argues that the real attention patterns of many heads are similar to each other, and that these similarity relationships stay stable across inputs and tasks. On that basis it proposes SharePrefill: compute full attention for a few 'pivotal' heads, extract exact block-sparse patterns from them, and share those patterns with similar heads, after a cheap safety check. The result, the authors claim, is a sparse attention method whose accuracy tracks dense attention while its latency matches or beats current sparse-attention baselines.

What carries the argument

The load-bearing mechanism is pattern sharing between heads that are offline-clustered as similar. Offline, an autoencoder compresses each head's attention score map to a 64-dimensional vector; hierarchical clustering with a distance threshold groups heads into clusters and isolates a noise cluster for outliers. Online, a global pivotal-pattern dictionary stores, per cluster, the block-averaged attention and the exact block-sparse mask derived from the pivotal head's dense attention via a cumulative-score threshold $\gamma$. Before accepting a shared mask, the method checks two Jensen-Shannon distances: the sparsity distance between the current head's last-row block-averaged attention and a uniform distribution (below $\delta$ means the head is not too sparse), and the similarity distance between the current head and the pivotal representative (below $\tau$ means the patterns are close). Only when both pass is the pivotal mask shared; otherwise the head uses a vertical-slash pattern. This gate is what lets the method reuse exact, dynamically computed patterns instead of estimating them from pooled keys and queries.

What would settle it

Run SharePrefill on inputs far from the Retr.KV sample used for clustering—for instance, code with irregular attention, or a prompt with reversed token order—and count how often the Jensen-Shannon gate accepts a shared pivotal mask; if accepted heads frequently turn out to have low true Jaccard similarity with the pivotal pattern (measured by computing their dense attention anyway), or if task accuracy drops relative to FlashAttention-2, the cross-input consistency assumption is falsified.

Watch

Extended reading notes

Core claim

SharePrefill is built on an empirical claim: different attention heads in a long-context transformer show strongly similar sparse patterns, and the similarity relationships among heads persist across very different inputs even though the patterns themselves change. The paper demonstrates this with visualisations and Jaccard-similarity matrices across tasks such as English dialogue, Chinese QA, and code debugging. Exploiting the property, heads are clustered offline: an autoencoder compresses each head's attention score map into a low-dimensional vector, and hierarchical clustering groups similar heads into a static dictionary. At inference, the first head of a cluster—the pivotal head—computes dense attention, and its exact block-wise sparse mask (the fewest blocks whose cumulative softmax score reaches a threshold $\gamma$) is stored in a global dictionary. Other heads receive that mask only if a Jensen-Shannon check on the last query block passes, otherwise they fall back to a vertical-slash pattern. The paper reports that this scheme keeps accuracy close to full attention while cutting prefill latency, with only a handful of heads per layer doing dense computation.

Load-bearing premise

The whole method rests on the assumption that head clusters learned offline from one sample, together with the online Jensen-Shannon check on the last query block, reliably identify heads whose full attention maps really match; if similarity relationships change with the input, or the last-block distance misjudges the whole map, shared patterns will be wrong and accuracy drops.

Editorial extensions

If this is right

  • Long-context prefill can be accelerated without any model fine-tuning, since the sparse masks are produced by exact dense attention on a few heads and reused, not learned.
  • Because the head clusters are computed from a single sample and stay fixed across inputs, the per-query cost of pattern generation is limited to a cheap Jensen-Shannon distance check rather than a full estimation pass.
  • The method's accuracy should degrade gracefully: when the safety check rejects a share, the head falls back to the vertical-slash pattern, so the worst case is the quality of existing sparse attention, not a catastrophic failure.
  • In the paper's latency measurements the scheme reaches roughly 1.3–1.8× end-to-end speedup over FlashAttention-2 at the longest contexts while keeping perplexity within a small margin of dense attention.
  • The same similarity principle is extensible in principle to the decoding phase and to multi-modal models, a direction the paper flags for future work.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • The paper itself notes that it has no explanation for why head-similarity relationships stay consistent across inputs, and that the method has only been evaluated on a single A100 GPU; both gaps are natural stress points for distributed or multi-device deployment, where a shared global pattern dictionary would become a communication bottleneck.
  • Because sharing is gated by a last-query-block Jensen-Shannon distance, a cheap alternative diagnostic such as top-block overlap between the current head and the pivotal mask could be tested against the same accuracy; comparing them would reveal how much accuracy the cheap proxy costs.
  • An oracle version of SharePrefill in which each head receives the true dense mask of its nearest neighbour would separate the loss from sharing from the loss from estimation; the paper does not run this decomposition, and it would locate the method's accuracy ceiling.
  • The offline clusters are trained once on a single Retr.KV sample; measuring how cluster membership changes across model checkpoints, languages, or prompt distributions would test whether the consistency is a genuine architectural property or an artefact of that sample.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

4 major / 6 minor

Summary. The paper proposes SharePrefill, a training-free sparse-attention method for the prefill phase of long-context LLMs. It is based on two observations: (1) attention heads exhibit similar sparse patterns, and (2) the similarity relationships among heads persist across different inputs. The method clusters heads offline using an autoencoder and hierarchical clustering on a single Retr.KV sample; online, one head per cluster computes dense attention and its block-thresholded mask is stored as a 'pivotal pattern,' which is then shared with other heads in the cluster if a Jensen-Shannon distance check on the last query block's block-averaged attention passes. Heads that fail the check or belong to noisy clusters fall back to a vertical-slash pattern. Experiments on Llama-3-8B-Instruct-262k and Qwen2.5-7B-Instruct over InfiniteBench, PG-19, and a latency benchmark report speedups over FlashAttention and accuracy comparable to MInference and FlexPrefill, with ablations isolating the sharing and exclusion components.

Significance. If the two empirical premises hold, sharing exact attention masks across similar heads is a principled alternative to estimation-based sparse attention and could generalize beyond the two models tested. The paper contains useful ablations (Table 2), a Triton kernel implementation, latency measurements with warm-up, and an honest limitations section. However, the foundational claim that head-similarity relationships are input-invariant is supported only by qualitative visualization, and the online safety gate that determines whether a pivotal mask is faithful for another head is unvalidated. The headline accuracy claim is also not supported by the default-configuration results on Llama, where MInference outperforms SharePrefill. These gaps are load-bearing for the central claim that pattern sharing preserves dense accuracy better than estimation-based methods.

major comments (4)
  1. [Section 5.2 and Figure 2] The cross-input cluster-stability claim rests on a qualitative figure showing a handful of heads for two tasks, with no quantitative measure of cluster agreement across inputs. Since the offline clusters are computed from a single Retr.KV sample (Section 5.2) and Table 1 evaluates Retr.KV among the benchmark tasks, the reported accuracy on Retr.KV is partly in-sample. Please report a quantitative cluster-stability metric (e.g., adjusted Rand index between clusterings computed on different tasks or Jaccard overlap of head-group memberships) and, ideally, re-run the full evaluation using clusters derived from a held-out task.
  2. [Algorithm 3, lines 2-8; Algorithm 2] The online safety check compares only the last query block's block-averaged attention distribution of the current head against the pivotal head's stored representative, but the object being shared is a whole-sequence gamma-thresholded mask constructed from the pivotal head's full attention map. The paper provides no evidence that agreement on the last block implies agreement on the locations of the other high-attention blocks. Please report a diagnostic, such as the correlation between the last-row JS distance and the Jaccard overlap of the gamma-thresholded masks, or the attention mass actually preserved on the candidate head when sharing the pivotal mask. Without such a diagnostic, incorrect pattern sharing is not ruled out, and the modest accuracy gain of sharing over the vertical-slash fallback (Table 2: 39.05 vs. 38.70) could be erased by gate failures.
  3. [Table 1 and Abstract] The abstract's claim of 'delivering the best overall accuracy' is contradicted by the default Llama row, where MInference averages 39.14 and SharePrefill 39.05. The same row also lacks error bars or significance tests, so a 0.09-point gap is not interpretable. Please either rephrase the claim to 'comparable accuracy with better latency,' report variances or multiple runs, or promote the delta=1.01 variant to the main configuration while making its higher latency (20.02 s vs. 16.92 s in Table 2) explicit.
  4. [Section 6.2, Table 1 and Table 2] The sentence 'However, our method outperforms MInference in both accuracy and efficiency by sharing all similar attention heads, including highly sparse ones' is only true for the delta=1.01 variant (39.35 average, 20.02 s), not for the default configuration (39.05 average, 16.92 s). The text should clearly distinguish the default configuration from the delta=1.01 variant wherever this claim appears, since the two configurations have different accuracy and latency trade-offs.
minor comments (6)
  1. [Algorithm 3] Algorithm 3 uses the square root of the Jensen-Shannon divergence as the distance measure, but the text refers to it as 'JS distance' and applies thresholds τ=0.2 and δ=0.3 without specifying that the thresholds are on the square-rooted scale. Please state this explicitly.
  2. [Figure 2] Figure 2(b) lacks a color scale, making the claimed similarity values (e.g., 'a large number of similarity scores exceed 0.5') difficult to verify from the figure.
  3. [Figure 5] The annotations '1.32x' and '1.78x' in Figure 5 are not explained in the caption; please specify the reference method and the context length to which they correspond.
  4. [Algorithm 2] The normalization expression in Algorithm 2 is typeset ambiguously; it should be written as Σ_{i,j} ÕA[i,j] in the denominator, with the flattened attention map normalized accordingly.
  5. [Section 6.1] The paper should state whether the reported InfiniteBench numbers are single runs or averaged over multiple runs, since the benchmark tasks are known to be noisy and the reported differences between methods are small.
  6. [References] Several reference entries contain 'and 1 others' (e.g., Gao et al., Jiang et al., Team et al.); these should be expanded or abbreviated consistently with the journal's style.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the shared pivotal patterns are generated online from exact block-averaged attention of heavily computed heads, not fitted to benchmark answers or to the heads that reuse them.

full rationale

SharePrefill's derivation chain is self-contained in the circularity-relevant sense. The central claim is that sparse patterns can be computed exactly for a small set of pivotal heads and then shared with similar heads, preserving dense-attention accuracy. The pivotal pattern is constructed in Algorithm 2 from block-averaged QK values that are obtained by actually computing full attention for the pivotal head (Algorithm 4 assigns a dense all-ones mask before the full attention computation). The shared mask is therefore an exact, measured object for the pivotal head rather than a fitted estimate of the target output. The similarity gate in Algorithm 3 compares the last-row block-averaged attention of the candidate head with the pivotal head's stored representative; this is a heuristic that may fail on some inputs, but it is not circular because the method does not define accuracy in terms of that gate, and the gate is not derived from the benchmark scores. The offline clustering is trained on attention score maps from one Retr.KV sample, and hyperparameters tau, delta, and gamma are manually chosen; this raises generalization and sensitivity concerns, but it is not a case of fitting a parameter to the quantity being predicted, since the clusters store only layer/head indices and the actual sparse patterns are re-derived online from the current input. No load-bearing self-citation chain appears: the fallback vertical-slash search is attributed to external prior work (FlexPrefill/MInference), and the central observations about head similarity are supported by direct visualizations and Jaccard statistics rather than by invoking the authors' own prior results. The limitations section candidly states that the underlying explanation for cross-input similarity consistency remains unclear, which further confirms that the premise is empirical rather than definitional. Overall, any weaknesses lie in validation and robustness, not in circular reasoning.

Assumptions & free parameters 5 free parameters · 5 assumptions · 0 invented entities

The central claim rests on the empirical observation that attention-head similarity relationships are consistent across inputs; this is supported only by qualitative visualizations. The online safety check adds an unvalidated proxy assumption. Hyperparameters tau, delta, gamma, and the clustering distance threshold are chosen by hand without sensitivity analysis.

free parameters (5)
  • gamma (cumulative attention threshold) = 0.9
    Controls the minimum cumulative attention mass a selected block set must cover for pivotal and vertical-slash patterns. Copied from FlexPrefill default; no sensitivity study reported.
  • tau (similarity threshold) = 0.2
    JS-distance threshold for deciding whether to share a pivotal pattern. Chosen by hand; no sensitivity analysis is provided.
  • delta (sparsity threshold) = 0.3 (default); 1.01 variant reported
    JS-distance threshold classifying heads as highly sparse and excluding them from sharing. The reported delta=1.01 variant changes accuracy and latency materially, showing the choice matters.
  • cluster distance threshold (scipy fcluster) = 10
    Hierarchical clustering cutoff for grouping heads offline. Chosen without sensitivity analysis; clusters with fewer than 5 heads are discarded as noise.
  • autoencoder latent dimension = 64
    Compression dimension for attention score maps used in offline clustering. Architecture fixed without ablation.
assumptions (5)
  • domain assumption Attention maps are sparse enough that block-wise sparse masks preserve output fidelity.
    Standard assumption in the sparse-attention literature (MInference, FlexPrefill) adopted as the starting point in Section 1.
  • domain assumption Inter-head similarity and its input-consistency hold across models and tasks.
    Stated as an empirical finding in Section 4 but demonstrated only qualitatively; the method's offline clustering depends on it.
  • ad hoc to paper JS distance between block-averaged last-row attention is a reliable proxy for full-pattern similarity.
    Algorithm 3 uses this distance to allow or deny pattern sharing; no derivation or empirical validation is given.
  • domain assumption Highly sparse heads are well approximated by vertical-slash patterns.
    Borrowed from MInference (Jiang et al., 2024) and used in the exclusion strategy in Section 5.2.
  • standard math Standard math: softmax, Jensen-Shannon divergence, hierarchical clustering.
    Used throughout Algorithms 2-5 without proof.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Accelerating Prefilling for Long-Context LLMs via Sparse Pattern Sharing." pith.science (2026). https://pith.science/paper/OBZQPH44

@misc{pith2026250519578,
  author       = {Pith},
  title        = {Pith review of: Accelerating Prefilling for Long-Context LLMs via Sparse Pattern Sharing},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/OBZQPH44}},
  note         = {Machine review of arXiv:2505.19578}
}
read the original abstract

Sparse attention methods exploit the inherent sparsity in attention to speed up the prefilling phase of long-context inference, mitigating the quadratic complexity of full attention computation. While existing sparse attention methods rely on predefined patterns or inaccurate estimations to approximate attention behavior, they often fail to fully capture the true dynamics of attention, resulting in reduced efficiency and compromised accuracy. Instead, we propose a highly accurate sparse attention mechanism that shares similar yet precise attention patterns across heads, enabling a more realistic capture of the dynamic behavior of attention. Our approach is grounded in two key observations: (1) attention patterns demonstrate strong inter-head similarity, and (2) this similarity remains remarkably consistent across diverse inputs. By strategically sharing computed accurate patterns across attention heads, our method effectively captures actual patterns while requiring full attention computation for only a small subset of heads. Comprehensive evaluations demonstrate that our approach achieves superior or comparable speedup relative to state-of-the-art methods while delivering the best overall accuracy.

Figures

Figures reproduced from arXiv: 2505.19578 by the authors.

Figure 1
Figure 1. Comparison of our method with baselines across different models between latency (under 128K) and the average score on Infinitebench. Sparse attention offers a promising solution by computing only significant attention scores, lever￾aging inherent sparsity in attention mechanisms. Many works have discovered various patterns with distinct characteristics and exploited them to per￾form sparse attention computations, su… view at source ↗
Figure 2
Figure 2. Attention patterns of different heads and their [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗
Figure 3
Figure 3. Overview of proposed SharePrefill. Attention heads are clustered offline based on the similarity of their [PITH_FULL_IMAGE:figures/full_fig_p005_3.png] view at source ↗
Figures from the paper (2 more)
Figure 5
Figure 5. Figure 5: Latency comparison of different approaches [PITH_FULL_IMAGE:figures/full_fig_p007_5.png]
Figure 6
Figure 6. Figure 6: Distribution of three sparse attention head [PITH_FULL_IMAGE:figures/full_fig_p008_6.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

22 extracted references · 10 canonical work pages

  1. [1]

    online" 'onlinestring :=

    ENTRY address archivePrefix author booktitle chapter edition editor eid eprint eprinttype howpublished institution journal key month note number organization pages publisher school series title type volume year doi pubmed url lastchecked label extra.label sort.label short.list INTEGERS output.state before.all mid.sentence after.sentence after.block STRING...

  2. [2]

    write newline

    " write newline "" before.all 'output.state := FUNCTION n.dashify 't := "" t empty not t #1 #1 substring "-" = t #1 #2 substring "--" = not "--" * t #2 global.max substring 't := t #1 #1 substring "-" = "-" * t #2 global.max substring 't := while if t #1 #1 substring * t #2 global.max substring 't := if while FUNCTION word.in bbl.in capitalize " " * FUNCT...

  3. [3]

    Ramakrishna Bairi, Atharv Sonwane, Aditya Kanade, Arun Iyer, Suresh Parthasarathy, Sriram Rajamani, B Ashok, and Shashank Shet. 2024. Codeplan: Repository-level coding using llms and planning. Proceedings of the ACM on Software Engineering, 1(FSE):675--698

    work page 2024

  4. [4]

    Yukang Chen, Shengju Qian, Haotian Tang, Xin Lai, Zhijian Liu, Song Han, and Jiaya Jia. 2024. Longlora: Efficient fine-tuning of long-context large language models. In The Twelfth International Conference on Learning Representations, ICLR 2024, Vienna, Austria, May 7-11, 2024

    work page 2024

  5. [5]

    Tri Dao. 2024. Flashattention-2: Faster attention with better parallelism and work partitioning. In The Twelfth International Conference on Learning Representations, ICLR 2024, Vienna, Austria, May 7-11, 2024

    work page 2024

  6. [6]

    Yao Fu. 2024. https://arxiv.org/abs/2405.08944 Challenges in deploying long-context transformers: A theoretical peak performance analysis . Preprint, arXiv:2405.08944

    arXiv 2024

  7. [7]

    Yao Fu, Litu Ou, Mingyu Chen, Yuhao Wan, Hao Peng, and Tushar Khot. 2023. Chain-of-thought hub: A continuous effort to measure large language models' reasoning performance. arXiv preprint arXiv:2305.17306

    arXiv 2023

  8. [8]

    Yizhao Gao, Zhichen Zeng, Dayou Du, Shijie Cao, Peiyuan Zhou, Jiaxing Qi, Junjie Lai, Hayden Kwok-Hay So, Ting Cao, Fan Yang, and 1 others. 2024. Seerattention: Learning intrinsic sparse attention in your llms. arXiv preprint arXiv:2410.13276

    arXiv 2024

Show all 22 references
  1. [9]

    Huiqiang Jiang, Yucheng Li, Chengruidong Zhang, Qianhui Wu, Xufang Luo, Surin Ahn, Zhenhua Han, Amir Abdi, Dongsheng Li, Chin-Yew Lin, and 1 others. 2024. Minference 1.0: Accelerating pre-filling for long-context llms via dynamic sparse attention. Advances in Neural Informatio...

    2024

  2. [10]

    Xunhao Lai, Jianqiao Lu, Yao Luo, Yiyuan Ma, and Xun Zhou. 2025. Flexprefill: A context-aware sparse attention mechanism for efficient long-sequence inference. In The Thirteenth International Conference on Learning Representations, ICLR 2025, Singapore, April 24-28, 2025

    2025

  3. [11]

    Enzhe Lu, Zhejun Jiang, Jingyuan Liu, Yulun Du, Tao Jiang, Chao Hong, Shaowei Liu, Weiran He, Enming Yuan, Yuzhi Wang, and 1 others. 2025. Moba: Mixture of block attention for long-context llms. arXiv preprint arXiv:2502.13189

    2025 arXiv

  4. [12]

    Leonid Pekelis, Michael Feil, Forrest Moret, Mark Huang, and Tiffany Peng. 2024. https://gradient.ai/blog/scaling-rotational-embeddings-for-long-context-language-models Llama 3 gradient: A series of long context models

    2024

  5. [13]

    Rae, Anna Potapenko, Siddhant M

    Jack W. Rae, Anna Potapenko, Siddhant M. Jayakumar, Chloe Hillier, and Timothy P. Lillicrap. 2020. Compressive transformers for long-range sequence modelling. In 8th International Conference on Learning Representations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020

    2020

  6. [14]

    Gemini Team, Petko Georgiev, Ving Ian Lei, Ryan Burnell, Libin Bai, Anmol Gulati, Garrett Tanzer, Damien Vincent, Zhufeng Pan, Shibo Wang, and 1 others. 2024. Gemini 1.5: Unlocking multimodal understanding across millions of tokens of context. arXiv preprint arXiv:2403.05530

    2024 arXiv

  7. [15]

    Qwen Team. 2024. https://qwenlm.github.io/blog/qwen2.5/ Qwen2.5: A party of foundation models

    2024

  8. [16]

    Philippe Tillet, Hsiang-Tsung Kung, and David Cox. 2019. Triton: an intermediate language and compiler for tiled neural network computations. In Proceedings of the 3rd ACM SIGPLAN International Workshop on Machine Learning and Programming Languages, pages 10--19

    2019

  9. [17]

    Yu Wang, Nedim Lipka, Ryan A Rossi, Alexa Siu, Ruiyi Zhang, and Tyler Derr. 2024. Knowledge graph prompting for multi-document question answering. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 38, pages 19206--19214

    2024

  10. [18]

    Guangxuan Xiao, Yuandong Tian, Beidi Chen, Song Han, and Mike Lewis. 2024. Efficient streaming language models with attention sinks. In The Twelfth International Conference on Learning Representations, ICLR 2024, Vienna, Austria, May 7-11, 2024

    2024

  11. [19]

    Jingyang Yuan, Huazuo Gao, Damai Dai, Junyu Luo, Liang Zhao, Zhengyan Zhang, Zhenda Xie, YX Wei, Lean Wang, Zhiping Xiao, and 1 others. 2025. Native sparse attention: Hardware-aligned and natively trainable sparse attention. arXiv preprint arXiv:2502.11089

    2025 arXiv

  12. [20]

    Guibin Zhang, Luyang Niu, Junfeng Fang, Kun Wang, Lei Bai, and Xiang Wang. 2025. Multi-agent architecture search via agentic supernet. arXiv preprint arXiv:2502.04180

    2025 arXiv

  13. [21]

    Xinrong Zhang, Yingfa Chen, Shengding Hu, Zihang Xu, Junhao Chen, Moo Hao, Xu Han, Zhen Thai, Shuo Wang, Zhiyuan Liu, and 1 others. 2024. bench: Extending long context evaluation beyond 100k tokens. In Proceedings of the 62nd Annual Meeting of the Association for Computational...

    2024

  14. [22]

    Celal Ziftci, Stoyan Nikolov, Anna Sj \"o vall, Bo Kim, Daniele Codecasa, and Max Kim. 2025. Migrating code at scale with llms at google. arXiv preprint arXiv:2504.09691

    2025 arXiv

Pith tools

Reviewed August 7, 2026 · model on record in the stance chip above.