acceptodds
Under review as a conference paper at ICLR 2027

CUDAHercules: Benchmarking Hardware-Aware Expert-level CUDA Optimization for LLMs

Abstract

Large language models show promise for automated CUDA programming, however even the strongest coding models (e.g., Claude-Opus-4.6) may still fall short of expert-level, architecture-aware optimization. We introduce \benchmark, a benchmark that evaluates generated CUDA against end-to-end human-expert SOTA systems. It spans single kernels, module-level operators, full applications, and unsolved challenge tasks across Ampere, Hopper, and Blackwell GPUs, with end-to-end tasks gated by domain-specific semantic validators. Evaluating models such as Claude-Opus-4.6 and GPT-5.4 shows a large gap between runnable CUDA and expert CUDA engineering: models often compile and pass tests, but rarely recover the optimization strategies needed to match expert performance. Application semantics further reduce success: semantics-valid solutions are found for only three of ten end-to-end applications, at no more than expert speed, and iterative or tool-augmented feedback can improve correctness while drifting toward slow fallback implementations. These results show that automated CUDA programming remains far from fully solved and requires stronger hardware reasoning, better tool use, and training objectives that connect code understanding to hardware architecture-grounded intelligence.

Primary area:
datasets and benchmarks
Keywords:
LLM, GPU, Automated CUDA Programming, Benchmark

Reviews

Among:
Shape:
1234this paper, Top 15%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.00 over 4 reviews, above 85% of the others.
Reviewer_Nv4ZOpenReview ↗
Rating
4(+1)
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes CUDAHercules, a benchmark for evaluating LLMs on hardware-aware CUDA code generation and optimization.

Existing GPU code benchmarks like KernelBench, CUDABench, and ComputeEval mainly compare generated code against PyTorch baselines on isolated kernels, without testing architecture-specific features on newer GPUs or comparing against human-expert implementations and full applications.

To address this, the authors collect 195 tasks across four classes (63 single kernels, 119 module-level kernels, 10 full applications, and 3 open challenges), and evaluate 4 models (GPT-5.4, Claude-Opus-4.6, Qwen3.5-122B-A10B, and Kevin32B) on general, Hopper, and Blackwell GPUs under single-shot, self-refine, and tool-augmented settings.

Critical strengths
  • Comparing generated CUDA kernels directly against human-expert code (like CUTLASS, FlashAttention-3, and cuFFT) across different GPU generations is a practical and relevant problem.

  • The task coverage is broad, ranging from single kernels and fused modules to full applications in compression, scientific computing, SAT solving, and zero-knowledge proving.

Critical weaknesses

W1. Bugs in the evaluation scripts and task definitions in the anonymous repository invalidate the model evaluation.

