acceptodds
Under review as a conference paper at ICLR 2027

MeEvo: Metacognitive Evolution Combined with Natural Evolution for Automatic Heuristic Design

Abstract

Large Language Models (LLMs) have advanced Automatic Heuristic Design (AHD) by enabling heuristic generation through reasoning and code synthesis. In LLM-based AHD, the LLM reasons about algorithm design and generates executable heuristic code. Existing architectures adopt two main paradigms: Natural Evolution applies crossover and mutation to this code to explore diverse strategies, but discards the reasoning traces behind the design decisions, weakening knowledge inheritance; Metacognitive Evolution retains these reasoning traces and refines them through reflection, but lacks population-level recombination, limiting exploration. These limitations reduce search efficiency, stability, and solution quality on complex problems. To address this gap, we propose MeEvo, an AHD framework that cyclically couples Natural Evolution and Metacognitive Evolution with operator balance that shifts from exploration to exploitation. Natural Evolution explores heuristic code while recording LLM-generated reasoning traces, fitness values, errors and best heuristic into a shared history; Metacognitive Evolution then reflects on this history to generate improved heuristics that feed into the next Natural Evolution cycle. This design enables population-driven exploration and reflection-driven refinement to reinforce each other. Experiments on five optimization problems show that MeEvo achieves stronger performance and lower variance than tested LLM-based AHD architectures, especially on complex constrained tasks.

Primary area:
optimization
Keywords:
Automatic Heuristic Design, Large Language Model, Natural Evolution, Metacognitive Evolution, Evolutionary Computation

Reviews

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

MeEvo is an LLM-based automatic heuristic design framework that alternates population-based crossover/mutation of heuristic programs with reflection over recorded reasoning, objective values, execution errors, and the best program. Reflection produces a Meta Insight that guides generation of further heuristic programs. The method also uses problem analysis, error repair, and a linear crossover-probability schedule. The paper evaluates two LLM backbones on TSP-ACO, BPP-ACO, adaptive curriculum sequencing (ACS), wireless sensor network deployment (WSN), and constructive TSP. It reports favorable objective values and stability on the first four tasks, competitive constructive-TSP performance, and ablations of phase schedules and inherited support components.

Critical strengths
  1. The framework is sound. Shared search records, reflection-to-code generation, and ordinary evolutionary operators form an implementable design, with detailed prompts, pseudocode, generated programs, accompanied by supplementary artifacts. This makes the work potentially useful to practitioners extending LLM-based heuristic search.

  2. The evaluation is comprehensive. It spans five tasks and two backbones and includes single-phase, schedule, APA, and ED ablations. Table 1 reports improvements over MeLA on ACS and WSN with both backbones, and Appendix provides exact nonparametric tests rather than relying only on mean rankings. Several supplied result groups, including ACS under both backbones, agree with the reported means. These are promising signals, subject to the concerns below.

Critical weaknesses
  1. The main evidence does not identify the claimed cyclic feedback mechanism. For BPP-ACO, ACS, and WSN, Table G4 gives N0=20, Npop=10, and L=50. With the default N=2, M=1, Algorithm 1 performs initialization (20), NE (10), NE (10), then ME (10) and terminates. No ME-generated heuristic participates in later NE crossover or mutation. The supplied artifacts likewise end after their first ME batch, with one additional expert seed evaluation. Consequently, these results support a terminal reflection stage but do not demonstrate the repeated NE->ME->NE reinforcement emphasized in the contribution. Table 3 changes phase allocation as well as ordering, while no control removes or shuffles trace history at matched resources. This matters because prior ReEvo already accumulates long-term reflection across iterations; the incremental benefit of full history and phase separation needs to be isolated, rather than inferred from the names of the phases.

  2. The empirical comparison needs reconciliation before the reported advantages are reliable. In addition, the statement that traditional ACS/WSN baselines receive larger computational budgets compares one execution of a generated heuristic with one baseline run. Searching roughly 50 heuristics on the same task entails approximately 50,000 ACS or 250,000 WSN objective calls before repairs, versus the traditional budgets of 15,000 and 100,000. Design costs could be amortized over future instances, but that interpretation requires held-out deployment results. Finally, repeating the selected ACS/WSN heuristic 30 times measures restart stability, not transfer to unseen task instances. Together these limitations weaken the interpretation of the constrained-task results as a fair, generalizable AHD advantage.

