Pith. sign in

REVIEW 4 major objections 5 minor 56 references

CAKE: Compiler-Agent Co-Design for Frontier Kernel Evolution

T0 review · 4 major / 5 minor · reviewed 2026-08-16 · deepseek-v4-flash

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

Pith's one-line read The paper claims that a fixed coding agent, writing in a typed hardware-explicit schedule language and receiving localized compiler diagnostics, outperforms the same agent writing CUDA/PTX in matched implementation-hidden clean starts…

desk verdict The system is genuinely new, but the clean-start head-to-head is confounded by the harness's prior exposure to the benchmark family, so the paper's central evidence is weaker than it looks. read the letter →

arxiv 2608.12629 v1 pith:RIZKVIAR submitted 2026-08-12 cs.LG

Zihao Ye , Yingyi Huang , Hongyi Jin , Bohan Hou , Junru Shao , Zhongming Yu , Jinqi Chen , Meghan Cowan
show 6 more authors
Shiyi Cao Shanli Xing Hanfeng Chen Vinod Grover Tianqi Chen Luis Ceze
This is my paper · ORCID
classification cs.LG
keywords compiler-agentco-designGPUkerneloptimizationscheduleIRagentswarpspecializationFlash-KMeansBlackwellcompilerevolution
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

This paper argues that the bottleneck in GPU kernel agents is the programming environment, not the agent. CAKE co-designs a typed, hardware-explicit schedule representation called CAKE IR with a compiler harness that returns localized correctness and performance diagnostics instead of a pass/fail bit, and the harness evolves: recurring failures become new verifier rules, IR primitives, and cost-model calibrations. The central experimental claim is a matched three-run flash-k-means clean start on a B200 GPU: at an 80-million-token budget, the best CAKE IR candidate reaches 1.144 times the tuned FlashML baseline, while the best direct CUDA/PTX candidate reaches 0.928 times. If correct, this means the representation and feedback loop, not the model, determine how far agent-driven kernel evolution goes. The paper also reports broader transfer: agent-generated attention kernels with a 2.05x geometric-mean speedup over a black-box baseline, dispatcher-backed KNN and KMeans families with 1.42x–2.12x gains across more than 400 shapes, and four upstream kernel PRs.

What carries the argument

The load-bearing object is CAKE IR, a typed, hardware-explicit schedule representation for GPUs from Ampere through Blackwell. It makes four properties do the work: a fixed type-checked operation vocabulary; declared resources such as memory regions, synchronization state, and pipelines; named warp roles with visible cross-role handoffs; and auto-derived metadata, so the agent writes storage and access decisions directly instead of manipulating a layout algebra. Around this IR, the harness provides pre-compile verifier gates, a calibrated cost model, numerical validation, and localized diagnostics, and the compiler itself is updated when kernels expose capability gaps. The clean-start comparison isolates this machinery because the model, scaffold, task, oracle, and budget are held fixed across the CAKE IR and direct CUDA/PTX arms.

What would settle it

An independent replication of the matched Flash-KMeans clean start with third-party auditing of every file the agent can see, using the same model, scaffold, 80-million-token budget, and tuned baseline; if the best CAKE IR candidate does not exceed the best direct CUDA/PTX candidate under a verifiably sealed reference policy, the central claim fails. A cheaper check is to inspect the retained audit logs for the three CAKE IR runs and confirm that no low-level schedule source was accessible.

Watch

Extended reading notes

Core claim

Working from a corpus of production kernels, agents discovered a schedule vocabulary that records what should happen on the machine—warp roles, memory staging, barrier handoffs, pipeline stages, and target instruction forms—while lowering derives the mechanical consequences such as barrier addresses, phase bits, and warp identity. Because programs are typed and resource declarations are explicit, the compiler can check synchronization, memory safety, and hardware conformance before GPU time is spent, and it can localize a failure to the resource, role, or stage responsible. The same evidence loop that evolves kernels also evolves the compiler: failed candidates become verifier rules, missing patterns become new IR primitives, and systematic mispredictions become cost-model calibrations, each gated by corpus tests. The paper's claim is that this co-evolution lets a fixed agent model reach and exceed tuned baselines in implementation-hidden clean starts, and that the resulting schedules transfer to serving libraries through a separate dispatch stage.

Load-bearing premise

The clean-start comparison assumes the implementation-hidden policy was actually enforced in both arms; if any low-level schedule knowledge leaked into the CAKE IR arm, the 1.144x versus 0.928x gap would not measure what the paper claims, and with three runs per arm on a single workload such a leak would be hard to detect.

Editorial extensions

If this is right

  • A fixed coding agent can move from a high-level specification to a production-competitive kernel without ever inspecting a low-level target implementation.
  • Recurring failures during kernel search become verifier rules, IR primitives, and cost-model calibrations, so the harness improves as it is used.
  • One schedule language spans GPU generations from Ampere through Blackwell, with target-specific instruction admission and lowering rather than separate rewrites.
  • Single-shape tuning and library generalization are separate stages: dispatcher-backed portfolios can cover hundreds of shapes while guarding against evaluation leakage.
  • Generated kernels reach downstream libraries as standard kernel PRs, so users benefit without depending on the CAKE system itself.

