acceptodds
Withdrawn from ICLR 2027

Hyper Algorithm Design Agent: Evolving Learnable Optimizer from Zero

Withdrawn from ICLR 2027, so left out of the paper lists and the map.

Abstract

Meta-Black-Box Optimization (MetaBBO) is one of the highlights in the recent AI for Optimization trend. This paradigm's bi-level workflow leverages the learnable algorithm design policy at meta level to ensure the performance and generalization improvement on the low-level optimization task. While MetaBBO helps advance the performance lower bound of the resulted optimization system, it is currently handcrafted and customized case by case to adapt different optimization problems, which inevitably introduces inherent subjectivity and hence restricts the performance upper bound and usability in practice. In this paper, we address this issue by regarding MetaBBO's design loop as coding task, where we could introduce openendedness into MetaBBO with recursive self-improvement capability of advanced coding agents. Specifically, we propose a dual-agent framework: i) a task agent continuously refines the codebase of a target MetaBBO approach through code evolution; ii) a hyper agent progressively modifies the task agent and itself to provide open-ended design behavior; iii) the evolved MetaBBO codebase is evaluated and all in-execution information is fed back to the agents for recursive self-referential improvement. As a result, given a naive MetaBBO template, our framework automates a design evolution and finds novel variants superior to up-to-date human-made MetaBBO baselines. Surprisingly, the experimental results also demonstrate that our framework supports fast adaption across different optimization domains. Solid interpretation analysis further reveals interesting design principles emerge in such open-ended process. This work serves as the first exploration on automating design of complex learning-assisted optimization algorithms.

Primary area:
optimization
Keywords:
Optimization, Meta-Black-Box Optimization, Automated Algorithm Design, Openendedness

Reviews

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

