acceptodds
Under review as a conference paper at ICLR 2027

ForgeKernel: Self-Evolving Kernels Catching And Surpassing Experts And Agents

Abstract

Frontier coding agents now write GPU kernels that rival expert ones: left to run, even a generic agentic loop beats hand-tuned references on many operators. Yet every such loop stops at a ceiling of its own making. It settles a kernel’s architecture in its first few attempts and spends the rest of the run tuning beneath it, and each run starts from the same knowledge as the last and discards what it measured. We present ForgeKernel, a self-evolving kernel agent built to break that ceiling. It reads a reference kernel’s architecture from hardware behavior alone — running, timing and profiling a sealed binary, never its source — and turns it into an architecture-first curriculum that a coding agent implements and that is reopened whenever measurement shows the architecture, not the tuning, is the bottleneck. Every accepted kernel is sealed and promoted to the next campaign’s reference, so optimization continues past the best known implementation, and every finding certified by a hardware probe enters a knowledge base shared across operators. Across 27 operators on Hopper and Blackwell, ForgeKernel matches or beats 18 of 22 expert-library kernels, including FlashAttention-4, cuDNN and DeepGEMM, and all 7 published kernels of three kernel-generation systems, the latter by up to +170.6% (+39.4% in geometric mean). On DeepSeek-V4.1’s sparse-MLA prefill and fused attention kernels, released 15 days before this submission with no paper or second implementation, it comes within 1.3% and 3.7%. With only its profiler swapped, it leads the best public submission on all 8 level-4 CANN-Bench operators on Ascend, by +33.1% in geometric mean. Promoting the best known kernel to the reference, a generic loop’s included, gains up to a further +9.9%.

Primary area:
infrastructure, software libraries, hardware, systems, etc.
Keywords:
GPU kernel optimization, long-horizon autonomous agents, agent harness evaluation, domain-specific orchestration

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 4 reviews, above 27% of the others.
Reviewer_rLtsOpenReview ↗
Rating
1
Confidence
4
Informativeness
1
Presentation
2
Soundness
2
Read review
Paper summary

This paper introduces ForgeKernel, a self-evolving GPU kernel optimization agent designed to overcome the architectural and knowledge-retention limits of single-run coding agents. ForgeKernel profiles sealed reference kernels to infer architectural decisions, guides a coding agent through measurement-driven optimization milestones, accumulates verified hardware knowledge across campaigns, and promotes its own best kernels as references for subsequent generations. Across Hopper and Blackwell, the system matches or surpasses most expert-library kernels and all evaluated kernels from prior generation systems, while self-evolution further improves already optimized kernels.

Critical strengths
  • The paper explores a timely and ambitious direction for autonomous research systems: rather than treating kernel generation as a one-shot optimization problem, it explicitly targets long-horizon self-improvement through reference promotion, architectural re-planning, and persistent knowledge accumulation.
  • The empirical results are strong and broad for this setting. ForgeKernel is evaluated across multiple operator families and GPU architectures, including Hopper, Blackwell, and Ascend, and is compared against both expert libraries and prior kernel-generation systems, with several cases reaching or surpassing highly optimized references.
Critical weaknesses

This paper presents very strong empirical results and an ambitious vision for autonomous kernel optimization. However, I believe the paper still requires substantial writing and methodological clarification before acceptance, as several important parts of the system and evaluation are difficult to follow.

(1) The manuscript appears insufficiently polished and is difficult to follow in several places. For example, the main text points readers to Appendix H for the cost of each campaign, but the corresponding cost table appears before the Appendix H heading, while the Appendix H section itself is effectively empty before Appendix I begins.

(2) The concrete organization of the hardware knowledge base is underspecified. The paper gives a high-level description of each recipe as containing a mechanism, trigger symptom, runnable example, and known gotchas, but it does not clearly describe the category taxonomy, the concrete representation of an entry, or provide a complete end-to-end example of how a piece of knowledge is stored and maintained.

(3) The comparison with prior kernel-generation systems such as KDA and CAKE is not controlled for optimization cost. ForgeKernel is evaluated against the final published kernels produced by these systems, but it is unclear whether those kernels were obtained under comparable model, token, GPU-time, or wall-clock budgets. Therefore, the results demonstrate stronger final kernel performance, but do not establish that ForgeKernel is a more effective or efficient optimization system under comparable resources.