Questions for authors
  1. Mechanism clarification and targeted validation: Under the reported L=50 settings, where does any ME-generated candidate enter a subsequent NE round? Can you show phase-resolved results that distinguish repeated coupling from a single terminal reflection, with equal NE/ME candidate counts and comparable model-call/token budgets? TSP-ACO already has a longer trajectory that could help address this question.

  2. Budget and generalization clarification: Do the ACS/WSN baseline rankings persist when all objective calls across heuristic search, seeds, and repairs are included, or when the learned heuristic is evaluated on genuinely held-out learners/materials and sensor layouts? Please distinguish search-time solution quality from deployment-time algorithm performance.

4 comments

Dear Reviewer:

We address the two points in turn.

1. Cyclic feedback and history isolation

ME is a separate prompt-level local-search step. It reads the shared history (traces, fitness, errors, best heuristic), forms a Meta Insight, and uses that insight to generate a batch of improved heuristics. It therefore improves the reasoning process that produces code. These heuristics then rejoin NE for crossover and mutation, bringing the local search gains back into global search.

Table G4 (P34) sets L=100 for all four AHD tasks; Table 3 (P9) uses the same budget. The default (2,1) schedule is:

Budget (P9 Table 3; P34 G4)Phase sequence (10 candidates/generation)Primary evalsME->NE returns
L=50 (old)20 init + 2NE x 10 + 1ME x 10500
L=100 (revised)20 init + [2NE x 10 + 1ME x 10] x 2 + 2NE x 101002

Thus each main task completes two ME->NE cycles. The artifact contains complete logs for all five rounds, including every NE/ME batch, candidate, objective, error, and ME-to-NE handoff; it no longer stops after the first ME batch.

Updated Table 1 (P7) at L=100 over five runs:

Problem (P7 Table 1)MeEvo (DeepSeek)MeLA (DeepSeek)MeEvo (MIMO)MeLA (MIMO)
TSP-ACO5.716 ± 0.0035.828 ± 0.015.718 ± 0.015.824 ± 0.01
BPP-ACO203.28 ± 0.97204.16 ± 0.72203.40 ± 0.96203.68 ± 0.36
ACS554.29 ± 8.92568.32 ± 10.16558.08 ± 9.36579.16 ± 11.85
WSN50.00 ± 0.0054.19 ± 0.8750.00 ± 0.0055.12 ± 1.31

MeEvo wins all eight cells; DeepSeek gains over MeLA are 1.92%/0.43%/2.47%/7.73% (TSP/BPP/ACS/WSN).

The controls below separate return timing from phase allocation (Tables 3-4, P9):

Setting (Tables 3-4, P9)NE/MEReturnsTSP-ACOBPP-ACO
5NE->3ME (terminal)50/3005.753 ± 0.02204.04 ± 0.64
4NE->4ME (equal-count, terminal)40/4005.772 ± 0.04204.44 ± 0.53
Cyclic (1,1), equal-count40/4035.747 ± 0.01204.00 ± 0.92
Cyclic (2,1), MeEvo60/2025.716 ± 0.003203.28 ± 0.97

The two 40/40 rows use the same prompts, operators, N0, model calls, and token budget. At this fixed allocation, cyclic (1,1) lowers the TSP-ACO/BPP-ACO means from 5.772/204.44 to 5.747/204.00. The NE-heavy cyclic (2,1) lowers them further to 5.716/203.28. Thus, the best design is the 2:1 NE-heavy cyclic schedule: ME->NE returns help, and the larger NE share improves the balance between global search and local refinement.

Removing all accumulated traces raises the means to 5.873/205.28/625.83/62.43, i.e. 2.75%/0.98%/12.91%/24.86% above full MeEvo (Table 5, P10); the gap exceeds the SD on every task. MeEvo runs a separately budgeted ME batch and returns its output to NE. The two controls show distinct contributions from the ME->NE return and accumulated history.

2. Budget-inclusive ranking and deployment checks