Reading between the lines

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

  • Beyond the paper: if the clean-start advantage holds, compiler–agent co-design becomes an evaluation variable worth isolating in every kernel-agent benchmark, not just a system detail.
  • Beyond the paper: the human merge gates that currently approve harness changes could become the scaling limit; a testable extension is automating more of the compiler-evolution loop under corpus tests alone.
  • Beyond the paper: the decision to omit a layout algebra suggests that agent-facing languages should expose hardware contracts while deriving mechanical bookkeeping automatically, a principle that could transfer to other accelerator targets.
  • Beyond the paper: varying the agent model and workload family in the same matched clean-start protocol would show whether the CAKE IR advantage is uniform or concentrated in synchronization- and pipeline-heavy kernels.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

4 major / 5 minor

Summary. The paper presents CAKE, a compiler-agent co-design in which agents write kernels in CAKE IR, a typed, hardware-explicit schedule representation exposing warp roles, memory movement, synchronization, and pipelines, while the compiler harness (verifier, cost model, diagnostics) evolves as recurring failures become new rules, primitives, calibrations, and tactics. The main empirical evidence is presented in three parts: (i) a matched implementation-hidden Flash-KMeans clean-start comparison on B200 reporting that the best CAKE IR candidate at an 80-million-token budget reaches 1.144x the tuned FlashML baseline versus 0.928x for direct CUDA/PTX, with three runs per arm; (ii) frontier-kernel synthesis, most prominently agent-generated Kimi Delta Attention reaching a 2.05x geometric-mean speedup over official FlashKDA and passing end-to-end serving validation; and (iii) dispatcher-backed KNN and KMeans portfolios improving performance by 1.42x-2.12x across more than 400 shapes, plus a known-kernel reproduction table against TensorRT-LLM, CUTLASS, DeepGEMM, FlashAttention-4, and FlashInfer. The paper claims that co-designing the IR and compiler harness improves frontier kernel evolution, and it reports four kernel changes available as upstream PRs.

Significance. If the results hold, this is a significant systems contribution: it demonstrates that an evolving, structured harness around a low-level IR can produce competitive or superior kernels relative to unaided CUDA/PTX authoring, and the reported upstream PRs and end-to-end serving validation give the work real-world grounding. The paper is candid about limitations, including the incompleteness of static analyses and the fact that the timing model is calibrated only for B200 and H100 (Section 8, Appendix C). However, the central clean-start comparison is weakened by a corpus-overlap confound, missing audit artifacts, and the small number of runs, so the significance of the headline claim is conditional on addressing these issues. The paper does not contain formal derivations or machine-checked proofs; its value is empirical, and the evidence needs to be tightened accordingly.

major comments (4)
  1. [Section 5 (Protocol/Reference access), Table 2, with Sections 2.1, 5.3, and Appendix A] The head-to-head clean-start comparison is confounded by corpus-derived harness knowledge. Appendix A lists Flash-KMeans [11] among the production kernels used to derive CAKE IR, and Section 5.3 states that the validated corpus contains KMeans. The verifier rules, IR primitives, and cost-model calibrations in the CAKE arm can therefore encode KMeans-family schedule knowledge, while the direct CUDA/PTX control arm has no equivalent evolving harness. The implementation-hidden restriction limits only what the agent may inspect; it does not strip the harness of task-specific prior capabilities. Consequently, the 1.144x versus 0.928x difference does not isolate the IR representation: it measures the combination of representation, static verifier, cost-model guidance, and accumulated KMeans prior against unaided CUDA/PTX authoring. Please provide an ablation or audit showing which harness components were not derived from KMeans/Flash-KMeans, or re-run the comparison on a workload outside the evolution corpus.
  2. [Section 5 (Reference access)] The claim that the implementation-hidden condition "was enforced in isolated clean-start environments and audited afterward" is not supported by any artifact in the manuscript. No audit log, environment snapshot, or third-party verification is provided. Because the entire clean-start result depends on both arms receiving identical reference access, this missing evidence is load-bearing. Please include the audit artifact, or state explicitly that the restriction was not independently verified and explain what was checked.
  3. [Section 5, Table 2 and Figure 5] The headline comparison rests on three runs per arm on a single workload. The reported min-max intervals overlap (CAKE 1.041-1.205, CUDA 0.852-1.151), and no per-run traces or random seeds are reported. This is too little evidence to support the abstract's unqualified "matched implementation-hidden Flash-KMeans clean starts" phrasing. Either report more runs, provide the individual run data, or soften the claim to a pilot demonstration that motivates the co-design rather than establishing it.
  4. [Section 5.1 and Section 6] The KDA frontier-synthesis speedup (2.05x) and the KNN/KMeans portfolio aggregates (Gspan 1.418x, 2.116x, 1.803x) are reported as point estimates without confidence intervals or run-to-run variance, and the KDA arm has no matched control against an equivalent direct-CUDA effort. These are valuable end-to-end results, but they do not carry the same evidential weight as the clean-start comparison and should be described as single-session demonstrations rather than as controlled evidence for the representation advantage.