(4) The mechanism and contribution of cross-operator knowledge reuse are not sufficiently characterized. The paper reports that recipes learned from earlier campaigns are prescribed to later ones, but it is unclear how relevant entries are selected, what subset of the knowledge base is exposed to the Arch Agent, and how applicability across operators is determined. Moreover, the paper reports extensive reuse statistics but does not provide a controlled with-KB vs. without-KB ablation, making it difficult to quantify the causal contribution of knowledge reuse to the final performance gains.

Questions for authors

(1) Could the authors provide a more concrete description of the hardware knowledge base? In particular, what are the nine knowledge categories, what does a complete entry look like in practice, and how are entries represented and maintained as the knowledge base grows?

(2) For the comparisons against KDA and CAKE, were the systems evaluated under comparable optimization budgets, such as agent turns, tokens or wall-clock time?

(3) How exactly is cross-operator knowledge reuse implemented? Specifically, how are relevant recipes retrieved or selected for a new turn, what subset of the knowledge base is exposed to the Arch Agent, and how is applicability across operators determined?

(4) While /goal serves as a stateless single-episode baseline, it differs from ForgeKernel in several other components besides the knowledge base. The paper lacks a controlled ablation that isolates the contribution of persistent cross-campaign knowledge reuse. Could the authors also provide a controlled with-KB vs. without-KB ablation to quantify the contribution of knowledge reuse?

2 comments

We thank the reviewer for asking us to clarify the knowledge base, comparison, and ablations. We will make the final-artifact target, campaign accounting, and mechanism evidence explicit, and add controlled experiments for workflow components currently shown through traces.

R1: Presentation and appendix organization

The apparently empty cost section was an arXiv-cleanup error: the campaign table was removed while references remained. We will restore the campaign-ledger section and repair cross-references. We will also define “architecture” earlier with a concrete example.

R2: What the hardware knowledge base contains

The knowledge base stores validated hardware mechanisms, not just code snippets or operator-specific recipes. Each entry records:

  1. mechanism and target architecture;
  2. applicability conditions and trigger symptoms;
  3. a runnable probe or example;
  4. expected behavior, failure modes, and limitations; and
  5. validation evidence and provenance.

The SM90 snapshot contains 71 entries covering pipeline/barrier scheduling, asynchronous-copy/TMA organization, warp-specialized movement, register/shared-memory pressure, predication/selection, and instruction packing/layout. We will add a category table and one complete entry.

The lifecycle is: observe a bottleneck; propose and independently probe a mechanism; admit it with applicability conditions; retrieve matching entries; cite them in milestones; and check predicted behavior, correctness, and performance. Later tasks can reject or refine entries when their boundaries fail; a successful rollout is not treated as universally reusable.

R3: KDA/CAKE and optimization cost

The original KDA/CAKE comparison evaluates released final-artifact quality, not optimization resource efficiency. We will state this scope, add a transparent campaign ledger with budgets and stopping conditions, and redo the comparison under a matched protocol when task, reference, input, correctness gate, model, and optimization budget can be aligned.

Representative active budgets are 9.9 h for H100 GQA forward, 56.0 h for H100 GQA backward, 10.7 h for H100 MLA decode, 30.1 h for B200 GDN varlen, and 97.8 h for B200 recurrent KDA. The revised comparison will report the full protocol and stopping rule rather than conflate final performance with optimization cost.

R4: Cross-operator knowledge reuse

The architecture agent does not place the entire KB in every context. It first measures task characteristics such as memory traffic, occupancy, resource pressure, instruction mix, synchronization, and profiling/disassembly symptoms, then retrieves entries with matching hardware and applicability predicates.

Only the selected subset enters the architecture context. Each entry must be cited by a milestone, whose acceptance check tests the predicted effect. The coding agent receives a conditional mechanism hypothesis and verification obligation, not an unfiltered history of tricks.

R5: KB ablation and causal interpretation

We will strengthen the KB evaluation with a matched factorial experiment. The experiment will hold model, reference, inputs, correctness gate, and budget fixed while comparing full, frozen-KB, empty-KB, no-reopening, and matched continued-search arms. This will separately quantify the effects of KB reuse, reopening, and continued search instead of relying on an unmatched module ablation.