At L=100, one ACS/WSN heuristic uses 1,000/5,000 objective calls. Objective columns: Table 1 (P7); call totals: Table G11a (P38), including all candidates and repairs across five runs. Table 6 (P10) gives per-run counts:

MethodACS callsACS objectiveWSN callsWSN objective
MeEvo0.50M554.292.60M50.00
MeLA0.54M568.322.80M54.19
ReEvo0.50M634.092.50M106.39
MCTS-AHD0.50M639.922.50M78.09
SCSO (best traditional)0.075M1673.530.50M417.02

ReEvo (Ye et al., 2024) is the best other AHD method on ACS, and MCTS-AHD is the best on WSN. MeEvo uses fewer calls than MeLA and remains first. SCSO uses 6.7x/5.2x fewer calls, but its objective is 201.9%/734.0% above MeEvo. The ordering is unchanged when all search calls are counted (Table G11a, P38).

Table 1 is search-time quality. At deployment, the selected heuristic is fixed and run without retraining. On five fresh WSN layouts, all 25 runs reach the 50.00 lower bound (Table G11b, P38). Three disjoint 10-learner ACS cohorts give 145.26 ± 9.02, 148.47 ± 8.08, and 164.28 ± 8.71. ACS contains one 30-learner population, so this is a within-population robustness check. TSP/BPP-ACO provide external held-out evidence on 64 instances at n=100/1000 (Figure 3, P8). The 30 ACS/WSN runs execute the fixed best heuristic after search; they measure restart stability, not another search stage.

References.

  • Ye et al., ReEvo: Large language models as hyper-heuristics with reflective evolution, NeurIPS 37:43571-43608 (2024).
  • Seyyedabbasi and Kiani, Sand Cat swarm optimization: A nature-inspired algorithm to solve global optimization problems, Engineering with Computers 39(4):2627-2651 (2023).
  • Qiu et al., MeLA: A metacognitive LLM-driven architecture for automatic heuristic design, Expert Systems with Applications 330:133022 (2026).
AuthorsOpenReview ↗

Request for Reviewer Follow-up Before the Discussion Deadline

Dear Reviewer,

Thanks for your time and effort in reviewing this paper. Your comments are valuable to improve the quality of this paper. As the author–reviewer discussion period will end in about 1 day, we gently request that you read the rebuttal and check whether your concerns are addressed. Thanks again for your time and help in improving the quality of this paper.

Regards from the authors.

Thank you for the additional experiments. The revised schedule, allocation-matched control, trace ablation, and hybrid comparisons substantially address my main concern. Please clarify reflection-call matching and uncertainty in the matched control, and qualify the unequal-budget comparisons and limited ACS generalization. The new allocation-matched comparison provides evidence that this organization improves performance, and I am raising my initial rating accordingly.

However, I believe the technical novelty remains incremental: ReEvo already uses accumulated reflection to guide evolutionary search; MeEvo’s distinction is organizing these mechanisms into separate, cyclically coupled phases.

AuthorsOpenReview ↗

Response to Reviewer qLtP

Dear reviewer:

We thank you for taking the time to re-examine the paper and for raising the rating. The comparison with ReEvo is the right one to draw: both methods reflect, and the difference lies in what the reflection reads and what it produces.

1. MeEvo evolves the design prompt; ReEvo evolves code with prompt hints.

In ReEvo the evolutionary unit is heuristic code: short-term reflection is written for one parent pair and inserted into the crossover prompt, and long-term reflection compresses accumulated hints into a string inserted into the elitist-mutation prompt (Ye et al., 2024, §4). Reflection conditions an operator. Each generation it produces is anchored to an existing individual, a parent pair or the elite, and the only persistent artifact of reflection is the compressed hint string, which is never itself searched or evaluated. The search remains single-level, over code.

MeEvo adds a prompt level, and this is prompt evolution: what evolves is the design guidance behind the code, not the code itself. ME reads shared history (traces TH, fitness F, errors ERR, incumbent h*) and writes a Meta Insight stating what to change and why; that insight is the unit that improves from round to round. It is mapped to a batch of N_pop heuristics, generated from the insight rather than by recombining selected parents, and because the batch returns to the NE pool and its outcomes feed the next ME round, the prompt level accumulates across cycles.