This paper proposes HADA (Hyper Algorithm Design Agent), an LLM-driven framework aimed at automating the design of Meta-Black-Box Optimization (MetaBBO) systems. Rather than searching over a fixed operator space or only tuning low-level heuristics, the authors treat an entire MetaBBO repository—comprising the meta-level RL controller, the low-level evolutionary optimizer, and the training pipeline—as editable Python source code. Following recent self-referential agent designs (such as Darwin Gödel Machine and Hyperagents), HADA pairs a Task Agent (which edits the MetaBBO codebase) with a Hyper Agent (which inspects execution logs to rewrite both the Task Agent's prompt and its own prompt/logic), organized around an Algorithm Evolution Tree (AET). Starting from a simple DQN-DE template, the authors evaluate HADA across single-objective (COCO-BBOB), constrained, multi-objective (WFG), and UAV path planning benchmarks, reporting improvements over existing BBO and MetaBBO baselines.

Critical strengths

Extending code-level LLM evolution to bi-level MetaBBO pipelines: Most existing LLM-for-algorithm-design studies (e.g., FunSearch, EoH, LLaMEA) only synthesize isolated heuristic functions or single-level optimizers. Applying code-editing agents to jointly modify both the meta-level learning controller (state features, network architecture, RL updates) and the low-level evolutionary solver is a sensible and ambitious step forward for the MetaBBO community.

Broad experimental testbeds with a unified evaluation interface: The experimental setup connects with MetaBox-v2 and spans unconstrained, constrained, multi-objective, and realistic UAV planning problems. Normalizing objective progress into a unified [0,1][0, 1] metric makes cross-problem feedback practical for LLM agents.

Critical weaknesses

Severe contradiction between the "evolving from zero / domain-agnostic" claim and the heavy manual priors baked into the initial prompts (Appendix B): A central claim of the paper is that HADA removes human subjectivity and evolves learnable optimizers "from zero" in an open-ended, domain-agnostic manner (Abstract; Sec. 1, Lines 077–088). However, inspecting the first-generation Hyper Agent prompt in Appendix B.1 (Lines 970–1100) reveals that extensive human expertise and prior experimental debugging were manually hardcoded into the initial prompt: Lines 1036–1039 of the initial prompt state: "Analysis of previous experiments shows that Task Agents consistently ONLY make small PSO parameter tweaks... and NEVER replace the algorithm entirely. This has caused scores to plateau for 20+ generations." Why does the generation-1 prompt of a run starting from DQN-DE contain manual post-mortems of 20+ generations of failed PSO runs? Lines 1043–1050 explicitly instruct the agent on which human-designed SOTA algorithms to implement for each specific benchmark folder (DE, CMA-ES, SHADE, JADE, GLPSO for bbob_unconstrained; NSGA-II, NSGA-III, MOEA/D, SPEA2 for metabox_mo; PPO, Bayesian Optimization for meta-learning). Feeding a curated menu of textbook algorithms per testbed into the initial prompt undermines the claim of autonomous, open-ended discovery from scratch. Opaque final algorithm M* and evidence of dummy/disconnected meta-controllers in the evolved code: While Appendix A details the starting DQN-DE baseline, the paper never provides the mathematical formulation, state-action design, or code of the final best MetaBBO algorithm M* (e.g., Node #63 in Fig. 3). Worse, looking at the evolved Task Agent prompt in Appendix B.2 (Lines 1321–1420), the Hyper Agent provides a 90-line full implementation of standard CMA-ES (CMAESOptimizer) to overwrite DEOptimizer. In Lines 1408–1411 of that template: if self.controller is not None: obs = {'iteration': iteration, 'evals': evals, 'gbest_f': gbest_f, ...} step_params = self.controller.step(obs)

The output step_params from the meta-level controller is never used anywhere in the optimization loop. It acts as a dead call solely to satisfy the evaluation harness interface contract (dqn_de_util.py) without throwing an error, while the underlying solver runs pure, non-learned CMA-ES. This raises a major soundness concern: how much of HADA's performance gain actually comes from a learned bi-level MetaBBO policy versus simply swapping weak DE/rand/1/bin for standard human-known algorithms (like SHADE or CMA-ES) while bypassing the meta-controller? Missing ablation on the core contribution (the self-modifying Hyper Agent): The paper's main methodological claim is the bi-agent recursive self-improvement mechanism, where the Hyper Agent modifies the Task Agent and itself (building closely on Darwin Gödel Machine and Hyperagents, cited in Line 266). Yet the ablation study in Appendix D (Table 4) only tests Modifiable Policy (Yes/No), Initial Optimizer (DE/PSO), and LLM Backbone. There is no ablation comparing: (a) Task Agent alone with a fixed initial prompt, (b) a fixed Hyper Agent that only updates the Task Agent without self-modification, and (c) the full self-modifying HADA setup. Without this, we cannot tell if recursive self-modification of the Hyper Agent contributes anything beyond what the heavily engineered initial prompt already provides. Misleading headline metrics and imprecise theoretical framing: In the Abstract (Line 026) and Introduction (Line 102), the authors claim a "121.7% performance leap compared to existing state-of-the-art baselines". As clarified in Line 353 and Table 2, the normalized score increases from 0.8942 (GLEET) to 0.9674 (HADA)—an absolute improvement of 0.0732 (or ~8.2%). The 121.7% figure is obtained by anchoring zero at the worst-performing baseline, CMA-ES (0.8342), and computing (0.9674−0.8342)/(0.8942−0.8342)−1(0.9674 - 0.8342)/(0.8942 - 0.8342) - 1. Presenting this relative-margin ratio as a raw percentage leap in the abstract is misleading. Similarly, framing MetaBBO as "resolving the No-Free-Lunch (NFL) issue" (Line 053) is theoretically inaccurate: exploiting structural regularities across a restricted distribution of continuous benchmark functions does not violate or resolve the NFL theorem.

Questions for authors

Question 1 :Exact specification of the discovered M*: Could you provide the exact code or mathematical specification of the best discovered algorithm (Node #63 on BBOB, and the final models on Constrained/WFG)? Specifically, what is the low-level solver, what are the state features and action space of the meta-level policy, and how are the controller's outputs (step_params) actually consumed during optimization?

Question 2 :Dead controller.step(obs) calls: In the Appendix B.2 CMAESOptimizer code (Lines 1408–1411), step_params = self.controller.step(obs) is computed and immediately discarded. How does HADA prevent the Task Agent from gaming the interface contract by implementing a standalone heuristic (like standard CMA-ES or L-SHADE) and leaving the meta-learning controller disconnected? And in Table 4 (Modifiable Policy: No), if meta_learning.py is frozen to output 25 discrete (F, CR) pairs for DE, how did the Task Agent switch to other low-level optimizers without breaking the controller semantics?

Question 3 :Prior leakage in Generation-1 Prompt: Why does the first-generation Hyper Agent prompt (Appendix B.1, Lines 1036–1050) already contain conclusions from prior 20-generation PSO runs and an explicit list of domain-specific SOTA algorithms (CMA-ES, SHADE, JADE, NSGA-III, MOEA/D, etc.)? What happens if HADA is initialized with a genuinely minimal, domain-agnostic prompt that does not name existing evolutionary algorithms?

Quesiton 4 :Ablation of the Hyper Agent: Could you provide an ablation study isolating the effect of the Hyper Agent—specifically comparing (i) Task Agent only (fixed prompt), (ii) Hyper Agent modifying Task Agent only (no self-modification of hyper_agent.py), and (iii) full HADA under the same 100-generation budget?

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

This paper shows that coding agents can be used in a hyper-agent framework to modify source code for 1) itself and 2) the task agent that is responsible for modifying the Python implementation of an optimization algorithm for improving its performance.

Critical strengths

One strength of this paper is that using coding agents for MetaBBO kind of setups might be practically useful in various industries. Additionally, one strength is that this might be the first time a hyper-agents like framework is being applied to the MetaBBO setup.

Critical weaknesses
  1. HADA does not feel novel to me, given there has been extensive research in this area, including hyperagents, darwin godel machine, and recent works like meta-harness: https://arxiv.org/abs/2603.28052 as well. It is unclear what new learning this paper brings to the community, since it is established that coding agents in auto-research or hyperagent-like loops can hill-climb on a number of tasks.

The authors claim this to be a “paradigm innovation”; however, the paradigm has already been long established. Hence the novelty, if at all, is very domain-specific.

  1. There is repeated evaluation of candidate algorithms on a “test set” during evolution, and this is used to select future candidates. Is this test set the same as the test set used for final evaluations to compare candidates? If that is so, then the reported performance might also be the result of overfitting. The exact experimental configuration and details should be part of the paper to clarify this.

  2. Recursive self-improvement: I do not find convincing evidence of recursive self-improvement on the MetaBBO domain studied in this paper. Showing recursive self-improvement requires a result that shows that allowing a hyperagent to modify its own harness can enable better discovery. Appendix D shows the difference between “Modifiable MetaBBO policy” and “Fixed MetaBBO policy”, which does not measure “Hyper Agent self-modification”. Can the authors compare setups with 1) task agent only with a fixed prompt, 2 task agent and a hyperagent, 3) hyperagent only editing the task agent prompt/harness but not itself, and 4) the complete HADA algorithm? - All should be compared in a budget-matched setting. Additionally, does this paper propose any novelty over the original hyper-agent work?

  3. Does HADA discover any novel algorithms, or does it lead to using known algorithms in various ways? This is important to be reflected in the claims of the paper. It is also important to show and characterize what kind of final algorithms are discovered.