minor comments (5)
  1. [Throughout] The system name is used inconsistently as both "Cake" and "CAKE" (title and abstract use CAKE; body text mostly uses Cake). Please unify the capitalization.
  2. [Table 2] The table reports "Plateau by 80M" and "Best at 80M" but does not define the plateau criterion or state explicitly whether the interval brackets are medians of the three runs. Please add the definitions to the table caption.
  3. [Section 6, Figure 9] The text reports a KNN search Gspan of 2.116x across 198 shapes, but Figure 9 has panels only for KNN build and Flash-KMeans. Please include the KNN search route breakdown or note that it is omitted for space.
  4. [Appendix D.3, Figure 8] The caption says "shading is pre-checkpoint bring-up," but the term "checkpoint" is not defined. Please clarify what a checkpoint is and what the shaded region represents.
  5. [Section 5 (Protocol)] The text refers to "provider-token consumption" without defining whether this is input-only, output-only, or input plus output tokens. The later figure captions use "input + output, millions"; please make the units consistent.

Circularity Check

2 steps flagged · score 4.0 of 10

Flash-KMeans clean-start comparison is partially circular: the CAKE harness was evolved on the same KMeans family it is then credited with predicting.

  1. fitted input called prediction [Section 5 (Flash-KMeans clean-start protocol and Table 2), read against Section 2.1 and Section 5.3]
    "CakeIR was designed bottom-up through agent-driven abstraction discovery over a corpus of production kernels, guided by the requirement that it reproduce the physical schedules and performance of expert-written kernels. ... The validated corpus contains more than 400 static and compile cases and 399 GPU correctness cases across roughly 28 families, including attention, dense and sparse GEMM, MoE, quantization, normalization, state-space models, KNN, and KMeans."

    The clean-start head-to-head attributes the CAKE arm's 1.144x versus 0.928x gap to the typed IR representation. But the IR's vocabulary, verifier rules, and cost-model calibrations were formed bottom-up from production kernels, and the same Section 5.3 says KMeans is in the validated corpus. The 'implementation-hidden' restriction governs only which target code the agent may inspect; it does not remove the harness's corpus-derived KMeans schedule knowledge. The control arm writes CUDA/PTX with no equivalent prior. The Flash-KMeans result is therefore partly an evaluation of harness priors fitted on that kernel family, not a clean prediction of what a representation alone enables.

  2. self definitional [Section 5.1, frontier-kernel synthesis definition]
    "A kernel is frontier here in the operational sense that the agent must discover its physical schedule without inspecting a low-level target implementation."

    This definition makes 'frontier' depend only on what the agent may inspect, never on what the evolved harness already knows. Because Section 5.3 lists KMeans in the validated corpus, Flash-KMeans is labeled frontier even though its schedule patterns were part of the corpus that defined CAKE IR's abstractions. The operational definition thereby classifies the benchmark as novel even when the harness has already been fitted to that family.

full rationale

No equation-level circularity is present: there is no formal derivation chain, the speedup figures are on-device measurements against external baselines, and no uniqueness theorem or load-bearing self-citation is invoked. However, the strongest controlled comparison is not a clean test of the IR representation alone. Section 2.1 says CAKE IR was built bottom-up from production kernels, and Section 5.3 lists KMeans in the validated corpus, including in the clean-start workload. The implementation-hidden reference restriction hides target implementations from the agent but does not remove the harness's corpus-derived KMeans knowledge, while the CUDA/PTX control arm has no equivalent prior. The 1.144x versus 0.928x gap is therefore partly a fit on the evaluation family rather than a prediction. The broader claims retain independent content through external baselines (KDA, TinyGEMM, known-kernel reproduction, upstream PRs), so the circularity is partial rather than total. Score 4 reflects this partial contamination with no formal circularity and no load-bearing self-citation.

Assumptions & free parameters 1 free parameters · 6 assumptions · 1 invented entities

The central claim is an empirical systems claim, not a derivation, so the ledger is dominated by protocol and measurement assumptions rather than fitted constants. The only clearly fitted quantities are cost-model calibrations, which are used for candidate ranking and not for the final speedup numbers, so they are non-load-bearing.

free parameters (1)
  • B200/H100 cost-model calibration coefficients = not disclosed
    The cost model is used for ranking and filtering candidates during evolution. An inaccurate model could affect which candidates reach the GPU, but the final reported speedups are on-device measurements. This is a fitted quantity in the harness but is not load-bearing for the central claim.
assumptions (6)
  • domain assumption Matched clean-start protocol: the only difference between arms is authored representation (CAKE IR vs CUDA/PTX).
    Section 5 protocol. If task statement, scaffold, model, oracle, hardware, or auditing differ between arms, the comparison is invalid.
  • domain assumption Implementation-hidden isolation: agents did not see CUDA/PTX/SASS or equivalent reference implementations during clean-start and frontier synthesis.
    Section 5 'Reference access'. The paper states the restriction was audited afterward, but no audit artifact is included.
  • domain assumption Three runs per arm on a single workload are enough to detect the representation effect.
    Table 2 uses median[min,max] over 3 runs. No power analysis or effect-size justification is given.
  • domain assumption CUPTI GPU-span timing on B200 with L2 cache flush gives a stable and comparable performance signal.
    Section 5 protocol. All timing and speedup claims rely on this measurement assumption.
  • domain assumption Black-box baselines (FlashML, FlashKDA, FlashInfer) are correct and fairly measured.
    Section 5.1 and 5.2. Baselines are not independently reproduced in the paper.
  • domain assumption Closed model GPT-5.6-sol with fixed scaffold is a stable substrate for the comparison.
    Section 4. Holding the model fixed makes the comparison attributable to the environment, but the model is closed and results may not transfer to other agents.