ReEvo reflects on algorithms: its input is a pair of heuristics in code with their relative scores, and its accumulated object is the hint string those comparisons produce. ME reflects on how the algorithms were designed: its input is the shared history of reasoning traces, the fitness trajectory, error records and the incumbent, and its output is a Meta Insight mapped to a batch. Code is the object under comparison in ReEvo; in ME it is a reference point and the form the batch takes. ReEvo's accumulation therefore conditions an operator and is never evaluated in its own right, whereas the insight is what ME searches over, measured through the batch it produces. That batch enters NE recombination rather than remaining a variation of one parent. The matched control tests that return path, and the schedule comparison tests when it runs.

2. Matched control: call matching. The control pairs 4NE→4ME with cyclic (1,1) at N0=20, L=100: both use 20 initial + 40 NE + 40 ME evaluations and four ME reflection calls, with identical prompts, operators, backbone and five runs, so only the return path differs. One ME block is one reflector call followed by one batch of ten candidates; model calls are matched by construction.

Arm (L=100, five runs)TSP-ACOBPP-ACO
4NE→4ME (terminal)5.772 ± 0.04204.44 ± 0.53
Cyclic (1,1), matched5.747 ± 0.01204.00 ± 0.92

Both means fall, as do the best values (5.738→5.733; 203.80→203.60). The gaps (0.025 and 0.44) do not exceed one SD in either arm (0.04/0.01; 0.53/0.92); the direction is the same on both tasks. NE-first also beats ME-first (5.772/204.44 vs 5.794/204.68), and the default (2,1) with a different allocation is lower still (5.716/203.28). The trace ablation isolates the shared-history input: removing traces while keeping code and fitness gives 5.873/205.28/625.83/62.43 vs 5.716/203.28/554.29/50.00.

3. Unequal budgets. Design and deployment costs are reported separately (§4.3): Table 6 gives tokens, program evaluations and wall-clock time, and Table G11 charges every objective call of five search runs, including repairs. Per algorithm, a generated heuristic is executed with 1,000 ACS or 5,000 WSN calls, whereas a classical baseline runs its full configuration, 15,000 or 100,000 calls (30×500; 100×1,000), so the per-algorithm evaluation budget is not larger for the heuristics we generate. In total, all AHD methods use L=100 primary evaluations; under the full count MeEvo uses 0.50M/2.60M calls versus 0.50M/2.50M for FunSearch, EoH and ReEvo and 0.54M/2.80M for MeLA. MeEvo attains the lowest objective on both tasks whether costs are counted per algorithm or in full, so the ranking is unchanged by the accounting choice.

4. ACS generalization. The ACS experiment uses the established 30-learner OULAD instance; its 30 executions measure search-time quality and restart stability, and the three 10-learner cohorts are disjoint subsets of the same learners. The ACS numbers are therefore search-time results. Held-out evaluation is reported for TSP-ACO and BPP-ACO (64 unseen instances at n=100/1000) and for WSN on five fresh layouts (25/25 at the lower bound).

References.

Ye, H., et al. (2024). ReEvo: Large Language Models as Hyper-Heuristics with Reflective Evolution. NeurIPS 37, 43571–43608.

Qiu, Z., et al. (2026). MeLA: A metacognitive LLM-driven architecture for automatic heuristic design. Expert Systems with Applications 330, 133022.

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

This paper introduces MeEvo, an automatic heuristic design(AHD) framework that couples LLM-driven population-based Natural Evolution (NE) with a Metacognitive Evolution (ME) phase operating on shared search history. NE generates candidates via LLM-mediated crossover and mutation, while ME distills accumulated reasoning traces, fitness values, execution errors, and the current best heuristic into meta-insights that guide subsequent candidate generation. The framework is evaluated on five optimization tasks using two LLM backbones, with baseline comparisons, ablations, and cost analyses.

Critical strengths

The core idea of coupling history-level reflection with population-based search is well-motivated. Table 3 offers preliminary evidence that the two phases are complementary, as coupled configurations consistently outperform standalone NE and ME baselines. The empirical evaluation is reasonably broad, covering five tasks and two LLM backbones, including constrained domains like ACS and WSN, which helps assess the method beyond standard benchmarks.

