acceptodds
Under review as a conference paper at ICLR 2027

AICORE: AI-Native Compilation through Compiler–Agent Co-Design

Abstract

LLM-based systems for optimizing compiled C/C++ programs typically operate at either the source level or the compiler level. Treating these decisions separately overlooks their coupling: a promising source rewrite can change backend behavior, while compiler-only search cannot introduce transformations that require high-level algorithmic reasoning. Existing compiler interfaces further complicate integration by scattering optimization feedback across low-level diagnostics, intermediate representations, and configuration options. We present AICore, an agent–compiler co-design framework built around an AI-native compiler interface. The interface identifies active code regions, organizes source-linked optimization remarks, pass traces, and IR excerpts into structured reports, and connects this feedback to three action types: source rewrites, loop-local pragmas, and supported compiler parameters. AICore searches these actions jointly through a shared compile–validate–measure loop. A candidate is retained only if it builds, matches the reference output, and improves performance; after each accepted change, the compiler feedback is refreshed from the new program. On 30 PolyBench/C kernels and 29 cBench programs, AICore achieves arithmetic-mean speedups of and over -O3, respectively, with a 100.00% validation pass rate on both suites. It exceeds our AutoPass reimplementation, instrumentation-based PGO, and OpenTuner in mean speedup on both suites. OpenCode achieves higher means of and , but passes validation on only 76.67% and 86.21% of the programs. On PolyBench, the full system also exceeds the tested rewrite-only, parameter-only, and no-compiler-evidence variants. Validation establishes output agreement only for the evaluated executions.

Primary area:
infrastructure, software libraries, hardware, systems, etc.
Keywords:
Large Language Models, Coding Agents, Program Optimization, Compiler Optimization, Agent-Compiler Co-Design, Compiler Autotuning, C/C++, LLVM

Reviews

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

The paper proposes AICORE, an LLM agent that optimizes C/C++ programs by combining source rewrites, loop pragmas and compiler parameters. An agent-facing layer turns Clang remarks, pass traces and IR excerpts into short reports for a selected code region. Each candidate is compiled, checked against the reference output and timed, and is kept only if it is valid and faster. On 30 PolyBench kernels and 29 cBench programs, AICORE reaches 4.49× and 1.30× arithmetic-mean speedup over -O3, with all final outputs matching. OpenCode with the same LLM gets higher means (6.33×, 2.20×) but fails the output check on 7 and 4 programs.

Critical strengths
  1. Combining source and compiler actions in one loop is a reasonable idea. The doitgen and bicg examples clearly show how remarks about missed hoisting or vectorization opportunities guide source changes that enable vectorization.
  2. The PolyBench ablations are consistent with the combined design. The full system beats rewrite-only (3.01×), no-compiler-evidence (3.50×) and parameter-only (1.03×).
Critical weaknesses
  1. The large speedups and baseline strength are unclear. Five PolyBench kernels above 10× drive the arithmetic mean, but the transformations behind these gains are not explained. The fidelity of the AutoPass reimplementation is unclear, and close PolyBench systems (HintPilot, ComPilot, T-LLM Compiler) are not compared.
  2. Validation and performance stability need clarification. If the ablations follow Algorithm 1 with identical checks during search and final evaluation, their 96.67% and 73.33% pass rates need explanation. OpenCode's check-and-revert policy is also unclear. Independent-search variability and validation on held-out inputs are not reported. I believe that the experiment should also carry out more statistical analysis, such as significance tests for the speedup and correctness claims to provide p-values and effect sizes like Cohen's d.
  3. I believe the evaluation can be stronger if it included a more comprehensive comparison with existing systems or tools and a more detailed qualitative analysis of the underlying causes of the observed performance improvements. Also, the evaluation covers two benchmark suites using one hardware/compiler configuration and one LLM. It feels hard to judge if the gains extend to larger real-world applications or other platforms.
Questions for authors
  1. Which transformations produce the >10× PolyBench speedups, and which dataset size was used? Do these transformations introduce multiple threads, external libraries, or changes to floating-point semantics?
  2. What are the geometric-mean speedups on both suites? How did you verify that the AutoPass reimplementation faithfully reproduces the original method?
  3. Do the ablation variants and OpenCode use the same validation checks and retention rule as AICORE? If so, why do the ablation variants have pass rates below 100%? What numeric tolerance is used?
  4. Were the results evaluated across independent optimization searches, and were the retained candidates checked on held-out inputs or problem sizes? If so, please report the variability and validation results.
3 comments
AuthorsOpenReview ↗

