- 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 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 . 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?