Critical weaknesses
  1. The methodological novelty is not yet convincingly established relative to closely related approaches. MeEvo combines evolutionary variation and history-conditioned reflection, both established in LLM-based AHD. Although the paper discusses related hybrids like EoH-MR and PyVRP+, it provides no quantitative comparison with them on compatible settings. It is therefore difficult to determine what is specifically gained from the proposed cyclic phase architecture, as opposed to using reflection integrated as an auxiliary component of evolutionary search, or from additional LLM computation and prompt design.

  2. The experimental evidence for the claimed cyclic feedback mechanism is incomplete. Under the default settings (N0=20, Npop=10, N=2, M=1) and L=50, the budget for BPP-ACO, ACS, and WSN is exhausted after two NE generations and one ME generation, meaning the default runs do not test the benefit of feeding ME-refined candidates back into a subsequent NE phase. While Table 3 supports the general value of combining the phases, the ablation schedules vary reflection timing and, in some configurations, candidate allocation; the (1,1) variant includes an ME-to-NE step but does not isolate its contribution. Furthermore, repair evaluations are excluded from the primary budget L, so equal budgets do not imply equal total computational effort. A matched-budget comparison that isolates recurrent feedback and reports full-run costs would strengthen the claims.

Questions for authors

I currently lean toward weak rejection. Clarification of the following points could affect my assessment:

  1. What is the specific benefit of a dedicated cyclic reflection phase compared to reflection integrated as an auxiliary component of evolutionary search, as in EoH-MR or PyVRP+? Can you provide a controlled comparison on compatible tasks or a more direct mechanism-level ablation?

  2. For the L=50 tasks, can you confirm the exact phase sequence and per-phase candidate counts? Can you isolate the contribution of subsequent ME-to-NE feedback under a matched budget, and report the total number of primary and repair evaluations, LLM tokens, and runtime to enable a fair cost comparison?

2 comments
AuthorsOpenReview ↗

Response to Reviewer 2: Local-Search ME, Cyclic ME–NE Coupling, and Cost Evidence

Dear reviewer:

We clarify ME's prompt-level local-search role (Gap 1, P2; Section 3.1, P3) and add matched-budget, expanded-budget, and cost evidence.

1. What the dedicated cyclic ME phase adds beyond auxiliary reflection

ME is an independent prompt-level local-search phase, not a second population-based EA: it has no internal population, survival, crossover, or mutation. It maps shared history (traces, fitness, errors, best heuristic) to a Meta Insight, then to a batch of locally improved heuristics. ME thus refines the prompt-level thought process that generates algorithms, not a code population. Each ME batch returns to the NE pool for recombination and renewed global search.

EoH-MR (Qi et al., 2025) uses CMA-ES plus metacognitive operator/template adjustment; PyVRP+ (Malik et al., 2026) applies Reason-Act-Reflect to individual solutions. Their reflection is auxiliary control inside an existing loop, not a separately budgeted local-search phase. MeEvo's global NE -> local ME -> global NE loop prevents ME's trajectory lock-in and preserves local designs that global search may miss, improving search performance.

Setting (P9 Table 3; L=100)TSP-ACO mean ± SD [best]BPP-ACO mean ± SD [best]
EoH-MR5.802 ± 0.01 [5.783]204.48 ± 0.93 [203.40]
EvoPH (Liu et al., 2025)5.816 ± 0.02 [5.790]204.08 ± 0.36 [203.80]
PyVRP+5.793 ± 0.02 [5.773]203.84 ± 0.58 [203.20]
4NE->4ME5.772 ± 0.04 [5.738]204.44 ± 0.53 [203.80]
4ME->4NE5.794 ± 0.02 [5.779]204.68 ± 0.46 [204.20]
5NE->3ME5.753 ± 0.02 [5.739]204.04 ± 0.64 [203.60]
5ME->3NE5.758 ± 0.01 [5.748]204.84 ± 0.32 [204.40]
Cyclic (2,1), MeEvo5.716 ± 0.003 [5.712]203.28 ± 0.97 [202.40]