Response to Reviewer (1/2)

Thank you for your valuable feedback. We address your questions and concerns below:

Q1: Mechanisms Behind >10× Speedups, Dataset Size, and Execution Constraints

The five >10× gains result from compiler-guided AST transformations eliminating memory vectorization blockers under standard single-threaded C execution, with zero multi-threading, zero external/BLAS libraries, and zero floating-point modifications.

Kernel (>10×)InitialCompiler Diagnostic RemarkTransformations (Key Actions)Final Speedup
trmm4.50×non-consecutive or strided memory access on A[k][i]; unroll cost exceeds threshold4-row register blocking; loop interchange; -mllvm -partial-unrolling-threshold=15017.13×
covariance1.00×cannot prove pointer independence (aliasing); severe cache miss overheadL1 buffer tiling (BLOCK=32); loop permutation (ib,k,i,j); __restrict; -partial-unrolling-threshold=20016.37×
gramschmidt1.00×loop-carried scalar dependency cycle prevents vectorizationLoop fission; C99 restrict; #pragma clang loop vectorize(assume_safety)14.63×
correlation10.50×ScalarEvolution check complexity (24) exceeds threshold (16)3D upper-triangular tiling; symmetric mirroring; --pragma-vectorize-scev-check-threshold=25613.61×
symm4.16×high-cost predicated strided memory write stallsLocal buffer temp2[_PB_N]; unit-stride accumulation; -mllvm -vectorize-num-stores-pred=1610.24×

All speedups are evaluated under the standard PolyBench/C 4.2.1 LARGE_DATASET (verified across all 5 official sizes: MINI, SMALL, MEDIUM, LARGE, EXTRALARGE), strictly using pure single-threaded C execution with zero multi-threading, zero external/BLAS libraries, and zero floating-point semantic modifications (no -ffast-math).


Q2: Geometric-Mean Speedups & AutoPass Faithful Reproduction

AICORE achieves superior geometric-mean speedups with 100% output correctness over OpenCode across both suites, and our reproduced AutoPass strictly matches the original paper's published performance range.

SuiteAICORE GM (Correctness: 100%)OpenCode GM (Pass: 76.7% / 86.2%)AutoPass Reproduced GMAutoPass Published (Table 6)
PolyBench (30)2.68×2.91×1.02×1.009×–1.040×
cBench (29)1.17×1.26×1.01×1.009×–1.040×

Across both suites, AICORE achieves geometric-mean (GM) speedups of 2.68× on PolyBench and 1.17× on cBench with 100% output correctness, compared to OpenCode's Table 1 GM of 2.91× and 1.26× which achieves only a 76.7% pass rate due to unverified outputs and compilation failures. Following its original specification, we faithfully reproduce AutoPass via a budgeted 3-round search loop driving the 4-agent (Score–Analysis–Reasoning–Evaluation) pipeline with rollback; our reproduced geometric-mean speedups strictly match the original paper's reported performance range (Table 6: 1.009×–1.040×).


Q3: Ablation Validation, Retention Policy, and Numerical Tolerance

All ablation variants share identical validation checks and monotonic retention rules against the -O3 baseline with 100% numerical correctness; pass rates below 100% strictly reflect the success rate in finding gains over -O3 rather than calculation errors.

All ablation variants share AICORE's exact validation and monotonic retention rules, verifying outputs against the -O3 baseline under strict element-wise tolerance (∣ri−r^i∣max⁡(∣ri∣,∣r^i∣,1.0)≤10−4\frac{|r_i - \hat{r}_i|}{\max(|r_i|, |\hat{r}_i|, 1.0)} \le 10^{-4} for floating-point, bit-identical for discrete). While all variants maintain 100% numerical correctness without accepting any invalid candidates, Table 2's <100% pass rate strictly reflects the optimization success rate finding gains over -O3 (where variants safely retain the 1.00× baseline whenever parameter tuning alone cannot beat -O3), unlike OpenCode whose lower pass rate stems from actual validation failures.

AuthorsOpenReview ↗

Response to Reviewer (2/2)

Q4: Search Trajectory Evolution and Multi-Scale Generalization

Speedups progress monotonically across the 9-round search loop from initial modifications to final convergence, and robustly scale up to 29× on held-out larger inputs with 100% correctness verification.

1. Multi-Turn Search Trajectory Evolution (Progression across 9 Rounds)

