acceptodds
Under review as a conference paper at ICLR 2027

Online Automated Algorithm Design with Large Language models

Abstract

Large language models (LLMs) enable automated algorithm design (AAD) through reasoning and code synthesis. However, most existing LLM-based AAD methods separate algorithm design from target optimization, deploying a fixed design even as the optimization state evolves. Conventional adaptive optimizers can respond to such changes, but their adjustments remain confined to predefined parameters, operators, or strategies. To address these limitations, we introduce online LLM-based AAD, a novel optimization paradigm that treats the algorithm itself as a state-dependent decision variable. At each stage, LLM agents synthesize an algorithm with new decision rules from the current optimization state. Executing the generated algorithm advances the search and provides feedback for subsequent designs, coupling algorithm design with target optimization without requiring a separate offline algorithm pretraining stage. To implement this paradigm, we propose OnDesign, a multi-agent framework that reconciles competing design perspectives to synthesize executable algorithms and uses execution feedback to refine how runtime evidence is interpreted for subsequent designs. We evaluate OnDesign across two mainstream black-box optimization paradigms on three scenarios: Bayesian optimization, evolutionary continuous optimization, and evolutionary mixed-variable optimization. Extensive experiments on six benchmark suites and one engineering problem across multiple problem dimensions demonstrate superior overall performance over conventional optimizers and offline LLM-based AAD methods.

Primary area:
optimization
Keywords:
Automated Algorithm Design, Evolutionary Computation, Large Language Model

Reviews

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

The paper proposes online LLM-based automated algorithm design (AAD): instead of designing an algorithm offline and deploying it fixed, LLM agents re-synthesize the algorithm at every stage of the target run, conditioned on the current optimization state. OnDesign has three modules: (1) State Analysis, where an LLM writes a state report from runtime observations, guided by a State Analysis Guideline (SAG); (2) Multi-Agent Deliberation, with exploration- and exploitation-oriented Proposers and an Arbiter that writes the code; and (3) SAG Evolution, which periodically refines the SAG using the execution gains credited to it. The method is instantiated for Bayesian optimization (BO), where it generates acquisition functions, and for evolutionary continuous and mixed-variable optimization, where it generates offspring operators. It reports the best average rank in all 17 suite–dimension configurations (Tables 1–2) and the best result on an LS-DYNA crashworthiness problem (Fig. 3).

Critical strengths
  • Treating the algorithm as a state-dependent decision variable is a natural step for LLM-based AAD, and Figure 1 and Section 2 lay out the distinction from offline design well.
  • The paper covers three scenarios, six benchmark suites, and one real expensive engineering problem.
  • Figures 15–17 trace one design decision end to end, which makes the mechanism concrete.
Critical weaknesses

1. The BO gains are implausibly large for the design space and need an implementation-parity check

The design space is narrow. Every generated acquisition function has the signature acquisition(best_y, mean, std) (Figure 5): a pointwise function of the GP posterior mean and standard deviation, maximized to pick the next point (Appendix C, step 4). This is the same family as LogEI, LogPI, and UCB. All methods share the same GP: a Matérn-5/2 kernel on standardized observations (Appendix H.2).

The generated functions are close to existing baselines. The case-study output (Equation 37, Figure 17) is:

α=log⁡(1+EI)+0.35⋅σσ+10−8⋅sigmoid(b−μσ)\alpha = \log\big(1 + \mathrm{EI}\big) + 0.35 \cdot \frac{\sigma}{\sigma + 10^{-8}} \cdot \mathrm{sigmoid}\left(\frac{b - \mu}{\sigma}\right)

Since log⁡(1+⋅)\log(1+\cdot) is monotone, the first term has the same maximizer as EI. Since σ/(σ+10−8)≈1\sigma/(\sigma + 10^{-8}) \approx 1 for any non-negligible σ\sigma, the second term is effectively 0.35⋅sigmoid(u)0.35 \cdot \mathrm{sigmoid}(u) with u=(b−μ)/σu = (b-\mu)/\sigma, a smooth PI-like term. So the generated rule is approximately EI plus a small PI-like term, both already baselines (LogEI, LogPI).