Table 3 fixes descriptions, repair support, DeepSeek, L=100, and five runs; one-shot and cyclic rows share prompts, operators, and N0=20. MeEvo has the lowest mean/best value against all references, 1.33%/0.27% below PyVRP+, and cyclic (2,1) beats every one-shot schedule. Against the best one-shot 5NE->3ME, it improves TSP/BPP from 5.753/204.04 to 5.716/203.28 (0.64%/0.37%); NE-first also beats ME-first in both splits, supporting global exploration before local refinement. One-shot schedules have at most one ME-NE transition; cyclic repeats it, preserving local gains while restoring global search. On ACS/WSN, hybrids had too many execution/interface/constraint errors for five-run estimates; MeEvo ran all five problems.

2. L=50 confirmation, expanded L=100 experiment, and full cost

With N0=20 and Npop=10, each (2,1) cycle uses 30 primary evaluations (20 NE + 10 ME).

BudgetPhase sequencePrimary evalsME->NE returns
L=5020 init + 2NE x 10 + 1ME x 10500
L=10020 init + [2NE x 10 + 1ME x 10] x 2 + 2NE x 101002

At L=50 ME is terminal (no return); we therefore expanded the evaluation budget from L=50 to L=100, where every ME batch returns to NE twice. Updated results:

Problem (P7 Table 1)MeEvo (DeepSeek)MeLA (DeepSeek)MeEvo (MIMO)MeLA (MIMO)
TSP-ACO5.716 ± 0.0035.828 ± 0.015.718 ± 0.015.824 ± 0.01
BPP-ACO203.28 ± 0.97204.16 ± 0.72203.40 ± 0.96203.68 ± 0.36
ACS554.29 ± 8.92568.32 ± 10.16558.08 ± 9.36579.16 ± 11.85
WSN50.00 ± 0.0054.19 ± 0.8750.00 ± 0.0055.12 ± 1.31

MeEvo has the lowest mean in all eight cells. Table 6 (P10) reports five-run means:

ProblemMeEvo tokens (k) / evals / time (s)MeLA (Qiu et al., 2026) tokens (k) / evals / time (s)
TSP-ACO400 / 102 / 320380 / 110 / 300
BPP-ACO350 / 104 / 350400 / 146 / 500
ACS420 / 100 / 420400 / 108 / 450
WSN380 / 104 / 480300 / 112 / 500

Primary evaluations are 100 for both; totals imply 2/4/0/4 repairs for MeEvo versus 10/46/8/12 for MeLA. Objectives are 1.92%/0.43%/2.47%/7.73% lower while total evaluations are lower on every task. BPP saves 50k tokens/150 s; ACS/WSN save 30/20 s at +20k/+80k tokens; TSP adds 20k/20 s but saves 8 evaluations. Cyclic alternation thus gives higher quality with fewer evaluations under the same primary budget; BPP also saves tokens and runtime. We therefore adopt MeEvo to maximize search performance.

References.

  • Qi et al., A memetic and reflective evolution framework for automatic heuristic design using large language models, Applied Sciences 15(15):8735 (2025).
  • Malik et al., PyVRP+: LLM-driven metacognitive heuristic evolution for Hybrid Genetic Search in Vehicle Routing Problems, arXiv:2604.07872 (2026).
  • Liu et al., Experience-guided reflective co-evolution of prompts and heuristics for automatic algorithm design, arXiv:2509.24509 (2025).
  • Qiu et al., MeLA: A metacognitive LLM-driven architecture for automatic heuristic design, Expert Systems with Applications 330:133022 (2026).
AuthorsOpenReview ↗

Request for Reviewer Follow-up Before the Discussion Deadline

Dear Reviewer,

Thanks for your time and effort in reviewing this paper. Your comments are valuable to improve the quality of this paper. As the author–reviewer discussion period will end in about 1 day, we gently request that you read the rebuttal and check whether your concerns are addressed. Thanks again for your time and help in improving the quality of this paper.

Regards from the authors.

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