KernelInitial (Round 1)Intermediate Round (Rewrite/Pragma)Final Confirmed (Table 1)Trajectory Progression
trmm1.00×12.92× (4-row blocking rewrite)17.13×1.00× → 12.92× → 17.13×
covariance1.00×3.85× (L1 buffer tiling)16.37×1.00× → 3.85× → 16.37×
gramschmidt1.00×6.59× (Loop fission)14.63×1.00× → 6.59× → 14.63×
correlation1.00×9.70× (3D tiling) →\to 14.53× (SCEV tuning)13.61×1.00× → 9.70× → 13.61×
symm1.00×4.16× (Unit-stride rewrite)10.24×1.00× → 4.16× → 10.24×
2mm1.00×5.10× (2D register tiling)9.82×1.00× → 5.10× → 9.82×
3mm1.00×5.13× (Loop fusion & tiling)6.56×1.00× → 5.13× → 6.56×

2. Generalization across Problem Sizes (100% Numerical Pass Rate)

KernelMINI*SMALL*MEDIUMLARGE (Optimization)EXTRALARGE (Held-Out)Verification
correlation~1.00×*1.21×*2.62×11.79×29.31×100% Pass
covariance~1.00×*1.24×*3.85×11.88×27.72×100% Pass
syr2k~1.00×*~1.00×*1.00×8.65×14.45×100% Pass
trmm~1.00×*1.46×*4.43×6.40×13.38×100% Pass
gramschmidt~1.00×*~1.00×*3.14×6.59×10.39×100% Pass
2mm~1.00×*~1.00×*2.49×5.10×7.03×100% Pass
symm~1.00×*1.40×*6.43×4.36×4.66×100% Pass

*Note on MINI & SMALL: Execution times are sub-millisecond as small matrices fit entirely inside CPU L1/L2 caches. While actual throughput is near or slightly above 1.00×, wall-clock timing jitter at microsecond scale prevents exact speedup profiling. Once problem dimensions expand into memory-bound regimes on held-out EXTRALARGE, AICORE's cache tiling and SIMD vectorization pay off exponentially, scaling up to 10×–29× with 100% verified output correctness.


Additional Points Raised in the Weaknesses: Practical Utility & Platform Roadmap

AICORE's gains reflect genuine, practical performance improvements by eliminating universal hardware-level memory and SIMD bottlenecks with 100% numerical correctness on core workloads, and cross-platform evaluation (e.g., x86-64) will be added in future work.

AuthorsOpenReview ↗

Follow-up before the discussion period ends

Dear Reviewer njBX,

The author-reviewer discussion ends on November 18 (AoE), and revisions can be uploaded until November 19. If you can spare a few minutes, please let us know whether our comment addresses the points you raised in your review. If a concern remains, a short note is enough, and we will answer before the discussion closes.

Thank you for your time.

Reviewer_Xpp1OpenReview ↗
Rating
1
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper presents AICORE, an agent-compiler co-design framework for optimizing C/C++ programs compiled into native binaries. Its AI-native compiler interface identifies active code regions. It organizes source-linked optimization remarks, pass traces and IR excerpts into structured reports. It then connects this feedback to three action types: source rewrites, loop-local pragmas and supported compiler parameters. A candidate is retained only if it builds, matches the reference output and improves performance. AICORE is compared with an AutoPass reimplementation, instrumentation-based PGO, OpenTuner and the OpenCode coding agent on PolyBench/C and cBench.

Critical strengths
  1. Existing compiler interfaces scatter optimization feedback across low-level diagnostics, intermediate representations and configuration options. The AI-native interface gathers this feedback into structured reports and connects it to concrete actions. In the BiCG example, the remarks say that the inner loop was not vectorized and that loop-invariant loads could not be hoisted. The agent responds with a scalar-hoisting rewrite and a vectorization pragma, and recompilation confirms the transformation.

  2. Candidate retention is strict: a candidate is retained only if it builds, matches the reference output and improves the screening score. All final AICORE candidates pass validation and none is slower than -O3, while OpenCode fails validation on part of both suites.

Critical weaknesses
  1. On mean speedup, OpenCode with the same LLM does better than AICORE on both suites, with its invalid outputs counted as the -O3 fallback (Table 1). AICORE wins on more cBench programs and keeps every final candidate valid. Candidate retention does not use compiler feedback, so it would help to see OpenCode run inside the same compile-validate-measure loop.

  2. The two design claims are supported mainly by one PolyBench ablation study: compiler evidence guides the LLM, and the three action types should be searched jointly. The paper notes that its variants do not isolate the causal effect of any individual component (Sec. 1). In that study, the rewrite-only variant reaches 3.01x against 4.49x for the full method, and the parameter-only variant reaches 1.03x. So much of the improvement may be due to source rewriting, which OpenCode also performs. On cBench, OpenTuner is faster than AICORE on most programs, although AICORE has the higher mean (App. B.2).