The SM90 provenance already records cross-operator reuse, including reciprocal DSA--GQA and GEMM--MHA exchanges. The matched experiment will add quantitative comparison to this traceable evidence.

The DSA case provides a concrete mechanism trace. Continued tuning within the original architecture gives about 4.5% improvement over the previous generation. A store-removal probe changes runtime by about 6.0%; the subsequent reopening adopts a persistent loop, and the confirmed generation improves the previous one by about 7.2%. The matched experiment will provide the corresponding quantitative attribution.

Measurement clarification

All 27 released kernels were audited under the /goal gate: all 26 applicable cells pass, while DSA indexer backward is inapplicable because the reference itself disagrees with the FP32 oracle. Same-input paired timing used five processes and 15 repetitions per process, and reproduces the main performance improvements. We will include this protocol and its reproducibility statement in the revised paper.

Thank you for your clarification. However, I'm still negative about the paper in its current form and will maintain my original rating.

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

ForgeKernel uses profiling information from a sealed reference binary to guide kernel generation. An arch agent proposes a plan, and a coding agent implements and tests it. The arch agent can revise architectural choices when tuning stalls. The system also keeps findings from earlier runs in a shared knowledge base and uses its best generated kernel as the reference for the next round. The evaluation covers expert libraries on H100 and B200, published kernels from three kernel-generation systems, and an Ascend 910C test. The authors report matching or beating 18 of 22 expert-library cells and all 7 generation-system kernels, with a 39.4% geometric-mean gain on the latter. On Ascend, they report a 33.1% geometric-mean gain over the public best.

Critical strengths

S1. Getting competitive kernels out of sealed binaries is a useful result. With no source code, the system reaches or beats FlashAttention-4, DeepGEMM, cuBLAS and cuDNN on most cells, and it recovers the tasks where the /goal agent fell short of the same references. The reference ablation shows that having the source adds little over having the binary.

S2. Timing each candidate against a pinned reference in the same GPU job is a good choice. I also appreciate that the paper reports the cells where it loses and describes the CAKE result as parity.

Critical weaknesses

W1. Uncontrolled comparison with /goal. I cannot tell how much of the improvement over /goal comes from ForgeKernel's design. The model setup differs: /goal uses Claude Fable 5.1 with up to 24 hours per kernel (L104-106), while ForgeKernel pairs a Fable 5.1 arch agent with a Claude Opus 5 coding agent (L252-253). Several ForgeKernel campaigns also exceed /goal's budget. In Table 4, 7 of the 25 campaigns log more than 24 active hours (agent plus GPU hours), up to 97.8, and 5 exceed 24 agent hours alone. Figures 3 and 4 report the best campaign per cell (L287-288), but the paper does not give the number of attempts behind each result. Table 4 lists only one campaign per operator despite 79 runs overall (L405). There is also no /goal restart from the promoted kernels, although L373-375 describe promotion as a restart. I also could not verify that both systems use the same correctness threshold. /goal kernels had to stay within twice the reference's own error (L130-131) and pass the Section 4.1 judges (L501-504). ForgeKernel's kernels are said to pass the judges, but Appendix D lists criterion types without the numerical tolerances promised at L485.

W2. Unsupported ceiling claim. I do not think the results establish that ForgeKernel exceeds the ceiling of generic agentic loops. On 7 of the 10 shared Hopper tasks, /goal's final kernel is faster than ForgeKernel's Figure 3 result (Table 5). Some gaps are substantial: +82.6% versus -0.2% on GDN prefill fwd, and +22.8% versus +0.3% on GQA attention fwd. The campaigns stop once they reach a target gain (L253-254), so they do not establish how far ForgeKernel can go. Table 2 also shows a strong dependence on the reference: the kernel built against cuDNN-frontend remains slower than DeepGEMM. 6 of the 18 reported wins are below 1%, and only 2 of the 4 B200 cells are positive. These need per-cell timing uncertainty to distinguish improvements from parity. It is unclear whether any self-evolution chain actually reached a plateau before its budget ran out. The noise threshold ε\varepsilon ranges from 1 to 5%, all 6 gains in Table 1 exceed 1%, and chains can also stop when the budget ends (L243). The paper needs to give the threshold and stopping reason for each chain. The abstract's +9.9% gain also needs more precise wording. It comes from promoting the gen-0 GQA attention fwd kernel (+0.3%), although /goal already had a +22.8% kernel for that task (Table 1). The gain from promoting that stronger /goal kernel is +5.0%.