Paper introduces MeEvo, an LLM-based framework for automatic heuristic design that alternates population-based code evolution with reflection on accumulated search history. The population phase generates candidates through LLM-mediated crossover and mutation. The reflection phase summarizes reasoning traces, fitness outcomes, execution errors, and the best heuristic into “Meta Insights”. A predetermined linear schedule changes crossover and mutation probabilities during search. The evaluation with two LLM backbones and five independent runs. MeEvo achieves the best reported mean objectives on the four main tasks, with particularly encouraging results on the constrained applications.

Critical strengths
  • MeEvo achieves the best reported means among the tested LLM architectures on all four tasks under both backbones. This supports the practical value of the combined search-and-reflection procedure beyond a single classical benchmark.
  • Useful component ablations and implementation disclosure. The supplied prompts, algorithms, and generated code make the approach verifiable
Critical weaknesses
  • The architectural novelty and benefit of cyclic feedback are insufficiently established. Existing frameworks already combine evolutionary search with reflection. Moreover, under a small budget (L=50). I am concerned that initialization, NE generations, and ME batch exhaust the budget. So ME-generated heuristics return to NE is limited. These experiments therefore do not clearly show the benefit of the proposed repeated feedback cycle over a simpler approach.
  • The comparisons do not establish performance under comparable computational resources. Repair evaluations are excluded from the primary budget, and generated heuristics can perform substantial additional computation.
Questions for authors
  1. What training, validation, and test splits are used for each task?
  2. Why are closely related hybrid frameworks such as EoH-MR and EvoPH discussed but not evaluated? Would MeEvo retain its advantage against these methods with equivalent problem descriptions, repair support, and computational budgets?
  3. Please distinguish heuristic-design cost from the cost of applying the resulting heuristic. Can you report objective quality against cumulative tokens, total wall-clock time, and total program evaluations for each task?
  4. From tables 3 & 4, are smaller improvements from individual components distinguishable from variation across runs, and does reflection still help when reasoning traces are removed while code and fitness feedback are retained?
2 comments
AuthorsOpenReview ↗

Response to Reviewer 1: Data Splits, Cyclic ME–NE Feedback, Baselines, Costs, and Ablations

Dear reviewer: We have clarified the L=50/L=100 schedule and added the requested baseline, cost, and trace-ablation results.

1. Cyclic feedback with L=100. At L=50, N0=20 and Npop=10, the schedule ends at ME (20 initial + 20 NE + 10 ME), so no ME batch returns to NE. We expanded to L=100 (20 initial + 2x[20 NE + 10 ME] + 20 NE), giving two returns. We show a subset below; the full results are in Table 1 (P7):

Problem (P7 Table 1)MeEvo (DeepSeek)MeLA (DeepSeek)MeEvo (MIMO)MeLA (MIMO)
TSP-ACO5.716 ± 0.0035.828 ± 0.015.718 ± 0.015.824 ± 0.01
BPP-ACO203.28 ± 0.97204.16 ± 0.72203.40 ± 0.96203.68 ± 0.36
ACS554.29 ± 8.92568.32 ± 10.16558.08 ± 9.36579.16 ± 11.85
WSN50.00 ± 0.0054.19 ± 0.8750.00 ± 0.0055.12 ± 1.31

MeEvo has the lowest mean in all eight cells; DeepSeek gains over MeLA are 1.92%, 0.43%, 2.47%, and 7.73% on TSP-ACO, BPP-ACO, ACS, and WSN. In the matched-budget control (Table 3, P9; same backbone, prompts, operators, N0=20, five runs), cyclic (2,1) improves TSP-ACO/BPP-ACO from 5.753/204.04 to 5.716/203.28 over terminal 5NE->3ME (0.64%/0.37%).

2. Training and test splits. AHD searches over code rather than model parameters. The train/test allocation is:

Task (P6 §4.1; P34 Table G4)TrainTest
TSP-ACOn=5064 held-out n=100
BPP-ACOn=50064 held-out n=1000
TSP-Construct64 n=5064 held-out at n=50/100/200
ACSNoNo
WSNNoNo

ACS and WSN directly solve fixed real-world instances without a split (Martins et al., 2021; Chen et al., 2024).