Code bugs:

  1. Explicitly passing the "a"-suffixed architecture flags (sm_90a / sm_120a) when compiling the reference code, but omitting them when compiling model solutions (so PyTorch defaults to compiling with standard sm_90 / sm_120 without the "a" suffix): src/cuda_hercules/eval.py, tasks/class2/hopper/fa3_/def.py, tasks/class2/blackwell/sageattn3_fp4_/def.py
  2. Checking two internal temporary variables from the reference code (dsoftmax_sum and dq_accum) as required outputs in all 20 Hopper FlashAttention-3 backward tasks, even though the task prompt never asks the model to output them: src/cuda_hercules/eval.py, tasks/class2/hopper/fa3_bwd_*/def.py
  3. Setting the test input weight gamma to all 1s and bias beta to all 0s in all 16 LayerNorm tasks: tasks/class2/general/layernorm_*/def.py
  4. Telling the model in the Class 2 tool-augmented prompt that CUTLASS (#include <cutlass/...>) is allowed, and then blocking CUTLASS as cheating in the anti-cheat checker: scripts/eval_agent.py, src/cuda_hercules/static_checker.py

Consequences:

  1. In nvcc, Hopper wgmma and Blackwell FP4 instructions require the "a"-suffixed targets (sm_90a / sm_120a) and fail to compile under PyTorch's default auto-detected sm_90 / sm_120 flags (which is why the authors had to explicitly add sm_90a / sm_120a for the reference code).
  2. In the 20 fa3_bwd_* tasks (31% of Hopper Class 2), even if a model computes the exact gradients dQ, dK, and dV, it is marked wrong unless those two unmentioned temporary variables also match the reference code's internal values.
  3. Section 4.3 blames GPT-5.4's drop from 72% (1-sample) to 2% (Tool-augmented) on Class 2 on multi-round edits breaking working code. In reality, eval_agent.py keeps the best passing solution across all rounds (so later bad edits never overwrite an earlier passing result), and Figure 5(a) shows that accuracy is already ~2% at Round 0 before any tool is called (because the prompt tells the model to use CUTLASS and the checker immediately blocks it).

W2. Heavy task duplication in Class 2 by changing parameter constants. The paper claims 119 tasks in Class 2, but most of them in the repo are just copies of the same kernel with different dimension or dtype constants. For example, 60 of the 64 Hopper Class 2 tasks are the same 3 FlashAttention-3 templates copied 20 times across different head dimensions, precisions, and causal flags.

Questions for authors

Plz solve these bugs and I am happy to raise my scores.

  1. Why does eval.py omit the sm_90a / sm_120a flags when compiling model code?

  2. Why do the 20 fa3_bwd_* tasks check unmentioned internal temporary variables (dsoftmax_sum and dq_accum)?

  3. Why does eval_agent.py allow CUTLASS in the Class 2 prompt and then block it as cheating in static_checker.py, and why is GPT-5.4 Tool-augmented in Figure 5(a) already at ~2% at Round 0 before any tool is called?

2 comments

Thank you for the very careful review and for inspecting our code in such detail. We apologize that the anonymous repository had not been synchronized with our latest code. We have since audited all evaluation scripts and task definitions, and every bug you identified has been fixed. The anonymous repository is now fully synchronized with our latest code. We treat maintaining this benchmark as a long-term effort and have kept improving and updating it until very recently, including adding new tasks. Throughout the review period, we will keep the anonymous repository synchronized with our latest code. The current behavior is as follows.

1. Architecture flags for model solutions (eval.py, fa3_*, sageattn3_fp4_*). Model solutions are now compiled for exactly the same target as the reference. For Hopper and Blackwell tasks, the solution reuses the reference's -gencode pairs (compute_90a/sm_90a, compute_120a/sm_120a, sm_100a), so wgmma, setmaxnreg and block-scaled FP4 MMA instructions are available to models exactly as they are to the reference. For general tasks, both the reference and the solution are compiled for the architecture of the GPU in use, and flags that affect code generation (e.g., -DNDEBUG) are shared by both sides.

2. Outputs checked in the FA3 backward tasks (fa3_bwd_*). All 20 tasks now check only the gradients dQ, dK and dV, which is exactly what the prompt asks for. The reference's internal buffers (dsoftmax_sum, dq_accum) are treated as scratch space and are never compared.

3. LayerNorm inputs (layernorm_*). In all 16 tasks, gamma and beta are now drawn at random instead of being all ones and zeros, so a solution that ignores the affine parameters fails.

4. CUTLASS policy (eval_agent.py, static_checker.py). The library rules are now defined once in the static checker, and the same text is inserted into every prompt, including the tool-augmented prompts, so the prompt and the checker can no longer disagree. Prebuilt CUTLASS device-, kernel-, collective- and threadblock-level templates are disallowed in both. CuTe and CUTLASS's low-level building blocks (numeric types, cutlass::arch, layouts, warp-level MMA) are allowed in both and are not blocked.

5. Round 0 in Figure 5(a). The tool-augmented setting has 10 rounds, which we numbered 0–9 in the figure rather than 1–10. Round 0 is therefore the first round of the tool-augmented loop, not a state before the loop starts. We will relabel the axis 1–10 in the revision.

I am glad to see that all the bugs are fixed and the author's promise to make a long-term effort for maintaining and improving this benchmark. Therefore, I have raised my score to 4.

Reviewer_naTQOpenReview ↗
Rating
2
Confidence
4
Informativeness
1
Presentation
3
Soundness
1
Read review
Paper summary

This paper introduces CUDAHercules, a benchmark that evaluates generated CUDA against end-to-end human-expert SOTA systems.

Critical strengths
  • Good problem domain.
Critical weaknesses
  • I don't understand the x and y axis of figure 4. These are qualitative, not quantitative axes. Why is there a line-fit over them?
  • It is well known that Nvidia hardware changes across generations renders prior optimizations less useful (e.g., FlashAttention), because the optimizations have been made in a co-design fashion to take advantage of the hardware (in this case, operator fusion). This paper at a high level is very agent heavy, in that I did not extract an actual "hardware centric config file" of sorts that provide hints to agents. The takeaways are all honest and pure intended, but are not actually positive or solve any thing (see all the headers in Section 4). Overall, I think the idea of a benchmark suite of experts is nice, but I did not gather how this benchmark itself is "agent proof", in that agents might quickly find this benchmark and mimic it quickly. More benefitial in my opinion would be a way to guide/instruct agents to leverage the hardware semantics, just as an expert would, and then fall back on traditional optimizations like tiling or fusion (just as an expert would). The intent is well received, but to this reviewer, the paper falls short in actually addressing the problem.
Questions for authors

The paper seems more of an analysis paper than providing a solution to inter-generation nvidia kernel programming. While experts are nice, it seems that CUDA Hercules is a collection of existing "expert" implemntations, not a pure, new expert library of kernels. If the authors can provide the latter (and verify that the new benchmark includes true, novel, beneficial expert-level optimizations) that would encourage me to increase my score.

1 comment
  1. Following your suggestion, we have added new tasks whose reference implementations are our own, previously unreleased kernels and applications, not existing open-source code, and each of them outperforms the state-of-the-art implementation in its domain (all measured on an RTX PRO 6000 Blackwell, SM120):
New task(s)Our reference implementationSpeedup over the state of the art
Class 1: SpMV, SpMM, SpGEMM on large public sparse matrices from SuiteSparseSparse kernels specialized to each matrix's structure (storage format, load balancing, tensor-core blocks)vs cuSPARSE, geomean: SpMV 1.18×, SpMM 2.24× (up to 12.3×), SpGEMM 2.78× (up to 6.45×)
Class 2: sparse direct solver for complex-symmetric 3D electromagnetic FEM systems with 7.0M and 18.7M unknowns (relative residual ≤ 1e-8)GPU solver: GPU nested-dissection ordering, GPU symbolic analysis, supernodal multifrontal FP32 LDLᵀ, FP64 FGMRES refinementvs cuDSS: 3–4× (7.0M) and 5–7× (18.7M) per solve against its default pipeline
Class 3: long-context serving of Qwen3.8-27B on vLLM, time to first token (TTFT) at 64K / 128K / 256K tokensFP8 block-sparse prefill attention kernels customized for SM120 (TMA pipelines, FP8 KV cache read in place), integrated into vLLMvs vLLM: 1.84× / 2.06× / 2.37× TTFT; 1.28× / 1.53× / 1.93× with vLLM's FP8 GEMM enabled on both sides, at unchanged output quality (needle retrieval correct, ΔNLL −0.001)

These implementations contain genuinely new, hardware-aware optimizations that do not exist in any library or public repository, so no model could have seen them during training. In these tasks the agent must reach the same performance in CUDA C++, which directly tests whether agents can discover novel, expert-level optimizations rather than reproduce known ones. The evaluation results of StitchCUDA (with GPT-5.4 as backbone LLM) on these new tasks are shown as follows.

TaskPassSpeedup over reference
Class 1: SpMV, SpMM, SpGEMMyes0.563x
Class 2: GPU-solverfail-
Class 3: Qwen3.8 TTFTfail-
  1. We must respectfully challenge several criticisms that appear to mischaracterize the fundamental research contribution of CUDAHercules. You repeatedly ask CUDAHercules to propose new libraries/kernels, whereas this is a benchmark paper. These are fundamentally different scientific questions. A benchmark's contribution should be assessed by the rigor, coverage, and discriminative power of its evaluation, not by demanding a new optimization.

You argue that CUDA optimizations become obsolete across GPU generations. This is exactly the motivation of our work, not a criticism of it. CUDAHercules explicitly evaluates architecture-specific optimization against expert implementations on Ampere, Hopper, and Blackwell. Moreover, the suggestion to guide agents using hardware semantics is already partially investigated in Section 4.2, where we provide expert optimization strategies to models. The results demonstrate that knowing what optimization to perform and successfully implementing it are fundamentally different capabilities. Simply providing hardware hints does not eliminate this gap.

  1. We respectfully disagree with your interpretation of Figure 4. The figure is deliberately designed as a qualitative taxonomy rather than a quantitative scatter plot. Its two axes represent distinct dimensions of CUDA programming challenges—optimization depth and evaluation strictness—each systematically divided into meaningful categories. The diagonal line is not a statistical regression or fitted trend, but a conceptual indicator of increasing reasoning difficulty as tasks progress toward more sophisticated hardware-specific optimizations and stricter semantic requirements. The purpose is to illustrate how CUDAHercules extends evaluation coverage into regions largely overlooked by existing benchmarks. Therefore, the qualitative nature of the axes is an intentional design choice, not a methodological flaw. We will clarify this distinction in the caption to avoid further misunderstanding.
Reviewer_XyV5OpenReview ↗
Rating
3
Confidence
3
Informativeness
3
Presentation
3
Soundness
2
Read review
Paper summary

CUDAHercules evaluates CUDA generation against expert implementations using 195 tasks spanning single kernels, modules, full applications, and challenge problems. Tasks specify hardware requirements and use task-specific correctness or application-level validity checks before assigning performance credit. Experiments cover four models and several generation/refinement settings on Ampere, Hopper, and Blackwell hardware. The results expose a substantial gap between passing task checks and matching expert performance, especially on architecture-specific and application-level tasks.

Critical strengths
  1. The benchmark addresses a consequential evaluation gap: expert references, explicit hardware targets, and task-specific application-level checks make success more representative of practical CUDA engineering than speedup over a functional baseline alone. The 195-task collection covers several optimization scopes and domains, and the task metadata and backend descriptions provide a useful foundation for further evaluation (Sections 3 and Appendix A).

  2. The results separate compilation, task-specific validity, and expert-relative performance across hardware targets and optimization scopes. In particular, the application results show how apparently successful generation can still fall short of practical CUDA engineering (Tables 3 and 6). This distinction makes the findings more useful than an aggregate success rate alone.

Critical weaknesses

The claimed understanding-to-implementation gap is not sufficiently substantiated. Section 4.2 reports that models can describe expert optimization strategies but fail to implement them. However, the strategy-enriched prompting experiment is described only qualitatively. The paper does not present corresponding results or examples linking strategy descriptions to generated code. The evidence therefore leaves unclear whether the failures reflect incomplete understanding of the required optimization or difficulty implementing a sound optimization plan.

Questions for authors

What evidence from the reported strategy-enriched prompting experiment supports the understanding-to-implementation gap? Please present the existing results and representative comparisons between strategy descriptions and generated code. How do these examples distinguish incomplete understanding from failure to implement a sound optimization plan?

2 comments

Our evidence comes from two complementary observations: inconsistencies between models' own code comments and implementations, and failures to realize optimization strategies explicitly provided in task descriptions.

First, models frequently describe their intended computation in code comments, giving us an opportunity to compare their expressed intent with the actual implementation. For example, in Hopper MHA, Qwen3.5-122B-A10B correctly states the online-softmax recurrence in its comments: both the rescaled previous output and the new weighted-value contribution must be divided by the updated normalization factor, l_new. However, the code normalizes only the previous accumulator:

O_acc[d] *= (l_old / l_new) * exp_scale;
O_acc[d] += w * __bfloat162float(v_tile_row[d]);

The second line omits division by l_new, and no subsequent normalization compensates for it. This is a specific, inspectable mismatch between a correctly stated mathematical relationship and its implementation, rather than merely an incorrect answer or a repetition of optimization terminology.

Second, many task descriptions already specify the intended optimization strategy, yet even Claude Opus 4.6 and GPT-5.4 fail to realize it. This is particularly evident in architecture-aware optimization:

Task / modelStrategy supplied in the task descriptionGenerated codeRecorded result
B200 (SM100a): BF16x9 GEMM / Claude Opus 4.6BF16x9 emulation using tensor coresSplits inputs into high/low BF16 components, but evaluates their products with scalar FP32 arithmetic instead of tensor-core MMACorrectness: Pass; 0.0278× expert speed
INT8/FP16 SageAttention, head dimension 128 / GPT-5.4INT8 tensor-core MMA for QK, followed by dequantization, softmax, and FP16 tensor-core MMA for PVUses __dp4a with warp reductions for QK and scalar FP32 accumulation for PV; neither stage implements the specified tensor-core MMACorrectness: Pass; 0.0176× expert speed

Together, these observations distinguish a failure to identify a sound strategy from a failure to implement a correctly expressed or explicitly supplied strategy, supporting the understanding-to-implementation gap. They are representative of patterns we repeatedly observe across tasks and models during evaluation. We can provide many additional comparisons upon request and will include more examples in the appendix of the camera-ready version.

Thank you for providing the concrete examples. Both the comment-to-code normalization mismatch in Hopper MHA and the tensor-core fallback cases (BF16x9 GEMM and SageAttention, where models pass correctness with scalar or dp4a code despite explicit tensor-core MMA instructions) offer clear qualitative illustrations of the gap between stated or supplied strategies and generated code. However, quantitative statistics on how frequently these failures occur across tasks—and aggregate results from the strategy-enriched prompting experiment—remain unclear. I therefore maintain my rating of 3 (Weak acceptance).

Reviewer_vyg9OpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper introduces CUDAHercules, a benchmark for evaluating LLM-based CUDA programming against human-expert implementations on Ampere, Hopper, and Blackwell GPU architectures. It comprises 195 tasks spanning single kernels, module-level operators, full applications, and unsolved challenges across diverse domains, including scientific computing, graph analytics, and cryptography. Beyond functional correctness, the benchmark evaluates architecture-aware optimization and requires application-level semantic validation before performance credit is awarded. Experiments with frontier models and agentic systems reveal a substantial gap between generating runnable CUDA code and achieving expert-level performance. Iterative refinement, tool use, and expert-guided prompting do not consistently close this gap, highlighting the need for stronger hardware reasoning and optimization capabilities, as well as better preservation of application semantics.

Critical strengths
  1. Broader task and hardware coverage. This work expands the scope of benchmarks for LLM-based CUDA programming to cover diverse domains, including scientific computing, cryptography, and graph analytics, as well as tasks targeting different GPU architectures. This enables a more comprehensive evaluation of models’ CUDA programming and optimization capabilities across workloads and hardware platforms.

  2. More practically relevant performance references. Compared with existing benchmarks that primarily rely on basic functional implementations as performance baselines, this work evaluates generated code against human-expert-optimized implementations. This provides a more direct measure of the gap between model-generated code and high-performance CUDA implementations, making the evaluation more discriminative and more informative regarding the practical performance value of the generated code.

Critical weaknesses
  1. Limited coverage of agentic baselines. For Classes 1 and 2, the evaluation primarily considers direct generation, CUDAForge-based refinement, and LangChain-based tool augmentation. This limited diversity of agentic systems makes it difficult to determine whether the observed degradation reflects a general limitation of agentic CUDA optimization or is specific to the frameworks and configurations evaluated.
  2. Insufficient justification for framework selection across task classes. Class 3 is evaluated exclusively using StitchCUDA, whereas StitchCUDA is not evaluated on Classes 1 and 2. Without further justification or cross-framework comparisons, the respective effects of task complexity and framework choice are difficult to disentangle.
  3. Limited analysis of the refinement budget. Both self-refinement and tool augmentation use a fixed budget of 10 rounds, without clear justification or sensitivity analysis. Although Figure 5 presents per-round trajectories for selected settings, it remains unclear whether performance has saturated within this budget or whether longer searches would alter the conclusions. Reporting both final-round and best-so-far performance would also help distinguish transient degradation from a failure to discover better solutions.
Questions for authors
  1. Have the authors considered including additional CUDA programming agents with different search strategies or tool-use mechanisms for Classes 1 and 2? Such comparisons would help clarify how broadly the observed degradation patterns apply.
  2. Could the authors elaborate on the rationale for using StitchCUDA exclusively for Class 3? It would be helpful to understand whether its omission from Classes 1 and 2 reflects compatibility constraints or other experimental considerations.
  3. Could the authors explain how the 10-round refinement budget was chosen? It would be helpful to understand whether allowing more rounds leads to further improvements or whether performance generally plateaus within 10 rounds.
1 comment
AuthorsOpenReview ↗

More evaluations according to reviewer's questions.

Thank you for the review. To address your concerns, we ran several new experiments.

  1. We evaluated KDA (Kernel Design Agents, NVlabs), a more recent agent framework, on all Class 1 and Class 2 tasks of all three architectures, using Claude Opus 5 as its backbone, a newer and stronger model than the ones evaluated in the paper. Unlike the agents in the paper, KDA is not a fixed workflow but a flexible agent with richer strategies: it decides when to plan, implement, compile, test, micro-benchmark or profile kernels in its sandbox, revises its plan from the evidence, and submits only selected candidates for evaluation. Accordingly, it has no fixed number of rounds but a per-task time limit (60 minutes here). As shown below, KDA also generally does not surpass the expert references.
Tasks (hardware)#TasksPass rateMean speedup (fail = 0)≥ 1.0× speedup
General, overall (RTX PRO 6000)6379% (50/63)0.82×23 (37%)
  Class 12095% (19/20)0.95×6 (30%)
  Class 24372% (31/43)0.76×17 (40%)
Hopper, overall (H200)8595% (81/85)0.75×25 (29%)
  Class 12195% (20/21)0.80×9 (43%)
  Class 26495% (61/64)0.73×16 (25%)
Blackwell, overall (B200)1989% (17/19)0.47×3 (16%)
  Class 11587% (13/15)0.28×0 (0%)
  Class 24100% (4/4)1.17×3 (75%)

The degradation pattern reported in the paper also holds for this stronger agent. KDA's mean speedup falls from 0.82× on general tasks to 0.75× on Hopper and 0.47× on Blackwell, and the share of tasks that match or beat the expert implementation falls from 37% to 29% to 16%. The drop is sharpest on single-kernel Class 1 tasks (0.95× → 0.80× → 0.28×), where expert references exploit architecture-specific features such as TMA, WGMMA/tcgen05 and narrow-precision tensor cores; no Blackwell Class 1 task reaches the expert speed. Correctness remains high throughout, so the gap lies in realizing hardware-specific optimizations rather than in producing correct code.

  1. For each task type we aimed to use the strongest open-source agentic framework designed for it. Class 3 tasks are end-to-end applications in which an agent must modify many kernel files within one project while keeping the whole application correct. To our knowledge, StitchCUDA is the open-source agentic CUDA programming framework that natively supports this multi-file, end-to-end setting, which is why we chose it for Class 3.

To address the question directly, we have now also evaluated StitchCUDA on the general Class 1 tasks. The backbone model was GPT-5.4, with 15 rounds per task.

Agent (backbone) on general Class 1Pass rateMean speedup (fail = 0)
StitchCUDA (GPT-5.4)90% (18/20)0.35×
KDA (Claude Opus 5)95% (19/20)0.95×

StitchCUDA produces correct kernels for almost all tasks, but its kernels rarely use the advanced memory-hierarchy techniques found in the expert references (e.g., asynchronous multi-stage pipelines and ldmatrix), and its speedups remain well below the expert baselines. This is consistent with the gap between correctness and expert-level performance reported in the paper. Because of the limited rebuttal period, we could not complete StitchCUDA runs on the remaining Class 1 and Class 2 tasks during rebuttal, but these results do not change our conclusions.

  1. In the paper, we fixed the refinement budget at 10 rounds because this is the setting adopted by many related works on LLM-based CUDA kernel generation, which keeps our results directly comparable with theirs[1,2].

To test whether a larger budget helps, we reran KDA, which is time-bounded, on the same 20 general Class 1 tasks with 50% more time per task:

Budget (KDA, Claude Opus 5, 20 general Class 1 tasks)Pass rateMean speedup
60 minutes95% (19/20)0.95×
90 minutes80% (16/20)0.73×

A larger budget did not improve KDA's overall performance on these tasks, so the default budget does not limit our conclusions. In fact, after the budget was increased to 90 minutes, the overall performance even decreased, from a mean speedup of 0.95× to 0.73× and from 19 to 16 passing tasks. Figure 5 of the paper also already reports how the self-refine and tool-augmented methods perform at each round, and it shows that adding more rounds does not lead to better results:

[1] Ouyang, Anne, et al. "Kernelbench: Can llms write efficient gpu kernels?." ICML 2025.

[2] Li, Shiyang, et al. "Stitchcuda: An automated multi-agents end-to-end gpu programing framework with rubric-based agentic reinforcement learning." ICML 2026.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.