Questions for authors

See Weaknesses

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

This paper presents HADA, a two-agent large language model (LLM) coding system that automates the design of meta-black-box optimization (MetaBBO) systems. HADA consists of a task agent that edits the code of a MetaBBO system, and a hyper agent that edits the instructions/logic of the task agent (and possibly also its own instructions/logic). Candidate implementations, their execution logs, patches, and scores are stored in an algorithm evolution tree. From this tree, new candidates are selected to be evolved. Results are reported on unconstrained BBOB, constrained optimization, multi-objective WFG problems and a UAV planning task. The authors provide qualitative analysis of the evolution processes and perform extensive ablation studies on various aspects such as editable parts, initial optimizers, and LLMs.

Critical strengths
  • The paper addresses the problem of automated optimizer discovery by exploring how LLMs can be used as coding agents to automatically design BBO algorithms, beyond optimizing a pre-defined optimizer template.

  • It treats the entire MetaBBO pipeline as an executable and modifiable system, incorporating insights from execution logs, patch updates, and performance metrics. To evaluate robustness and validity, the research considers multiple optimization scenarios.

  • The observed improvements could inspire additional efforts towards designing optimized algorithms at the code level within MetaBBO.

Critical weaknesses
  • The authors need to explain better which data was used for training the MetaBBO policy, which data was used for searching and validating candidates using HADA (candidate-search/validation data), which data was used for tuning the baseline (baseline-tuning data), and what the final test set looks like (final test set). The final test set cannot be seen by the agents at any point during the experiment. Otherwise, this might just imply overfitting

  • The prompts include many hints about the types of optimizers to try, how to accept/reject them, what code/interface structure to use, what domain-specific recommendations to use, and even an implementation of algorithms like CMA-ES. The work is best described as a strong human scaffolding LLM-guided search over an optimizer design space rather than autonomous or open-ended discovery. We suggest that this be clarified in the paper, i.e. by discussing the discoveries in more detail.

  • There are several LLM-based discovery system that need to be compared in order to establish that the BBO-specific HADA method achieves improvements, e.g. OpenEvolve, ShinkaEvolve, etc.

  • Compute, API costs, and reproducibility reporting also appear missing

Questions for authors
  • Which tasks are used for MetaBBO training, HADA candidate evaluation, tree-based parent selection, baseline tuning, final-project selection, and final reporting? Are any instances or aggregate scores in the main tables exposed to test problems?

  • Please compare HADA against baselines like OpenEvolve, ShinkaEvolve, etc.

  • What are the exact final discovered algorithms in each setting? In general, the paper would benefit from a proper analysis of the discovered algorithms.

  • Please report full resource and cost accounting.

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

Related papers

Discussion (0)

Sign in to comment.