invented entities (1)
  • CAKE IR (typed hardware-explicit schedule representation)
    purpose: Gives agents fine-grained control over warp roles, memory movement, synchronization, and pipelines without a layout algebra, and carries enough information for static analysis and cost modeling.
    The IR appears only as code examples and descriptions; no public compiler artifact is shipped, so a reader cannot exercise the IR outside the paper. Generated CUDA in PRs is evidence of outputs, not of the IR's usability.

how reviews work

0 comments
Cite this review

Pith. "Pith review of CAKE: Compiler-Agent Co-Design for Frontier Kernel Evolution." pith.science (2026). https://pith.science/paper/RIZKVIAR

@misc{pith2026260812629,
  author       = {Pith},
  title        = {Pith review of: CAKE: Compiler-Agent Co-Design for Frontier Kernel Evolution},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/RIZKVIAR}},
  note         = {Machine review of arXiv:2608.12629}
}
read the original abstract

GPU kernel agents and GPU programming languages have advanced separately, leaving expert kernels difficult to reproduce. Agents usually treat the compiler as a fixed black box and receive only errors, correctness outcomes, and timing, while existing DSLs either hide critical scheduling decisions or expose them through difficult layout abstractions. We present CAKE, a compiler-agent co-design in which agents author CAKE IR, a typed, hardware-explicit schedule representation. CAKE exposes warp roles, memory movement, synchronization, and pipelines while supporting verification, cost modeling, and localized diagnostics. The harness itself evolves: recurring failures become verifier rules, IR primitives, model calibrations, and reusable optimization tactics. In matched implementation-hidden Flash-KMeans clean starts on B200, the best CAKE IR candidate at an 80-million-token budget runs at 1.144x the tuned FlashML baseline, compared with 0.928x for direct CUDA/PTX. Beyond this benchmark, agent-generated Kimi Delta Attention achieves a 2.05x geometric-mean speedup over official FlashKDA and passes end-to-end serving validation. Dispatcher-backed KNN and KMeans improve performance by 1.42x to 2.12x across more than 400 shapes, and four kernel changes are available as upstream PRs. CAKE targets NVIDIA GPUs from Ampere through Blackwell and separates single-shape evolution from library generalization and dispatch.

Figures

Figures reproduced from arXiv: 2608.12629 by the authors.