Yet the reported gaps span many orders of magnitude. For example, Table 15 (BO, CEC2026, D=30D = 30) shows OnDesign vs. the best baseline:

  • F4: 8.08×1028.08 \times 10^{2} vs. 1.18×1051.18 \times 10^{5} (LogPI)
  • F6: 1.03×1031.03 \times 10^{3} vs. 2.63×1062.63 \times 10^{6} (JES)
  • F15: 5.74×1035.74 \times 10^{3} vs. 1.36×1091.36 \times 10^{9} (MEoH)
  • F16: 4.28×1034.28 \times 10^{3} vs. 5.43×10145.43 \times 10^{14} (JES)
  • F18: 6.55×1086.55 \times 10^{8} vs. 6.69×10146.69 \times 10^{14} (ATRBO-LCB)
  • F22: 3.14×1033.14 \times 10^{3} (std 3.853.85) vs. 5.65×1045.65 \times 10^{4} (SETUP-BO)
  • F28: 1.78×1041.78 \times 10^{4} vs. 1.45×10131.45 \times 10^{13} (LogEI)

Table 10 (BBOB, D=30D = 30) shows similar gaps (e.g., F9: 9.89×1019.89 \times 10^{1} vs. ≥9.95×104\geq 9.95 \times 10^{4}; F20: 5.27×1025.27 \times 10^{2} vs. ≥1.40×104\geq 1.40 \times 10^{4}). With the same GP, the same 161 evaluations, and acquisition rules close to EI and PI, gaps of 10510^{5} to 101110^{11} are hard to explain by the acquisition formula alone. The paper does not specify:

  • how the argmax in Appendix C, step 4 is computed for each method (candidate set or gradient-based optimizer, number of restarts);
  • whether baselines such as JES, SETUP-BO, FunBO, and TREvol run through the same candidate-selection routine or their own implementations;
  • input normalization and boundary handling per method.

2. OnDesign finishes last on a consistent set of functions, which average rank hides

On the following functions, OnDesign is last among 12 methods, while the baselines cluster tightly:

  • Table 13 (CEC2022, D=10D=10): F3 (6.48×1026.48 \times 10^{2} vs. baselines at 6.006.00–6.01×1026.01 \times 10^{2}); F5 (1.66×1031.66 \times 10^{3} vs. baselines at 9.069.06–9.13×1029.13 \times 10^{2}).
  • Table 14 (CEC2022, D=20D=20): F3 (6.43×1026.43 \times 10^{2} vs. 6.016.01–6.03×1026.03 \times 10^{2}); F5 (1.66×1031.66 \times 10^{3} vs. 9.069.06–9.33×1029.33 \times 10^{2}).
  • Table 11 (CEC2020, D=10D=10): F8 (3.98×1033.98 \times 10^{3} vs. 2.352.35–2.47×1032.47 \times 10^{3}).
  • Table 12 (CEC2020, D=20D=20): F8 (7.97×1037.97 \times 10^{3} vs. 2.702.70–3.88×1033.88 \times 10^{3}).
  • Table 15 (CEC2026, D=30D=30): F5 (6.44×1026.44 \times 10^{2} vs. 5.00×1025.00 \times 10^{2}); F8 (4.60×1034.60 \times 10^{3} vs. 8.258.25–8.92×1028.92 \times 10^{2}); F9 (1.04×1041.04 \times 10^{4} vs. 6.836.83–7.58×1037.58 \times 10^{3}); F21 (1.10×1041.10 \times 10^{4} vs. 4.454.45–6.86×1036.86 \times 10^{3}).

These losses account for most of the baselines' "+" counts (e.g., LogEI's 4/25/0 on CEC2026 BO consists exactly of F5, F8, F9, and F21). Average rank conceals both extremes, because a 1011×10^{11}\times win and a 2×2\times loss each move the rank by a fixed amount. Together, extreme wins and systematic losses suggest OnDesign's search behaves structurally differently rather than uniformly better (e.g., a different region or boundary preference in candidate selection).

3. The central claim, that state-conditioned redesign helps, is not isolated by any experiment

The paper's thesis is that the algorithm should be designed from the current optimization state (Section 2, Equation 3), but none of the ablations tests this. w/o SA (Table 3) still passes runtime observations directly to the designer, and w/o MAD and w/o SAGE keep full state conditioning.