W3. Unisolated value of architecture reopening and the knowledge base. I would like to see separate ablations for these two components. The current examples leave their contribution unclear. For DSA sparse attention, Appendix I shows that reopening improved DSA sparse attention from +4.5% to +7.2%. L376-377 should distinguish this additional gain from the improvement already achieved by tuning. This is the only such reopening documented in the main text. GDN prefill fwd raises a further question: with the same information as /goal (L264-265) and 7 arch-agent re-entries (Table 4), ForgeKernel ends at -0.2%, whereas /goal found a kernel 82.6% faster than FlashInfer. I would like to know what those re-entries changed and why they did not reach the structure /goal found. A comparison with architecture reopening disabled would help measure its benefit. The 71 entries and 553 (entry, run) reuse pairs (L405-406) show that the knowledge base is being used, but do not show how much it improves performance. The comparison across three periods (L406-408) does not resolve this, given the run-to-run variation acknowledged at L491-493. Please compare against an empty or frozen knowledge base.

Questions for authors

Q1. Could you report the number of campaigns, total budget, target gain τ\tau, and stopping reason for each cell in Figures 3 and 4?

Q2. Can you compare against /goal using the same model setup, budget and correctness threshold? Restarting /goal from the promoted kernels on the 2 Table 1 tasks where it led would also help assess the benefit of self-evolution.

Q3. How much do architecture reopening and the knowledge base improve performance when ablated separately?

I would consider raising my rating if the authors report per-cell campaign counts and budgets and provide a controlled /goal comparison, either with the same model setup and budget or restarted from the promoted kernels. The title and abstract should narrow the ceiling claim unless further evidence supports it.

2 comments

We thank the reviewer for identifying the most important experimental-control issues. We would like to clarify one point about the scope of our claim: the paper compares the quality of the converged artifacts, not the resource efficiency of the optimizers. We agree, however, that the comparison should be made under a more controlled protocol, and we will rerun it accordingly. We will also add a per-campaign ledger and strengthen the experimental controls in the revision.

W1: Controlled comparison with /goal

The /goal baseline uses Claude Fable 5.1 in the stock goal-driven workflow. ForgeKernel uses Fable 5.1 for architecture planning and Claude Opus 5 for implementation. Our claim is about the quality of the converged artifact under the stated task, hardware, input, correctness, and timing settings; it is not a claim that ForgeKernel uses fewer optimization resources than /goal.

To address the reviewer's concern directly, we will rerun the /goal comparison with matched task definitions, references, inputs, correctness gates, model configuration, and optimization budgets. We will report the complete protocol and all per-cell outcomes, rather than relying only on the best aggregate result. The current campaign ledger will also report campaign count, iterations, sessions, agent hours, GPU hours, active hours, wall-clock span, stopping condition, and confirmation status for every reported cell.

W2: Ceiling claim, small gains, and stopping conditions

We agree that “surpassing the ceiling of general agent loops” is too strong. We will replace it with “feedback-driven continual kernel optimization with architecture reassessment.” A target- or budget-terminated run will not be described as having reached a fundamental plateau.

We performed same-input paired timing on the same GPU, alternating candidate and reference order, with five processes and 15 repetitions per process. The major gains reproduce, including the K-Search decode/prefill cells, DSA score recomputation, and the self-evolution chain. We will include this repeated measurement protocol and the corresponding results in the revision.

We will also state the self-evolution reference points precisely. In the GQA forward chain, generation 0 is about 0.3% faster than FlashAttention-4, generation 1 improves generation 0 by about 9.9%, and generation 2 improves generation 1 by about 4.2%, giving approximately 15% cumulative improvement over FlashAttention-4. The 9.9% figure is a gain over the previous generation, not a direct comparison to FlashAttention-4. In a separate reference-free path, ForgeKernel improves a /goal GQA-forward artifact by about 5.0% and a /goal GDN-forward artifact by about 9.5%; these results demonstrate cross-run promotion, not universal superiority under an unrelated protocol.

W3: Reopening and KB ablations