Figure 1
Figure 1. Overview of [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. Cake IR evolves from kernels rather than a fixed language design. The initial corpus enters once; the three-step loop repeats for each new kernel family or capability gap. 2.2 Explicit machine schedules in Cake IR Cake IR records how the machine should be driven—which warps take which roles, which buffers are staged how deeply, which barrier gates which handoff, which instruction form consumes which operand. The cor… view at source ↗
Figure 3
Figure 3. A Cake IR schedule fragment. Resources and roles are declared; the producer–consumer handoff is an explicit barrier; addresses, phases, and warp identity are derived by lowering. the schedule. The compiler then checks that producer and consumer representations are compatible with the target hardware (Appendix B.4). 2.3 Architecture and lowering The same schedule language targets NVIDIA GPUs from Ampere through Black… view at source ↗
Figures from the paper (6 more)
Figure 4
Figure 4. Figure 4: Evidence-driven compiler evolution. Corpus and runtime evidence drive validated compiler [PITH_FULL_IMAGE:figures/full_fig_p006_4.png]
Figure 5
Figure 5. Figure 5: Flash-KMeans fixed-shape clean-start attainment on B200. At each 5-million-token budget [PITH_FULL_IMAGE:figures/full_fig_p008_5.png]
Figure 6
Figure 6. Figure 6: KDA prefill evolution on B200. Orange is fixed [PITH_FULL_IMAGE:figures/full_fig_p019_6.png]
Figure 7
Figure 7. Figure 7: TinyGEMM evolution on B200. Orange tracks [PITH_FULL_IMAGE:figures/full_fig_p020_7.png]
Figure 8
Figure 8. Figure 8: Alpha-MoE W8A8 Hopper-to-Blackwell rewrite on B200. Gray shows per-shape CUPTI [PITH_FULL_IMAGE:figures/full_fig_p020_8.png]
Figure 9
Figure 9. Figure 9: GPU-span speedup by dispatch family (KNN build) and final route (Flash-KMeans). Val [PITH_FULL_IMAGE:figures/full_fig_p021_9.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

56 extracted references · 29 canonical work pages

  1. [11]

    Flash-kmeans: Fast and memory- efficient exact k-means.arXiv preprint arXiv:2603.09229, 2026

    Shuo Yang, Haocheng Xi, Yilong Zhao, Muyang Li, Xiaoze Fan, Jintao Zhang, Han Cai, Yujun Lin, Xiuyu Li, Kurt Keutzer, Song Han, Chenfeng Xu, and Ion Stoica. Flash-kmeans: Fast and memory- efficient exact k-means.arXiv preprint arXiv:2603.09229, 2026. doi: 10.48550/arXiv.2603.09229. URL https://arxiv.org/abs/2603.09229

    arXiv doi:10.48550/arxiv.2603.09229 2026

  2. [1]

    Zhang, William Hu, Christopher Ré, and Azalia Mirhoseini

    Anne Ouyang, Simon Guo, Simran Arora, Alex L. Zhang, William Hu, Christopher Ré, and Azalia Mirhoseini. Kernelbench: Can llms write efficient gpu kernels?, 2025. URLhttps://arxiv.org/abs/ 2502.10517

    arXiv 2025

  3. [2]

    Kernelevolve: Scaling agentic kernel coding for heterogeneous ai accelerators at meta, 2026

    Gang Liao, Hongsen Qin, Ying Wang, Alicia Golden, Michael Kuchnik, Yavuz Yetim, Jia Jiunn Ang, Chunli Fu, Yihan He, Samuel Hsia, Zewei Jiang, Dianshi Li, Uladzimir Pashkevich, Varna Puvvada, Feng Shi, Matt Steiner, Ruichao Xiao, Nathan Yan, Xiayu Yu, Zhou Fang, Roman Levenstein, Kunming Ho, Haishan Zhu, Alec Hammond, Richard Li, Ajit Mathews, Kaustubh Gon...

    arXiv 2026

  4. [3]

    KernelBlaster: Continual cross-task CUDA optimization via memory- augmented in-context reinforcement learning.arXiv preprint arXiv:2602.14293, 2026

    Kris Shengjun Dong, Sahil Modi, Dima Nikiforov, Sana Damani, Edward Lin, Siva Kumar Sastry Hari, and Christos Kozyrakis. KernelBlaster: Continual cross-task CUDA optimization via memory- augmented in-context reinforcement learning.arXiv preprint arXiv:2602.14293, 2026. URLhttps: //arxiv.org/abs/2602.14293

    arXiv 2026

  5. [4]

    Accelopt: A self-improving llm agentic system for ai accelerator kernel optimization, 2026

    Genghan Zhang, Shaowei Zhu, Anjiang Wei, Zhenyu Song, Allen Nie, Zhen Jia, Nandita Vijaykumar, Yida Wang, and Kunle Olukotun. Accelopt: A self-improving llm agentic system for ai accelerator kernel optimization, 2026. URLhttps://arxiv.org/abs/2511.15915

    arXiv 2026

  6. [5]

    Autocomp: A powerful and portable code optimizer for tensor accelerators, 2025

    Charles Hong, Sahil Bhatia, Alvin Cheung, and Yakun Sophia Shao. Autocomp: A powerful and portable code optimizer for tensor accelerators, 2025. URLhttps://arxiv.org/abs/2505.18574

    arXiv 2025

  7. [6]

    KernelAgent: Hardware-guided GPU kernel optimization via multi-agent orchestration

    Kaiming Cheng, Laura Wang, Jack Khuu, Mark Saroufim, Wenyuan Chi, Jiannan Wang, and Joe Isaacson. KernelAgent: Hardware-guided GPU kernel optimization via multi-agent orchestration. PyTorch Blog, 2026. URLhttps://pytorch.org/blog/ kernelagent-hardware-guided-gpu-kernel-optimization-via-multi-agent-orchestration/

    work page 2026

  8. [7]

    Cuda agent: Large-scale agentic rl for high-performance cuda kernel generation, 2026

    Weinan Dai, Hanlin Wu, Qiying Yu, Huan ang Gao, Jiahao Li, Chengquan Jiang, Weiqiang Lou, Yufan Song, Hongli Yu, Jiaze Chen, Wei-Ying Ma, Ya-Qin Zhang, Jingjing Liu, Mingxuan Wang, Xin Liu, and Hao Zhou. Cuda agent: Large-scale agentic rl for high-performance cuda kernel generation, 2026. URL https://arxiv.org/abs/2602.24286

    arXiv 2026

Show all 56 references
  1. [8]

    Kimi linear: An expressive, efficient attention architecture, 2025

    Kimi Team. Kimi linear: An expressive, efficient attention architecture, 2025. URLhttps://arxiv. org/abs/2510.26692

    2025 arXiv

  2. [9]

    Gated delta networks: Improving mamba2 with delta rule

    Songlin Yang, Jan Kautz, and Ali Hatamizadeh. Gated delta networks: Improving mamba2 with delta rule. InThe Thirteenth International Conference on Learning Representations, 2025. URLhttps: //openreview.net/forum?id=r8H7xhYPwz

    2025

  3. [10]

    GPT-5.6 Sol Model

    OpenAI. GPT-5.6 Sol Model. OpenAI API Documentation, 2026. URLhttps://developers.openai. com/api/docs/models/gpt-5.6-sol. Accessed: 2026-08-09

    2026

  4. [12]

    Sparse videogen2: Accelerate video generation with sparse attention via semantic-aware permutation.arXiv preprint arXiv:2505.18875,

    Shuo Yang, Haocheng Xi, Yilong Zhao, Muyang Li, Jintao Zhang, Han Cai, Yujun Lin, Xiuyu Li, Chenfeng Xu, Jianfei Chen, Song Han, Kurt Keutzer, and Ion Stoica. Sparse videogen2: Accelerate video generation with sparse attention via semantic-aware permutation.arXiv preprint arXi...

    arXiv

  5. [13]

    Alpha-moe: A fused mixture of experts megakernel.https://github.com/Aleph-Alpha/ Alpha-MoE, 2025

    Aleph Alpha. Alpha-moe: A fused mixture of experts megakernel.https://github.com/Aleph-Alpha/ Alpha-MoE, 2025. Software for fused Mixture of Experts kernels compatible with vLLM and SGLang

    2025

  6. [14]

    TensorRT-LLM

    NVIDIA. TensorRT-LLM. GitHub, . URLhttps://github.com/NVIDIA/TensorRT-LLM

  7. [15]

    CUTLASS: CUDA templates for linear algebra subroutines

    NVIDIA. CUTLASS: CUDA templates for linear algebra subroutines. GitHub, . URLhttps://github. com/NVIDIA/cutlass

  8. [16]

    Deepgemm: clean and efficient blas kernel library on gpu.https://github

    Chenggang Zhao, Zhean Xu, Liang Zhao, Jiashi Li, Chenhao Xu, Anyi Xu, Shengyu Liu, Kexing Zhou, and Kuai Yu. Deepgemm: clean and efficient blas kernel library on gpu.https://github. com/deepseek-ai/DeepGEMM, 2025. 13

    2025

  9. [17]

    Flashattention- 4: Algorithm and kernel pipelining co-design for asymmetric hardware scaling, 2026

    Ted Zadouri, Markus Hoehnerbach, Jay Shah, Timmy Liu, Vijay Thakkar, and Tri Dao. Flashattention- 4: Algorithm and kernel pipelining co-design for asymmetric hardware scaling, 2026. URLhttps: //arxiv.org/abs/2603.05451

    2026

  10. [18]

    Flashinfer: Efficient and customizable attention engine for LLM inference serving

    Zihao Ye, Lequn Chen, Ruihang Lai, Wuwei Lin, Yineng Zhang, Stephanie Wang, Tianqi Chen, Baris Kasikci, Vinod Grover, Arvind Krishnamurthy, and Luis Ceze. Flashinfer: Efficient and customizable attention engine for LLM inference serving. InEighth Conference on Machine Learning...

  11. [19]

    Philippe Tillet, H. T. Kung, and David Cox. Triton: An intermediate language and compiler for tiled neural network computations. InWorkshop on Machine Learning and Programming Languages (MAPL),

  12. [20]

    URLhttps://openreview.net/forum?id=RXPofAsL8F

  13. [21]

    Tilelang: A composable tiled programming model for ai systems,

    Lei Wang, Yu Cheng, Yining Shi, Zhengju Tang, Zhiwen Mo, Wenhao Xie, Lingxiao Ma, Yuqing Xia, Jilong Xue, Fan Yang, and Zhi Yang. Tilelang: A composable tiled programming model for ai systems,

  14. [22]

    cuTile Python: A parallel programming model for NVIDIA GPUs

    NVIDIA. cuTile Python: A parallel programming model for NVIDIA GPUs. NVIDIA Documentation,

  15. [23]

    Helion: A high-level DSL for performant and portable ML kernels

    PyTorch Team. Helion: A high-level DSL for performant and portable ML kernels. PyTorch Blog, 2025. URLhttps://pytorch.org/blog/helion/

    2025

  16. [24]

    Gluon: A lower-level GPU programming language on the Triton compiler stack

    Triton Contributors. Gluon: A lower-level GPU programming language on the Triton compiler stack. Triton Documentation and Tutorials, 2026. URLhttps://github.com/triton-lang/triton/tree/ main/python/tutorials/gluon. Accessed: 2026-07-27

    2026

  17. [25]

    URLhttps://arxiv.org/abs/2504.17577

    arXiv

  18. [26]

    XLA: Optimizing compiler for machine learning

    XLA Team. XLA: Optimizing compiler for machine learning. Google, 2017. URLhttps://openxla. org/xla

    2017

  19. [27]

    MLIR: Scaling com- piler infrastructure for domain specific computation

    Chris Lattner, Mehdi Amini, Uday Bondhugula, Albert Cohen, et al. MLIR: Scaling com- piler infrastructure for domain specific computation. InIEEE/ACM International Symposium on Code Generation and Optimization (CGO), 2021. URLhttps://research.google/pubs/ mlir-scaling-compiler...

    2021

  20. [28]

    CuTe DSL: Python DSL for CUTLASS

    NVIDIA. CuTe DSL: Python DSL for CUTLASS. CUTLASS 4 Documentation, 2025. URLhttps: //docs.nvidia.com/cutlass/latest/media/docs/pythonDSL/cute_dsl.html

    2025

  21. [29]

    Gonzalez, and Ion Stoica

    Lianmin Zheng, Chengfan Jia, Minmin Sun, Zhao Wu, Cody Hao Yu, Ameer Haj-Ali, Yida Wang, Jun Yang, Danyang Zhuo, Koushik Sen, Joseph E. Gonzalez, and Ion Stoica. Ansor: Generat- ing high-performance tensor programs for deep learning. InUSENIX Symposium on Operating Sys- tems D...

    2020

  22. [30]

    Yan, Haichen Shen, Meghan Cowan, Leyuan Wang, Yuwei Hu, Luis Ceze, Carlos Guestrin, and Arvind Krishnamurthy

    Tianqi Chen, Thierry Moreau, Ziheng Jiang, Lianmin Zheng, Eddie Q. Yan, Haichen Shen, Meghan Cowan, Leyuan Wang, Yuwei Hu, Luis Ceze, Carlos Guestrin, and Arvind Krishnamurthy. TVM: an automated end-to-end optimizing compiler for deep learning. In Andrea C. Arpaci-Dusseau and ...

    2018

  23. [31]

    Graphene: An IR for optimized tensor computations on GPUs

    Bastian Hagedorn, Bin Fan, Hanfeng Chen, Cris Cecka, Michael Garland, and Vinod Grover. Graphene: An IR for optimized tensor computations on GPUs. InProceedings of the 28th ACM International Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS),

  24. [32]

    It’s about time: Temporal abstractions for asynchronous GPU tensor computations

    Bastian Hagedorn and Vinod Grover. It’s about time: Temporal abstractions for asynchronous GPU tensor computations. InProceedings of the 35th ACM SIGPLAN International Conference on Compiler Construction (CC), 2026. doi: 10.1145/3771775.3786277

    2026

  25. [33]

    TensorIR: An abstraction for automatic tensorized program optimization

    Siyuan Feng, Bohan Hou, Hongyi Jin, Wuwei Lin, Junru Shao, Ruihang Lai, Zihao Ye, Lianmin Zheng, Cody Hao Yu, Yong Yu, and Tianqi Chen. TensorIR: An abstraction for automatic tensorized program optimization. InInternational Conference on Architectural Support for Programming L...

    2023

  26. [34]

    Tawa: Automatic warp specialization for modern gpus with asynchronous references, 2025

    Hongzheng Chen, Bin Fan, Alexander Collins, Bastian Hagedorn, Evghenii Gaburov, Masahiro Masuda, Matthew Brookhart, Chris Sullivan, Jason Knight, Zhiru Zhang, and Vinod Grover. Tawa: Automatic warp specialization for modern gpus with asynchronous references, 2025. URLhttps://a...

    2025

  27. [35]

    Tensor program optimization with probabilistic programs

    Junru Shao, Xiyou Zhou, Siyuan Feng, Bohan Hou, Ruihang Lai, Hongyi Jin, Wuwei Lin, Masahiro Masber, Cody Hao Yu, and Tianqi Chen. Tensor program optimization with probabilistic programs. Advances in Neural Information Processing Systems (NeurIPS), 2022. URLhttps://dl.acm.org/...

    2022

  28. [36]

    AVO: Agentic variation operators for autonomous evolutionary search.arXiv preprint arXiv:2603.24517, 2026

    Terry Chen, Zhifan Ye, Bing Xu, Zihao Ye, Timmy Liu, Ali Hassani, Tianqi Chen, Andrew Kerr, Haicheng Wu, et al. AVO: Agentic variation operators for autonomous evolutionary search.arXiv preprint arXiv:2603.24517, 2026. URLhttps://arxiv.org/abs/2603.24517

    2026

  29. [37]

    Gonzalez, and Ion Stoica

    Shiyi Cao, Ziming Mao, Joseph E. Gonzalez, and Ion Stoica. K-Search: LLM kernel generation via co-evolving intrinsic world model.arXiv preprint arXiv:2602.19128, 2026. URLhttps://arxiv.org/ abd/2602.19128

    2026

  30. [38]

    Autotriton: Automatic triton programming with reinforcement learning in llms.arXiv preprint arXiv:2507.05687, 2025

    Shangzhan Li, Zefan Wang, Ye He, Yuxuan Li, Qi Shi, Jianling Li, Yonggang Hu, Wanxiang Che, Xu Han, Zhiyuan Liu, et al. Autotriton: Automatic triton programming with reinforcement learning in llms.arXiv preprint arXiv:2507.05687, 2025

    2025 arXiv

  31. [39]

    Optimal software pipelining and warp specialization for tensor core GPUs.arXiv preprint arXiv:2512.18134, 2024

    Rupanshu Soi, Rohan Yadav, Fredrik Kjolstad, Alex Aiken, Maryam Mehri Dehnavi, Michael Garland, and Michael Bauer. Optimal software pipelining and warp specialization for tensor core GPUs.arXiv preprint arXiv:2512.18134, 2024. URLhttps://arxiv.org/abs/2512.18134

    2024

  32. [40]

    AlphaEvolve: A coding agent for scientific and algorithmic discovery.arXiv preprint arXiv:2506.13131, 2025

    Alexander Novikov, Ngan Vu, Marvin Eisenberger, et al. AlphaEvolve: A coding agent for scientific and algorithmic discovery.arXiv preprint arXiv:2506.13131, 2025. URLhttps://arxiv.org/abs/2512. 23236

    2025 arXiv

  33. [41]

    Evoengineer: Mastering automated cuda kernel code evolution with large language models, 2025

    Ping Guo, Chenyu Zhu, Siyuan Chen, Fei Liu, Xi Lin, Zhichao Lu, and Qingfu Zhang. Evoengineer: Mastering automated cuda kernel code evolution with large language models, 2025. URLhttps:// arxiv.org/abs/2510.03760

    2025

  34. [42]

    Darwingodelmachine: Open-ended evolution of self-improving agents, 2026

    JennyZhang, ShengranHu, CongLu, RobertLange, andJeffClune. Darwingodelmachine: Open-ended evolution of self-improving agents, 2026. URLhttps://arxiv.org/abs/2505.22954

    2026 arXiv

  35. [43]

    Meta- harness: End-to-end optimization of model harnesses, 2026

    Yoonho Lee, Roshen Nair, Qizheng Zhang, Kangwook Lee, Omar Khattab, and Chelsea Finn. Meta- harness: End-to-end optimization of model harnesses, 2026. URLhttps://arxiv.org/abs/2603. 28052. 15

    2026

  36. [44]

    Self-defining systems

    Thomas Anderson, Ratul Mahajan, Simon Peter, and Luke Zettlemoyer. Self-defining systems. Technical report, Paul G. Allen School of Computer Science & Engineering, University of Washington, 2025. URL https://foci.uw.edu/papers/whitepaper2025-sds.pdf

    2025

  37. [45]

    Mathematical discoveries from pro- gram search with large language models.Nature, 625:468–475, 2023

    Bernardino Romera-Paredes, Mohammadamin Barekatain, et al. Mathematical discoveries from pro- gram search with large language models.Nature, 625:468–475, 2023. URLhttps://www.nature.com/ articles/s41586-023-06924-6

    2023

  38. [46]

    Sonicmoe: Accelerating moe with io and tile-aware optimizations, 2025

    Wentao Guo, Mayank Mishra, Xinle Cheng, Ion Stoica, and Tri Dao. Sonicmoe: Accelerating moe with io and tile-aware optimizations, 2025. URLhttps://arxiv.org/abs/2512.14080

    2025

  39. [47]

    Automated design of agentic systems

    Shengran Hu, Cong Lu, and Jeff Clune. Automated design of agentic systems. InInternational Confer- ence on Learning Representations, volume 2025, pages 21344–21377, 2025

    2025

  40. [48]

    CuTe layout representation and algebra.arXiv preprint arXiv:2603.02298, 2026

    Cris Cecka. CuTe layout representation and algebra.arXiv preprint arXiv:2603.02298, 2026. doi: 10.48550/arXiv.2603.02298. URLhttps://arxiv.org/abs/2603.02298

    2026 doi arXiv

  41. [49]

    Linear layouts: Robust code generation of efficient tensor computation usingF 2.arXiv preprint arXiv:2505.23819, 2025

    Keren Zhou, Mario Lezcano, Adam Goucher, Akhmed Rakhmati, Jeff Niu, Justin Lebar, Pawel Szczer- buk, Peter Bell, Phil Tillet, Thomas Raoux, and Zahi Moudallal. Linear layouts: Robust code generation of efficient tensor computation usingF 2.arXiv preprint arXiv:2505.23819, 2025...

    2025 doi

  42. [50]

    Axe: A simple unified layout abstraction for machine learning compilers

    Bohan Hou, Hongyi Jin, Guanjie Wang, Jinqi Chen, Yaxing Cai, Lijie Yang, Zihao Ye, Yaoyao Ding, Ruihang Lai, and Tianqi Chen. Axe: A simple unified layout abstraction for machine learning compilers. arXiv preprint arXiv:2601.19092, 2026. doi: 10.48550/arXiv.2601.19092. URLhttp...

    2026 doi

  43. [51]

    cutile: Simplify gpu programming with nvidia cuda tile in python

    Jonathan Bentz and Tony Scudiero. cutile: Simplify gpu programming with nvidia cuda tile in python. https://github.com/NVIDIA/cutile-python, 2025. NVIDIA Technical Blog and software repository

    2025

  44. [53]

    On the era of proof abundance: generation, verification, and digestion

    Terence Tao. On the era of proof abundance: generation, verification, and digestion. Mastodon thread, https://mathstodon.xyz/@tao/116477351524980995, 2026. Accessed 2026-04-30

    2026

  45. [2019]

    URLhttps://dl.acm.org/doi/10.1145/3315508.3329973

  46. [2023]

    doi: 10.1145/3582016.3582018

  47. [2025]

    URLhttps://arxiv.org/abs/2505.18875

    doi: 10.48550/arXiv.2505.18875. URLhttps://arxiv.org/abs/2505.18875

    doi arXiv

  48. [2026]

    URLhttps://docs.nvidia.com/cuda/cutile-python/

Pith tools

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