The feedback signal is also very sparse. In BO, a new acquisition function is generated for every evaluation (Algorithm 1), so each design is judged on a single sample, and the gain rtr_t is zero whenever the incumbent does not improve (Equation 31). In the case study (Figure 4), only 8 of 100 evaluations improve the incumbent, meaning roughly 92% of archived gains are zero. The SAG scores and the archive the Proposers reason over therefore carry little signal about whether a design was good. A simpler explanation is that the benefit comes from diversity (frequently switching among reasonable EI-like rules) rather than from reading the state.

4. Strong and closely related baselines are missing

  • CMA-ES is cited (Hansen & Ostermeier, 2001, Section 1) but not run; it is the standard reference optimizer on BBOB.
  • L-SHADE or jSO, the standard strong DE variants on CEC suites. SHADE (2013) is the strongest DE baseline included.
  • TuRBO or HEBO for the 30-D BO settings, where vanilla GP-BO is known to struggle.
  • Ngo et al. (2026), LLM-based adaptive acquisition selection for BO, cited in Section 1. It is the closest prior work on online LLM adaptation and directly tests whether synthesizing new logic beats selecting among predefined acquisition functions. AutoEP, the only online LLM baseline, appears only in the EC continuous setting.

Several included baselines (CoDE, CLPSO, ParEvo1) are weak and widen the rank gaps without informing the comparison.

5. LLM cost is unreported, and the fixed-evaluation comparison favours OnDesign on cheap benchmarks

The paper fixes the objective-evaluation budget but reports no LLM usage. Estimated from Algorithms 1–3:

  • BO: Each of the 100 stages calls the State Analyst, two Proposers, and the Arbiter (4 calls), plus a SAG refinement every 10 stages, giving about 410 LLM calls per run, or roughly 5×1055 \times 10^{5} calls over 121 function–dimension configurations ×\times 10 runs.
  • EC: 5,000 evaluations with N=100N = 100 gives about 49 generations, so about 200 calls per run, or roughly 4×1054 \times 10^{5} more over the 199 continuous and mixed-variable configurations ×\times 10 runs.

Offline AAD amortizes its design cost across tasks; OnDesign pays it on every run. A fixed-evaluation budget is the right axis for the LS-DYNA problem (Appendix H.4), where each evaluation is a finite-element simulation. For BBOB and CEC functions, which evaluate in microseconds, the same compute could buy orders of magnitude more evaluations for CMA-ES or L-SHADE.

Questions for authors
  1. How is the acquisition function maximized for each BO method, and do the CEC2026 gaps survive replaying OnDesign's generated acquisition functions through the LogEI pipeline?
  2. Why does OnDesign finish last among all 12 methods on CEC2022 F3/F5 (Tables 13–14) and CEC2026 F8/F9 (Table 15)?
  3. How do state-blind online redesign and random switching over an LLM-generated pool perform?
  4. What are the LLM calls, tokens, wall-clock time, and cost per run?
  5. What were the training problems and design budgets for EoH, MEoH, and ReEvo?
  6. Are the per-function differences statistically significant (e.g., Wilcoxon rank-sum)?
  7. Is Figure 13 measured data, and what does "adjusted" mean?
Reviewer_qzcZOpenReview ↗
Rating
4
Confidence
4
Informativeness
3
Presentation
3
Soundness
3
Read review
Paper summary

The authors introduce a new paradigm, online LLM-based automated algorithm design (AAD), together with a multi-agent framework called OnDesign. The framework comprises three modules: State Analysis, Multi-Agent Deliberation, and SAG Evolution. Its core idea is to enable LLM agents to generate algorithms during optimization, rather than only beforehand, so that the algorithm can adapt to the evolving search state. OnDesign is evaluated on Bayesian optimization, evolutionary continuous optimization, and evolutionary mixed-variable optimization. The results show that OnDesign often achieves better average rankings than traditional optimizers and offline LLM-based AAD methods. The authors further demonstrate its applicability to an engineering crashworthiness problem.