We agree that the reopening and KB contributions should be tested with a more controlled experiment. We will therefore rerun these ablations with matched models, inputs, references, correctness gates, and budgets. The new study will include full, frozen-KB, empty-KB, no-reopening, and matched continued-search arms, so that the effects of KB reuse and architecture reopening can be separated from differences in task setup or search effort.

The existing DSA trace motivates this experiment: local tuning improves one generation by about 4.5%, a store-removal probe changes runtime by about 6.0%, and the subsequent persistent-loop redesign improves the preceding generation by about 7.2%. We will retain this trace as qualitative mechanistic evidence, while using the new matched ablations for the quantitative comparison.

I appreciate the care the authors took in checking correctness and repeating the timings. The response addresses my concerns about the tolerances (W1) and the interpretation of the small gains (W2).

  • Comparison with /goal (Q2). The distinction the authors draw between final kernel quality and the performance of the two optimization workflows is helpful. The proposed matched-budget runs would address my remaining concern about how the workflows compare under the same conditions.
  • Architecture reopening and knowledge reuse (Q3). The DSA example helped me understand why the agent revisited the architecture and what it changed. The planned ablations should clarify how much each component contributes to the measured gains.
Reviewer_689wOpenReview ↗
Rating
3
Confidence
2
Informativeness
3
Presentation
1
Soundness
3
Read review
Paper summary

This paper introduces ForgeKernel, a self-evolving kernel agent to do GPU kernel optimization work. The authors observe that agents settle the architecture in the first few attempts, then kept tuning on the existing architecture and will not reach to the hardware limit. The authors address this issue by introducing an architecture level loop that allows ForgeKernel to revisit design decisions rather than continuing local tuning within a fixed architecture. The results shows that on GPUs, this agent design shows competitive performance against expert implementations and existing automated kernel generation systems.

Critical strengths
  • Motivation is strong and novel, observation of the pattern of agents on a pre-settled decision will affect subsequent operations spinning in the local optimization requires insights and attention, and will inspire new agent design work
  • The performance is strong on evaluated hardware, and cross-architecture test shows the generalizability of the approach.
  • The knowledge is reusable, stores the optimization mechanism, the profiler symptoms that trigger it, a minimal runnable example, and known limitations.
Critical weaknesses
  • The paper presentation is very hard to read for general readers. For example, author's motivation on the design is about architecture and it appears many times in paper, but paper gives very little info about the definition or background/example.
  • Some experiment setup are not clear in the paper, for example the Opus and Fable model in coding agent, are mentioned but never discussed anymore. Also, does human experts also use coding agent to write kernels? If so, do they also suffer the local best issue found in paper?
  • From reading the paper, the pipeline seems very relying on the reference binary's performance to guide the workflow, authors also mentions this limitation, and it might make this agent work more like a feedback rather than the self-evolving claim in title and abstract
Questions for authors
  • Can you demonstrate more on the experiment setup and how each model is used, as these 2 models are having a noticeable capability difference
  • Can you justify the self-evolving, which is relatively a large claim, in the agent design and workflow? does agent have ability to generate these reference program itself?
  • Is there any representative case study rather than aggregated result can be provided to back up the main motivation?
2 comments

We thank the reviewer for pointing out that the paper assumes too much background. We will define architecture earlier, explain the two model roles, and give “self-evolving” an operational definition tied directly to the experiment.

L1: What does “architecture” mean?

Here, kernel architecture is the interdependent organization of computation and data movement: kernel decomposition, data dependencies, tiling, CTA/work-item mapping, persistent versus non-persistent execution, warp roles, pipeline stages, register budgets, shared-memory layouts, and synchronization.

Local tuning changes parameters within this organization. Architecture revision changes the organization itself. For example, changing a kernel in which one CTA processes one query block and exits into a persistent CTA that processes multiple query blocks is an architectural change, not merely a tile-size adjustment. The architecture agent plans these changes; the coding agent implements them and responds to correctness, performance, and mechanism checks.

L2: Experimental setting and model roles

ForgeKernel uses Claude Fable 5.1 as the architecture agent. It analyzes the operator, executable reference, profiling/disassembly observations, trajectories, and applicable hardware knowledge, then produces an ordered milestone plan. Claude Opus 5 is the coding agent: it implements the plan, runs correctness and timing checks, and revises the implementation in response to feedback.

