- Rating
- 3(+1)
- Confidence
- 4
- Informativeness
- 2
- Presentation
- 3
- Soundness
- 2
Read review
Paper summary
This paper studies how common workflow design choices affect program speed and search cost in agentic code optimization. The authors develop a controlled, configurable framework that combines four design choices—direct versus delegated coding, raw versus analyzed execution feedback, tools and skills, and history—into 24 workflows under a common task contract and evaluation protocol. The main experiments evaluate all 24 configurations with three models on 54 NPBench CPU kernels, with additional transfer tests on three further models using smaller fixed panels. The evaluation measures achieved program speed-up, token cost, and search time to examine the benefits of different design choices and how they depend on the model and the surrounding configuration. The results show that increasing workflow complexity does not consistently improve the trade-off between program speed and search cost. Analyzed feedback, combined with rebuilding the lead agent’s context at each turn, provides relatively consistent performance gains, while the benefits of delegated coding, tools and skills, and history depend more strongly on the specific setting.
Critical strengths
In my view, one of the paper’s main strengths is the systematic design of its experimental framework. I particularly appreciate how the authors bring coding mode, feedback, tools and skills, and history into a common optimization loop, with the same task contract and evaluator across the 24 workflows. The framework uses a shared controller to generate, validate, and benchmark candidates, while allowing changes to who writes the code, how execution feedback reaches the lead agent, and how earlier attempts are revisited. What I find especially useful is that the configuration design supports matched comparisons across different combinations of these choices. For example, it allows the authors to examine whether history that helps direct coding remains useful under delegated coding. Compared with ablations conducted only around a single full configuration, this provides broader coverage of how component benefits depend on the surrounding workflow and the underlying model. I also appreciate the joint evaluation of achieved program speed-up, token cost, and search time, including token cost by role. This helps assess whether the gains from additional components justify their search cost and gives the study practical value for workflow design.
Critical weaknesses
My concerns fall under two critical weaknesses: unquantified variability across independent optimization searches, and insufficient verifiable evidence connecting workflow configurations, task requirements, and the code changes that produce the reported gains. To make the priorities of this review explicit, I distinguish six points:
- Proprietary deployment models: an optional extension, with implications for the scope of the claims. I would find exploratory tests valuable, but I do not require them. I do expect a clear distinction between what has been directly validated and what remains untested in deployed coding-agent systems.
- Repeatability across independent optimization searches: an expected response. The authors need to address variability in generated code, optimization behavior, correctness, and final gains.
- Optimization trajectories and workflow configurations: an expected response. I need an analysis connecting configuration changes to the actual sequence of candidate-level code changes.
- Task requirements, code optimization, and workflow configurations: an expected response. I need a joint analysis establishing which component capabilities the workloads exercise and how this relates to the observed effects.
- Optimization in a real software repository: an optional extension. This would be an interesting additional case study. Its absence does not mean a change to the current claims or count against the paper in this review.
- Complete evidence from actual historical workflow executions: an expected response. I expect auditable records linked to representative runs underlying the reported results.
The paper provides a substantial comparison of final performance and resource consumption across workflows. However, a critical layer of evidence is missing from the step between these results and practical workflow-design recommendations: how different models use feedback, history, tools and skills, and delegation on different tasks during the optimization loop; how this use translates into code changes; how differences in workflow components correspond to differences in optimization behavior; and whether the experiments establish that these behaviors and gains are repeatable, meaningfully test the relevant component capabilities, and support consequential design recommendations. Insufficient analysis of generation variability, weak connections between task requirements and code changes, and incomplete disclosure and analysis of trajectories in relation to workflow components jointly limit the transferability and actionability of the recommendations. The absence of validation on proprietary deployment models raises a separate question about their scope. If these gaps in evidence and analysis were addressed, I would be much more confident in treating this paper as a reliable empirical basis for future code-optimization agent design and LLM coding-agent development. Unfortunately, the current evidence and analysis do not convince me that it has reached that point. I strongly encourage the authors to address these gaps so that I can assess the practical significance of this work more positively.
Regarding scope, I encourage the authors to distinguish more explicitly between validated configuration comparisons and deployment recommendations that remain untested. I recognize that the paper already demonstrates model dependence, particularly the substantially different gains from delegation observed for Qwen3.5-397B compared with GPT-OSS. However, these experiments do not establish whether the practical recommendations hold for proprietary deployment models, and this matters for the scope of the paper's advice. I support the use of open-weight models for workflow research: they facilitate version control and deeper analysis. The key question for me is whether the finding that code-optimization performance does not grow monotonically with workflow complexity, and the recommendations about the order in which components should be adopted, continue to hold across a broader range of frontier models. I understand that extending these findings to proprietary models is not the central focus of the study. Nevertheless, it is relevant to the applicability of its recommendations. I would welcome a qualitative assessment of whether programmers using models such as GPT-6 Astra, Claude Opus 5.5, GPT-6.1 Sol, and Claude Fable 5.1 should adjust their code-optimization workflows in light of these results, and whether developers of coding-agent products, including Claude Code, should adjust their built-in workflows. Broader coverage could also include additional open-weight models such as DeepSeek-V4-Pro. That would address a complementary question rather than provide proprietary-model validation. As the authors note, differences in how models use feedback, history, tools and skills, and delegation may materially change the value of these components. The full-suite experiments currently cover only three open-weight models, while the additional models are evaluated on smaller panels selected using GPT-OSS results. Readers therefore still cannot determine how much of the observed component benefit reflects transferable workflow principles and how much depends on the particular behavior of the evaluated models. The recommendation to start with analyzed feedback, choose the coding mode according to the model, and add tools and skills last has no direct or behavioral validation on proprietary coding models. I am therefore not yet convinced of its value for these everyday deployment settings or for developing agents intended to operate in them. If resources permit, I encourage exploratory tests on a small set of representative tasks and configurations, with explicit model versions, prompts, budgets, repeated searches, and clearly stated limits on applicability. Even then, I would treat the results as informative but limited transfer evidence: changes or uncertainty in model versions, serving conditions, sampling, and potentially request routing would make broad generalization difficult. That evidence could still provide valuable practical intuition. If the authors choose not to conduct these experiments, I fully understand, and that choice alone will not count against the paper. I do, however, expect the recommendations to state explicitly that direct validation is currently limited to the evaluated open-weight models and experimental conditions, while applicability to untested deployed coding-agent systems remains open.
Proprietary-model testing is an extension. The following concerns are central to my assessment, and I strongly expect detailed responses and, where needed, additional experiments. My first major reservation is that variability across independent optimization searches under the same configuration has not been quantified. My concern is primarily about the process of generating and modifying code, rather than the timing protocol. Section 3 explicitly states that each model-kernel-configuration combination receives one search, and all models use a temperature of 0.7. Each result therefore represents one optimization search with stochastic sampling and its associated candidate selection; the distribution of outcomes across independent searches under the same configuration has not been characterized. The authors also explicitly acknowledge that the kernel bootstrap does not measure variability between repeated optimization searches. Repeated timing and checks using mean versus median runtimes likewise cannot replace independent searches that regenerate candidates. These checks clarify sensitivity to workload composition, timing variation for fixed candidates, and the choice of aggregation statistic, respectively. They still do not quantify the probability and distribution of finding useful optimizations, passing correctness checks, and obtaining performance gains when the same configuration is rerun independently. Because later candidates depend on earlier generated content and feedback, different sampled outputs may alter subsequent attempts; the current single-search design cannot determine how much this affects the configuration comparisons. Beyond repeated searches with fixed prompts, semantically equivalent prompt paraphrases on a small set of representative tasks would provide an additional sensitivity check. Prompt paraphrasing is optional. Independent repeated searches are the central requirement. Appendix J describes joint accumulation across output channels and 4 x 4 spatial tiling for convolution, as well as parallel trailing-matrix updates in the LU factorization stage of ludcmp, and reports performance differences between the corresponding final programs. These examples do not establish how frequently the strategies are discovered and correctly implemented across repeated searches, or quantify the effects of small changes in generation. As the authors acknowledge at the end of Appendix J, each configuration contributes one search, so the examples describe selected programs rather than the probability that a component discovers a particular strategy. This acknowledged limitation still requires targeted repeated experiments. I ask the authors to conduct independent searches on a preselected subset of representative tasks and key configurations, jointly reporting the distribution of final performance, the frequency of useful strategies, rates of correct implementation and successful repair, and whether subsequent candidates retain previously effective transformations. What needs to be established is whether a workflow reliably improves the distribution of final outcomes across independent searches and increases the success rate of useful optimization behavior. I am not asking for identical code transformations or search paths in every run. Timing variation for fixed programs has already received substantial attention; variation in final outcomes and behavior across independent searches still needs to be quantified.
I recognize the paper's joint comparison of speed-up, correctness, token use, and search time, as well as its per-kernel results, context and role-level cost statistics, and Appendix J's analysis of final implementation differences. My second major reservation is that these analyses do not adequately establish how the benefits of different configurations arise through concrete code changes, or whether these explanations hold across models and tasks. The framework requires the model to identify bottlenecks, choose optimization directions, implement transformations, preserve correctness, and use feedback to decide whether to continue, revise, or abandon an attempt. Final correctness, the speed of the selected program, and total token use cannot distinguish these stages. Existing process statistics provide useful clues, but they have not been systematically connected to candidate-level code changes. For example, a component might help discover a new effective strategy, primarily reduce repair or repeated exploration costs, or help later candidates retain and combine previously effective transformations. These effects also need to be distinguished from the controller's own mechanism for retaining the best measured valid candidate. They have different implications for workflow design, yet the current analysis does not adequately distinguish them using candidate code and the feedback actually received. The available clues have not been developed into verifiable patterns of code modification across models and tasks. Figures 9 and 10 show that component effects vary with the kernel, model, and coding mode, but these differences have not been systematically linked to specific transformations, failure types, and feedback use. The few final-program examples in Appendix J do not establish that connection: they are comparisons of selected implementations, not an analysis of the optimization processes that produced them. For representative models, tasks, and configurations, I ask for a verifiable classification of optimization transformations, correctness repairs, repeated attempts, and reversions, using each candidate and its actual base implementation as the unit of analysis, and linking these actions to the model, task, workflow, and evaluation outcome. For the same model and workload under different workflows, this should include code diffs for every candidate in each turn relative to its actual base, so that readers can inspect where and how the code changed. Readers could then assess which behaviors produce the observed configuration advantages, whether they repeatedly yield gains in independent searches, and under what conditions they work. I accept execution-based evaluation of candidate performance and the evidence that matched configuration comparisons provide about overall component benefits. What remains insufficient is a verifiable explanation of how those benefits arise. Candidate source code, the context actually supplied, and targeted controls where needed to distinguish mechanisms would help fill that gap.
I am equally concerned about whether the requirements of the experimental tasks make particular components especially valuable, or leave little opportunity for them to contribute. Data layout, dependency structure, numerical constraints, and the available optimization space can all affect the usefulness of feedback, history, tools and skills, and delegation. The paper still lacks a systematic analysis connecting these task properties to the observed configuration differences and establishing whether the workloads adequately test the capabilities in question. Table 4, the reference implementations, the full results matrix, and the evaluation protocol help readers inspect the workloads and measurements. However, task names, reference-code line counts, and final speed-ups are not enough to characterize the optimization reasoning and component capabilities that each task requires. Appendix J provides useful explanations of performance differences between final programs, but does not trace those differences through the actual optimization process. For example, which feedback or tool evidence led to convolution tiling or parallel updates in LU factorization? At which turn were they implemented? Did they require repair? Were they attempted unsuccessfully under other configurations? This is currently unclear. More fundamentally, can these transformations be connected to a component's particular contribution, to the changes it makes to the model's available context, or to an interaction between the two? This distinction is especially relevant because analyzed feedback combines an analysis report with a compact-context rebuild by design. A comparison of this combined setting does not, by itself, identify the contribution of each mechanism. One possibility is that some workloads place little demand on particular component capabilities. If so, using those workloads to draw general conclusions about those capabilities without establishing that they were meaningfully exercised would be methodologically unsound. The paper does not provide the joint analysis of optimization behavior, search trajectories, task properties, and component configurations needed to examine this possibility and substantiate the proposed explanations of component effects. Task simplicity is not itself a problem. However, if the goal is to explain a component's role, an account of the final optimized code is no longer sufficient. The connection between optimization behavior and configuration must be examined jointly with task requirements, so that readers can distinguish an unhelpful component from a workload that offers little opportunity to use it, and understand their interaction. As a separate, optional extension, I would be very interested in optimization within a real repository or a larger codebase. In my view, such settings would be particularly valuable testbeds for broader advice about coding agents and would be closer to everyday use. They often create substantial opportunities to use feedback, history, tools and skills, and delegation, potentially allowing more informative comparisons of their roles. I am not making such a case study a requirement for the current claims or my assessment. My concern is whether the present tasks, trajectories, and code changes support the component-level interpretations being offered. The current cases do not yet allow me to determine whether changes in components produce stable patterns of optimization behavior, or how those patterns would carry over to practical use.
I strongly value the effort to organize code-optimization workflows within a unified experimental framework, the discussion of their key components, and the quantitative analysis of program speed, token consumption, and search cost. Comparing program performance jointly with the cost of finding the program has clear practical value. My main reservation is that the current evidence does not adequately support the paper's positioning as a contribution that moves from configuration comparisons to workflow-design principles. The paper shows that configurations produce different outcomes and that those outcomes depend on the model and task. It does not yet sufficiently explain how the differences arise through actual code changes, whether they are repeatable, how workflow changes correspond to modification patterns, whether the workloads meaningfully exercise the component capabilities being assessed, or how these observations transfer to other deployment models and task requirements. Adding model names, listing more tasks, or further decomposing resource costs cannot by themselves resolve these questions. I would certainly welcome broader open-weight model coverage, more repeated searches, more detailed analysis, and more comprehensive workloads. What is needed is a connected body of evidence: observe how components are used across the evaluated models and configurations; establish whether useful optimization behavior and final gains are repeatable across independent searches; connect task requirements to actual code transformations; and use the actual prompts and complete trajectories to document the progression from information to action to outcome. Additional open-weight experiments and limited exploratory proprietary-model tests could broaden that evidence, but proprietary-model tests remain optional. The appendices provide a starting point, and the code artifact supplies prompt templates and their construction logic. However, the supplied material does not provide a complete account of the actual optimization histories for a given task and model under different configurations: from the initial prompt and the context supplied to each model call, through feedback and component use, to candidate changes, their actual bases, correctness and repair outcomes, candidate selection, and the final code transformation. I specifically expect a report of actual historical executions that contributed to the paper's reported results, including a clearly identified model-task-configuration run underlying a main-table result. A generic description of how the harness operates, or a new illustrative run without a demonstrated connection to the reported results, would not meet this request.
I therefore regard these gaps as substantive weaknesses affecting the paper's main contribution. Even if all the reported performance numbers are accurate, I still find it difficult to determine which workflow to choose for a new task, why to choose it, and which lessons remain trustworthy after changing the model. I need the authors to establish what bounded, testable, and transferable design knowledge the paper provides through evidence on independent-search repeatability and the connections among task requirements, trajectories, code changes, and workflow configurations. I expect a direct and substantive response to each of the four expected points: independent repeated searches; the connection between configurations and candidate-level optimization trajectories; the joint analysis of task requirements, optimization behavior, and component effects; and complete, auditable historical execution evidence linked to the reported results. General summaries or another description of final implementations would not be sufficient. A convincing response, supported by specific evidence and analysis, would improve my assessment of the paper, strengthen my confidence in the authors' interpretation of its contribution, and lead me to raise my rating. If these issues remain unanswered, or the response does not provide the evidence needed to examine them, my assessment will become less favorable and I will lower my rating accordingly. The optional proprietary-models and real-repositories extensions are separate from these requirements. Declining to undertake them will not itself count against the paper. I have high expectations for the ideas and potential of this work, and I would sincerely appreciate a response that resolves these concerns and gives me a sound basis for a more positive recommendation.
Questions for authors
What do the authors see as the core value of this work, and how should readers understand the scope of its conclusions?
I would appreciate a clearer statement of the paper’s intended contribution. Is the main aim to develop an empirical understanding of code-optimization workflows for the evaluated open-weight models under controlled conditions, or to provide guidance for everyday code optimization and the development of LLM coding-agent systems? If both are intended, please distinguish what the current evidence establishes from the broader practical value the authors hope to offer.
This distinction matters to me because the paper goes beyond comparing configurations and offers recommendations about adopting analyzed feedback, choosing the coding mode, and adding tools and skills. I would like to understand what the authors believe readers should take away from these recommendations. Which decisions can users and developers reasonably make based on the present results, and which lessons should still be treated as hypotheses to test when the model, workload, or environment changes? I recognize that the paper already discusses model dependence, but I would welcome a more explicit connection between those limitations and the scope of its advice.
My expectations are high because I see considerable potential in this work. If the authors can connect task requirements, feedback, component use, candidate-level code changes, and final outcomes into a complete and verifiable account of the optimization process, and establish that the useful behaviors and gains recur across independent searches, the paper would provide a much stronger basis for workflow design. If its key conclusions also hold in exploratory tests with proprietary models and real software repositories, it could become an important empirical foundation for future research and engineering practice.
At the same time, I would not regard a more focused contribution as inherently low-impact. A study of the evaluated open-weight models, a fixed experimental environment, and a bounded set of clearly specified workloads, with some comparisons conducted on selected panels, can still be valuable. If this is the intended scope, I would simply ask the authors to make that positioning explicit and keep the recommendations within the boundaries of the evidence, so that conditional findings are not read as generally applicable guidance.
With this positioning clarified, I would appreciate a direct, point-by-point response to the six questions already raised in my weaknesses. Points 2, 3, 4, and 6 are central to my assessment. Additional experiments under Points 1 and 5 are optional, and their absence alone would not count against the paper. I would nevertheless welcome the authors’ views on the corresponding limits of applicability.
1. Applicability to proprietary deployment models. How do the authors expect the findings to inform programmers using proprietary models and developers of coding-agent systems? Please distinguish directly supported recommendations from untested expectations. If resources permit, could a small exploratory evaluation help clarify this boundary?
2. Repeatability across independent optimization searches. Could the authors conduct independent repeated searches on a preselected subset of representative tasks and key configurations, reporting final performance distributions, correctness and repair success, and how consistently useful strategies are discovered, implemented, and retained? Repeated timing of fixed programs does not address this question.
3. The connection between workflow configurations and optimization trajectories. Could the authors use candidate-level code changes, measured relative to each candidate’s actual base implementation, to explain how configurations affect strategy discovery, repair, repeated exploration, and reversions—and how these behaviors produce the reported gains?
4. The relationship among task requirements, code optimization, and component effects. Could the authors jointly analyze task properties and actual optimization trajectories to distinguish an unhelpful component from a workload that offers little opportunity to use it? Please also clarify the attribution limits of combined mechanisms, particularly analyzed feedback and context rebuilding.
5. Applicability to real software repositories. How do the authors view the transfer of these findings to optimization in real repositories or larger codebases? An exploratory case study would be welcome, but is optional. Without one, which aspects of that transfer can reasonably be discussed, and which remain open?
6. Complete historical execution evidence linked to the reported results. Could the authors provide auditable records of actual runs underlying the reported results, including a clearly identified run contributing to a main-table result? These should connect the actual prompts and contexts, feedback and component use, candidates and their bases, evaluation and repair outcomes, candidate selection, and final program.
4 comments
Thank you again for your encouraging review. Could you let us know whether the revision resolves your concerns? If anything is still unclear, we would be glad to address it in the final revision.
Sorry for the late reply
Thank you for the detailed reply. Sorry for the little reply and limited revision time. Forgive that I am a little busy....
Your reply convinced me about the repeatability and how the task component used. (I have seen the revision in the appendix)
I don't find any useful info in the reply of repo functions. Maybe there's some misunderstanding. Proprietary models and harness transfer here I want to see the data about its performance. But these are just for my own curiosity and this is not related to my confidence about your paper.
The key problem is that I still miss the info of a full life-turn optimization behavior. Could you expand it in Appendix J by walking through the report-guided and raw-feedback runs side by side, with the available code diffs for each candidate against the version it started from? I’d particularly like to see the qualitative analysis between the code diff and component's role.
Please revise the paper to add the optimization behavior includes the code diff and qualitative analysis between the code diff and component's role. Especially the code diff provided by agents! I have raised my score accordingly, but still want to see these details to be mentioned in the appendix.
Sorry again for the late reply and limited revision time!
Dear Reviewer,
Thank you for raising your score and for your suggestions. To examine how report guidance affects optimization trajectories, we traced the original raw-feedback and report-guided searches side by side, covering code changes, failed evaluations, correctness repairs, and final selections.
Two examples illustrate the observed behavior:
- conv2d: Following an analysis recommendation, the report-guided agent adds SIMD across output channels, then spatial tiling and weight reuse. Later repairs remove these optimizations, but the agent retrieves and returns to an earlier optimized implementation. The raw-feedback agent repeatedly submits a slower implementation, while the controller retains its first valid candidate.
- ludcmp: The report-guided workflow progresses from SIMD reductions to parallel row updates and a persistent OpenMP region, following the corresponding recommendations. The recorded starting implementations let us distinguish delegated code changes from correctness repairs. We also observed a direct-coding search that retrieves and reuses an earlier blocked implementation after repairs remove that structure.
These trajectories connect feedback recommendations to subsequent code changes and show how agents recover earlier optimizations after unsuccessful attempts. The raw-feedback searches do not exhibit the same successful sequences in these examples.
We also added source-provenance recording and an on-demand visualization linking code changes, feedback, repairs, and evaluation outcomes. Across 100 additional searches with GPT-OSS-20B and GPT-OSS-120B, we verified source records for all 1,731 evaluations. In one softmax search, a repair replaces an attempted vector exponential with scalar code, while a later candidate builds on that repaired source to produce a valid vectorized implementation.
Appendix J includes a complete optimization walkthrough, with actual code diffs and the feedback received at each step.
Best regards, The Authors
1. Proprietary models and harness transfer.
Claude Code tests harness transfer with GPT-OSS-120B (G3). Our six-model sweep guides targeted API tests of feedback/context, delegation, and history, retaining controls without assuming rankings transfer to proprietary models.
2. Repeatability and repairs.
All five repetitions favor reports (G2). Within-kernel highest/lowest ratios are:
The audit covers all 560 searches across five repetitions and 5,599 evaluated submissions. One ten-turn search submits nine candidates.
Of 2,439 initially unsuccessful submissions, 2,294 pass after repairs; 5,454 pass in total. Failures include compilation problems, output mismatches, and timeouts. Reports require more repairs but produce faster selected programs. All 560 final selections pass and retain the fastest valid candidate measured, including 433 searches with later slower or unsuccessful submissions.
3. Recommendations and code changes.
Historical GPT-OSS-120B conv2d/ludcmp traces in Appendix J connect prompts, code, correctness, and selection. These trajectory ratios use native median timings; final paper figures use the shared mean-baseline statistic.
Both conv2d workflows start near 16× Numba. A report recommends output-channel SIMD before the next recovered candidate implements it and reaches 106×. Later candidates add 4×4 output tiling and weight reuse. The valid turn-7 winner reaches 584× and stays selected. Raw feedback retains its first candidate near 16×.
Recorded starting code allows verified comparisons for six delegated ludcmp candidates. Reports first produce SIMD at 1.13×. A report on remaining serial work precedes an accepted request for parallel row-wise trailing-matrix updates, reaching 23.20×. A report on per-pivot parallel-region overhead precedes one persistent region, reaching 28.51× after repair and correctness checks. Raw feedback ends after SIMD at 1.12×.
4. Task requirements and component use.
Conv2d reuses inputs across channels and weights across neighboring outputs. Ludcmp parallelism must respect dependencies.
We classified 400 post-repair candidates from 20 searches per kernel across five repetitions. Conv2d output-channel SIMD appears in 10/10 report searches versus 4/10 raw searches. Trailing-matrix LU updates appear in 5/10 versus 1/10. Every discovered feature remains in the selected code. These counts describe selected cases, not benchmark-wide behavior.
Across all 560 searches, rebuilt context has successful best-source reads in 138/140 raw and 136/140 report searches. At least one next proposal copies that source exactly in 121/140 versus 54/140 searches; appended-context counts are 13/140 versus 0/140. These counts exclude modified reuse and do not establish wasted work. Core retrieval is separate from optional tools and graphs, disabled here.
The four historical paired cases contain five successful best-source reads, one graph query returning no rows, and nonempty automatic history in 33/35 lead requests. The 17 denied file requests are excluded from successful use. Exposure does not establish benefits; full-suite comparisons measure performance effects.
5. Repository functions.
Extracting a function with its dependencies, representative inputs, and correctness constraints could provide a comparable optimization contract. The extraction must preserve caller assumptions, data layouts, and integration constraints. Reports could help identify relevant performance evidence in that context, but performance transfer remains untested. Reintegration requires application tests and timings; application speed-up also depends on the function's runtime share and integration overhead.
6. Auditable historical evidence.
Five selected programs have model, kernel, workflow, timings, and source hashes. Conv2d C06 contributes to Table 5 and reproduces Appendix J's 569.85× under the mean-based statistic. All 94 calls in the four paired searches match responses and message counts. Both conv2d winners and 17/20 candidate sources are recovered; three intermediates are missing. Direct-coding traces establish chronology, without explicit parent hashes. The evidence contains all five winners, 29/36 candidate sources, six parent diffs, prompts, responses, validation, and timings. The manifest lists hashes and missing sources.