Critical strengths
  1. The paper makes a useful contribution to automated algorithm design by bringing algorithm design into the optimization process. Rather than fixing the algorithm before the search starts, the method allows the algorithm to change with the search state. This is a promising step beyond offline design and fixed algorithms, and it offers the field a direction worth further exploration.
  2. The framework is reasonably well organized, mainly because it clearly separates state analysis, design proposals, and code synthesis. Execution feedback is used to improve the analysis guideline, which makes the design loop more adaptive over time. The acquisition-function example is helpful because it shows how runtime observations can lead to new algorithm changes and helps readers follow the whole process.
  3. The experimental evaluation is fairly broad and covers different optimization paradigms and variable types. OnDesign tends to achieve better overall results than many strong baselines, and the comparisons with adaptive optimizers and offline LLM-based methods seem fair and relevant. The module ablations and the engineering example further support the value of the method and help make the contribution more convincing.
Critical weaknesses
  1. OnDesign is only compared with three offline LLM-based AAD methods: ReEvo, EoH, and MEoH. Although these are advanced methods, the paper does not compare OnDesign with more recent methods published in 2025 or 2026.
  2. I appreciate the adoption of matched objective-evaluation budgets, a design choice particularly meaningful for expensive optimization. Nevertheless, OnDesign repeatedly invokes multiple LLM agents, and the associated inference overhead is insufficiently characterized.
  3. The related-work discussion would benefit from a broader literature review. This would help readers better understand the specific methodological contribution of OnDesign.
Questions for authors

See Weaknesses.

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

This paper introduces online LLM-based automated algorithm design, a paradigm that integrates algorithm generation into the target optimization process rather than relying on a fixed algorithm designed offline. The proposed OnDesign framework consists of three components: State Analysis, Multi-Agent Deliberation, and State Analysis Guideline Evolution. These components enable LLM agents to interpret evolving optimization states, synthesize executable algorithms, and refine subsequent designs using execution feedback. Experiments across Bayesian optimization, evolutionary continuous optimization, and mixed-variable optimization demonstrate strong performance against conventional optimizers and offline LLM-based algorithm design methods.

Critical strengths
  1. The paper presents an interesting conceptual contribution by integrating LLM-based algorithm synthesis directly into the optimization process, allowing algorithmic behavior to change in response to evolving search states.
  2. The proposed framework has a coherent modular design, combining state analysis, multi-agent deliberation, and feedback-driven guideline evolution. The accompanying theoretical formulation provides a useful perspective on different sources of algorithm design error.
  3. The experimental evaluation is extensive, covering multiple benchmark suites, three optimization scenarios, and an engineering application. The consistent improvements in average rankings and the component ablations provide encouraging evidence of effectiveness.
Critical weaknesses
  1. The comparison between online and offline algorithm design is not fully controlled for computational resources. Although the methods share fitness-evaluation budgets, online algorithm generation introduces additional LLM inference and code-generation costs. The absence of a systematic end-to-end runtime and token-cost comparison makes it difficult to assess practical efficiency.
  2. The contribution of state-dependent online redesign is not sufficiently isolated from the benefits of repeated LLM generation and multi-agent reasoning. The existing component ablations do not directly establish whether the performance gains arise from online state feedback or simply from additional design opportunities and inference resources.
  3. The theoretical performance-gap bound is based on abstract design-space, representation, and synthesis errors, but these quantities are not empirically estimated or connected to measurable improvements. Consequently, the theoretical analysis offers limited explanatory evidence for the observed performance gains.
Questions for authors
  1. Can the authors provide end-to-end wall-clock time, LLM invocation counts, and token consumption for OnDesign and the offline LLM-based baselines under comparable computational budgets?
  2. How would OnDesign perform against an online baseline that periodically regenerates algorithms using the same LLM budget but without state-conditioned analysis or multi-agent deliberation?
  3. Can the authors provide empirical evidence linking the theoretical error decomposition to the improvements achieved by individual framework components?
1 comment

Thank you for the rebuttal. The reported runtimes and token counts show that online redesign is costly. OnDesign performs better than the variant without state feedback. Both use multi-agent deliberation and make a similar number of LLM requests.

The response leaves one question open. It is still unclear how the theoretical error terms relate to the observed gains. I maintain my rating of 3.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.