The /goal comparison uses Fable 5.1 in the stock goal-driven workflow. The DeepSeek-V4.1 case is separate: it uses a single Claude Opus 5.5 coding agent at high effort for approximately 24 hours per generation on B200, and the revised paper identifies that setting separately. Human authors supplied task definitions, harnesses, correctness oracles, and evaluation protocols; they did not hand-write the reported kernel implementations. We do not claim that human experts necessarily exhibit the same local-optimum behavior as an LLM agent.

L3: What does “self-evolving” mean, and can the agent create references?

We define self-evolution operationally as cross-run promotion of an accepted artifact followed by renewed measurement and architecture analysis.

ForgeKernel can start from an existing reference or a simple implementation from /goal. Once a candidate passes correctness and performance validation, the accepted artifact can become a measurable reference for the next run. The next architecture analysis may preserve, modify, or reject its organization; the source is not a fixed template that must be inherited.

This means that ForgeKernel can generate and promote its own intermediate references: an accepted artifact becomes a new measurable object on which the next run can perform fresh architecture analysis. The system therefore does not merely replay an external reference; it can build a sequence of increasingly strong references through repeated promotion and reassessment.

The experiments show both paths. In a reference-free path, ForgeKernel improves a /goal GQA-forward artifact by about 5.0% and a /goal GDN-forward artifact by about 9.5%. In the expert-reference GQA chain, generation 0 is about 0.3% faster than FlashAttention-4, generation 1 improves generation 0 by about 9.9%, and generation 2 improves generation 1 by about 4.2%, for about 15% cumulative improvement over FlashAttention-4. These results demonstrate the intended self-evolution loop: each accepted generation becomes the measurable starting point for the next architecture analysis, and the gains accumulate across promotions.

L4: Representative case study

The DSA sparse-attention-forward case illustrates the motivation:

  1. The initial organization uses one resident CTA per SM and is non-persistent; after local tuning, the trajectory plateaus.
  2. A diagnostic probe removes output stores while preserving the remaining work; runtime changes by about 6.0%, indicating exposed store-path cost.
  3. The agent revises the organization to a persistent loop so one work item's output store can overlap with the next work item's loads.
  4. Correctness, resource behavior, and paired device timing validate the new implementation; the confirmed generation improves the preceding one by about 7.2%.

This example demonstrates the motivating failure mode and the resulting self-evolution loop: local tuning can plateau within a fixed organization, while renewed architecture analysis can propose, validate, and promote a different organization.

Thanks for the clarification, I am happy to keep my current score.

Reviewer_fe1UOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

ForgeKernel optimizes GPU kernels by profiling sealed references, constructing and revising architectural milestones, and generating implementations. Findings validated through hardware probes accumulate in a shared knowledge base, and accepted kernels become subsequent references. Across 27 operators, it reports matching or beating 18 of 22 expert-reference cases and all seven evaluated kernels from other generation systems, with further gains through promotion.

Critical strengths

The problem is practically relevant. Architectural replanning, independent correctness checks and paired timing form a sensible optimization workflow. The reported DSA persistent-loop redesign provides concrete evidence that revisiting architecture can improve performance (Sections 3 and 4.3).

Results against strong expert implementations are encouraging. The reference-access ablation supports the usefulness of hardware observations beyond operator specifications and a target latency (Figure 5).

Critical weaknesses

The experiments do not isolate the central mechanisms. Section 4.4 varies reference access and strength, rather than architectural reopening or knowledge reuse. Recipe-use counts establish adoption, not benefit. Since campaigns stop upon reaching targets, promotion gains also need comparison with equally resourced continuation or restarts (Sections 4.1–4.4).

The combination may be distinctive, but its contribution needs sharper positioning. KernelBlaster [1] already accumulates profiling-guided knowledge, and daVinci-kernel [2] maintains execution-verified skills. The paper should clarify what independent mechanism certification and sealed-reference promotion add beyond these capabilities.

The architectural case study supports useful redesign, but does not directly validate recovery of hidden reference features. A complete inference and mechanism-verification trace would strengthen this claim (Section 3.2). Best-campaign results also lack independent-run distributions and per-result timing uncertainty, limiting conclusions about reliability and small performance advantages (Figures 3–4).

[1] Dong, K. S., et al. (2026). KernelBlaster: Continual Cross-Task CUDA Optimization via Memory-Augmented In-Context Reinforcement Learning. arXiv:2602.14293.