3. Hybrid frameworks. ME is a separate prompt-level phase: it writes a Meta Insight, turns it into a new batch, and returns the batch to NE. Auxiliary reflection instead only guides the next step inside an existing loop. EoH-MR, EvoPH, and PyVRP+ were run under the same descriptions, repair support, L=100, backbone, and five runs:

Method (P9 Table 3)TSP-ACOBPP-ACO
EoH-MR5.802 ± 0.01 [5.783]204.48 ± 0.93 [203.40]
EvoPH5.816 ± 0.02 [5.790]204.08 ± 0.36 [203.80]
PyVRP+5.793 ± 0.02 [5.773]203.84 ± 0.58 [203.20]
MeEvo5.716 ± 0.003 [5.712]203.28 ± 0.97 [202.40]

MeEvo has the lowest mean and best value on both. On ACS/WSN, the hybrids had too many execution/interface/constraint errors to evaluate reliably, so we report them on TSP-ACO/BPP-ACO; MeEvo covers all five.

4. Cost and performance. L=100 counts design evaluations. Table 6 (P10) reports cumulative LLM tokens, all program evaluations (including repairs), and wall-clock time over five runs:

Problem (P10 Table 6)MeEvo tokens (k) / evals / time (s)MeLA tokens (k) / evals / time (s)
TSP-ACO400 / 102 / 320380 / 110 / 300
BPP-ACO350 / 104 / 350400 / 146 / 500
ACS420 / 100 / 420400 / 108 / 450
WSN380 / 104 / 480300 / 112 / 500

Versus MeLA, objectives fall from 5.828/204.16/568.32/54.19 to 5.716/203.28/554.29/50.00 by 1.92%/0.43%/2.47%/7.73% (TSP/BPP/ACS/WSN). Evaluations fall by 8 on TSP-ACO/ACS/WSN and 42 on BPP-ACO (Table 1, P7; Table 6, P10); BPP-ACO saves 50k tokens/150 s, ACS/WSN save 30/20 s at +20k/+80k tokens, and TSP-ACO adds 20k tokens/20 s.

5. Component and reasoning-trace ablation. Removing reasoning traces while retaining code and fitness feedback produces the largest degradation:

Setting (P10 Table 5)TSP-ACOBPP-ACOACSWSN
No APA5.723 ± 0.01203.32 ± 0.43562.13 ± 8.7352.35 ± 1.05
No ED5.724 ± 0.01203.84 ± 1.34558.57 ± 10.3551.83 ± 0.46
No reasoning trace5.873 ± 0.02205.28 ± 0.43625.83 ± 10.7262.43 ± 3.77
Full MeEvo5.716 ± 0.003203.28 ± 0.97554.29 ± 8.9250.00 ± 0.00

Removing reasoning traces makes performance worse: the mean objective increases from 5.716/203.28/554.29/50.00 to 5.873/205.28/625.83/62.43 (+2.75%/+0.98%/+12.91%/+24.86%; TSP/BPP/ACS/WSN), with gaps larger than run-to-run SD on every task. Reflection therefore needs accumulated reasoning traces; code and fitness alone are not enough. APA and ED, adapted from MeLA (Qiu et al., 2026), mainly add convenience and robustness; their performance changes are small and mostly within or close to run-to-run SD, so we treat them as supporting features. See Table 5 (P10) for all means and SDs.

References.

  • Martins et al., A comparative analysis of metaheuristics applied to adaptive curriculum sequencing, Soft Computing 25(16):11019-11034 (2021).
  • Chen et al., Optimizing k-coverage in energy-saving wireless sensor networks based on the Elite Global Growth Optimizer, Expert Systems with Applications 256:124878 (2024).
  • Qiu et al., MeLA: A metacognitive LLM-driven architecture for automatic heuristic design, Expert Systems with Applications 330:133022 (2026).
AuthorsOpenReview ↗

Request for Reviewer Follow-up Before the Discussion Deadline

Dear Reviewer,

Thanks for your time and effort in reviewing this paper. Your comments are valuable to improve the quality of this paper. As the author–reviewer discussion period will end in about 1 day, we gently request that you read the rebuttal and check whether your concerns are addressed. Thanks again for your time and help in improving the quality of this paper.

Regards from the authors.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.