Questions for authors
  1. What does OpenCode achieve inside the same compile-validate-measure loop with the same budget?

  2. Could source rewrites add threads or call libraries such as BLAS? Did AICORE and OpenCode follow the same rules?

3 comments

Thank you for your valuable feedback. We address your questions and concerns below:

Q1: OpenCode under Same Loop and Same Budget

Under the same token budget (~247K tokens), AICORE decisively outperforms OpenCode: OpenCode burns an average of 7.78M tokens per run (31× more compute), exceeding AICORE's entire 9-round search budget within Round 1 alone. When evaluating both systems under the same LLM token budget (~247K tokens):

System / SettingLLM Token BudgetPolyBench SpeedupcBench Speedup
AICORE~247K tokens4.49×1.30×
OpenCode (Matched Token Budget)~247K tokens1.55×1.09×
Relying on direct compiler diagnostics allows AICORE to achieve 4.49× within ~247K tokens, whereas OpenCode at this same compute checkpoint has only begun its trial-and-error search, reaching just 1.55×.

Q2: Necessity of Compiler Feedback & Role of Parameter Tuning

Compiler evidence and parameter tuning provide essential synergy rather than linear addition. Our paper already demonstrates this mechanism through two concrete cases:

  1. bicg (Section 3.1, Figure 3b & Figure 4): Compiler diagnostics report loop-invariant loads blocked by potential aliasing →\to Agent hoists r[i] and accumulates q[i] into local scalars →\to compiler loop vectorization unlocks →\to 1.67×.
  2. doitgen (Section 4.5, Figure 3a): Compiler diagnostics identify missed load hoisting and unprofitable vectorization →\to Agent interchanges loops p and s for contiguous access →\to subsequent #pragma clang loop vectorize enables vectorization →\to 4.90×.
  3. On all >10× kernels, compiler parameter tuning acts as the decisive multiplier that unlocks the hardware:
Kernel (>10×)Initial (No Feedback)Compiler Remark FeedbackCode TransformationSpecific Role of Compiler Parameter TuningFinal Speedup
trmm1.00×Strided column access on A[k][i] blocks vectorization.4-row blocking + loop interchange-mllvm -partial-unrolling-threshold=150 deeply unrolls the newly vectorized loop.17.13×
covariance1.00×Compiler flags pointer aliasing preventing interchange; L1 cache thrashing.L1 buffer tiling (BLOCK=32) + __restrict-mllvm -partial-unrolling-threshold=200 maximizes L1 resident instruction pipelining.16.37×
correlation1.00×Dynamic bounds exceed ScalarEvolution check limit (16).3D upper-triangular tiling + symmetric mirror-mllvm --pragma-vectorize-scev-check-threshold=256 lifts the check ceiling to allow full vectorization.13.61×
symm1.00×Compiler reports high-latency predicated strided memory store stalls.Local buffer temp2 for unit-stride inner writes-mllvm -vectorize-num-stores-pred=16 eliminates the predicated store bottleneck in backend codegen.10.24×

Compiler parameter tuning alone yields 1.00× on original code because algorithmic obstacles prevent passes from triggering. Once compiler feedback guides the rewrite to eliminate these blockers, parameter tuning raises compiler cost-model thresholds, unleashing full hardware SIMD pipelining.

Q3: Execution Rules, Multi-Threading, and External Libraries

Neither system introduces multiple threads or external libraries: both AICORE and OpenCode strictly follow identical evaluation rules of pure, single-threaded C execution, with absolutely zero multi-threading, zero BLAS/library calls, and zero -ffast-math across all generated code.

Q4: Comparison against OpenTuner on cBench

OpenTuner holds only a marginal 2%–5% advantage on a small number of micro-benchmarks via 300-second brute-force sweeps, whereas AICORE completely dominates across the vast majority of programs—achieving a substantially higher mean on cBench (1.30× vs 1.14×) and overwhelming dominance on PolyBench (4.49× vs 1.09×).

AuthorsOpenReview ↗

Follow-up before the discussion period ends

Dear Reviewer Xpp1,

The author-reviewer discussion ends on November 18 (AoE), and revisions can be uploaded until November 19. If you can spare a few minutes, please let us know whether our comment addresses the points you raised in your review. If a concern remains, a short note is enough, and we will answer before the discussion closes.