[2] Fu, D., et al. (2026). daVinci-kernel: Co-Evolving Skill Selection, Summarization, and Utilization via RL for GPU Kernel Optimization. arXiv:2606.16497.

Questions for authors

Could you isolate the contributions of architectural reopening and knowledge reuse under matched models, references and search budgets?

Could you compare reference promotion with continuation and fresh restarts using comparable starting references, accumulated knowledge, targets and total resources?

Could you provide a complete example linking observations, a discriminating probe, an inferred architectural feature and its verification criterion, and clarify how this certification differs from prior verified-skill methods?

2 comments

Response to Reviewer fe1U

We thank the reviewer for asking about mechanism isolation, related work, and the missing inference trace. The revision will distinguish final-kernel performance, architecture-reassessment evidence, and controlled attribution to reopening and KB reuse. Existing traces show the mechanisms; matched experiments will complete the attribution.

F1: Can the core mechanisms be isolated?

Existing traces show the mechanism in operation: architecture analysis proposes a change, the coding agent implements it, and correctness, performance, and mechanism checks validate the result. To complete the attribution, we will rerun a matched factorial ablation with the same model, reference, inputs, correctness gate, and budget across full, frozen-KB, empty-KB, no-reopening, and matched continued-search arms. This experiment will isolate KB reuse, reopening, and continued search rather than conflating them in one module ablation.

The current evidence establishes:

  • all 26 applicable cells in the 27-cell correctness audit pass the /goal numerical gate;
  • same-input paired retiming confirms large gains, while several sub-2% gains are indistinguishable from parity;
  • the GQA and DSA traces show architecture decisions being proposed, implemented, measured, and checked against mechanism-specific evidence; and
  • the revision will quantify the independent contributions of reopening and KB reuse under matched model, input, reference, budget, and correctness-gate conditions.

F2: Relation to KernelBlaster and daVinci-kernel

These are direct precedents for the two axes of our system, but neither is the same method as ForgeKernel. KernelBlaster accumulates profile-guided CUDA optimization experience in a persistent, retrievable knowledge base. It is therefore directly related to ForgeKernel's knowledge self-accumulation and cross-task reuse. daVinci-kernel learns a dynamically evolving skill library through skill selection, summarization, execution verification, and reinforcement learning. It is directly related to our feedback-driven self-evolution of reusable optimization artifacts.

ForgeKernel differs in the reusable object and the feedback loop. First, it stores a hardware mechanism certified by a discriminative probe, with applicability conditions, predicted behavioral signatures, and failure modes; this is more specific than storing optimization experience or a verified skill. Second, a correctness/performance-accepted kernel is promoted as a source-hidden, measurable reference, after which architecture analysis can preserve, modify, or reject its organization. Thus the next run re-evaluates the promoted artifact through device feedback rather than merely retrieving a past experience or updating a skill library.

F3: Complete inference and mechanism-validation trace

The DSA sparse-attention-forward case gives the following trace.

  1. Observation. After local tuning, one resident CTA processed one work item and exited after its query load, KV fill, and final output store. The organization exposed no obvious local lever for overlapping adjacent items.
  2. Probe. The architecture agent removed output stores while preserving the remaining work. Runtime changed by about 6.0%. This was a diagnostic probe, not a proposed final kernel; it tested whether the store path was exposed.
  3. Inference. The result supported the hypothesis that one work item's final store was not overlapped with useful work from a neighboring item. The agent therefore changed the organization to a persistent CTA loop.
  4. Verification. The candidate passed numerical checks and resource/ occupancy checks, and was retimed on device. The confirmed generation improved the preceding generation by about 7.2%.

The distinction from a verified skill is that the probe is intended to discriminate among hardware explanations, and the stored entry records the observation, probe, predicted signature, applicability boundary, and failure mode. A skill can record what worked; this record also tests when and why it should work. The matched factorial experiment will provide the complementary quantitative attribution.

Scope clarification

The same-input paired audit used the same GPU, alternating order, five processes, and 15 repetitions per process, and reproduces the main performance improvements. We will make this protocol and its reproducibility explicit in the revision.

Reviewer_fe1UOpenReview ↗

Response to Authors

I appreciate the authors providing this clarification. However, I will retain my recommendation.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.