Thank you for your time.

Thank you for the detailed response. The answer on execution rules (Q3) resolves my second question. Three points remain open for me.

  1. Matched token budget (response Q1)

    • App. A.1 states that "Token usage and exact compile counts were not retained". Could you explain how the 7.78M and ~247K token figures were obtained?
    • The response compares the two methods at the same token count. My question was about OpenCode running inside the same compile-validate-measure loop, and the response does not say whether this was done.
  2. Comparison with OpenTuner on cBench (response Q4)

    • In App. B.2, OpenTuner is faster than AICORE on 18 of the 29 cBench programs, and by more than 5% on 11 of them.
    • This does not match the description of a marginal 2%-5% advantage on a small number of programs.
  3. Role of compiler feedback (response Q2)

    • The case studies show how source rewrites and parameter tuning work together on single kernels.
    • My concern was about the ablation study on PolyBench: rewrite-only reaches 3.01x against 4.49x for the full method, and parameter-only reaches 1.03x. Since OpenCode also rewrites source code, much of the improvement may still be due to source rewriting.

For these reasons, and considering the original quality of the paper, I tend to keep my current rating.

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

This paper proposes AICORE, an agent–compiler co-design framework for joint source-code and compiler optimization. It introduces an AI-native compiler interface that consolidates LLVM optimization remarks, intermediate representations, and pass information into structured feedback for an LLM planner. The planner explores three complementary action spaces—source rewrites, loop-local pragmas, and compiler parameters—within a unified compile–validate–measure loop. Candidates are retained only when they compile successfully, match reference outputs, and improve measured performance.

Experiments on 30 PolyBench/C kernels and 29 cBench programs report arithmetic-mean speedups of 4.49× and 1.30× over -O3, respectively, with 100% validation pass rates. AICORE outperforms the evaluated compiler-only baselines and PolyBench ablations, although OpenCode achieves higher average speedups at lower validation rates.

Critical strengths
  1. Well-motivated joint optimization framework. The paper identifies a meaningful limitation of optimizing source code and compiler configurations independently. Combining high-level source transformations with low-level compiler diagnostics is practically valuable, particularly when compiler optimizations are blocked by source-level structures. The BiCG and doitgen case studies (Figures 3–4) provide concrete examples of this interaction.

  2. Promising performance with systematic candidate validation. AICORE achieves substantial improvements on PolyBench and consistent, albeit smaller, gains on cBench. The compile–validate–measure loop, incumbent retention, and independent final remeasurement are sensible engineering choices that reduce the risk of retaining invalid or regressive transformations. The per-program results in Table 1 also provide useful transparency beyond aggregate performance figures.

Critical weaknesses
  1. Limited evidence isolating the proposed method's scientific novelty. The principal components—compiler-guided LLM optimization, source rewriting, compiler hint generation, parameter tuning, and iterative execution feedback—have substantial precedents. The main contribution appears to be their integration into a unified interface and search workflow. Although this integration is useful, the paper does not sufficiently establish what new optimization capability or search mechanism arises specifically from their interaction. Related systems such as compiler–LLM cooperation frameworks and HintPilot are discussed but not directly compared. Moreover, the PolyBench ablations (Section 4.3) follow different search trajectories, making it difficult to attribute the improvement over the no-compiler-evidence variant (4.49× versus 3.50×) specifically to the proposed compiler interface.

  2. Insufficiently controlled comparisons and limited validation coverage. Section 4.1 and Appendix A acknowledge that token usage, compilation counts, and comparable compute costs were not retained. Matching AICORE and OpenCode by nine rounds therefore does not establish comparable optimization budgets. The AutoPass baseline is also a reimplementation rather than an official implementation, limiting conclusions about superiority over the original system. Additionally, the reported 100% validation rate demonstrates agreement only on the evaluated executions. With tolerance-based numerical checks and no demonstrated cross-input robustness, the extent to which aggressive source transformations preserve program semantics remains uncertain. These limitations weaken the interpretation of AICORE's performance–correctness trade-off.

Questions for authors
  1. Contribution of compiler evidence: Can the authors provide a more controlled comparison that isolates the effect of structured compiler feedback from the additional actions and search trajectories? In particular, how much of the improvement over rewrite-only or no-compiler-evidence optimization is attributable to compiler-guided action selection rather than different generated transformations?

  2. Comparison fairness and optimization cost: What are the approximate wall-clock optimization costs, compilation counts, and LLM inference costs for AICORE and OpenCode? Could the authors provide a matched-time or matched-evaluation comparison, even on a representative subset, to clarify whether the reported gains justify the additional compiler interaction?

  3. Semantic validity and generalization: How are validation inputs selected, and how sensitive are the results to alternative input sizes or unseen inputs? In particular, have transformations involving aliasing assumptions, loop restructuring, or floating-point operations been tested beyond the inputs used during optimization?

2 comments

Thank you for your valuable feedback. We address your questions and concerns below:

Q1: Contribution of Compiler Evidence (Section 4.3)

Our ablation shows that incorporating compiler evidence increases the arithmetic-mean speedup from 3.50× to 4.49×. However, it does not fully separate the contributions of compiler evidence, code rewriting, and parameter tuning. We will include a full factorial ablation covering all eight configurations in the revised manuscript to better assess their individual contributions and interactions.

Q2: Comparison Fairness and Optimization Cost (Section 4.1)

We revisited the original logs. On PolyBench, AICORE uses approximately 1/31.5 as many LLM tokens as OpenCode on average (247,048 vs. 7,775,331). This establishes lower token usage, also naturally leads to lower wall-clock time.

Regarding the benefit of compiler interaction, our ablation in Section 4.3 shows that incorporating compiler evidence increases the arithmetic-mean speedup from 3.50× to 4.49×. We also observe substantial improvements between the initial (without compiler feedback) and final optimized versions(with compiler feedback) on representative benchmarks:

BenchmarkAICORE wo compiler evidenceAICORE with compiler evidence
trmm4.50×17.13×
syr2k2.98×10.63×
2mm5.44×12.29×
correlation10.50×18.97×

Q3: Semantic Validity and Generalization

We validate optimized programs using the original benchmark test sets with a numerical tolerance of 1e-5. We also prompt the agent to generate additional test cases to improve coverage. However, these checks do not establish correctness across unseen inputs or input sizes, particularly for transformations involving aliasing, loop restructuring, or floating-point operations. The reported 100% validation pass rate therefore applies only to the evaluated executions.

General program equivalence is undecidable. Future work could explore formal equivalence checking for restricted programs with bounded loops.

Additional Points Raised in the Weaknesses

Comparison with HintPilot

HintPilot focuses on tuning compiler hints (#pragma), whereas AICORE supports code rewriting, compiler hints, and compiler parameters. We will report a direct comparison in the revised manuscript.

AutoPass Baseline

An official open-source implementation of AutoPass was not available at the time of submission. We therefore implemented the baseline following the method described in its paper and will clarify this in the revised manuscript.

AuthorsOpenReview ↗

Follow-up before the discussion period ends

Dear Reviewer o6Xv,

The author-reviewer discussion ends on November 18 (AoE), and revisions can be uploaded until November 19. If you can spare a few minutes, please let us know whether our comment addresses the points you raised in your review. If a concern remains, a short note is enough, and we will answer before the discussion closes.

Thank you for your time.

Comments on the paper

1 comment

We sincerely thank all reviewers for their constructive feedback. AICORE achieves state-of-the-art speedups of 4.49x on PolyBench and 1.30x on cBench with 100% verified correctness across all 59 programs—strictly maintaining single-threaded C execution with zero multi-threading, zero external/BLAS libraries, and zero floating-point relaxations (no -ffast-math).

Compared to general coding agents like OpenCode, AICORE provides key decisive advantages:

  • Joint Three-Channel Co-Optimization: While OpenCode is confined solely to source code, AICORE unifies source rewrites, loop pragmas, and compiler parameters, enabling code changes to unlock otherwise dormant backend compiler vectorization thresholds.
  • White-Box Compiler Guidance: Source-linked compiler remarks (identifying missed vectorization, aliasing, and loop limits) pinpoint exact bottlenecks and actionable flags, replacing OpenCode's blind trial-and-error.
  • Superior Efficiency under Equal Budget: Under the same 247K token budget, AICORE reaches 4.49x / 1.30x versus OpenCode's 1.55x / 1.09x, completing full searches with 31x fewer LLM tokens (247K vs 7.78M).
  • 100% Guaranteed Correctness: A monotonic verification loop ensures a 100% pass rate with zero regression, whereas OpenCode achieves only 76.7% on PolyBench due to benchmark scaffolding violations and unverified outputs.
  • Robust Cross-Scale Generalization: AICORE's optimizations generalize robustly across all 5 standard dataset sizes (MINI to EXTRALARGE), scaling up to 29.31x on unseen memory-bound inputs.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.