| 24/30 |
2026-09-04 |
CoSkill: Joint Reinforcement Learning of Reasoning and Meta-Skill Agents for Hierarchical Skill EvolutionCoSkill introduces a multi-agent reinforcement learning framework where a Reasoning Agent and a Meta-Skill Agent are jointly trained to co-evolve a hierarchical skill library alongside the reasoning policy. The results are rigorously backed by empirical data, achieving state-of-the-art success rates of 98.4% on ALFWorld and 90.6% on WebShop while demonstrating superior sample efficiency. The key insight is treating the skill editor (the Meta-Skill Agent) as a learnable policy rather than a frozen LLM prompt, updating it via RL using post-edit verification success as a delayed reward. This is highly relevant for LLM evolutionary search and multi-agent optimization, as it provides a concrete, RL-backed methodology for 'evolving the evolver' and maintaining a high-utility persistent memory of discovered procedures. |
Jinyuan Feng et.al. |
ByteDance, Institute of Automation Chinese Academy of Sciences, Renmin University of China |
|
pdf / code
|
| 25/30 |
2026-09-02 |
RideSkill: A Hierarchical Algorithm for Generalized Ride Sharing with LLM-Driven Automatic EvolutionThis paper proposes RideSkill, a hierarchical ride-sharing dispatch algorithm where a skill repository, a skill combiner, and a vehicle repositioner are all generated offline via LLM-assisted evolutionary search. The results are backed by strong empirical evidence on large-scale NYC data (up to 1500 vehicles), outperforming MARL and prior LLM-based heuristics by 11-40% in reward while drastically reducing detour times. The key insight is the integration of a self-check audit loop where the LLM evaluates empirical rollout metrics against its intended design, alongside a zero-shot combiner that probes unknown objective functions at runtime to dynamically mix frozen skills. This is highly relevant for LLM evolutionary search and multi-agent optimization, as the self-auditing mechanism and multi-task fitness normalization directly address sample efficiency and search signal quality in automated algorithm design. |
Zijian Zhao et.al. |
Huawei, The Hong Kong University of Science and Technology |
|
pdf / code
|
| 24/30 |
2026-08-25 |
Recursive Experiential-Working Memory Evolution for Long-Horizon Agent HarnessesRecuris introduces a recursive memory evolution architecture that couples Working Memory (for task state tracking) with Experiential Memory (for skill storage), using structured execution traces to localize failures and apply validation-gated updates to specific memory components. The results are backed by rigorous empirical evidence, showing massive gains on long-horizon tasks (e.g., +17.8 points for GPT-5.6 Sol and +15.6 for Claude Opus 5 on the $\tau$2-Retail benchmark). The key insight is using structured execution traces to localize failures to specific harness components (skill content, state tracking, invocation trigger, or verification checker) rather than rewriting the entire memory or prompt, enabling highly targeted and stable evolutionary updates. This is highly relevant for LLM evolutionary search and multi-agent optimization, as it provides a concrete mechanism for persistent memory evolution, step-by-step credit assignment, and safe recursive self-improvement. |
Zhaochen Yu et.al. |
Princeton University, Stanford University, University of Oxford, NUS |
|
pdf / code
|
| 23/30 |
2026-08-25 |
RecurSE: Bounded Recursive Self-Evaluation for LLM Rubric JudgesRECURSE enables LLM judges to recursively self-improve via RL by using a synchronized copy of the policy as a process checker to provide scalar rewards, eliminating the need for external reward models. The method is backed by strong empirical results across Qwen and Gemma models, showing significant improvements on held-out transfer benchmarks like HealthBench and CheckEval. The key insight is 'interface decoupling'—structurally separating the judge's output format (YES/NO tokens) from the checker's reward format (0-4 scalar) to prevent the policy from exploiting token-copying shortcuts during self-play. Furthermore, tracking checker ranking fidelity on a small holdout set reliably prevents over-optimization. This is highly relevant for our work on process reward models and RL-infused search, providing a concrete mechanism to train reliable process evaluators without massive human annotation. |
Kaiyuan Liu et.al. |
Zhejiang University, Meituan LongCat Team |
|
pdf / code |
| 27/30 |
2026-08-24 |
FormuEvo: LLM-Guided Evolution for Discovering Solver-Efficient Mixed-Integer Programming FormulationsFormuEvo is an LLM-guided evolutionary framework that discovers solver-efficient mixed-integer programming (MIP) formulations by searching the symbolic space of executable modeling programs. Backed by strong empirical results, it accelerates solvers by up to 5.5x compared to expert-designed formulations and existing LLM-based cutting plane generation baselines across diverse OR benchmarks. THE KEY INSIGHT is the 'solver-informed diagnosis' mechanism, which translates fine-grained solver statistics (e.g., root gap, branch-and-bound node count, presolve reductions) into interpretable verbal gradients to guide LLM mutation, coupled with a structured memory of Condition-Strategy-Effect triplets. This is highly relevant to our work in LLM evolutionary search; adopting internal solver statistics as dense feedback signals rather than relying solely on end-to-end runtime fitness can drastically improve sample efficiency and search direction. |
Haofeng Yuan et.al. |
Tsinghua University, Nanyang Technological University, Singapore Management University |
the Proceedings of EMNLP 2026 |
pdf / code
|
| 25/30 |
2026-08-24 |
Autonomous Mathematical Discovery in an Open-World Multi-Agent EnvironmentThis paper introduces an open-world multi-agent environment where LLMs autonomously conduct mathematical research, write papers, and build on shared literature to solve complex construction problems. The results are rigorously backed by numbers, with the system discovering novel infinite families and exact configurations that outperform AlphaEvolve on several benchmarks (e.g., a 604-point kissing configuration in d=11). The key insight is that replacing rigid evolutionary pipelines with a persistent 'Archive Room' (shared memory) and 'Stagnation/Holiday' protocols allows agents to escape local optima and accumulate knowledge across generations. This is highly relevant for our work in LLM evolutionary search and multi-agent optimization, as adopting shared literature memory and stagnation-breaking mechanisms could significantly improve sample efficiency and prevent idea stagnation in automated heuristic discovery. |
Stephen Chung et.al. |
University of Cambridge, University of California San Diego, University of Hong Kong, DualverseAI |
|
pdf / code
|
| 23/30 |
2026-08-21 |
AsmEvo: Agentic Assembly-Level Optimization of AMD GPU Kernels with Functional Equivalence VerificationAsmEvo uses a long-horizon LLM agent to optimize compiled AMD GPU kernels at the assembly level, relying on the original binary as a differential oracle to verify functional equivalence before measuring performance. The paper presents strong empirical results on real hardware (MI308X/MI300X), achieving up to 3.88x speedups on KernelBench and 1.18x geometric-mean speedups on production vLLM/SGLang Triton kernels. The key insight is the strict separation between the LLM proposer and a deterministic, correctness-gated verification harness (using real-dispatch capture for a non-hackable fitness signal), which prevents the search from exploiting fast but incorrect programs. This is highly relevant for our work in LLM evolutionary search and LLM serving optimization, as the architecture for verified composition and anti-stall memory can be directly adapted to improve the robustness and sample efficiency of our own agentic search frameworks. |
Ji Liu et.al. |
Advanced Micro Devices, Inc. (AMD), Southern University of Science and Technology |
|
pdf / code |
| 24/30 |
2026-08-19 |
Eureka: Task-Conditioned Meta-Agent Orchestration for Scientific DiscoveryManXis introduces Eureka, a task-conditioned Meta-Agent architecture that dynamically compiles long-horizon tasks into obligation graphs and forms specialized Macro-Agents with tailored state, memory, and verifiers during execution. The results are backed by extensive empirical validation, including a 57.8% reduction in median context usage across 12,000 dependency-update tasks and successful application to open mathematical conjectures. The key insight is governed evolution: rather than continuously mutating the agent, the system uses a mathematically grounded cost-benefit threshold to trigger architecture evolution only when the expected amortized savings exceed the fixed cost of diagnosis and migration. This is highly relevant to LLM evolutionary search and multi-agent optimization, as it provides a rigorous, actionable framework for improving sample efficiency, managing persistent memory, and dynamically scaling agent architectures. |
Alizer Wong et.al. |
Duke University, Shanghai Jiao Tong University, Hokkaido University, South China Normal University, Guangdong University of Technology, ManXis |
|
pdf / code
|
| 19/30 |
2026-08-17 |
Improving the matrix multiplication exponent with modern optimization and AlphaEvolveThis paper applies gradient-based optimization and AlphaEvolve to the combination loss analysis problem, improving the theoretical upper bound on the matrix multiplication exponent to ω < 2.371177. The results are rigorously verified using rational arithmetic, proving a genuine state-of-the-art advance over the previous 2.371339 bound. The key insight for LLM evolutionary search is the preparation pipeline: the authors relaxed discrete max-entropy constraints into a differentiable tensor program using the Sinkhorn-Knopp algorithm and Jax, enabling hardware parallelization up to 7 million parameters. They then applied AlphaEvolve using 'evolving constructions' to iteratively refine the optimizer while passing the best solution state between generations. This is highly relevant for our work, as it demonstrates how to successfully scale LLM-driven algorithm discovery for massive, highly constrained combinatorial problems. |
Emilien Dupont et.al. |
Google DeepMind, MIT, Carnegie Mellon University, Columbia University |
|
pdf / code |
| 23/30 |
2026-08-17 |
GoalEvolve: From Handcrafted Algorithm Priors to Goal-Driven Evolution of Physical Design AlgorithmsGoalEvolve is an LLM-based evolutionary search framework that optimizes physical design algorithms by targeting final full-flow metrics rather than stage-local objectives. The results are backed by strong empirical evidence, demonstrating a 30.67% improvement in total negative slack over default OpenROAD and outperforming standard Codex goal mode under matched evaluation budgets. The key insight is the use of 'effect-debt analysis' combined with an Evolutionary Program Database (EPD), which tracks whether a local algorithmic change causes downstream degradation and stores this as persistent mechanism memory to guide future LLM prompts. This is highly relevant to our research in LLM evolutionary search; the team can adapt the EPD and effect-debt tracking to improve sample efficiency and credit assignment in our own multi-stage optimization pipelines, such as routing or scheduling. |
Haixu Liu et.al. |
Fudan University |
|
pdf / code |
| 25/30 |
2026-08-17 |
Competing at Every Price Point with Agentic Evolution over a Menu of LLMsBorthwick introduces a cost-targeted evolutionary meta-agent that writes Python programs utilizing a menu of differently-priced LLMs to optimize the cost-accuracy Pareto frontier. The results are highly rigorous, Pareto-dominating nearly all baselines (including hand-engineered systems) on two AstaBench tasks using only 66 to 100 training examples. The key insight is that exposing a priced menu of LLMs to the evolutionary search and using a graded cost-penalty objective (pricing cost overages in error-equivalents) naturally forces the discovery of cheap-first cascades and selective strong-model escalation. This is essential reading for our work in LLM evolutionary search and multi-agent optimization, as it provides a concrete, proven mechanism for managing inference costs and sample efficiency during automated agent design. |
Andrew Borthwick et.al. |
|
|
pdf / code |
| 27/30 |
2026-08-12 |
$\varepsilon$-MemEvo: Adaptive Cross-Task Memory Transfer for LLM Program Evolutionε-MemEvo introduces a cross-task memory framework for LLM program evolution that stores natural-language strategy summaries from prior tasks and uses a contextual Thompson Sampling gate to control their injection into new tasks. The results are rigorously backed by empirical data, demonstrating an 8.7% improvement in convergence area (AUCC) and a 9.4% boost in early-stage convergence across 8 optimization benchmarks using GPT-5. The key insight is that cross-task memory transfer in evolutionary coding is fundamentally a safety problem; naive memory injection causes catastrophic negative transfer, but an adaptive bandit gate successfully suppresses mismatched tactics while retaining the benefits of aligned ones. This is exceptionally relevant to our research in LLM evolutionary search, providing a concrete, low-overhead mechanism to safely reuse algorithmic discoveries across different optimization domains without sacrificing search stability. |
Aofan Liu et.al. |
|
|
pdf / code |
| 26/30 |
2026-08-11 |
MEGA: Self-Evolving Agent Optimization Infrastructure via Wisdom GraphMEGA is a three-layer infrastructure for self-evolving agent optimization that distills execution traces into a structured 'Wisdom Graph' and uses a multi-agent loop to iteratively improve agent workflows. The results are backed by strong empirical numbers, achieving a 76.55 aggregate score on four benchmarks (HotpotQA, IFBench, HoVer, PUPA) and outperforming SOTA optimizers like GEPA and TextGrad. The key insight is the 'Seed-Epoch' evaluation regime—which fixes the evaluation seed during an optimization epoch to eliminate data variance and isolate the true impact of strategy changes—alongside the decomposition of memory into atomic Primary-Context-Resultant (PCR) triplets for logical reasoning. This is highly relevant to our work in LLM evolutionary search and multi-agent optimization, offering concrete architectural blueprints for persistent memory and reliable fitness attribution across search runs. |
Jung Hwan Lee et.al. |
megacode.ai |
|
pdf / code
|
| 24/30 |
2026-08-09 |
Hierarchical Self-Improvement: A Framework for Task-Specific Evolvable Agent HarnessesZhou introduces Hierarchical Self-Improvement (HSI), a framework where a single frozen LLM evolves both its task-specific execution harness and the evolutionary search strategy used to improve that harness. The results are backed by strong empirical evidence on the BALROG benchmark, showing massive gains (e.g., +39.3% on BabyAI, +33.0% on Crafter) using DeepSeek-V4-Flash, with ablation studies proving that evolving the search strategy itself contributes significantly to the performance. The key insight is the three-layer hierarchical architecture (task harness, evolver, meta-evolver) bounded by a frozen outer anchor, which allows the system to safely rewrite its own seed selection and commit policies without unbounded self-reference. This is highly relevant to our work in LLM evolutionary search, as it provides a concrete, implementable blueprint for 'evolving the evolver' to improve search efficiency and discovery quality. |
Tailin Zhou et.al. |
HKUST |
|
pdf / code
|
| 25/30 |
2026-08-07 |
PACE: Primitive-Aware Code Evolution for Automated Algorithm DesignXie et al. introduce Primitive-Aware Code Evolution (PACE), which improves LLM-based automated algorithm design by extracting and preserving useful local logic as reusable Executable Algorithmic Primitives (EAPs). The method demonstrates strong empirical results, outperforming recent baselines like ReEvo and MCTS-AHD on zero-shot transfer for TSP (e.g., achieving a cost of 28.13 vs 50.29 on 1000-node TSP-ACO) and continuous control tasks. The key insight is using Thompson Sampling to evaluate the parent-relative performance improvement of individual EAPs, effectively solving the credit assignment problem for sub-components without requiring extra evaluation budgets. This is highly relevant to our work in LLM evolutionary search, as it provides a concrete, implementable architecture for persistent memory and modular code generation that directly improves search efficiency. |
Zhuoliang Xie et.al. |
Southern University of Science and Technology, Shenzhen University |
|
pdf / code |
| 25/30 |
2026-08-06 |
Relay, Don't Route: Adaptive Population Handoff for Cost-Efficient LLM-Driven EvolutionRelayEvolve is a training-free framework that reduces the cost of LLM-driven evolutionary search by using a cheap model to explore and curate a quality-diverse population, which is then handed off to a strong model for refinement. The results are backed by solid empirical evidence, showing it outperforms single-model and call-level routing baselines in 11 of 12 budget-benchmark settings across four program evolution tasks. The key insight is that because evolutionary search is stateful, budget allocation should focus on population handoff rather than individual mutation steps; cheap models can efficiently capture front-loaded progress to build a diverse seed bank. This is highly relevant for our research in LLM evolutionary search, offering a concrete, implementable strategy to drastically reduce API costs while maintaining or improving search quality. |
Sichun Luo et.al. |
Carnegie Mellon University, The University of Hong Kong, City University of Hong Kong, JIUTIAN Research, China Mobile |
|
pdf / code |
| 24/30 |
2026-08-04 |
MuEvo: LLM-Driven Evolution of Multi-Heuristic EnsembleMuEvo introduces an LLM-driven co-evolutionary framework that simultaneously optimizes multiple interacting heuristics within an algorithmic solver (like ACO or Selection Hyper-Heuristics) rather than isolating a single component. The results are backed by extensive numerical evidence across TSP, CVRP, BPP, and Flowshop, showing consistent improvements over human-designed defaults and single-component LLM-AHD baselines (e.g., reducing the TSP-L optimality gap from 6.26% to 5.24%). KEY INSIGHT: To prevent a component from overfitting to a specific set of collaborators, candidate heuristics should be evaluated across multiple contexts (e.g., the current best ensemble, the initial ensemble, and a diverse secondary ensemble), while an LLM summarizes cross-component interaction history to guide joint pair evolution. This is highly relevant to our work in LLM evolutionary search; the multi-ensemble evaluation and dynamic component lifecycle directly address the co-adaptation challenges we face when evolving complex, multi-operator routing and scheduling solvers. |
Haoze Lv et.al. |
Southern University of Science and Technology, The Hong Kong University of Science and Technology |
|
pdf / code |
| 27/30 |
2026-08-01 |
DGA$_2$D: Directed Graph-Guided Automated Algorithm Design with Large Language ModelsDGA2D is an LLM-driven automated algorithm design framework that represents the search space as a directed graph, allowing simultaneous evolution of both the algorithmic pipeline structure and the underlying operator implementations. The results are rigorously backed by numbers across 12 combinatorial optimization problems (including routing and scheduling), showing a reduction in the optimality gap by up to 10.96 percentage points compared to state-of-the-art baselines like EoH and ReEvo. The KEY INSIGHT is the first-order path-dependent credit assignment mechanism, which evaluates the fitness of a specific code implementation based on its immediate topological context (the preceding operator) rather than just the end-to-end score. This is highly relevant to our work in LLM evolutionary search, as it provides a concrete architectural upgrade over fixed-template generation and directly solves the sparse reward problem in long algorithmic pipelines. |
Jiale Zhao et.al. |
Beihang University |
|
pdf / code |
| 22/30 |
2026-07-31 |
MOT-SR: Multi-Objective Tool-Augmented Scientific Equation Discovery with Large Language ModelsWang et al. propose MOT-SR, an LLM-based evolutionary search framework for symbolic regression that uses a meta-strategy LLM to analyze data residuals with external tools and maintains a multi-objective Pareto front to guide equation generation. The results are rigorously backed by numbers, achieving state-of-the-art NMSE on 40 benchmark tasks and a 26.8x error reduction on a real-world astrophysics dataset compared to prior LLM-SR methods. The key insight is the 'Meta Strategy Generator' which autonomously invokes external analysis tools on the residuals of the current Pareto-optimal candidates to synthesize a natural language search strategy for the generator LLM, effectively acting as an automated planner for the evolutionary process. This is highly relevant for our work in LLM evolutionary search; the dual-LLM strategy-generation loop and their AST-based structural diversity sampling could be directly adapted to improve sample efficiency and population diversity in automated heuristic design. |
Boxiao Wang et.al. |
Institute of Automation, Chinese Academy of Sciences, University of the Chinese Academy of Sciences, Goethe University Frankfurt |
arXiv.org |
pdf / code
|
| 25/30 |
2026-07-31 |
MOSAIC: Adversarial Co-evolution of Specialist Heuristics and Problem Instances for LLM-based Automated Heuristic DesignMOSAIC introduces an adversarial co-evolution framework for LLM-based automated heuristic design, simultaneously evolving problem instances and specialist heuristics within a Quality-Diversity (QD) grid archive. The results are rigorously backed by numbers, showing up to a 52% reduction in optimality gap on TSP and 33% on CVRP compared to state-of-the-art methods like ReEvo and EoH-S. The key insight is replacing global scalar feedback with contrastive multi-directional reflection: an LLM analyzes pairs of heuristics on adversarially generated instances, and a decision tree anchors these insights to specific feature-space regions in the QD archive to form a persistent, region-aware memory. This paper is highly significant for LLM evolutionary search, as it provides a concrete, implementable architecture for improving sample efficiency, memory, and fitness signaling when discovering algorithms for combinatorial optimization. |
Oguzhan Gungordu et.al. |
Georgia Institute of Technology |
|
pdf / code |
| 27/30 |
2026-07-30 |
Frontis-MA1: Training an AI4AI Model towards Recursive Self-Improvement in Machine Learning EngineeringYang et al. introduce OpenMLE, a full-stack framework that post-trains an LLM via execution-grounded RL to act as the variation engine for long-horizon evolutionary search in machine learning engineering. The results are highly rigorous and backed by extensive numbers, showing their 35B model improving from a 39.4% to 71.2% medal rate on MLE-Bench Lite, surpassing GPT-5.5. The key insight is the meta-evolutionary loop: instead of using a frozen LLM, they explicitly train atomic operators (Draft, Improve, Debug, Crossover) using RL with adaptive bounds and entropic advantages, and deploy them in a search harness that uses multi-factor parent selection (quality, progress, novelty) and lazy, operator-conditioned memory synthesis. This is a must-read for LLM evolutionary search, as the structured experience cards and RL-infused operator training directly address the community's core challenges in sample efficiency, memory, and scalability. |
Junlin Yang et.al. |
Horizon Research, Frontis.AI, Tsinghua University, Zhejiang University, Shanghai Jiao Tong University, Georgia Institute of Technology |
arXiv.org |
pdf / code
|
| 24/30 |
2026-07-29 |
Budget-Aware LLM Discovery via Cost-Calibrated Frontier UtilityThis paper introduces CostAda, an adaptive controller for LLM evolutionary search that allocates compute across search frontiers based on cost-calibrated utility (progress divided by realized token cost) and remaining budget. The results are rigorously backed by empirical evaluations across 8 benchmarks using GLM-5 and GPT-5.4, demonstrating that CostAda reaches the full-budget quality of state-of-the-art baselines (AdaEvolve, EvoX) using only half the token budget. The key insight is that progress-only credit is fundamentally flawed when search actions (e.g., short refinements vs. long-context guidance) have vastly different token costs; dividing fitness gains by the log of realized cost and shifting weight from local to global progress as the budget drains drastically improves search efficiency. This is highly relevant to our focus on sample efficiency and scalability in LLM evolutionary search, providing a concrete, implementable utility formulation to optimize massively parallel evolution runs and reduce compute costs. |
Yansen Zhang et.al. |
Mohamed bin Zayed University of Artificial Intelligence (MBZUAI), City University of Hong Kong, International Digital Economy Academy (IDEA) |
arXiv.org |
pdf / code
|
| 23/30 |
2026-07-29 |
EvoPINN: Agentic Discovery of Executable Algorithms for Physics-Informed Neural NetworksEvoPINN is an LLM-driven evolutionary framework that autonomously discovers novel neural architectures and training programs for Physics-Informed Neural Networks (PINNs). Backed by rigorous empirical results, the framework evaluated only 56 candidates to discover algorithms that outperformed expert-designed baselines by up to 35% on complex PDE benchmarks. The key insight is its decoupled, module-wise evolution strategy: it uses a UCB scheduler to dynamically allocate LLM mutation budget between different algorithm components, combined with AST-based structural verification to filter out cosmetic LLM edits before triggering expensive evaluations. This is highly relevant for LLM evolutionary search research, as the telemetry-guided generation and modular credit assignment directly address the sample efficiency and sparse reward challenges inherent in automated heuristic discovery. |
Peng Yin et.al. |
Institute of Automation, Chinese Academy of Sciences, University of Chinese Academy of Sciences |
arXiv.org |
pdf / code |
| 23/30 |
2026-07-29 |
FunL2O: LLM-Guided Feature Function Design for Learning to OptimizeFunL2O uses an LLM in an evolutionary loop to automatically generate executable feature extraction code for Learning-to-Optimize (L2O) pipelines, replacing hand-crafted representations. Results are rigorously backed by numbers, showing consistent improvements across eight L2O baselines (e.g., reducing MILP solver wall time by 11-55% and LP objective gaps by 16-49%) while controlling for feature width and LLM sampling budgets. The key insight is the use of 'semantic feature contracts' to statically and dynamically validate LLM-generated tensor operations before triggering expensive model retraining, effectively constraining the search space. This is highly relevant to our work in LLM evolutionary search for operations research, demonstrating that evolving the state representation can be just as impactful as evolving the heuristic itself. |
Bingheng Li et.al. |
IBM Research, University of Southern California, University of Wisconsin–Madison, Michigan State University |
arXiv.org |
pdf / code |
| 20/30 |
2026-07-28 |
A Control System, a Dataset, and a Recipe for Making Frozen LLM Agents Learn a DomainThis paper formulates LLM agent harness optimization (prompts, tools, memory, planning) as a discrete control problem and evaluates online RL (bandits, REINFORCE) against a static DSPy-optimized baseline. Backed by rigorous empirical results across multiple domains and models, the authors find that online RL consistently underperforms the static DSPy baseline within practical episode budgets (e.g., 62% vs 96% success on tool-use). The key insight is that starting online controllers from a uniform prior over a discrete harness space is severely sample-inefficient; dynamic harness optimization must be bootstrapped from a metric-guided static optimizer to be viable. This is highly relevant for our work in LLM evolutionary search and agent optimization, as it provides concrete evidence on the sample efficiency bottlenecks of dynamic harness tuning and offers a practical deployment recipe. |
Debjyoti Paul et.al. |
|
arXiv.org |
pdf / code |
| 20/30 |
2026-07-27 |
VPR-Evolve: Multi-Agent-Driven Algorithm Evolution for FPGA Place and RouteWu et al. introduce VPR-Evolve, a multi-agent LLM framework that specializes FPGA place-and-route algorithms by directly evolving the tool's source code for specific hardware designs. The results are backed by rigorous empirical evaluation on VTR-9 benchmarks, showing up to a 9.8% reduction in critical-path delay and outperforming Bayesian hyperparameter tuning with significantly fewer evaluations. The key insight is the framework's architecture, which uses staged evolution to optimize different algorithmic components sequentially and employs an 'Inspiration Collector' agent that injects new literature-based ideas specifically when the search plateaus. This is highly relevant for our research in LLM evolutionary search, as the multi-agent memory and plateau-recovery mechanisms can be directly adapted to improve search efficiency in our automated heuristic design pipelines. |
Qihang Wu et.al. |
Arizona State University |
arXiv.org |
pdf / code
|
| 25/30 |
2026-07-26 |
SpecAHD: Localize to Specialize for Automated Heuristic Design in Large-Scale Routing ProblemsSpecAHD introduces a bilevel LLM evolutionary search framework that co-evolves an upper-level program to expose local repair regions and a lower-level repertoire of specialized constructive heuristics to repair them. The results are rigorously backed by extensive empirical evidence, showing cost reductions of up to 57.7% against state-of-the-art AHD baselines (like EoH and ReEvo) on large-scale routing benchmarks including CVRP and VRPTW up to 10,000 nodes. The key insight is the 'Repair Response Archive'—a memory mechanism that logs heuristic performance on specific local structures during training, allowing a k-NN router to dynamically select the best specialized heuristic for new regions at inference time. This is highly relevant for our work in LLM evolutionary search and large-scale routing, as it provides a concrete, scalable architecture for within-instance specialization and memory-augmented heuristic selection. |
Kezhao Lai et.al. |
Guangdong University of Technology |
arXiv.org |
pdf / code |
| 19/30 |
2026-07-26 |
NeurGO: Learning to Generate Elite Candidates for Meta-Black-Box Expensive OptimizationNeurGO is a generative meta-black-box optimization framework that uses a Transformer encoder to capture population search trends and an MLP decoder to directly synthesize a small set of elite candidates for expensive optimization tasks. The method is backed by strong empirical results on CEC 2008 and COCO BBOB benchmarks (D=10), demonstrating faster convergence and better final performance than Bayesian Optimization and other MetaBBO baselines under a strict 300-evaluation budget. The key insight is that instead of generating raw candidate coordinates, the decoder outputs contribution weights used to recombine the existing population's representations, ensuring generated candidates remain anchored to known promising regions and avoiding out-of-distribution proposals. This architectural design is highly relevant for continuous latent-space optimization and could be directly adapted to improve sample efficiency when optimizing continuous representations of algorithms or heuristics. |
Jintao He et.al. |
China University of Geosciences |
arXiv.org |
pdf / code
|
| 27/30 |
2026-07-24 |
Teaching LLMs to Self-Evolve: Cultivating Core Meta-Skills with Reinforcement LearningWu et al. introduce METAEVOLVE, a framework that uses reinforcement learning (GRPO) to explicitly train LLMs to perform iterative self-evolution and refinement. The results are rigorously backed by execution-based metrics, showing a 24% absolute improvement over AlphaEvolve on out-of-distribution coding tasks and a 46% relative speedup on open-ended algorithm optimization benchmarks. The key insight is that instead of relying on zero-shot prompting in an evolutionary loop, researchers can synthesize evolution trajectories (current code, fitness, history) from static datasets and use execution feedback as a verifiable reward to fine-tune the mutator LLM. This is a highly significant paper for our work in LLM evolutionary search, as it provides an actionable, scalable blueprint for RL-infused evolution that directly improves sample efficiency and search quality. |
Shujin Wu et.al. |
University of Illinois Urbana-Champaign |
arXiv.org |
pdf / code |
| 21/30 |
2026-07-21 |
From Monolithic to Modular: Segment-level Automatic Prompt OptimizationSAPO improves automatic prompt optimization by decomposing prompts into explicit segments (role, context, tasks, format) and applying targeted mutations only to weak segments identified via contrastive training examples. The results are backed by solid empirical evidence, showing a 5-7% average improvement over strong baselines like OPRO and EvoPrompt across five datasets (including GSM8K) using GPT-4o-mini. The key insight is the use of contrastive evidence (top-5 successes vs. bottom-5 failures) to explicitly classify components as 'strong' (to be frozen) or 'weak' (to be mutated), which prevents destructive interference during iterative search. This is highly relevant for LLM evolutionary search, as this segment-level diagnosis can be directly adapted to evolve specific sub-components of heuristic code or meta-prompts rather than relying on monolithic rewrites. |
Nikita Kulin et.al. |
ITMO University, AXXX |
the IJCAI-ECAI 2026 Workshop on Robustifying Generative AI for Reliable |
pdf / code |
| 23/30 |
2026-07-20 |
Autonomous Discovery of Wireless Communications AlgorithmsAït Aoudia et al. introduce AITE, an LLM-driven evolutionary search framework that uses a two-tier orchestrator-worker architecture with agentic tool-use to autonomously discover wireless communication algorithms. The framework produces real, empirically validated results, discovering an OTFS equalizer that is 3.6x faster than the state-of-the-art with better error rates, and the first explainable pilotless OFDM receiver matching neural network performance. The most transferable methodological insights are the post-processing adherence check (where an LLM verifies if the generated code actually implemented the assigned idea before updating the orchestrator's leaderboard) and the prompt refinement stage (which critiques worker execution journals to improve instructions for the next generation). This is highly relevant to our work in LLM evolutionary search; while the telecom application is outside our scope, the architectural enhancements for agentic code generation, adherence filtering, and prompt refinement directly address sample efficiency and search observability. |
Fayçal Aït Aoudia et.al. |
NVIDIA |
arXiv.org |
pdf / code
|
| 25/30 |
2026-07-20 |
Automated Discovery Has No Universally Superior HarnessGupta et al. systematically decompose and evaluate LLM-guided discovery harnesses across 3.1 million rollouts to show that no single fixed harness universally generalizes across models and problems. The results are highly rigorous, utilizing budget-matched statistical bootstrap tests to prove that complex evolutionary machinery often underperforms simpler tree-search or epsilon-greedy baselines. The key insight is that early search progress strongly predicts final performance, enabling an online adaptive allocation strategy that prunes weak partial runs and reallocates compute to surviving trajectories. This is a must-read for our work in LLM evolutionary search, as it dictates a shift away from engineering complex, fixed search harnesses toward implementing dynamic, early-stopping compute allocation to maximize sample efficiency. |
Akshat Gupta et.al. |
UC Berkeley, MIT, MIT-IBM Watson AI Lab, Weizmann Institute of Science |
arXiv.org |
pdf / code
|
| 25/30 |
2026-07-15 |
How to Guide LLM Generation: Dual-Surrogate Guided Search for Automated Heuristic DesignWang et al. introduce Dual-Surrogate Guided Search (DGS) to improve sample efficiency in LLM-based automated heuristic design by learning which parent heuristics and mutation operators to select before querying the LLM. The results are backed by solid empirical evidence, showing superior performance over strong baselines like FunSearch and EoH across five combinatorial optimization tasks (including TSP and CVRP) within a strict 200-query budget. The key insight is the use of a transition surrogate that predicts the latent distribution of an ungenerated child heuristic based on the parent and operator, coupled with a utility surrogate to estimate its performance. This is highly relevant to our focus on LLM evolutionary search, as it provides a concrete, implementable mechanism to drastically reduce expensive LLM calls by shifting from post-generation filtering to pre-generation action selection. |
Yuhan Wang et.al. |
The Hong Kong Polytechnic University, Nankai University, South China Agricultural University |
arXiv.org |
pdf / code |
| 25/30 |
2026-07-15 |
Reward-Free Evolving Agents via Pairwise ValidatorLiu et al. replace the expensive scalar task reward in self-evolving agentic loops with a training-free pairwise LLM validator that compares parent and child candidates. The results are backed by rigorous empirical evaluations across prompt and code evolution engines, including ShinkaEvolve, demonstrating that this reward-free approach matches or exceeds full-reward baselines. The key insight is the 'Soft Elo' mechanism, which uses pairwise LLM verdicts to update candidate ratings for parent selection, entirely eliminating the need for scalar validation rewards. This is a must-read for our work in LLM evolutionary search, as it provides a highly actionable, drop-in replacement for costly reward engineering while maintaining search quality. |
Minghao Liu et.al. |
Accenture |
arXiv.org |
pdf / code |
| 18/30 |
2026-07-15 |
Harness Engineering: Anatomy, Architecture, and Evolution of Coding Agents -- A Source-Code Study of Eleven SystemsThis paper conducts a massive source-code analysis of 11 production LLM coding agents (including Claude Code, Codex, and OpenHands) to catalog their architectural patterns across loops, memory, tools, and multi-agent orchestration. The findings are backed by rigorous code audits rather than benchmark scores, revealing 29 recurring design patterns and two major 'absences' in production systems. The KEY INSIGHT is that production agents universally eschew heavy frameworks (e.g., LangChain, AutoGen) in favor of hand-rolled async loops, and rely on deterministic retrieval (ripgrep, ASTs) rather than vector-based RAG. This is highly relevant for our work in multi-agent optimization and LLM evolutionary search; adopting these production-grade architectural patterns—and dropping bloated frameworks—can significantly improve the scalability, debuggability, and reliability of our search scaffolds. |
Paul Barbaste et.al. |
Inclusive Brains, Wavestone AI Lab |
|
pdf / code |
| 26/30 |
2026-07-11 |
GAE: Graph-Augmented Evolution for Scientific Discovery via Reinforcement OptimizationChen et al. introduce Graph-Augmented Evolution (GAE), which enhances LLM-guided evolutionary search by integrating a GNN-based RL meta-controller for mutation selection and online GRPO fine-tuning for the LLM operator. The results are rigorously backed by empirical data, showing that GAE significantly outperforms static baselines like OpenEvolve and PACEvolve on symbolic regression benchmarks. The key insight is that replacing structurally blind, prompt-driven mutations with a learned policy (Discrete SAC) and continuously updating the LLM weights via group-relative rewards drastically improves sample efficiency and search trajectory. This is a critical read for our work in LLM evolutionary search, as the three-pillar architecture provides a concrete blueprint for implementing RL-infused evolution and overcoming the limitations of static LLM operators in heuristic discovery. |
Xuanzhou Chen et.al. |
Georgia Institute of Technology, Shanghai Academy of AI for Science |
ICML |
pdf / code |
| 27/30 |
2026-07-06 |
MetaSkill-Evolve: Recursive Self-Improvement of LLM Agents via Two-Timescale Meta-Skill EvolutionMetaSkill-Evolve introduces a two-timescale framework where a multi-agent pipeline recursively evolves its own meta-skills (diagnosis, retrieval, allocation, proposal) alongside task-specific skills. The results are backed by solid empirical evidence, demonstrating up to an 8-point accuracy gain over fixed-operator evolution on QA benchmarks using a frozen 31B model. The key insight is that evolutionary operators can be parameterized as standard text files and optimized by the exact same pipeline used for task skills, guided by a 'meta-productivity' score that measures a branch's ability to generate strong descendants. This is a must-read for our work in LLM evolutionary search, providing a concrete architecture for 'evolving the evolver' and preventing search stagnation. |
Zefeng Wang et.al. |
LMU Munich, The Chinese University of Hong Kong, MCML, MemAgents Lab |
arXiv.org |
pdf / code |
| 24/30 |
2026-07-06 |
QDEvo: A Multi-Objective Quality-Diversity Framework for Automated Heuristic DesignQDEvo integrates Quality-Diversity optimization into LLM-based heuristic generation by maintaining an archive of semantically diverse algorithms using pre-trained code embeddings and hierarchical reflection. Backed by strong empirical results, it outperforms the state-of-the-art MEoH baseline in Hypervolume and IGD across constructive routing, bin packing, and real-world scheduling tasks. The most actionable takeaway is using dense code embeddings to cluster generated heuristics and applying local Pareto competition within clusters, which effectively prevents the LLM from converging on homogeneous code structures. This is highly relevant for LLM evolutionary search, offering a concrete architectural improvement to maintain population diversity and improve exploration in automated algorithm design. |
Nam Do Khanh et.al. |
George Mason University, Hanoi University of Science and Technology |
Proceedings of the Genetic and Evolutionary Computation Conference Companion |
pdf / code
|
| 26/30 |
2026-07-04 |
Harness-Aware Self-Evolving: Co-Evolving Model Weights, Harness, and Task SolutionsHASE introduces an agentic reinforcement learning framework that allows a single LLM to co-evolve its policy weights, task solutions, and surrounding harness (prompts, memory, evaluators) within a unified multi-turn action space. Backed by strong empirical results, an 8B model matches or outperforms 120B models on text classification and alpha factor mining, and matches AlphaEvolve state-of-the-art on circle packing while successfully repairing an initially broken evaluator. The key insight is the divergence-driven evaluator repair mechanism, where the model edits the local evaluator only when its proxy score diverges from a sparse real-world oracle score, providing a safe way to fix flawed reward signals without unconstrained reward hacking. This is highly relevant for LLM evolutionary search and automated algorithm design, as it provides a concrete methodology for evolving the search pipeline itself and improving sample efficiency through dynamic harness optimization and RL-infused evolution. |
Haochen Luo et.al. |
The University of Hong Kong, China Mobile, Jiutian Research, Grace Investment Machine |
arXiv.org |
pdf / code |
| 18/30 |
2026-07-02 |
Symbolic Discovery of Iterative Algorithms: A Continuous Latent Space Bayesian Optimization FrameworkLiu and Mitrai propose a framework that maps discrete expression trees of iterative optimization algorithms into a continuous latent space using a Variational Autoencoder, enabling Bayesian Optimization to search for novel update rules. The results are backed by numbers but limited to a very small scale, showing that the method can discover a state-dependent step-size rule outperforming standard gradient descent on two 2-variable toy functions. The key insight is that transforming the discrete algorithm search space into a continuous one allows sample-efficient Bayesian Optimization to replace expensive combinatorial MINLP solvers. This is highly relevant to our research in continuous optimization for automated algorithm design, as it provides a concrete, non-LLM baseline methodology that we should compare against our generative approaches. |
Tongjia Liu et.al. |
The University of Texas at Austin |
|
pdf / code |
| 25/30 |
2026-07-02 |
SwarmResearch: Orchestrating Coding Agents for Open-Ended DiscoverySWARMRESEARCH introduces an orchestrator-subagent architecture for LLM-driven open-ended discovery that uses Git branching to maintain parallel code lineages and prevent premature convergence. The framework demonstrates strong empirical results, outperforming state-of-the-art baselines like EvoX and CORAL on 13 of 15 mathematical, heuristic, and systems optimization tasks. The key insight is that isolating agent context via separate Git branches—rather than relying on shared memory or long conversation histories—forces the exploration of diverse high-level approaches instead of greedy local micro-optimizations. This is highly relevant for our work in multi-agent evolutionary search and algorithm discovery, as adopting a Git-backed state management system could significantly improve the diversity and quality of our generated heuristics. |
Yuvraj Virk et.al. |
University of Illinois Urbana-Champaign |
arXiv.org |
pdf / code
|
| 25/30 |
2026-06-30 |
RAISE: LLM-based Automated Heuristic Design with Robust Adversary Instance SearchThis paper introduces a bi-level evolutionary framework (RAISE) that couples an LLM-driven heuristic search with an LLM-free adversarial instance generator to evolve distributionally robust heuristics. The results are strongly backed by empirical data; on Online Bin Packing, RAISE reduces waste by up to 19x compared to standard LLM-based methods under severe distribution shifts, and shows similar robustness gains on vehicle routing and scheduling tasks. The key insight is to avoid expensive LLM calls for adversarial generation by using a lightweight, LLM-free evolutionary inner loop that parameterizes instance distributions as a mixture of basis functions and projects them onto an epsilon-ball around the training data. This is highly relevant for LLM evolutionary search, providing a concrete, compute-efficient mechanism to ensure evolved heuristics generalize to real-world distributional shifts rather than just memorizing the training set. |
Fei Liu et.al. |
University of Zurich, ETH Zurich |
arXiv.org |
pdf / code |
| 24/30 |
2026-06-29 |
AlgoSkill: Learning to Design Algorithms by Scheduling Human-Like SkillsAlgoSkill frames LLM-based algorithm design as a sequential decision-making process, using Monte Carlo Tree Search to schedule a library of 20 typed algorithmic skills (e.g., constraint reading, state design, complexity refinement) guided by verification feedback. The method is backed by strong empirical results, significantly improving time-optimality and correctness over direct generation and free-form refinement on competitive programming and combinatorial optimization benchmarks (e.g., +44% time-optimality on a rule-based benchmark). The key insight is that constraining the LLM's search space to a discrete set of verifiable, typed algorithmic skills—rather than free-form code mutations—makes the search process more interpretable and efficient. This is highly relevant for LLM evolutionary search and automated algorithm discovery; the community could adopt typed skill operators as mutation strategies to improve sample efficiency and structural correctness in search-based frameworks. |
Xinyuan Song et.al. |
Emory University, The University of Tokyo, LocationMind |
arXiv.org |
pdf / code
|
| 24/30 |
2026-06-28 |
MeEvo: Metacognitive Evolution Combined with Natural Evolution for Automatic Heuristic DesignMeEvo is an automatic heuristic design framework that cyclically alternates between Natural Evolution (LLM-mediated crossover and mutation on code) and Metacognitive Evolution (LLM reflection on accumulated reasoning and fitness history). Backed by extensive experiments, it significantly outperforms state-of-the-art LLM-based methods like FunSearch, EoH, and ReEvo across five optimization problems, including routing and complex constrained tasks, though at a roughly 7x higher token cost. The key insight is the explicit separation of reasoning traces (treated as heritable genotype) from executable code (phenotype), utilizing a two-step pipeline where the LLM first generates a strategic 'Meta Insight' from historical data before mapping it to new code. This is highly relevant to our work in LLM evolutionary search, providing a concrete architectural blueprint for integrating persistent memory and metacognitive reflection to improve search efficiency and escape local optima. |
Zishang Qiu et.al. |
University of Nottingham, University of Nottingham Ningbo China |
arXiv.org |
pdf / code
|
| 21/30 |
2026-06-27 |
CHIA: An open-source framework for principled, agentic AI-driven hardware/software co-design researchCui et al. introduce CHIA, an open-source, Ray-based framework for orchestrating and scaling agentic AI and evolutionary search workflows across heterogeneous compute clusters. The authors demonstrate strong empirical results in hardware design, such as automatically implementing RISC-V extensions that pass 25+ trillion instructions of SPEC06 and achieving a 2x frequency increase in critical path optimization. The key insight is the framework's architectural design, which uses graph-based orchestration with built-in caching, bypassing, and fault tolerance to solve major ergonomic and scalability bottlenecks in long-running LLM evolutionary search. This is highly relevant for our work in scaling multi-agent optimization and LLM evolutionary search, as the engineering patterns used to manage distributed evaluator nodes can directly inform our infrastructure. |
Angela Cui et.al. |
University of California, Berkeley |
arXiv.org |
pdf / code |
| 26/30 |
2026-06-25 |
Scientific discovery as meta-optimization: a combinatorial optimization case studyZhang et al. introduce a multi-agent meta-optimization framework that co-evolves both algorithm designs and their evaluation criteria using Monte Carlo Graph Search. The results are backed by strong empirical evidence, showing a reduction in the scaling exponent of a 3-SAT MemComputing solver from N^2.51 to N^1.33, yielding a 67x speedup at N=1810. The key insight is 'consensus objective aggregation', which combines multiple LLM-generated proxy objectives via correlation-weighted voting and age decay to create a stable, self-correcting fitness signal that resists reward hacking. This is a fundamental advance for LLM evolutionary search, providing a concrete method to dynamically improve evaluation strategies and prevent the search from exploiting flawed proxy metrics. |
Yuan-Hang Zhang et.al. |
University of California San Diego |
arXiv.org |
pdf / code
|
| 19/30 |
2026-06-24 |
EVOM: Agentic Meta-Evolution of Actor-Critic Architectures for Reinforcement LearningEVOM introduces a bi-level LLM evolutionary search framework that designs actor-critic neural network architectures by using an LLM for mutation and crossover, while evaluating candidates via a low-fidelity reinforcement learning training loop. The authors demonstrate real empirical gains, outperforming manually designed architectures and baseline LLM-guided searches on MuJoCo continuous control tasks. The key insight is the explicit decoupling of the evolutionary search from full evaluation by using a low-budget proxy fitness signal, which makes population-level LLM search computationally feasible. This is highly relevant for our work in LLM evolutionary search; adopting low-fidelity proxy evaluators (such as testing generated heuristics on small-scale routing or scheduling instances) could significantly improve our sample efficiency and search scalability. |
Boyun Zhang et.al. |
Xidian University |
arXiv.org |
pdf / code
|
| 20/30 |
2026-06-24 |
AlgoEvolve: LLM-driven Meta-evolution of Algorithmic Trading ProgramsThis paper introduces a bi-level LLM evolutionary framework that synthesizes algorithmic trading programs in an inner loop while a meta-evolutionary outer loop optimizes the search prompts guiding the synthesis. The results are backed by empirical backtesting, showing the meta-evolutionary approach achieves a 5.60 annualized Sharpe ratio and successfully escapes the 'zero-trade' stagnation trap that plagues static-prompt baselines. The key insight is the use of a structured 'Prompt Genome' (separating mutation style, creative focus, constraints, and reasoning) combined with 'Informed Meta-Mutation,' where a Meta-LLM rewrites specific prompt genes based on a structured performance report (learning curves, error rates) from the inner loop. This is highly relevant for our work in LLM evolutionary search; the team can directly adapt this meta-evolutionary outer loop to improve search efficiency and prevent stagnation when discovering heuristics for combinatorial optimization. |
Dhruv Sharma et.al. |
Indraprastha Institute of Information Technology, Delhi |
arXiv.org |
pdf / code
|
| 21/30 |
2026-06-23 |
Project Auto-World: Towards Automated Benchmarking of Neural Relational ReasonersThis paper adapts FunSearch and an autonomous agentic loop to evolve Python priority functions that generate adversarial knowledge graph instances to stress-test neural relational reasoners. The authors provide strong empirical evidence showing both methods successfully drive down the accuracy of state-of-the-art Edge Transformers, and that training on these generated instances improves model robustness. The key insight is that a single autonomous coding agent iteratively refining a priority function can independently discover the same structural difficulty signals as a full population-based FunSearch pipeline, and can even break models that FunSearch fails to challenge. This is highly relevant for our work in LLM evolutionary search and automated benchmarking, as it suggests agentic iterative refinement can be a viable, sometimes superior, alternative to complex population-based evolution. |
Anirban Das et.al. |
Cardiff University, University of Pennsylvania |
NeurIPS |
pdf / code
|
| 20/30 |
2026-06-22 |
Discovering Crystal Structure Prediction Algorithms with an AI Co-ScientistThis paper introduces HACO, an AI co-scientist system that uses tree-based LLM search and sparse human steering to discover a novel masked generative model (MaskGXT) for crystal structure prediction. The results are backed by strong empirical evidence, achieving state-of-the-art match rates (79.06% METRe) on standard MP-20 and MPTS-52 benchmarks compared to continuous diffusion baselines. The key insight is the system's architecture for 'sparse human steering'—where humans inject high-level objectives or mechanisms while the agent handles code implementation—combined with a 'cross-domain idea operator' that explicitly searches literature outside the target domain to seed the evolutionary tree. This is highly relevant to our research in LLM evolutionary search; the team should evaluate adopting this specific orchestrator pattern to improve observability and human-in-the-loop intervention in our automated algorithm design systems. |
Kiyoung Seong et.al. |
KAIST |
arXiv.org |
pdf / code
|
| 24/30 |
2026-06-09 |
Beyond Static Evaluation: Co-Evolutionary Mechanisms for LLM-Driven Strategy Evolution in Adversarial GamesLi et al. introduce an LLM-driven code evolution framework for multi-agent adversarial games that combats search stagnation using evaluator co-evolution, hierarchical deep evaluation, and weakness pressure. The results are rigorously backed by empirical data, demonstrating a 20% performance gain over existing baselines in a 3v3 capture-the-flag environment and securing 1st place in an AAMAS competition. The key insight is that static evaluation in LLM code evolution leads to overfitting; dynamically updating the test pool with past champions and up-weighting the hardest test cases (weakness pressure) sustains selective pressure and yields more robust algorithmic innovations. This is highly relevant for our work in LLM evolutionary search, offering concrete, implementable techniques to improve fitness signals and evaluation efficiency when evolving complex heuristics. |
Haoran Li et.al. |
Baidu AI Cloud, University of Chinese Academy of Sciences, Peking University, The University of Sydney, Southeast University |
arXiv.org |
pdf / code
|
| 24/30 |
2026-06-09 |
Towards Diverse Scientific Hypothesis Search with Large Language ModelsThis paper introduces EvoDiverse, a parallel-tempered evolutionary framework that maintains multiple candidate pools at different selection pressures (temperatures) and exchanges them to balance exploration and exploitation in LLM-based search. The results are rigorously backed by empirical data across molecular, equation, and algorithm discovery (e.g., circle packing), demonstrating significant improvements in both solution quality and diversity under fixed evaluation budgets compared to standard single-pool or isolated-ensemble baselines. The key insight is the use of a Metropolis-Hastings acceptance gate for swapping candidates between high-temperature (exploratory) and low-temperature (exploitative) pools, which prevents disruptive candidates from destroying the exploitative pool while still allowing productive information flow. This is highly relevant for our work in LLM evolutionary search and automated algorithm design, offering a principled, easy-to-implement architectural pattern to prevent premature convergence and improve sample efficiency. |
Haorui Wang et.al. |
University of Cambridge, University of California, Berkeley, Microsoft Research New England, Carnegie Mellon University, Georgia Institute of Technology, Virginia Tech |
ICML |
pdf / code
|
| 25/30 |
2026-06-04 |
MLEvolve: A Self-Evolving Framework for Automated Machine Learning Algorithm DiscoveryMLEvolve is a multi-agent framework for automated algorithm discovery that replaces standard tree search with Progressive Monte Carlo Graph Search (MCGS) and integrates retrospective memory with hierarchical code generation. Backed by strong empirical numbers, it achieves a state-of-the-art 65.3% medal rate on MLE-Bench in half the standard time and outperforms AlphaEvolve on 11 of 15 mathematical optimization tasks. The key insight is the Progressive MCGS architecture, which enables cross-branch information flow (fusion and aggregation) and uses an entropy-based schedule to shift from broad exploration to elite-guided exploitation, effectively solving the branch isolation problem. This is highly relevant for our work in LLM evolutionary search and multi-agent optimization, providing concrete, implementable mechanisms for memory reuse and cross-trajectory crossover that improve sample efficiency and search quality. |
Shangheng Du et.al. |
Shanghai Artificial Intelligence Laboratory, East China Normal University |
arXiv.org |
pdf / code
|
| 23/30 |
2026-06-01 |
HarnessForge: Joint Harness and Policy Evolution for Adaptive Agent SystemsHarnessForge co-evolves an LLM agent's external execution harness (code for planning, action, memory) and its internal reasoning policy (via LoRA adapters) using a meta-agent for fault-guided tailoring. The results are backed by strong empirical evidence, showing up to 12% improvement on API and QA benchmarks using Qwen3-4B/8B, outperforming both search-only (e.g., AFlow, ADAS) and policy-only (e.g., GRPO, RLOO) baselines. The key insight is the sample-efficient co-evolution loop: using the meta-agent to evolve the code structure, filtering for successful trajectories, and immediately reusing those trajectories to fine-tune a harness-specific LoRA adapter without requiring additional rollouts. This is highly relevant for LLM evolutionary search, providing a concrete architecture for combining code-level evolutionary search with weight-level policy adaptation. |
Mingju Chen et.al. |
Tsinghua University, Beihang University |
arXiv.org |
pdf / code
|
| 25/30 |
2026-06-01 |
Adaptive Auto-Harness: Sustained Self-Improvement for Agentic System Deployment on Open-Ended Task StreamsAdaptive Auto-Harness introduces a framework for open-ended task streams that uses a stateful multi-agent evolver, a git-based harness tree for solve-time routing, and human-in-the-loop steering to prevent overfitting to early tasks. The results are rigorously backed by empirical data across three diverse benchmarks, showing significant improvements over baselines like A-Evolve and Meta-Harness. The key insight is the transition from a single dense harness to a git-based harness tree, where the evolver creates regime-specific branches for prompts and tools, and a solve-time router selects the optimal branch per task. This directly addresses the artifact dilution problem and is highly relevant to our focus on continuous learning, persistent memory, and expert-in-the-loop observability in LLM evolutionary search. |
Zewen Liu et.al. |
Amazon, Emory University, UIUC, The Pennsylvania State University, Northeastern University |
arXiv.org |
pdf / code
|
| 24/30 |
2026-05-30 |
LLM-Driven Co-Evolutionary Automated Heuristic Design for Bi-Component Coupled Combinatorial OptimizationCoEvo-AHD introduces a dual-population co-evolutionary framework that uses LLMs to automatically design and co-evolve paired heuristics for bi-component combinatorial optimization problems like the Traveling Thief Problem. The results are backed by empirical numbers, showing competitive performance against traditional metaheuristics on small-to-medium instances, though it trails specialized state-of-the-art solvers on large-scale instances. The key insight is the use of 'cross-component joint crossover' and a 'shared information memory' dictionary, which allow the LLM to rewrite highly synergistic operator pairs together and pass soft search guidance between heterogeneous components. This is highly relevant for our work in multi-agent LLM evolutionary search, providing concrete architectural patterns for co-evolving interdependent algorithmic components. |
Mingen Kuang et.al. |
Xi’an Jiao Tong University, Northwestern Polytechnical University |
arXiv.org |
pdf / code |
| 22/30 |
2026-05-29 |
MetaEvo: A Meta-Optimization Framework for Experience-Driven Agent EvolutionMetaEvo introduces a two-stage framework for agent evolution that first fine-tunes an LLM via Direct Preference Optimization (DPO) to improve its ability to abstract revision principles, and then iteratively accumulates these principles in a structured memory. The approach is backed by strong empirical results, demonstrating a 9.6% absolute accuracy gain on GSM8K for LLaMA-3.1-8B and consistent improvements across MATH, MMLU, and BBH compared to baselines like SE-GPT. The key insight is the 'meta-optimization' step: using a stronger model to generate preferred principles and applying DPO to the base model so it learns how to extract actionable, contrast-driven feedback rather than just memorizing task-specific corrections. This is highly relevant for our work in LLM evolutionary search; the team could directly adapt the DPO-based meta-optimization and Contrast-Driven Abstraction to train 'evolver' agents, thereby improving the quality of heuristic revisions and overall sample efficiency. |
Bowen Ren et.al. |
Beijing Institute of Technology, BIT Southeast Academy of Information Technology |
arXiv.org |
pdf / code |
| 24/30 |
2026-05-28 |
Evolve as a Team: Collaborative Self-Evolution for LLM-based Multi-Agent SystemsThis paper introduces Meta-Team, a framework for multi-agent system self-evolution where agents retain local execution contexts and communicate post-task to collaboratively update individual behaviors, interaction profiles, and team coordination rules. The approach is backed by strong empirical results, showing an average 6.3% improvement over the strongest MAS evolution baseline across six challenging, long-horizon benchmarks (including SWE-bench Pro and GAIA). The key insight is that flattening multi-agent trajectories for a centralized meta-optimizer creates a context bottleneck and degrades failure attribution; instead, evolution should be distributed, allowing agents to reflect locally and exchange evidence to pinpoint failures. This is highly relevant for our work in multi-agent evolutionary search, as the decentralized reflection and multi-scale update mechanism provides a concrete architectural blueprint for improving sample efficiency and credit assignment in complex optimization tasks. |
Zhezheng Hao et.al. |
Tencent, Zhejiang University, Hong Kong University of Science and Technology |
arXiv.org |
pdf / code
|
| 22/30 |
2026-05-28 |
AI-PROPELLER: Warehouse-Scale Interprocedural Code Layout Optimization with AlphaEvolveAI-PROPELLER applies an AlphaEvolve-based framework to discover fine-grained, interprocedural code layout heuristics for warehouse-scale binaries. The results are backed by rigorous hardware metrics, demonstrating statistically significant execution time reductions of 0.23% to 1.6% on massive applications like LLVM Clang and production search services. The key insight is the extreme lengths taken to ensure a noise-free reward signal for the LLM evolutionary loop; by locking CPU frequencies and disabling ASLR/Turbo Boost, they reduced run-to-run variance to under 0.05%, allowing the agent to accurately learn from micro-optimizations. This is highly relevant to our work in LLM evolutionary search, as it provides a concrete blueprint for scaling these methods to combinatorially massive search spaces by engineering high-fidelity empirical reward signals. |
Chaitanya Mamatha Ananda et.al. |
Google DeepMind, Google, University of California, Riverside |
arXiv.org |
pdf / code |
| 27/30 |
2026-05-21 |
Vector Policy Optimization: Training for Diversity Improves Test-Time SearchBahlous-Boldi et al. introduce Vector Policy Optimization (VPO), an RL post-training method that trains LLMs to generate diverse candidate sets by combining multi-answer autoregressive generation with stochastic reward scalarization. The results are rigorously backed by empirical data, demonstrating that VPO continuously scales with test-time compute and successfully solves hard LiveCodeBench problems inside an AlphaEvolve-style evolutionary loop where standard GRPO completely stalls. The key insight is that collapsing vector rewards (such as per-test-case correctness) into a single scalar during RL causes mode collapse; instead, sampling random weightings from a Dirichlet distribution forces the policy to maintain a Pareto-diverse set of strategies. This is a fundamental advance for LLM evolutionary search, as applying VPO to mutator or generator models directly addresses sample efficiency and prevents premature convergence in automated algorithm design. |
Ryan Bahlous-Boldi et.al. |
MIT, Sakana AI, Improbable AI Lab, MIT-IBM Computing Research Lab |
arXiv.org |
pdf / code |
| 27/30 |
2026-05-19 |
optimize_anything: A Universal API for Optimizing any Text ParameterAgrawal et al. introduce optimize_anything, a unified LLM-based evolutionary search API that optimizes arbitrary text artifacts (code, prompts, agent architectures) using Pareto-based selection and diagnostic side information. Results are highly rigorous and backed by numbers, including a controlled ablation showing it beats OpenEvolve on circle packing in 3x fewer evaluations, and achieving SOTA on ARC-AGI (89.5%), cloud scheduling, and CUDA kernel generation. The most actionable takeaway is the combination of multi-task search with a shared Pareto frontier, allowing optimization patterns discovered in one task to transfer to related tasks, alongside the formalization of Side Information (SI) as a first-class 'text gradient' to drive targeted mutations rather than blind evolution. This is a landmark paper for LLM evolutionary search; the team should immediately evaluate adopting the multi-task Pareto frontier and structured SI contracts to improve sample efficiency and cross-problem transfer in our own automated algorithm design frameworks. |
Lakshya A Agrawal et.al. |
UC Berkeley, MIT |
Proceedings of the ACM Conference on AI and Agentic Systems (CAIS 26), May 26-29, 2026, San Jose, CA, USA |
pdf / code
|
| 24/30 |
2026-05-18 |
Property-Guided LLM Program Synthesis for PlanningThis paper replaces scalar fitness scores in LLM heuristic synthesis with a counterexample-guided repair loop that checks formal properties and feeds specific failure states back to the LLM. The results are backed by strong empirical evidence on 10 planning domains, showing a 7.4x reduction in LLM generation cost, a 1000x reduction in evaluation compute, and higher task coverage compared to the previous sample-and-select state of the art. The key insight is that using verifiable properties to generate concrete, localized counterexamples (e.g., 'at state X, your heuristic gave value Y, but successors gave Z') is vastly more sample-efficient than end-to-end scalar rewards. This is highly relevant for LLM evolutionary search and automated algorithm design; the community should investigate defining checkable properties for routing or scheduling heuristics to replace or augment standard scalar fitness evaluations, drastically reducing LLM sample complexity. |
André G. Pereira et.al. |
University of Oxford, Linköping University, Federal University of Rio Grande do Sul |
arXiv.org |
pdf / code |
| 21/30 |
2026-05-14 |
Adapting AlphaEvolve to Optimize Fully Homomorphic Encryption on TPUsThis paper applies the AlphaEvolve framework to automatically optimize Fully Homomorphic Encryption (FHE) kernels for TPU execution, using LLM-driven code generation guided by hardware-in-the-loop latency feedback and strict correctness checks. The results are real and backed by physical hardware deployments, achieving up to a 2.5x speedup over human-engineered state-of-the-art baselines on TPUv5e chips. The key insight is that optimizing isolated operations often fails to yield end-to-end speedups; instead, co-evolving multiple components and scoring them against complete system execution, while feeding back low-level execution traces (e.g., Xprof) to the LLM, is necessary to discover non-obvious compiler and scheduling optimizations. This is highly relevant for our work in LLM evolutionary search, as the methodology of using execution traces as diagnostic feedback and enforcing end-to-end co-evolution directly informs how we should structure reward signals and evaluation environments for automated algorithm design. |
Shruthi Gorantala et.al. |
Google DeepMind, Google, Georgia Institute of Technology |
arXiv.org |
pdf / code |
| 25/30 |
2026-05-14 |
MetaAgent-X : Breaking the Ceiling of Automatic Multi-Agent Systems via End-to-End Reinforcement LearningMetaAgent-X is an end-to-end reinforcement learning framework that jointly optimizes a meta-agent (Designer) that generates multi-agent workflows and the downstream agents (Executors) that run them. The results are backed by strong empirical evidence, showing up to 21.7% improvement over baselines on math and code benchmarks using Qwen3-8B. The key insight is the Executor-Designer Hierarchical Rollout combined with stagewise co-evolution: by sampling M designs and executing each N times, the system isolates the designer's reward from the executor's reward, while alternating training phases stabilizes the non-stationary RL environment. This is highly relevant to our work in LLM evolutionary search and multi-agent optimization, providing a concrete, implementable architecture for RL-infused meta-agent training and credit assignment. |
Yaolun Zhang et.al. |
Amazon AGI, UCSD, Oregon State University, Pennsylvania State University, AG2AI, Inc. |
arXiv.org |
pdf / code |
| 19/30 |
2026-05-13 |
Graph-Grounded Optimization: Rao-Family Metaheuristics, Classical OR, and SLM-Driven Formulation over Knowledge GraphsThis paper introduces a graph-grounded optimization paradigm where operations research problem components are sourced directly from property knowledge graphs via Cypher queries, rather than from lossy natural language descriptions. The results are backed by strong empirical numbers across 7 real-world KGs, demonstrating that while classical solvers and metaheuristics succeed, frontier SLMs (including the MILP-tuned OptiMind) fail almost completely at zero-shot formulation. The key insight is the identification of a 'data-binding pathology': LLMs generate syntactically valid optimization code that silently fails or returns trivial solutions because it binds to hallucinated data structures instead of the actual operational database. This is highly relevant for our OR benchmarking and evaluation work, as it proves that evaluating LLMs purely on text-to-math translation ignores the critical, failure-prone step of grounding the formulation in real-world data schemas. |
Madhulatha Mandarapu et.al. |
Samyama.ai |
arXiv.org |
pdf / code
|
| 27/30 |
2026-05-13 |
Harnessing Agentic EvolutionZhang et al. introduce AEVO, a framework that formulates LLM evolutionary search as an interactive environment where a meta-agent edits the underlying search procedure or agent context rather than directly generating candidate solutions. The results are backed by strong empirical evidence, achieving state-of-the-art performance on Anthropic's Kernel optimization task (1138 cycles) and outperforming baselines like OpenEvolve and HyperAgents across multiple open-ended discovery and reasoning benchmarks. The key insight is separating the candidate generation loop from a meta-editing phase, allowing the system to dynamically revise its own selection rules, feedback summaries, and memory structures when search plateaus. This is a must-read for our work in LLM evolutionary search, as it provides a concrete, actionable architecture for 'evolving the evolver' and maintaining long-horizon search without agent drift. |
Jiayi Zhang et.al. |
Tsinghua University, Université de Montréal & Mila, The Hong Kong University of Science and Technology (Guangzhou), Nanyang Technological University, Shanghai Jiao Tong University, Singapore University of Technology and Design, DeepWisdom |
arXiv.org |
pdf / code
|
| 24/30 |
2026-05-13 |
EvolveMem:Self-Evolving Memory Architecture via AutoResearch for LLM AgentsEVOLVEMEM introduces a self-evolving memory architecture for LLM agents that autonomously optimizes its retrieval infrastructure (e.g., fusion weights, context budgets) using an LLM-powered diagnosis module that analyzes failure logs. The results are backed by strong empirical evidence, showing a 25.7% relative improvement over the state-of-the-art on the LoCoMo benchmark and positive transfer to MemBench. The key insight is treating the retrieval configuration as a structured action space and using an LLM to propose targeted adjustments based on per-question failure logs, safeguarded by a revert-on-regression mechanism. This is highly relevant to our work in LLM evolutionary search and multi-agent memory systems, as the closed-loop AutoResearch methodology can be directly adapted to evolve hyperparameters or retrieval strategies in our own agentic architectures. |
Jiaqi Liu et.al. |
UNC-Chapel Hill, UC Berkeley, UCSC |
arXiv.org |
pdf / code
|
| 26/30 |
2026-05-13 |
Effective Harness Engineering for Algorithm Discovery with Coding AgentsVesper introduces a novel execution harness for LLM-driven algorithm discovery that replaces stateless LLM API calls with autonomous coding agents capable of multi-step reasoning, debugging, and codebase inspection. Backed by concrete numbers, Vesper outperforms OpenEvolve and matches AlphaEvolve on the Circle Packing benchmark under strict token and cost budgets, achieving higher scores with significantly fewer generated algorithms. The key insight is that under a fixed budget, scaling the reasoning quality per algorithm (using expensive, multi-step coding agents) is vastly more efficient than scaling the number of evolutionary generations (using cheap, single-shot API calls). This is highly relevant for our work in LLM evolutionary search; the team should immediately evaluate shifting our mutation operators from single-shot prompts to agentic loops and adopt Git worktree isolation for safe, parallel execution. |
Yoichi Ishibashi et.al. |
NEC Corporation |
arXiv.org |
pdf / code |
| 22/30 |
2026-05-12 |
CVEvolve: Autonomous Algorithm Discovery for Unstructured Scientific Data ProcessingCVEvolve is an LLM-based evolutionary search framework that autonomously discovers data-processing algorithms using a generate-tune-evolve loop, lineage-aware sampling, and SQL-backed persistent memory. The results are backed by strong empirical evidence, showing significant improvements over baselines, such as reducing X-ray image registration error from 0.98 to 0.12. The key insight is the use of a relational SQL database to manage search history and lineage (avoiding context bloat) combined with a dedicated holdout-test agent to prevent over-optimization on small development sets. This is highly relevant for our work in LLM evolutionary search; the team could directly adopt the SQL memory architecture and holdout-test agent to improve the scalability and generalization of our own automated heuristic design frameworks. |
Ming Du et.al. |
Argonne National Laboratory |
arXiv.org |
pdf / code
|
| 25/30 |
2026-05-11 |
Budget-Efficient Automatic Algorithm Design via Code GraphThis paper proposes a graph-based search framework for LLM-driven automatic algorithm design where algorithms are represented as paths in a directed acyclic graph (DAG) of code blocks, allowing the LLM to generate composable corrections rather than full rewrites. The approach is backed by strong empirical results on TSP, LRP, and BRP, demonstrating up to 22% smaller optimality gaps than full-algorithm baselines at equal token budgets. The key insight is the use of a Random Forest surrogate model combined with Shapley values to perform correction-level credit assignment, effectively isolating the impact of specific code edits from the overall algorithm fitness. This is highly relevant for LLM evolutionary search; the DAG representation and Shapley-based credit assignment provide a concrete architectural blueprint for drastically improving sample efficiency, search signal quality, and observability in automated heuristic discovery. |
Maxime Bouscary et.al. |
Massachusetts Institute of Technology, University of California, Berkeley |
arXiv.org |
pdf / code |
| 25/30 |
2026-05-11 |
Teacher-Aware Evolution of Heuristic Programs from Learned Optimization PoliciesThis paper introduces a teacher-aware evolutionary framework that uses pre-trained neural optimization policies to provide step-by-step behavioral feedback to guide the LLM-based evolution of symbolic heuristics. The results are backed by strong empirical numbers, showing consistent improvements over standard performance-driven baselines (EoH, ReEvo) on scheduling, routing, and graph optimization benchmarks, while maintaining the fast inference of static code. The key insight is that instead of relying solely on delayed endpoint performance, one can query a black-box neural policy on the specific states visited by a candidate heuristic and use the behavioral discrepancies (top-1 action agreement) to prompt targeted LLM revisions. This is highly relevant for research in LLM evolutionary search, as it provides a concrete, actionable implementation of a process reward model that directly improves search guidance and sample efficiency. |
Minyu Chen et.al. |
Shanghai Jiao Tong University, Shenzhen Technology University, Shanghai Polytechnic University |
arXiv.org |
pdf / code |
| 23/30 |
2026-05-11 |
RubricEM: Meta-RL with Rubric-guided Policy Decomposition beyond Verifiable RewardsLi et al. introduce RubricEM, an RL framework for long-horizon LLM agents that uses dynamically generated rubrics to structure trajectories, assign stage-wise process rewards via Stage-Structured GRPO, and train a reflection memory bank for cross-episode transfer. The results are rigorously backed by numbers, showing their 8B model outperforming 30B+ open models and approaching proprietary systems on four long-form research benchmarks. The key insight is that rubrics can serve as a shared interface across the entire RL loop, acting simultaneously as structural priors for planning, dynamic process reward models for intermediate credit assignment, and structured memory for experience reuse. This is highly relevant for our work in LLM evolutionary search and multi-agent optimization, as the asynchronous reflection pipeline and stage-structured credit assignment directly address our core challenges in sample efficiency, process reward modeling, and persistent memory across search runs. |
Gaotang Li et.al. |
Google Cloud AI Research, University of Illinois Urbana-Champaign |
arXiv.org |
pdf / code |
| 25/30 |
2026-05-10 |
LEVI: Stronger Search Architectures Can Substitute for Larger LLMs in Evolutionary SearchLEVI introduces a cost-efficient framework for LLM-guided evolutionary search that replaces expensive frontier-model reliance with a stronger search architecture. The authors demonstrate that by combining a CVT-MAP-Elites archive, role-aware LLM routing (using small models for local edits and large models only for structural paradigm shifts), and rank-preserving proxy benchmarks, they can outperform existing frameworks like ShinkaEvolve and GEPA on systems-research and prompt-optimization tasks at 3.3 to 6.7x lower cost. The results are rigorously backed by empirical cost and performance metrics across 11 benchmarks. The key insight is the decoupling of mutation roles: routing 90% of mutations to cheap, open-weight models for local refinement while reserving frontier models strictly for escaping local optima via 'paradigm shifts.' This is a must-read for our work in LLM evolutionary search, as the role-aware routing and proxy benchmark techniques offer immediate, concrete ways to drastically improve the sample efficiency and scalability of our own optimization pipelines. |
Temoor Tanveer et.al. |
Independent Researcher |
arXiv.org |
pdf / code
|
| 24/30 |
2026-05-10 |
TacoMAS: Test-Time Co-Evolution of Topology and Capability in LLM-based Multi-Agent SystemsTacoMAS introduces a test-time co-evolution framework for LLM multi-agent systems that updates agent capabilities rapidly (via memory refinement) and communication topology slowly (via birth-death operations and edge edits). The results are backed by strong empirical evidence, achieving an average 13.3% accuracy improvement over 20 baselines across four diverse benchmarks. The key insight is the separation of evolution into two time scales—fast capability updates to handle immediate subtasks and slow topology updates to preserve coordination stability—which prevents the system from diverging during test-time adaptation. Furthermore, using a meta-judge to assign contribution scores to individual agents effectively acts as a process reward model to guide the replicator dynamics. This is highly relevant for our research in multi-agent optimization and LLM evolutionary search; the fast-slow update schedule and the meta-judge scoring mechanism are concrete techniques we should evaluate for our own multi-agent frameworks. |
Chen Xu et.al. |
Carnegie Mellon University, University of Science and Technology of China, National University of Singapore, Shanghai AI Lab |
arXiv.org |
pdf / code
|
| 24/30 |
2026-05-09 |
Evolutionary Ensemble of AgentsYu and Yang introduce Evolutionary Ensemble (EvE), a framework that co-evolves functional code solvers alongside the guidance and skills of the coding agents that produce them. The results are backed by rigorous ablations on a complex positional-encoding design task, demonstrating that continuous agent evolution prevents the phase mismatch and stagnation seen with static or frozen agents. The key insight is the dual-population credit assignment mechanism, which evaluates and evolves agent guidance based strictly on the downstream performance gains of the code they generate in a synchronous race. This is highly relevant for our work in LLM evolutionary search and multi-agent optimization, offering a concrete method to adapt search strategies dynamically as the optimization landscape shifts. |
Zongmin Yu et.al. |
National University of Singapore |
arXiv.org |
pdf / code
|
| 24/30 |
2026-05-08 |
HMACE: Heterogeneous Multi-Agent Collaborative Evolution for Combinatorial OptimizationHMACE decomposes LLM-based heuristic generation into a multi-agent workflow (Proposer, Generator, Evaluator, Reflector) to automate heuristic design for combinatorial optimization problems. Backed by strong empirical numbers, it achieves lower optimality gaps on TSP and Online BPP than SOTA baselines like EoH and CORAL, while using significantly fewer tokens (e.g., 0.13M vs 0.24M for TSP). The key insight is the integration of a CVT-MAP-Elites archive as a 'Reflector' memory to enable behavior-aware retrieval of past heuristics, which, combined with a lightweight deterministic pre-filter, drastically improves the sample efficiency of the evolutionary search. This is highly relevant to our work in multi-agent optimization and LLM evolutionary search, offering actionable techniques to reduce API costs and prevent premature convergence in heuristic discovery. |
Yuping Yan et.al. |
Westlake University |
arXiv.org |
pdf / code |
| 26/30 |
2026-05-08 |
FlashEvolve: Accelerating Agent Self-Evolution with Asynchronous Stage OrchestrationFlashEvolve accelerates LLM-based agent evolution by replacing synchronized execution stages with asynchronous workers and queues, allowing proposal, rollout, and evaluation to overlap. Backed by strong empirical numbers, it achieves up to 4.9x higher proposal throughput and reaches higher validation scores significantly faster on benchmarks like IFBench and HotpotQA compared to synchronous baselines. The key insight is 'Reflective Async' for handling data staleness: unlike continuous weights in RL, stale language artifacts (prompts or code) are inspectable and can be semantically patched by the LLM to incorporate recent pool updates, preventing wasted compute. This is highly critical for scaling LLM evolutionary search and optimizing LLM serving scheduling, providing a concrete architectural blueprint to drastically reduce the wall-clock time of evolutionary discovery pipelines. |
Zhengding Hu et.al. |
University of California, San Diego, Georgia Institute of Technology |
arXiv.org |
pdf / code |
| 23/30 |
2026-05-08 |
Kernel Foundry: A Diagnosis-driven Evolutionary Kernel Optimizer with Multi-ExpertsKernel Foundry proposes a multi-island evolutionary framework for GPU kernel optimization that uses retrieval-augmented initialization and a diagnosis-driven feedback loop to iteratively refine Triton kernels. The results are rigorously backed by empirical evaluations on KernelBench, demonstrating up to 100% correctness on complex multi-operator pipelines and consistent speedups over strong baselines like AutoTriton. The key insight is the integration of an 'Experience Library' and a 'Diagnosis Engine' that translate raw execution errors and performance bottlenecks into structured, reusable natural language hints, providing a far richer evolutionary signal than scalar fitness scores. This is highly relevant for our work in LLM evolutionary search, as the architecture for accumulating persistent optimization knowledge and structured feedback can be directly adapted to improve sample efficiency in automated algorithm discovery. |
Zixuan Huang et.al. |
Huawei, The Chinese University of Hong Kong |
arXiv.org |
pdf / code |
| 22/30 |
2026-05-07 |
CoupleEvo: Evolving Heuristics for Coupled Optimization Problems Using Large Language ModelsCoupleEvo extends LLM-driven heuristic evolution to coupled optimization problems by generating interacting Large Neighborhood Search (LNS) destroy operators using sequential, iterative, or integrated prompting strategies. Results are backed by empirical evaluations on the Inventory Routing Problem and a multi-robot pre-marshalling problem, showing the approach outperforms classical matheuristics but slightly trails highly specialized state-of-the-art solvers. The key insight is that decomposing the evolution of interacting heuristics into sequential or iterative phases yields significantly better and more stable convergence than integrated generation, which overwhelms the LLM's search complexity. This is highly relevant for our research in LLM evolutionary search and vehicle routing, as it provides a concrete architectural blueprint for evolving multi-component ALNS operators. |
Thomas Bömer et.al. |
Karlsruhe Institute of Technology |
GECCO 2026 |
pdf / code
|
| 24/30 |
2026-05-07 |
SkillOS: Learning Skill Curation for Self-Evolving AgentsSkillOS trains a dedicated skill curator model using Grouped Reward Policy Optimization (GRPO) to insert, update, and delete reusable skills in a persistent repository for a frozen agent executor. The results are backed by strong empirical evidence, showing up to a 9.8% relative performance improvement and a 6.0% reduction in interaction steps on ALFWorld, WebShop, and math reasoning benchmarks compared to strong memory baselines. The key insight is the training recipe for delayed memory feedback: grouping related tasks sequentially so that skills extracted from early tasks are explicitly rewarded based on their utility in solving later tasks, augmented by intermediate process rewards for skill conciseness and quality. This is highly relevant for LLM evolutionary search and multi-agent optimization, as it provides a scalable, RL-driven mechanism to maintain a persistent, cross-run memory of successful heuristics or strategies without relying on static rules. |
Siru Ouyang et.al. |
Google Cloud AI Research, Massachusetts Institute of Technology, University of Illinois Urbana-Champaign |
arXiv.org |
pdf / code |
| 22/30 |
2026-05-07 |
Intentmaking and Sensemaking: Human Interaction with AI-Guided Mathematical DiscoveryBäuerle et al. present a qualitative user study and interactive dashboard for AlphaEvolve, formalizing the iterative human-AI workflow into 'intentmaking' (problem definition) and 'sensemaking' (result interpretation). While results are qualitative (based on observations of 11 mathematicians running 2,300+ experiments) rather than algorithmic benchmarks, the operational insights are highly valuable. The key actionable insight is the implementation of a 'critique agent' and a low-cost test stage during experiment setup, which helps users catch underspecified constraints and prevent evolutionary reward hacking before launching expensive, multi-day compute jobs. This is highly relevant for our work in LLM evolutionary search, as adopting these pre-run validation steps can directly improve sample efficiency, reduce wasted compute, and enhance system observability. |
Alex Bäuerle et.al. |
Google DeepMind |
arXiv.org |
pdf / code |
| 22/30 |
2026-05-01 |
AlphaInventory: Evolving White-Box Inventory Policies via Large Language Models with Deployment GuaranteesAlphaInventory uses an RL-fine-tuned LLM (via GRPO) to iteratively evolve and certify white-box inventory policies for non-stationary environments. Backed by strong empirical results on synthetic and real-world retail data, it outperforms classical and deep learning baselines, discovering novel structural extensions to the Capped Base Stock policy (Tilted-CBS and Tilted-PIC). The key insight is the integration of a confidence-interval-based certification gate during the evolutionary search, which ensures that generated heuristics are statistically safe for future deployment by bridging the gap between historical replay and online performance. This is highly relevant for our work in LLM evolutionary search; the team should consider adopting the statistical certification framework and GRPO-based proposal training for evolving robust heuristics in stochastic routing and scheduling problems. |
Chenyu Huang et.al. |
Tsinghua University, Boston College, Shanghai Jiao Tong University, The Chinese University of Hong Kong, Shenzhen, Shanghai University of Finance and Economics |
arXiv.org |
pdf / code |
| 23/30 |
2026-04-30 |
Beyond the Training Distribution: Mapping Generalization Boundaries in Neural Program SynthesisVoigt et al. evaluate the out-of-distribution generalization limits of transformers in program synthesis by mapping arithmetic programs into continuous syntactic and semantic manifolds. Backed by rigorous evaluation on millions of programs, they demonstrate that while transformers can extrapolate semantically using known syntax, they suffer a massive >30% performance drop when forced to extrapolate to novel syntactic structures. The key insight is that pure autoregressive scaling yields strictly log-linear returns for structural extrapolation, exposing a fundamental bottleneck in LLMs that cannot be overcome by compute alone. This is highly relevant for LLM evolutionary search, as it provides empirical proof that evolutionary algorithms are strictly necessary to navigate beyond the learned data manifold. Furthermore, the community could directly adopt their dual-manifold projection technique to measure and enforce population diversity during evolutionary search. |
Henrik Voigt et.al. |
Friedrich Schiller University Jena |
arXiv.org |
pdf / code
|
| 25/30 |
2026-04-27 |
A2DEPT: Large Language Model-Driven Automated Algorithm Design via Evolutionary Program TreesA2DEPT advances LLM-driven algorithm design by evolving complete, open-ended solver programs via a tree-structured search with hierarchical operators and an automated dependency repair loop. The results are rigorously backed by empirical data, showing a 9.8% reduction in the mean normalized optimality gap relative to state-of-the-art baselines (FunSearch, EoH, ReEvo) across standard combinatorial optimization benchmarks like CVRP and FJSP. The key insight is the decoupling of mutations into hierarchical operators (macro-mutation for workflow restructuring vs. micro-tuning for local refinement) paired with a closed-loop dependency repair mechanism, which allows the LLM to safely rewrite system-level logic without permanently breaking executability. This is highly relevant for LLM evolutionary search research, as it provides a concrete, implementable mechanism to escape the performance ceiling of fixed algorithmic templates and synthesize entirely novel solver architectures. |
Bin Chen et.al. |
National University of Defense Technology, University of Electronic Science and Technology of China, Academy of Military Medical Sciences |
arXiv.org |
pdf / code |
| 27/30 |
2026-04-27 |
SeaEvo: Advancing Algorithm Discovery with Strategy Space EvolutionSeaEvo augments LLM-driven evolutionary search by maintaining a persistent, population-level memory of natural-language strategy descriptions, clustering them to ensure diverse parent selection and tracking strategy saturation. Backed by strong empirical results, it achieves up to a 66% improvement on systems optimization tasks (like GPU model placement) over state-of-the-art backbones like ShinkaEvolve, while reducing cumulative API costs. The key insight is the Stratified Experience Retrieval (SER) module, which clusters candidate strategies using text embeddings and selects parents based on behavioral complementarity rather than just fitness, preventing premature convergence on syntactic variants of the same flawed idea. This is a must-read for our work in LLM evolutionary search, as it provides a concrete, implementable architecture for persistent memory and sample efficiency, directly tested on the exact LLM serving and scheduling problems we target. |
Sichun Luo et.al. |
The University of Hong Kong, City University of Hong Kong, JIUTIAN Research, China Mobile |
arXiv.org |
pdf / code |
| 19/30 |
2026-04-24 |
GR-Evolve: Design-Adaptive Global Routing via LLM-Driven Algorithm EvolutionGR-Evolve applies an LLM-driven evolutionary search framework to automatically specialize C++ global routing algorithms for specific chip designs. The results are empirically strong, demonstrating up to an 8.72% reduction in post-detailed-routing wirelength over established baselines like FastRoute and CUGR. The key insight is the use of 'warm-start evolution'—evolving heuristics on smaller, cheaper-to-evaluate instances and transferring the modified codebase as the initialization for larger instances—combined with a stateless, Git-backed persistent memory to avoid context degradation. This is highly relevant to our work in LLM evolutionary search; the warm-start curriculum and stateless memory architecture are concrete techniques we should adopt to improve sample efficiency when evolving heuristics for large-scale optimization problems. |
Taizun Jafri et.al. |
Arizona State University |
arXiv.org |
pdf / code
|
| 25/30 |
2026-04-22 |
Learning to Evolve: A Self-Improving Framework for Multi-Agent Systems via Textual Parameter Graph OptimizationHe et al. introduce Textual Parameter Graph Optimization (TPGO), a framework that optimizes multi-agent systems by representing their configurations as modular graphs and evolving them using textual gradients. The results are backed by solid empirical evidence, demonstrating a 7-10% absolute success rate improvement on complex benchmarks like MCP-Universe and GAIA over strong baselines (ReAct, MiroFlow). The key insight is the Group Relative Agent Optimization (GRAO) mechanism, which maintains an 'Optimization Experience Memory' of past successful and failed graph edits, clustering and retrieving them to teach the LLM optimizer how to generate better updates over time. This is highly relevant for our work in LLM evolutionary search; adopting the graph-based representation and historical experience retrieval could significantly improve the sample efficiency and stability of our evolutionary algorithms. |
Shan He et.al. |
Future Living Lab of Alibaba |
arXiv.org |
pdf / code |
| 27/30 |
2026-04-14 |
BEAM: Bi-level Memory-adaptive Algorithmic Evolution for LLM-Powered Heuristic DesignBEAM reformulates LLM-based automatic heuristic design as a bi-level optimization problem, using a Genetic Algorithm to evolve high-level algorithmic structures and Monte Carlo Tree Search to implement specific function placeholders. The results are strongly backed by empirical evidence, showing a 37.84% aggregate reduction in optimality gap for CVRP hybrid algorithm design compared to existing LLM hyper-heuristics, and even outperforming the SOTA KaMIS solver on Maximum Independent Set problems. The key insight is the Adaptive Memory mechanism: instead of forcing the LLM to rewrite or patch long code blocks in every generation, BEAM stores high-performing functions in a repository and allows the LLM to simply `import` them by name, drastically reducing token consumption and improving sample efficiency. This is a must-read for our work on LLM evolutionary search, as the bi-level structure and import-based memory directly solve the scalability and context-limit bottlenecks inherent in AlphaEvolve-style frameworks. |
Chuyang Xiang et.al. |
|
arXiv.org |
pdf / code |
| 20/30 |
2026-04-08 |
PRIME: Training Free Proactive Reasoning via Iterative Memory Evolution for User-Centric AgentPRIME is a gradient-free framework that improves LLM agents by distilling multi-turn interaction trajectories into a structured memory library and optimizing it via evolutionary operators (mutation, crossover, generalization, pruning). The results are backed by strong empirical evidence, showing competitive performance with GRPO-trained models on 8 benchmarks while requiring 5-6x fewer GPU hours and demonstrating cross-architecture transferability. The key insight is the combination of multi-turn credit assignment (Reward-to-Go) to isolate pivotal decision steps for distillation, alongside LLM-driven evolutionary operators that continuously refine text-based memories into generalized strategies. This is highly relevant for research in LLM evolutionary search and multi-agent optimization, as the team can directly adapt the memory evolution operators and the three-zone (success, failure, preference) structured memory architecture for persistent heuristic discovery and multi-agent debate systems. |
Prince Zizhuang Wang et.al. |
Carnegie Mellon University |
arXiv.org |
pdf / code |
| 25/30 |
2026-04-07 |
ResearchEVO: An End-to-End Framework for Automated Scientific Discovery and DocumentationResearchEVO is an end-to-end framework that combines LLM-guided bi-dimensional co-evolution for algorithm discovery with a sentence-level RAG pipeline to autonomously generate scientific papers explaining the discovered algorithms. Results are backed by rigorous empirical evidence, demonstrating novel, human-interpretable algorithmic discoveries for Quantum Error Correction (using real hardware data) and PINN training stability, alongside compilable papers with zero hallucinated citations. The key insight is the bi-dimensional search space—explicitly separating the evolution of internal module logic from the overall algorithm architecture—combined with feeding structured execution errors back into the LLM for corrective guidance. This is highly relevant for LLM evolutionary search research, as it provides concrete mechanisms to escape local optima in template-based generation and offers a novel paradigm for making black-box evolutionary discoveries interpretable. |
Zhe Zhao et.al. |
City University of Hong Kong |
arXiv.org |
pdf / code
|
| 25/30 |
2026-04-06 |
RoboPhD: Evolving Diverse Complex Agents Under Tight Evaluation BudgetsRoboPhD optimizes LLM agent evolution under tight evaluation budgets by replacing traditional validation sets with an Elo-based tournament on training data and allowing agents to evolve their own diagnostic instrumentation. The results are backed by solid empirical comparisons, outperforming GEPA and Autoresearch on 3 out of 4 benchmarks (ARC-AGI, Text2SQL, DocFinQA) under a strict 1,500 evaluation budget. The single most useful takeaway we can steal is 'self-instrumenting agents'—seeding the initial agent with print() statements and letting the evolutionary process grow its own logging to provide richer Actionable Side Information (ASI) to the LLM optimizer. This paper matters immensely for AlgoEvo; we should immediately test dropping our validation splits in favor of Elo tracking and implement self-instrumenting diagnostics to improve our evolutionary signal without increasing API costs. |
Andrew Borthwick et.al. |
Independent Researchers |
arXiv.org |
pdf / code
|
| 24/30 |
2026-04-03 |
Breaking Validity-Induced Boundaries to Expand Algorithm Search Space: A Two-Stage AST-Based Operator for LLM-Driven Automated Heuristic EvolutionThis paper introduces a two-stage AST-based evolutionary operator for LLM-driven automated heuristic design that intentionally generates invalid code structures via AST crossover and mutation, followed by an LLM repair phase to produce executable heuristics. The approach is backed by empirical results on TSP and Online Bin Packing, demonstrating that integrating this operator into frameworks like EoH and ReEvo improves optimization performance while reducing token consumption by 18-45%. The key insight is that forcing the LLM to repair structurally broken code, rather than generating valid code end-to-end, breaks the model's pre-trained semantic biases and expands the algorithm search space. This is highly relevant for our research in LLM evolutionary search; decoupling structural perturbation (via cheap AST operations) from semantic repair is a concrete technique we should adopt to improve exploration diversity and sample efficiency. |
Sun Shengming et.al. |
Xi’an Jiaotong University |
arXiv.org |
pdf / code |
| 25/30 |
2026-04-01 |
CliffSearch: Structured Agentic Co-Evolution over Theory and Code for Scientific Algorithm DiscoveryCliffSearch is an LLM-based evolutionary framework that co-evolves algorithm theory and code, using specialized agents for crossover, two-path mutation (exploration vs. repair), and explicit reviewer gating. The results are backed by concrete empirical runs on nanoGPT optimizer discovery and transformer hyper-connection search, demonstrating the discovery of genuinely novel geometric routing and optimizer variants rather than trivial hyperparameter tweaks. The single most useful takeaway is the 'reviewer-gated selection' where an LLM explicitly scores candidates on originality and correctness as a hard survival gate before benchmark scores are considered. This is highly relevant for our AlgoEvo project; we should immediately steal the two-path mutation (novelty vs repair) and the originality hard-gate to prevent our populations from converging on unoriginal benchmark-hacking. |
Youssef Mroueh et.al. |
IBM Research |
arXiv.org |
pdf / code |
| 23/30 |
2026-03-30 |
Evolutionary Discovery of Reinforcement Learning Algorithms via Large Language ModelsThis paper evolves executable reinforcement learning update rules using LLMs as macro-mutation and crossover operators, explicitly forbidding standard RL mechanisms to force the discovery of novel algorithms. The results are backed by solid empirical evaluations on Gymnasium benchmarks, showing the evolved algorithms match or beat standard baselines like PPO and SAC on several tasks, though they struggle on a few complex continuous control environments. The single most useful takeaway for us is their diversity-aware crossover, which uses normalized Levenshtein distance to penalize recombining near-duplicate parents, alongside a post-evolution step where the LLM proposes bounds for internal scalar parameters before a final sweep. We should immediately test the Levenshtein-penalized crossover in AlgoEvo to prevent diversity collapse, and adopt the LLM-bounded HPO step to ensure we aren't discarding good heuristics simply because of bad default scalar parameters. |
Alkis Sygkounas et.al. |
Machine Perception and Interaction Lab, Örebro University, Sweden |
GECCO 2026 |
pdf / code |
| 23/30 |
2026-03-30 |
COvolve: Adversarial Co-Evolution of Large-Language-Model-Generated Policies and Environments via Two-Player Zero-Sum GameCOvolve uses LLMs to adversarially co-evolve Python code for both environments (tasks) and policies (agents), using Policy Space Response Oracles (PSRO) to compute a mixed-strategy Nash equilibrium (MSNE) that prevents catastrophic forgetting. The results are backed by solid empirical data across MiniGrid, PyGame, and CARLA, demonstrating that the MSNE approach maintains robust performance across a growing historical archive of environments much better than greedy retention. WHAT WE LEARNED: The use of an empirical payoff matrix and MSNE to evaluate new code against an archive of past opponents/environments is a powerful memory and evaluation mechanism for LLM evolution. This matters immensely for us: we can steal this exact architecture for AlgoEvo or EvoCut by co-evolving hard OR instances (environments) alongside our solver heuristics (policies), using MSNE to ensure our heuristics do not overfit to specific instance types. |
Alkis Sygkounas et.al. |
Örebro University |
GECCO 2026 |
pdf / code
|
| 26/30 |
2026-03-30 |
Kernel-Smith: A Unified Recipe for Evolutionary Kernel OptimizationKernel-Smith combines an evaluation-driven evolutionary agent with a step-centric reinforcement learning recipe to generate high-performance GPU kernels. The results are backed by strong empirical evidence, achieving state-of-the-art speedups on KernelBench (3.70x average vs Claude-4.6-opus's 3.33x) and resulting in merged pull requests for production engines like SGLang and LMDeploy. The key insight is that when training an LLM for evolutionary search, one should not train on full trajectories (which causes shortcut learning) or initial steps (which are too easy); instead, apply RL exclusively to the highest-gain atomic revision steps to optimize the model as a powerful local improver. This is a must-read for our work in LLM evolutionary search, as it provides a validated, reproducible recipe for fine-tuning models to act as highly efficient mutation operators. |
He Du et.al. |
Shanghai AI Laboratory, Fudan University, MetaX |
arXiv.org |
pdf / code
|
| 26/30 |
2026-03-25 |
AVO: Agentic Variation Operators for Autonomous Evolutionary SearchChen et al. (NVIDIA) introduce Agentic Variation Operators (AVO), replacing the fixed mutation and crossover pipelines in LLM evolutionary search with an autonomous coding agent that iteratively plans, implements, tests, and debugs candidate solutions. The results are highly rigorous and backed by hardware benchmarks, showing the evolved kernels outperform expert-tuned cuDNN (up to 3.5%) and FlashAttention-4 (up to 10.5%) on Blackwell B200 GPUs. The critical takeaway is elevating the LLM from a single-turn candidate generator to a self-directed variation operator with access to persistent memory, profiling feedback, and domain documentation, allowing it to perform multi-step hardware-level reasoning before committing a candidate. This is a must-read for LLM evolutionary search, as it directly challenges the standard FunSearch paradigm and provides a concrete architectural blueprint for integrating general-purpose coding agents into evolutionary optimization loops. |
Terry Chen et.al. |
NVIDIA |
arXiv.org |
pdf / code
|
| 28/30 |
2026-03-19 |
HyperagentsZhang et al. introduce DGM-Hyperagents, a self-referential evolutionary search framework where the task agent and the meta-agent (the evolver) are unified into a single editable program. The results are rigorously backed by empirical evaluations across coding, robotics reward design, and math grading, showing significant gains over fixed-meta-agent baselines like the original Darwin Gödel Machine. The key insight is 'metacognitive self-modification': by allowing the LLM to edit the improvement procedure itself, the system autonomously develops persistent memory, performance tracking, and compute-aware planning without explicit human prompting. This is a must-read for our work in LLM evolutionary search, as it provides a concrete blueprint for moving beyond fixed, handcrafted evolutionary operators to fully self-improving search architectures. |
Jenny Zhang et.al. |
Meta, University of British Columbia, Vector Institute, University of Edinburgh, New York University, Canada CIFAR AI Chair |
arXiv.org |
pdf / code
|
| 22/30 |
2026-03-18 |
Procedural Generation of Algorithm Discovery Tasks in Machine LearningThis paper introduces DiscoGen, a procedural generator that combinatorially creates millions of algorithm discovery tasks (varying domains, editable modules, and datasets) with strict meta-train/meta-test splits to evaluate and train Algorithm Discovery Agents (ADAs). The results are backed by extensive empirical evaluation of open-source LLMs on a fixed subset (DiscoBench), demonstrating that current ADAs struggle with multi-module discovery and that prompt-tuning over a diverse set of procedurally generated tasks significantly improves generalization. The single most useful takeaway is the combinatorial task generation approach (toggling which modules are editable vs. fixed), which provides a brilliant blueprint for creating an autocurriculum to train our 'evolver' agents. This matters immensely for us; we should immediately consider using DiscoGen to evaluate AlgoEvo, and adapt their procedural task generation strategy to create diverse OR/routing environments for our own RL-infused evolutionary search training. |
Alexander D. Goldie et.al. |
University of Oxford, University College London, University of California, Santa Barbara, University of Wisconsin–Madison, Delft University of Technology |
arXiv.org |
pdf / code
|
| 25/30 |
2026-03-15 |
CausalEvolve: Towards Open-Ended Discovery with Causal ScratchpadCausalEvolve enhances LLM evolutionary search frameworks (like AlphaEvolve and ShinkaEvolve) by introducing a causal scratchpad that extracts outcome- and procedure-level factors to explicitly guide program mutations via a Multi-Armed Bandit. The results are backed by solid empirical numbers, showing it outperforms the state-of-the-art ShinkaEvolve across four algorithmic and mathematical tasks (Hadamard, Autocorrelation, Circle Packing, AIME) by up to 9.1% in best-found scores. The single most useful takeaway for us is their 'surprise detection' module: using LLMs to perform abductive reasoning when a seemingly good combination of factors yields a score drop, thereby uncovering hidden confounders and generating new search directions. This is highly relevant to our work; we should immediately evaluate their MAB-driven causal intervention strategy and procedure-level factor extraction to improve the sample efficiency and memory mechanisms in AlgoEvo. |
Yongqiang Chen et.al. |
Carnegie Mellon University, MBZUAI, Hong Kong Baptist University, The University of Sydney |
arXiv.org |
pdf / code |
| 23/30 |
2026-03-12 |
CreativeBench: Benchmarking and Enhancing Machine Creativity via Self-Evolving ChallengesWang et al. introduce CreativeBench to evaluate LLM code generation creativity and propose EvoRePE, a representation engineering technique that extracts a 'creativity vector' from AlphaEvolve search trajectories to steer model activations at inference time. The results are backed by solid empirical evaluations, showing that injecting this vector improves novelty and correctness even without running the full evolutionary search. THE SINGLE MOST USEFUL TAKEAWAY: We can run our evolutionary search (e.g., AlgoEvo) offline to collect (base_heuristic, evolved_heuristic) pairs, compute the PCA of their hidden state differences, and inject this vector during standard inference to force the model into an exploratory mode. This is highly relevant to our work as it offers a completely new, training-free mechanism to solve the sample efficiency and scalability bottlenecks in LLM evolutionary search. |
Zi-Han Wang et.al. |
Tsinghua University, Peking University, Southern University of Science and Technology, University of Bristol, The Hong Kong University of Science and Technology (Guangzhou), Xi’an Jiaotong University |
ACL |
pdf / code
|
| 23/30 |
2026-03-12 |
KernelFoundry: Hardware-aware evolutionary GPU kernel optimizationKernelFoundry is an LLM-based evolutionary framework for GPU kernel optimization that combines MAP-Elites quality-diversity search with meta-prompt co-evolution and gradient-informed mutation hints. The results are rigorously backed by numbers, showing a 2.1x speedup over the AI CUDA Engineer baseline on KernelBench L2 and successful optimization of Llama 3 operations. The single most useful takeaway for us is their 'Gradient-Informed Evolution' technique: they track parent-to-child fitness transitions in the MAP-Elites archive to compute pseudo-gradients across behavioral dimensions, which are then translated into specific natural language mutation hints for the LLM (e.g., 'positive gradient in memory -> hint: add shared memory tiling'). While we do not write low-level GPU kernels, this exact architectural improvement—alongside their meta-prompting to prevent context pollution—is highly transferable and should be immediately tested in AlgoEvo and EvoCut to improve our search signal and sample efficiency. |
Nina Wiedemann et.al. |
Intel Corporation |
arXiv.org |
pdf / code |
| 20/30 |
2026-03-11 |
Reinforced Generation of Combinatorial Structures: Ramsey NumbersNagda et al. (DeepMind) apply the AlphaEvolve framework to discover novel stochastic search algorithms that improve lower bounds for five classical Ramsey numbers and match SoTA on 23 others. The results are mathematically verified and represent genuine SoTA advances in extremal combinatorics, proving the framework's capability to generate highly specialized, non-trivial heuristics. The single most useful takeaway for us is their meta-algorithm's scoring function: instead of only rewarding valid states, they evaluate a larger, infeasible 'prospect' state and provide a dense, continuous reward based on its violation count relative to a random baseline. We should immediately steal this 'prospect evaluation' trick for AlgoEvo to smooth the reward landscape when evolving heuristics for highly constrained OR problems like VRP, where finding strictly feasible intermediate solutions is a bottleneck. |
Ansh Nagda et.al. |
Google DeepMind, Google, University of California, Berkeley |
arXiv.org |
pdf / code |
| 23/30 |
2026-03-10 |
Code-Space Response Oracles: Generating Interpretable Multi-Agent Policies with Large Language ModelsThis paper replaces the deep RL oracle in Policy-Space Response Oracles (PSRO) with an LLM that generates interpretable Python code policies, using AlphaEvolve to iteratively refine the code against opponent meta-strategies. The results are backed by solid empirical metrics, showing that the AlphaEvolve variant achieves competitive exploitability and higher population returns than RL baselines (IMPALA) and CFR+ on Repeated Rock-Paper-Scissors and Leduc Poker. The single most useful takeaway for us is their 'context abstraction' technique—using an LLM to summarize opponent code into natural language to bypass context window limits during evolutionary search. This is highly relevant for our AlgoEvo project; we should immediately discuss implementing their two-level loop (outer meta-game equilibrium, inner AlphaEvolve refinement) and context abstraction for our multi-agent evolutionary search. |
Daniel Hennes et.al. |
Google DeepMind |
Proceedings of the 25th International Conference on Autonomous Agents and Multiagent Systems |
pdf / code |
| 26/30 |
2026-03-09 |
Advancing Automated Algorithm Design via Evolutionary Stagewise Design with LLMsEvoStage enhances LLM-based automated algorithm design by decomposing the generation process into sequential stages, using a multi-agent system (coordinator and coders) to iteratively refine code based on real-time intermediate execution feedback. The results are highly credible and backed by strong empirical numbers; it achieves state-of-the-art HPWL on 16 chip placement benchmarks and beats AlphaEvolve/EoH on Bayesian Optimization tasks using an incredibly small budget of just 9 to 25 evaluations. The single most useful takeaway is the shift from black-box end-to-end evaluation to stagewise intermediate feedback, where a coordinator agent reflects on mid-execution metrics to guide the next stage of heuristic design. This matters immensely for our AlgoEvo and MASPRM projects; we should immediately test pausing our VRP/scheduling environments mid-execution to feed intermediate state metrics to a coordinator LLM, which could drastically reduce the number of LLM samples we need to find optimal heuristics. |
Chen Lu et.al. |
Nanjing University, Huawei Noah’s Ark Lab |
arXiv.org |
pdf / code |
| 22/30 |
2026-03-08 |
CDEoH: Category-Driven Automatic Algorithm Design With Large Language ModelsThis paper extends the EoH framework by using an LLM to classify generated heuristics into algorithmic categories (e.g., greedy, DP) and applying a two-stage selection strategy to explicitly maintain diversity, alongside a standard reflection loop for code repair. The authors demonstrate empirical improvements over EoH, FunSearch, and ReEvo on Online Bin Packing and TSP, though they lack statistical significance testing. The single most useful takeaway is the 'category pool' concept: prompting the LLM to label the paradigm of the generated code and ensuring the top-1 of each discovered paradigm survives to the next generation. This matters directly for our AlgoEvo project, as it offers a cheap, explicit way to maintain search space exploration without the massive computational overhead of FunSearch's multi-island model. |
Yu-Nian Wang et.al. |
City University of Hong Kong, Nanjing University, Hohai University |
arXiv.org |
pdf / code |
| 26/30 |
2026-03-07 |
DyACE: Dynamic Algorithm Co-evolution for Online Automated Heuristic Design with Large Language ModelDyACE reformulates LLM-driven automated heuristic design from a static optimization task into a dynamic control problem, using a receding horizon architecture to continuously co-evolve phase-specific heuristic operators alongside the solution population. The results are backed by strong empirical numbers on JSSP, TSP, and CVRP, significantly outperforming state-of-the-art static baselines like ReEvo and FunSearch (e.g., reducing the optimality gap on CVRP CMT1 from ReEvo's 12.5% to 3.1%). The single most useful takeaway is the 'Look-Ahead Rollout Search' combined with a decoupled Diagnosis Agent: instead of evaluating an algorithm end-to-end, they run short rollouts to extract 'Search Trajectory Features' (landscape kinematics, operator telemetry) which an LLM translates into 'Verbal Gradients' to guide the next code mutation. This is a must-read for our AlgoEvo project; it directly addresses our bottlenecks in sample efficiency and search signaling by proving that dynamic, state-aware operator adaptation beats static heuristic generation, giving us a concrete architecture to steal. |
Guidong Lu et.al. |
|
arXiv.org |
pdf / code |
| 18/30 |
2026-03-05 |
Autonomous Algorithm Discovery for Ptychography via Evolutionary LLM ReasoningThis paper applies LLM-guided evolutionary search (similar to FunSearch/AlphaEvolve) to discover novel regularization algorithms for ptychographic image reconstruction. The results are backed by solid empirical metrics, showing up to +0.26 SSIM improvements over unregularized baselines across multiple datasets. The most useful takeaway for us is twofold: first, their 'semantically-guided crossover' explicitly prompts the LLM to analyze two successful parent algorithms and intentionally merge their complementary mathematical strengths, rather than blindly recombining code. Second, the LLM autonomously discovered the benefit of embedding stateful optimizers (like Adam) and iterative sub-loops directly inside a single heuristic step. This matters for our AlgoEvo and VRP work because we should immediately steal this semantic crossover prompting strategy and ensure our evaluation API permits the LLM to generate stateful, multi-pass operators rather than just stateless, single-pass functions. |
Xiangyu Yin et.al. |
Argonne National Laboratory, Rice University |
arXiv.org |
pdf / code |
| 25/30 |
2026-03-05 |
ReVEL: Multi-Turn Reflective LLM-Guided Heuristic Evolution via Structured Performance FeedbackReVEL enhances LLM-guided heuristic evolution by clustering candidate heuristics into behaviorally coherent groups and using multi-turn reflection to iteratively refine them based on group-level performance feedback. Backed by strong empirical numbers, it consistently outperforms state-of-the-art baselines like EoH and ReEvo on standard combinatorial optimization benchmarks including TSP, TSPLib, Online BPP, and CVRP. The key insight is the shift from pairwise comparison to group-wise reflection (inspired by GRPO), where heuristics are clustered using both performance profiles and semantic similarity (CodeBLEU) to provide the LLM with a richer, more stable context for proposing refinements. This is highly relevant for our work in LLM evolutionary search, as it directly addresses sample efficiency and the quality of the feedback signal, offering a concrete architectural improvement over existing evolutionary frameworks. |
Cuong Van Duc et.al. |
Hanoi University of Science and Technology, VinUniversity, Phenikaa University |
arXiv.org |
pdf / code |
| 25/30 |
2026-03-03 |
Rethinking Code Similarity for Automated Algorithm Design with LLMsZhang et al. propose BehaveSim, a metric that measures algorithmic similarity by applying Dynamic Time Warping (DTW) to the sequence of intermediate solutions (trajectories) generated during execution, rather than relying on static code analysis. By integrating this into FunSearch and EoH to enforce behavioral diversity, they achieve significant performance gains, notably reducing the optimality gap on TSP by ~7.8% compared to standard FunSearch. **Key Takeaway:** We must stop using code hashes or embedding cosine similarity for population diversity in AlgoEvo; instead, we should instrument generated heuristics to log intermediate states (e.g., partial VRP routes) and cluster them via DTW to prevent convergence to behaviorally identical local optima. This is a mandatory upgrade for our evolutionary search infrastructure. |
Rui Zhang et.al. |
City University of Hong Kong |
ICLR |
pdf / code
|
| 19/30 |
2026-03-03 |
Learning to Evolve for Optimization via Stability-Inducing Neural UnrollingGao et al. propose L2E, a meta-learned neural optimizer that uses Mamba blocks to parameterize evolutionary operators within a stability-enforcing unrolled loop (Krasnosel'skii-Mann iteration). Results on BBOB and LSGO-1000D are strong, showing it outperforms Transformer-based L2O methods (GLHF) and classical heuristics (DE) in sample efficiency and zero-shot generalization. **Key Takeaway:** We should investigate replacing Transformer-based population encoders in AlgoEvo with Mamba blocks to reduce complexity from quadratic to linear ($O(N)$), enabling larger population sizes in our meta-heuristic search. The theoretical framing of evolution as a fixed-point iteration also offers a rigorous stability constraint we could inject into our RL-guided search policies. |
Jiaxin Gao et.al. |
The Hong Kong Polytechnic University, The University of Hong Kong |
|
pdf / code |
| 24/30 |
2026-03-03 |
ParEVO: Synthesizing Code for Irregular Data: High-Performance Parallelism through Agentic EvolutionParEVO synthesizes high-performance parallel algorithms for irregular data by combining fine-tuned LLMs with an Evolutionary Coding Agent (ECA) that uses compilers, dynamic race detectors, and hardware profilers as absolute fitness functions. The results are highly rigorous and backed by extensive hardware benchmarks, showing up to a 106x speedup on ParEval and matching or beating expert human baselines on complex graph problems (e.g., 4.1x speedup on Maximal Independent Set). The single most useful takeaway for us is their evolutionary architecture: they use MAP-Elites (categorizing by code length, cyclomatic complexity, and sync primitives) to prevent diversity collapse, and they fine-tune their base models using Direct Preference Optimization (DPO) on past evolutionary trajectories to drastically improve sample efficiency. This is a must-read paper that directly advances our primary focus on LLM evolutionary search, providing concrete techniques we should immediately steal for AlgoEvo. |
Liu Yang et.al. |
Google DeepMind, Yale University |
arXiv.org |
pdf / code
|
| 23/30 |
2026-03-03 |
StitchCUDA: An Automated Multi-Agents End-to-End GPU Programing Framework with Rubric-based Agentic Reinforcement LearningStitchCUDA automates end-to-end GPU program generation using a multi-agent framework, but its core contribution is a training recipe that solves reward hacking in code optimization. They decompose expensive multi-turn agentic RL into single-turn 'atomic skills' (generation vs. refinement) and use GRPO with an LLM-evaluated 'Rubric Reward' (e.g., 'Did you use tiling?') rather than just sparse outcome metrics. This prevents the model from gaming the system (e.g., wrapping PyTorch code) and forces actual optimization behavior. We should steal the atomic skill decomposition to drastically reduce training costs for AlgoEvo and implement Rubric Rewards to fix our process reward models. |
Shiyang Li et.al. |
University of Minnesota-Twin Cities |
arXiv.org |
pdf / code |
| 19/30 |
2026-02-28 |
WirelessAgent++: Automated Agentic Workflow Design and Benchmarking for Wireless NetworksTong et al. automate the design of LLM agent workflows for wireless tasks using a domain-adapted MCTS over a code-structured search space. The results are rigorously backed by numbers, showing significant improvements over baselines like AFlow and ADAS with a total search cost under $5. The single most useful takeaway for us is their method for handling search efficiency and noise: they use a zero-cost rule-based 'heuristic critic' to pre-screen code mutations via AST analysis before expensive LLM evaluation, and a 3-class experience replay (using an epsilon-threshold) to prevent the optimizer from chasing evaluation noise. While we do not care about wireless networks, we should absolutely steal these two tricks to reduce API costs and stabilize fitness signals in our AlgoEvo pipeline. |
Jingwen Tong et.al. |
The Hong Kong University of Science and Technology, Shenzhen University |
arXiv.org |
pdf / code
|
| 24/30 |
2026-02-27 |
RF-Agent: Automated Reward Function Design via Language Agent Tree SearchRF-Agent frames LLM-based reward function design as a Monte Carlo Tree Search problem, using specialized expansion actions (mutation, crossover, path reasoning) and LLM self-verification to efficiently explore the code space. The results are real and backed by strong empirical numbers; it significantly outperforms Eureka and Revolve on 17 IsaacGym and Bi-DexHands tasks, achieving higher success rates with the same number of LLM samples, even when using the cheaper GPT-4o-mini model. The most stealable insights for us are the 'Path Reasoning' operator (prompting the LLM with the historical trajectory of code changes rather than just a single parent) and the 'Self-verify' score (using the LLM to predict code quality to bias MCTS selection before running expensive environment evaluations). Additionally, the 'thought-alignment' trick—regenerating the design thought after the code compiles to prevent hallucination drift—is a brilliant engineering fix. This is highly actionable for our work; we should immediately test the MCTS structure, path reasoning, and self-verify PRM-lite scoring in AlgoEvo to improve our sample efficiency. |
Ning Gao et.al. |
Beihang University |
arXiv.org |
pdf / code
|
| 27/30 |
2026-02-26 |
EvoX: Meta-Evolution for Automated DiscoveryEvoX introduces a two-level LLM-driven evolutionary framework that jointly evolves candidate solutions and the search strategies (parent selection rules, variation operators) used to generate them. The results are highly rigorous and backed by extensive numbers, demonstrating state-of-the-art performance across nearly 200 real-world optimization tasks (math, systems, Frontier-CS) and outperforming AlphaEvolve, OpenEvolve, and ShinkaEvolve. The single most useful takeaway is their use of a 'population state descriptor' combined with a sliding window stagnation detector; when progress stalls, EvoX prompts the LLM with this descriptor and a history of past strategies to generate a new, state-aware search policy (e.g., switching from free-form variation to UCB-guided structural variation). This paper is a mandatory read for us: it is a direct, high-quality implementation of our 'Evolving the Evolver' concept, and we should immediately steal their meta-evolution loop and state descriptor design to fix stagnation issues in AlgoEvo. |
Shu Liu et.al. |
UC Berkeley, Stanford University, Bespoke Labs |
arXiv.org |
pdf / code
|
| 24/30 |
2026-02-26 |
Enhancing CVRP Solver through LLM-driven Automatic Heuristic DesignThis paper integrates LLM-driven evolutionary search into the AILS framework to evolve 'ruin' heuristics for CVRP, employing a Chain-of-Thought 'voting' mechanism to filter out poor heuristics before expensive evaluation. The results are empirically strong: they claim 8 new Best-Known Solutions on the CVRPLib large-scale benchmark, outperforming HGS and AILS-II. **Key Takeaway:** We should steal the 'acceleration mechanism'—using the LLM to predict heuristic quality via CoT prior to execution—to address the sample efficiency bottleneck in our own evolutionary search loops. This is a direct proof-of-concept that LLM-evolved components can beat hand-crafted SOTA on hard OR instances. |
Zhuoliang Xie et.al. |
City University of Hong Kong, Southern University of Science and Technology |
arXiv.org |
pdf / code |
| 23/30 |
2026-02-25 |
ArchAgent: Agentic AI-driven Computer Architecture DiscoveryGupta et al. (Google/DeepMind) apply AlphaEvolve to generate C++ cache replacement policies, achieving ~1-5% IPC gains over SOTA (Mockingjay/SHiP) on SPEC and Google traces. The results are rigorous and demonstrate that LLM-driven evolution can outperform human experts in mature hardware domains 3-5x faster. WE LEARNED: The documentation of 'simulator escapes'—where the agent exploited a compiler optimization bug to delete memory writes and artificially boost scores—is a critical warning for our own automated benchmarking; we must harden our OR evaluators against adversarial optimization. Additionally, their 'hyperspecialization' approach (tuning policies per workload) validates our interest in instance-specific heuristic evolution. |
Raghav Gupta et.al. |
Google DeepMind, Google, University of California, Berkeley |
arXiv.org |
pdf / code |
| 27/30 |
2026-02-23 |
AdaEvolve: Adaptive LLM Driven Zeroth-Order OptimizationAdaEvolve replaces static evolutionary schedules with a three-tier adaptive controller: local exploration intensity based on an 'accumulated improvement signal' (pseudo-gradient), global compute allocation via a normalized bandit, and meta-level 'tactic' generation when stagnation occurs. Results are highly convincing, showing SOTA on Circle Packing (beating AlphaEvolve) and 185 other tasks while using the same LLM backbone as baselines, proving the gains are algorithmic. The most stealable insight is the $G_t$ signal metric—an exponential moving average of squared normalized improvements—which allows auto-tuning exploration rates without manual intervention. This is a direct upgrade for our AlgoEvo architecture, specifically addressing our sample efficiency and stagnation bottlenecks. |
Mert Cemri et.al. |
University of California, Berkeley, Bespoke Labs |
arXiv.org |
pdf / code
|
| 18/30 |
2026-02-18 |
RankEvolve: Automating the Discovery of Retrieval Algorithms via LLM-Driven EvolutionRankEvolve applies AlphaEvolve with MAP-Elites to evolve Python retrieval functions, achieving significant gains over BM25 on BEIR/BRIGHT by rediscovering concepts like soft stop-words and PMI-based scoring. The results are empirically rigorous, showing that 'Freeform' seeds (defining only I/O contracts) significantly outperform 'Composable' or 'Constrained' seeds, albeit at a 10x latency cost. For our AlgoEvo work, the key takeaway is the concrete evidence that constraining the search space to 'clean' components prematurely caps performance; we should adopt their 'Freeform' approach but add an explicit latency/cost constraint to the fitness function to manage the resulting complexity. |
Jinming Nian et.al. |
Walmart Global Tech, Santa Clara University, Independent Researcher |
arXiv.org |
pdf / code
|
| 27/30 |
2026-02-18 |
Discovering Multiagent Learning Algorithms with Large Language ModelsDeepMind applies AlphaEvolve to discover new variants of CFR and PSRO by evolving Python code for regret accumulation and meta-strategy solving. They identify VAD-CFR and SHOR-PSRO, which outperform human-designed SOTA (DCFR, PCFR+) on benchmarks like Leduc Poker and Liar's Dice; results are rigorous, using exact exploitability. The critical takeaway is the shift from evolving static functions to evolving **stateful classes** (e.g., tracking volatility via EWMA inside the accumulator), allowing the LLM to discover dynamic, adaptive schedules—a technique we should immediately port to AlgoEvo. |
Zun Li et.al. |
Google DeepMind |
arXiv.org |
pdf / code
|
| 24/30 |
2026-02-17 |
MadEvolve: Evolutionary Optimization of Cosmological Algorithms with Large Language ModelsMadEvolve extends AlphaEvolve by embedding a gradient-based optimization loop (via JAX) inside the fitness evaluation, allowing the LLM to focus purely on code structure while an optimizer (Adam) handles continuous parameters. They demonstrate 20-30% performance gains on complex cosmological reconstruction tasks, validated on held-out simulations. The critical takeaway is the architectural pattern: prompt the LLM to write differentiable code rather than tuning constants, and use a UCB1 bandit to dynamically select between cheap and expensive models. We should immediately adopt the differentiable inner-loop strategy for our continuous heuristic search projects. |
Tianyi Li et.al. |
University of Wisconsin-Madison |
arXiv.org |
pdf / code
|
| 28/30 |
2026-02-17 |
Heuristic Search as Language-Guided Program OptimizationLaGO decomposes automated heuristic design into three explicit modules: evaluation, a code-writing 'Analyst' (backward pass), and a diversity-aware 'Generator' (update), while co-evolving constructive and refinement heuristics. The authors demonstrate significant gains (+0.17 QYI) on PDPTW and Crew Pairing against ReEvo and EoH, showing that joint optimization of initialization and improvement prevents local optima. The critical takeaway is the 'Analyst' module: instead of asking the LLM for text critiques, they ask it to write Python feature extraction functions to statistically characterize solution quality—a technique we should immediately adopt to upgrade our fitness signals in AlgoEvo. |
Mingxin Yu et.al. |
Massachusetts Institute of Technology |
arXiv.org |
pdf / code |
| 21/30 |
2026-02-10 |
ImprovEvolve: Ask AlphaEvolve to Improve the Input Solution and Then ImproviseKravatskiy et al. introduce ImprovEvolve, a framework that restricts the LLM to evolving `improve()` (local search) and `perturb()` (mutation) operators, which are then executed by a fixed basin-hopping algorithm. They achieve new state-of-the-art results on Hexagon Packing and the Second Autocorrelation Inequality, demonstrating that this modular approach generalizes to unseen problem sizes where monolithic AlphaEvolve solutions fail. The critical insight is that LLMs are poor at designing global search logic and tuning hyperparameters (LLM edits actively harmed performance), so we should isolate the LLM to generating local moves while keeping the meta-heuristic framework deterministic. We should immediately apply this 'operator-only' evolution strategy to our ALNS research for VRP. |
Alexey Kravatskiy et.al. |
MIRIAI, FusionBrain Lab, Institute of Numerical Mathematics |
arXiv.org |
pdf / code |
| 25/30 |
2026-02-09 |
G-LNS: Generative Large Neighborhood Search for LLM-Based Automatic Heuristic DesignG-LNS extends LLM-based evolutionary search to ALNS by co-evolving Python code for Destroy and Repair operators rather than constructive priority rules. The authors introduce a 'Synergy Matrix' that tracks the performance of specific operator pairs during evaluation, using this data to guide a 'Synergistic Joint Crossover' where the LLM optimizes the coupling between destroy and repair logic. Results are strong: it significantly outperforms FunSearch and EoH on TSP/CVRP and beats OR-Tools on large-scale instances (N=200) under time constraints. The key takeaway for AlgoEvo is the synergy-aware co-evolution mechanism—explicitly tracking and prompting for component interaction is a concrete technique we can apply to multi-agent optimization systems. |
Baoyun Zhao et.al. |
Tsinghua University, University of Chinese Academy of Sciences, Northeastern University |
arXiv.org |
pdf / code
|
| 27/30 |
2026-02-09 |
Game-Theoretic Co-Evolution for LLM-Based Heuristic DiscoveryASRO adapts Policy Space Response Oracles (PSRO) to code generation, treating heuristic discovery as a zero-sum game where a 'Solver' evolves to minimize gaps and a 'Generator' evolves to create adversarial instances. The results are compelling: it consistently beats the static EoH baseline on TSPLIB and CVRPLIB, proving that adversarial training yields better generalization than training on fixed distributions. The critical takeaway is the architecture: explicitly co-evolving an 'Instance Generator' program alongside the solver prevents overfitting and exposes edge cases (like specific geometric traps in TSP) that static benchmarks miss. This is a direct upgrade to our AlgoEvo/AlphaEvolve pipelines, though it incurs higher computational costs due to the evaluation matrix required for the meta-game. |
Xinyi Ke et.al. |
Tsinghua University, Chinese Academy of Sciences, University of Chinese Academy of Sciences, AiRiA |
arXiv.org |
pdf / code |
| 21/30 |
2026-02-05 |
Mining Generalizable Activation FunctionsVitvitskyi et al. (DeepMind) utilize AlphaEvolve to discover novel activation functions by evolving Python code on small, synthetic datasets explicitly designed to test OOD generalization (e.g., polynomials, Feynman equations). The results are credible and backed by downstream transfer: discovered functions like `GELU * (1 + 0.5 sinc(x))` outperform baselines on algorithmic reasoning tasks (CLRS-30) while matching standard vision benchmarks. **Key Takeaway:** The 'Small-Scale Lab' methodology—optimizing on cheap, synthetic proxy tasks to find generalizable logic—is a validated strategy to bypass the computational bottleneck of evaluating evolved candidates on large-scale instances. We should steal this 'proxy evolution' setup for AlgoEvo to drastically reduce evaluation costs while targeting generalization in VRP heuristics. |
Alex Vitvitskyi et.al. |
Google DeepMind |
arXiv.org |
pdf / code
|
| 24/30 |
2026-02-04 |
Landscape-aware Automated Algorithm Design: An Efficient Framework for Real-world OptimizationYin et al. introduce a framework that decouples algorithm discovery from expensive evaluations by using Genetic Programming to evolve symbolic proxy functions that statistically match the target problem's landscape (via ELA features). Empirical results on photonics problems confirm that algorithms evolved on these cheap proxies transfer successfully to the real tasks, outperforming standard baselines like LSHADE with only 50×D real evaluations. **Key Takeaway:** We can synthesize 'symbolic gyms' that statistically mimic our target problems to run thousands of LLM iterations at near-zero cost. This directly addresses the sample efficiency bottleneck in AlgoEvo and suggests we should move beyond standard neural surrogates to evolved symbolic proxies. |
Haoran Yin et.al. |
|
arXiv.org |
pdf / code
|
| 19/30 |
2026-02-04 |
ProxyWar: Dynamic Assessment of LLM Code Generation in Game ArenasProxyWar introduces a tournament-based evaluation framework for LLM-generated code, using TrueSkill ratings from game simulations (Sudoku, Poker, etc.) instead of static unit tests. The results are robust (10k+ matches) and reveal a low correlation between Pass@1 and actual win rates; notably, 'reasoning' models like DeepSeek-R1 crush 'coding' models like Qwen-Coder in strategic tasks despite lower static scores. For our evolutionary search work, this confirms that we must move beyond static benchmarks to dynamic, competitive evaluation signals to avoid optimizing for syntax over strategy. We should also prioritize reasoning models over code-specialized ones for our agentic logic generation. |
Wenjun Peng et.al. |
|
arXiv.org |
pdf / code
|
| 26/30 |
2026-02-03 |
Contrastive Concept-Tree Search for LLM-Assisted Algorithm DiscoveryThe authors introduce Contrastive Concept-Tree Search (CCTS), which modifies the standard evolutionary loop by prompting the LLM to extract semantic 'concepts' from every generated program, building a dynamic hierarchy. They then apply a Tree-structured Parzen Estimator (TPE) to these concepts to learn a contrastive utility model (p(concept|good)/p(concept|bad)), using this to bias parent selection towards promising algorithmic strategies. Results are rigorous, showing consistent improvements over k-elite baselines on combinatorial tasks like Circle Packing, with a synthetic ablation confirming the model learns ground-truth concept utilities. **Key Takeaway:** We should immediately implement the 'Concept TPE' loop in AlgoEvo—asking the LLM to tag generated heuristics with concepts and maintaining a weight vector over these concepts provides a cheap, interpretable 'process reward model' to guide search. |
Timothee Leleu et.al. |
|
arXiv.org |
pdf / code |
| 19/30 |
2026-02-03 |
Persona Generators: Generating Diverse Synthetic Personas at ScalePaglieri et al. (DeepMind) apply AlphaEvolve to optimize Python code that generates synthetic personas, explicitly maximizing diversity metrics (convex hull, coverage) in embedding space rather than just fidelity. They achieve >80% coverage of the behavioral space compared to <50% for baselines, proving that evolving the *generator function* is more effective than prompting for diversity. The key takeaway is their two-stage architecture (autoregressive high-level trait generation $\to$ parallel detail expansion), which we should steal to evolve 'Solution Generators' for VRP/OR that inherently resist mode collapse. This validates our direction with AlgoEvo but offers a concrete architectural pattern for maintaining population diversity. |
Davide Paglieri et.al. |
Google DeepMind |
arXiv.org |
pdf / code
|
| 28/30 |
2026-02-02 |
DeltaEvolve: Accelerating Scientific Discovery through Momentum-Driven EvolutionDeltaEvolve replaces the standard full-code history in evolutionary search with 'semantic deltas'—structured text summaries capturing the 'from/to' logic of modifications and their hypotheses. Across 5 domains (including BBOB and Symbolic Regression), they demonstrate superior objective scores over AlphaEvolve while reducing token consumption by ~37%. The critical takeaway is the 'Progressive Disclosure' mechanism: treating history as a momentum vector (deltas) rather than a state archive (snapshots) allows us to fit a deeper evolutionary trajectory into the context window. We should immediately test their 'Delta Plan' prompt structure in AlgoEvo to improve sample efficiency and reduce costs. |
Jiachen Jiang et.al. |
Microsoft, The Ohio State University |
arXiv.org |
pdf / code
|
| 21/30 |
2026-02-02 |
Automatic Design of Optimization Test Problems with Large Language ModelsAchtelik et al. adapt LLM-driven evolutionary search (EoH) to generate interpretable Python functions that match specific landscape features (ELA), effectively creating synthetic benchmarks on demand. Unlike prior neural network approaches that fail to scale, this method performs robustly in higher dimensions (3D-5D) and produces portable code. The key takeaway is the capability to procedurally generate 'hard' or specific-property instances; we should immediately adopt this to create a dynamic training curriculum for AlgoEvo, ensuring our evolved metaheuristics generalize beyond standard libraries like BBOB. |
Wojciech Achtelik et.al. |
AGH University of Krakow, Warsaw University of Technology |
arXiv.org |
pdf / code
|
| 24/30 |
2026-02-01 |
Evolving Interdependent Operators with Large Language Models for Multi-Objective Combinatorial OptimizationE2OC introduces a hierarchical search framework where MCTS optimizes 'design thoughts' (textual strategies) rather than raw code, subsequently using these strategies to guide a coordinate-descent-style evolution of interdependent operators. While the computational cost is high due to the inner-loop operator rotation, the results on FJSP/TSP (+20% HV vs expert) and comparisons against FunSearch/EoH demonstrate that explicitly modeling operator coupling is superior to isolated evolution. The critical takeaway for us is the **'strategy-first' search layer**: evolving a semantic blueprint for component interaction *before* code generation prevents the local optima trap of independent component optimization, a technique we should immediately test in AlgoEvo. |
Junhao Qiu et.al. |
|
arXiv.org |
pdf / code
|
| 24/30 |
2026-01-29 |
READY: Reward Discovery for Meta-Black-Box OptimizationREADY introduces a multi-task evolutionary framework where LLMs evolve reward functions for multiple MetaBBO algorithms simultaneously, utilizing explicit 'Knowledge Transfer' operators to translate successful logic between distinct tasks. The results are robust, demonstrating superior performance over Eureka and EoH on BBOB benchmarks with a 2-4x reduction in search time due to parallelization and shared heuristics. The most stealable insights are the 'History-Reflection' operator—which prompts the LLM to extrapolate trends from the evolutionary trajectory rather than just mutating the current state—and the cross-niche transfer mechanism, both of which should be implemented in our multi-agent optimization stack immediately. |
Zechuan Huang et.al. |
|
arXiv.org |
pdf / code
|
| 26/30 |
2026-01-29 |
LLaMEA-SAGE: Guiding Automated Algorithm Design with Structural Feedback from Explainable AILLaMEA-SAGE augments LLM-based evolutionary search by extracting AST features (complexity, graph metrics) from generated code, training a surrogate model to predict fitness from these features, and using SHAP analysis to generate natural language prompts that guide the LLM to modify specific structural properties (e.g., 'increase cyclomatic complexity'). On the MA-BBOB benchmark, it outperforms state-of-the-art methods (MCTS-AHD, LHNS) and converges faster than vanilla LLaMEA, although the authors honestly report that statistical significance was limited (p=0.44) due to small sample sizes (5 runs). The critical takeaway for us is the pipeline of using static code analysis as a feedback signal—we can immediately steal this 'SAGE' loop to guide AlgoEvo or EvoCut by telling the LLM *how* to structurally mutate code based on surrogate correlations, rather than just hoping for random improvements. |
Niki van Stein et.al. |
Leiden University |
arXiv.org |
pdf / code
|
| 27/30 |
2026-01-29 |
TIDE: Tuning-Integrated Dynamic Evolution for LLM-Based Automated Heuristic DesignTIDE introduces a nested evolutionary framework that strictly decouples algorithmic structure generation (via LLM) from numerical parameter tuning (via Differential Evolution), managed by a Tree Similarity Edit Distance (TSED) guided island model. Results on 9 COPs (TSP, BPP, etc.) show it consistently outperforms ReEvo and EoH, primarily because the DE layer optimizes constants at zero token cost, preventing the discard of structurally sound but poorly tuned heuristics. The critical takeaway is the necessity of a gradient-free tuning layer for LLM-generated code; relying on LLMs for numerical constants is inefficient and imprecise. We should immediately implement a similar parameter-tuning inner loop in our AlgoEvo framework. |
Chentong Chen et.al. |
|
arXiv.org |
pdf / code |
| 24/30 |
2026-01-29 |
PathWise: Planning through World Model for Automated Heuristic Design via Self-Evolving LLMsPathWise reformulates heuristic discovery as a sequential planning problem over an 'Entailment Graph,' where a Policy Agent generates high-level evolutionary directives (rationales) and a World Model executes the code, guided by specific Critic reflections. The results are robust: it outperforms ReEvo, FunSearch, and MCTS-AHD on TSP, CVRP, and Bin Packing while using half the evaluation budget (500 vs 1000), demonstrating genuine sample efficiency. The key takeaway is the **Entailment Graph** structure: explicitly storing the *derivation rationale* and lineage allows the LLM to reason about the search trajectory and avoid redundant failures, a mechanism we should immediately adapt for AlgoEvo to fix our memory bottleneck. |
Oguzhan Gungordu et.al. |
|
arXiv.org |
pdf / code
|
| 24/30 |
2026-01-28 |
Magellan: Autonomous Discovery of Novel Compiler Optimization Heuristics with AlphaEvolveMagellan couples AlphaEvolve with a black-box autotuner (Vizier) to evolve C++ compiler heuristics, achieving >5% binary size reduction in LLVM and beating both human experts and prior neural policies. The results are rigorous, validated on production workloads and showing temporal generalization. **The critical takeaway is the 'Hierarchical Search' strategy:** rather than asking the LLM to write fully specified code, they prompt it to generate *templates* with exposed parameters (flags), delegating numerical tuning to a cheap external optimizer. This directly addresses the sample efficiency issues we face in AlgoEvo; we should immediately steal this architecture to separate structural evolution from parameter tuning. |
Hongzheng Chen et.al. |
Google DeepMind, Google, Cornell University |
arXiv.org |
pdf / code |
| 20/30 |
2026-01-27 |
Algorithmic Prompt-Augmentation for Efficient LLM-Based Heuristic Design for A SearchThis paper introduces 'Algorithmic-Contextual EoH' (A-CEoH), which injects the actual source code of the search algorithm (e.g., the A* driver loop, neighbor generation) into the LLM prompt alongside the problem description. Experiments on the Unit-Load Pre-Marshalling Problem and Sliding Puzzle Problem demonstrate that this algorithmic context allows a 32B parameter model (Qwen2.5-Coder) to generate heuristics superior to those from GPT-4o and human experts. The results are credible and backed by comparisons against optimal baselines. The key takeaway is a transferable 'prompt trick': explicitly showing the LLM the code that *calls* its generated function aligns the heuristic significantly better with the search dynamics than natural language descriptions alone. We should immediately test injecting our ALNS/search driver code into our evolutionary prompt templates. |
Thomas Bömer et.al. |
|
EvoStar conference; Code: https://github |
pdf / code
|
| 21/30 |
2026-01-27 |
CASTER: Breaking the Cost-Performance Barrier in Multi-Agent Orchestration via Context-Aware Strategy for Task Efficient RoutingCASTER implements a context-aware neural router for multi-agent systems that dynamically selects between weak and strong models, reducing inference costs by ~72% compared to a GPT-4o-only baseline. The authors validate this on a custom benchmark across four domains, showing it outperforms cascading strategies (FrugalGPT) by avoiding the 'double-billing' of failed weak calls. The standout takeaway for us is the 'On-Policy Negative Feedback' mechanism: training the router by explicitly relabeling instances where the weak model failed as 'Strong-Required'. We should adapt this active learning logic to train our proxy reward models in AlgoEvo, allowing us to reliably offload expensive evaluations to cheaper proxies without manual annotation. |
Shanyv Liu et.al. |
University of Houston, China University of Petroleum (East China), Southwest Jiaotong University |
arXiv.org |
pdf / code |
| 20/30 |
2026-01-23 |
The Art of Being Difficult: Combining Human and AI Strengths to Find Adversarial Instances for HeuristicsThis paper applies FunSearch to generate adversarial instances for classical OR heuristics (Knapsack, Bin Packing, k-median), successfully breaking long-standing theoretical lower bounds. The results are rigorous: they disprove the output-polynomial time of the Nemhauser-Ullmann algorithm and improve the Best-Fit bin packing bound to 1.5. The key takeaway for our AlgoEvo work is the workflow: the LLM finds 'messy' structural patterns (e.g., repeated floats) which humans then manually generalize into asymptotic proofs. This validates Program Search over vector search but exposes the 'generalization gap'—we should implement a post-processing agent to automate this manual refinement step. |
Henri Nikoleit et.al. |
Google DeepMind, University of Bonn, University of Manitoba |
arXiv.org |
pdf / code
|
| 24/30 |
2026-01-23 |
Scaling the Scaling Logic: Agentic Meta-Synthesis of Logic ReasoningLiu et al. introduce SS-Logic, an agentic framework that evolves Python 'Generator-Validator' pairs to scale logic task families, using a rigorous 'Code-Augmented Blind Review' where independent agents must write code to solve generated tasks to verify their validity. They expand 400 seed families to over 21k instances, achieving consistent gains on AIME (+3.0) and SynLogic (+5.2) via RLVR. **Crucial Takeaway:** We should steal the 'Blind Review' mechanism for AlgoEvo—using the solvability of a generated problem (by an independent code agent) as a strict fitness filter for the generator itself. This directly addresses our bottleneck in filtering invalid or hallucinated heuristics during evolutionary search. |
Bowen Liu et.al. |
Tencent, The Hong Kong University of Science and Technology (Guangzhou) |
arXiv.org |
pdf / code
|
| 20/30 |
2026-01-23 |
Talking to Yourself: Defying Forgetting in Large Language ModelsSun et al. propose SA-SFT, a method where the model generates its own 'self-talk' data before fine-tuning, which is then mixed with task data to prevent catastrophic forgetting. The results are compelling: they show that this self-generated data preserves reasoning skills (like GSM8K) better than external datasets, and crucially, ablation studies prove that removing math content from the self-data *still* preserves math skills. The key takeaway is that forgetting is largely driven by style-induced gradient drift rather than knowledge overwriting. This offers a practically free way to stabilize our specialized heuristic-generation models without needing to curate external replay buffers. |
Yutao Sun et.al. |
Zhejiang University, Stanford University, ETH Zürich, Binjiang Institute of Zhejiang University, Om AI Research |
arXiv.org |
pdf / code |
| 20/30 |
2026-01-22 |
LLM-Assisted Automatic Dispatching Rule Design for Dynamic Flexible Assembly Flow Shop SchedulingLLM4DRD employs a dual-agent framework (Generator & Evaluator) to evolve priority dispatching rules for dynamic flexible assembly flow shops. The core contribution is the **Hybrid Evaluation** mechanism, where the Evaluator generates qualitative critiques (strengths/weaknesses) that are injected into the Generator's prompts to guide specific operators like 'Dominance-Fusion Crossover' and 'Directed Optimization.' Empirical results show it outperforms FunSearch and EOH, avoiding the premature convergence seen in other methods. The most stealable insight is the prompt structure for crossover: rather than blindly combining code, it uses the Evaluator's analysis of parent strengths to direct the merger, a technique we should implement to improve sample efficiency in our evolutionary search. |
Junhao Qiu et.al. |
|
arXiv.org |
pdf / code |
| 29/30 |
2026-01-22 |
Learning to Discover at Test TimeTTT-Discover introduces a method to fine-tune an LLM (gpt-oss-120b) *during* inference on a single test problem using RL, replacing the frozen-model evolutionary search of AlphaEvolve. They employ a novel 'entropic objective' that optimizes for the single best solution (discovery) rather than expected return, combined with PUCT-based state reuse. The results are empirically rigorous, setting new SOTA on Erdős’ problem, GPU kernel optimization, and AtCoder contests, directly beating AlphaEvolve and ShinkaEvolve. The critical takeaway is that for hard discovery tasks, shifting the model's distribution via online updates is superior to context-based search; we should immediately test their entropic objective in our AlgoEvo pipeline. |
Mert Yuksekgonul et.al. |
Stanford University, NVIDIA, UC San Diego, Together AI, Astera Institute |
arXiv.org |
pdf / code
|
| 22/30 |
2026-01-22 |
Online Operator Design in Evolutionary Optimization for Flexible Job Shop Scheduling via Large Language ModelsLLM4EO embeds an LLM directly into the Genetic Algorithm loop to dynamically generate and replace gene-selection operators whenever the population stagnates, rather than training them offline. Results on FJSP benchmarks (Brandimarte, Fattahi) show a 3-4% improvement over static GA and GP, with convergence plots demonstrating that LLM interventions successfully break local optima. The most stealable insight is the 'Perception and Analysis' prompt structure: it forces the LLM to explicitly diagnose *why* the current population is stuck (based on fitness stats) before generating new code, a mechanism we should port to AlgoEvo to handle search stagnation. This validates the viability of online, state-aware LLM intervention in OR scheduling problems. |
Rongjie Liao et.al. |
City University of Hong Kong, Guangdong University of Technology |
|
pdf / code |
| 21/30 |
2026-01-15 |
Global Optimization for Combinatorial Geometry Problems Revisited in the Era of LLMsBerthold et al. demonstrate that standard global NLP solvers (SCIP, Xpress) outperform DeepMind's AlphaEvolve on its own benchmarks (circle/hexagon packing, min-max distance) without any learning or evolution. The results are rigorous, improving on 'newly discovered' solutions within minutes using default solver settings. **CRITICAL TAKEAWAY:** We must validate our AlgoEvo results against classical global solvers to ensure we aren't claiming 'discovery' on problems that are trivial for SCIP; furthermore, it suggests a hybrid path where LLMs generate NLP models for solvers rather than evolving raw heuristic code. This is a necessary reality check for our benchmarking strategy. |
Timo Berthold et.al. |
|
|
pdf / code |
| 23/30 |
2026-01-09 |
Weights to Code: Extracting Interpretable Algorithms from the Discrete TransformerZhang et al. introduce the 'Discrete Transformer,' a constrained architecture that learns algorithmic tasks via gradient descent and allows for the post-hoc extraction of exact, human-readable Python code. By enforcing functional disentanglement (using attention strictly for routing and MLPs for arithmetic) and employing temperature-annealed sampling, they recover symbolic laws for arithmetic and physics tasks with near-zero error. The critical takeaway is their 'continuous-to-discrete homotopy' strategy—annealing from soft to hard selection during training—which enables differentiable search to converge on discrete, symbolic solutions. This suggests a viable path to discover heuristics via continuous optimization rather than purely stochastic LLM evolution. |
Yifan Zhang et.al. |
|
arXiv.org |
pdf / code |
| 24/30 |
2026-01-06 |
CodeEvolve: an open source evolutionary coding agent for algorithm discovery and optimizationCodeEvolve couples islands-based genetic algorithms with LLMs, utilizing CVT-MAP-Elites for diversity and a specific 'inspiration-based' crossover operator where the LLM integrates logic from high-ranking peer solutions. The results are strong and backed by numbers: they beat AlphaEvolve on 5/9 benchmarks and demonstrate that Qwen3-Coder-30B matches Gemini-2.5 performance at ~10% of the cost. The single most useful takeaway is the implementation of the 'inspiration' operator and the necessity of MAP-Elites over simple elitism to escape local optima in code space. We should immediately benchmark their open-source framework against our internal AlgoEvo builds. |
Henrique Assumpção et.al. |
Inter&Co., Worcester Polytechnic Institute, Universidade Federal de Minas Gerais |
arXiv.org |
pdf / code
|
| 28/30 |
2025-12-30 |
LoongFlow: Directed Evolutionary Search via a Cognitive Plan-Execute-Summarize ParadigmLoongFlow replaces the standard stochastic mutation operator in LLM evolutionary search with a 'Plan-Execute-Summarize' (PES) cognitive loop. Instead of random code changes, a Planner retrieves the 'intent' and 'summary' of the parent solution's lineage to generate a directed hypothesis, which is then executed and summarized for the next generation. The authors demonstrate a 60% reduction in evaluations and a 100% success rate on AlphaEvolve tasks where standard methods fail or stagnate. The critical takeaway is the 'Lineage-Based Context Retrieval' mechanism: explicitly passing the parent's plan and retrospective summary to the child allows for directed rather than random walks in the search space. We must implement this PES loop in AlgoEvo immediately to fix our sample efficiency issues. |
Chunhui Wan et.al. |
|
arXiv.org |
pdf / code
|
| 25/30 |
2025-12-22 |
Mathematical exploration and discovery at scaleDeepMind applies AlphaEvolve to 67 math problems, formalizing the distinction between 'Search Mode' (evolving heuristics for fixed instances) and 'Generalizer Mode' (evolving algorithms that extrapolate from small to large n). Results are rigorous, establishing new bounds on Kakeya sets and 10+ other problems by exploiting verifier loopholes and heuristic specialization. The most critical takeaway for AlgoEvo is Section 44: evolving code that *calls* other LLMs leads to emergent prompt optimization and injection strategies, suggesting a path for our multi-agent optimization work. We must adopt their 'Generalizer' training curriculum (train on small n, test on large n) to fix our scalability bottlenecks. |
Bogdan Georgiev et.al. |
Google DeepMind, UCLA, Brown University, Institute for Advanced Study |
arXiv.org |
pdf / code
|
| 26/30 |
2025-12-22 |
Let the Barbarians In: How AI Can Accelerate Systems Performance ResearchCheng et al. (UC Berkeley) perform a rigorous empirical evaluation of LLM evolutionary search (ADRS) across 10 systems problems, achieving SOTA results on MoE load balancing (13x speedup via rediscovering Hamilton's Apportionment) and cloud scheduling. The results are real and backed by code, comparing frameworks like OpenEvolve, GEPA, and ShinkaEvolve. **Key Takeaway:** Their 'Best Practices' section offers concrete engineering constraints we should adopt: specifically, that 'moderate' feedback (worst-k cases) outperforms 'detailed' feedback (prevents overfitting), and that restricting mutations to diff-based edits is essential to prevent reward hacking. This paper validates our core research thesis while providing the benchmarks we now need to beat. |
Audrey Cheng et.al. |
UC Berkeley |
arXiv.org |
pdf / code
|
| 23/30 |
2025-12-19 |
Reinforced Generation of Combinatorial Structures: Hardness of ApproximationNagda et al. utilize AlphaEvolve to discover combinatorial gadgets that improve hardness of approximation bounds for MAX-CUT and TSP, validating findings with formal proofs. The standout contribution is not the hardness results themselves, but the methodology: they tasked AlphaEvolve with optimizing the *verification code* (checking correctness against a slow ground truth), achieving a 10,000x speedup that enabled searching gadgets of size 19 (vs. 11 previously). We should immediately adopt this 'evolve the verifier' loop for our computationally expensive fitness functions in AlgoEvo to break current scalability limits. |
Ansh Nagda et.al. |
Google DeepMind, Google, University of California, Berkeley |
|
pdf / code |
| 26/30 |
2025-12-17 |
EvoLattice: Persistent Internal-Population Evolution through Multi-Alternative Quality-Diversity Graph Representations for LLM-Guided Program DiscoveryEvoLattice replaces the standard 'overwrite-based' evolution of monolithic programs with a persistent DAG where each node holds multiple alternative implementations, evaluating all valid combinatorial paths to compute fine-grained performance statistics for every micro-operator. The results are strong: it outperforms AlphaEvolve and FunSearch styles on NAS-Bench-Zero by explicitly preserving diversity and enabling surgical, data-driven pruning rather than blind mutation. The critical takeaway is the 'alternative-level statistic' mechanism: by aggregating performance across all paths a component participates in, they generate a high-fidelity signal that tells the LLM exactly which lines of code are working, effectively solving the sparse reward problem in code evolution. We should immediately discuss refactoring our AlgoEvo representation to support this multi-alternative graph structure, as it maximizes signal extraction per LLM call. |
Kamer Ali Yuksel et.al. |
aiXplain Inc |
arXiv.org |
pdf / code |
| 24/30 |
2025-12-10 |
Beyond Algorithm Evolution: An LLM-Driven Framework for the Co-Evolution of Swarm Intelligence Optimization Algorithms and PromptsThe authors introduce a co-evolutionary framework where both the optimization algorithm (Fireworks Algorithm operators) and the prompt templates used to generate them are evolved simultaneously by the LLM. The results demonstrate a massive performance jump on constrained Aircraft Landing problems (from ~56% with FunSearch to 100% with their method), suggesting that static prompts are a primary failure mode for complex OR constraints. The critical takeaway is their prompt fitness function: evaluating a prompt template based on the *performance improvement* (`child - parent`) of the code it generates, rather than absolute performance. We should immediately implement this 'prompt-delta' fitness signal in AlgoEvo to automate our prompt engineering loop. |
Shipeng Cen et.al. |
Peking University |
arXiv.org |
pdf / code |
| 23/30 |
2025-12-04 |
RoCo: Role-Based LLMs Collaboration for Automatic Heuristic DesignRoCo replaces standard evolutionary mutation operators with a 4-agent collaboration loop (Explorer, Exploiter, Critic, Integrator) that iteratively refines heuristics and accumulates long-term reflection memory across generations. While the empirical gains over ReEvo are marginal (often <1%) and likely expensive in token cost, the architecture successfully demonstrates how to embed structured multi-agent reasoning into the evolutionary loop to stabilize black-box search. The key takeaway is their Long-term Reflection mechanism, which aggregates critic feedback into a persistent memory buffer to guide future mutations—a technique we should immediately test to improve sample efficiency in AlgoEvo. |
Jiawei Xu et.al. |
South China University of Technology |
arXiv.org |
pdf / code |
| 19/30 |
2025-12-03 |
Structuring Collective Action with LLM-Guided Evolution: From Ill-Structured Problems to Executable HeuristicsECHO-MIMIC presents a framework that first uses LLM-guided evolution to generate Python heuristics for agents (ECHO), and subsequently evolves natural language 'nudges' (MIMIC) to persuade simulated agents to adopt these global-optimal policies. While the experiments rely on synthetic data for agriculture and EV charging, the approach outperforms DSPy and AutoGen baselines in driving collective action. The most valuable takeaway is the architectural separation of 'policy discovery' (code evolution) and 'adoption mechanism' (message evolution)—a pattern we could adapt to evolve incentive structures or negotiation protocols in our multi-agent optimization systems (MASPRM/HERMES). The analysis of code complexity (Halstead metrics) versus fitness also provides a useful empirical reference for our observability work. |
Kevin Bradley Dsouza et.al. |
University of Waterloo, Royal Bank of Canada |
arXiv.org |
pdf / code |
| 28/30 |
2025-11-28 |
ThetaEvolve: Test-time Learning on Open ProblemsThetaEvolve integrates test-time reinforcement learning (GRPO) directly into an AlphaEvolve-style loop, allowing a single 8B model to learn from its own successful mutations and achieve new SOTA bounds on Circle Packing and Autocorrelation inequalities. The results are rigorous, showing that RL applied to the *dynamic* environment (sampling from the evolving database) vastly outperforms RL on static prompts or pure inference search. The most stealable insight is the 'lazy penalty' mechanism—penalizing semantically equivalent code or stagnation—which forces the RL policy to learn genuine exploration strategies rather than memorization. This is a blueprint for the 'RL-infused evolution' milestone in our AlgoEvo roadmap. |
Yiping Wang et.al. |
Microsoft, University of Washington, Carnegie Mellon University, University of Wisconsin-Madison, University of California, San Diego |
arXiv.org |
pdf / code
|
| 23/30 |
2025-11-17 |
GigaEvo: An Open Source Optimization Framework Powered By LLMs And Evolution AlgorithmsGigaEvo is an open-source reproduction of the AlphaEvolve framework that implements MAP-Elites with an asynchronous DAG execution engine, successfully reproducing SOTA results on Heilbronn triangles and beating FunSearch on Weibull Bin Packing. The results are credible and backed by code, specifically highlighting that 'rewrite-based' mutation outperforms 'diff-based' approaches for open-weights models—a crucial engineering constraint for us. The most actionable takeaway is their 'bidirectional lineage tracking' mechanism, which enriches mutation prompts by analyzing both how a program improved over its ancestor and how its descendants further improved, a technique we should steal for AlgoEvo's mutation operator. Their negative result regarding multi-island MAP-Elites (added complexity, no gain) suggests we should deprioritize similar complex topologies. |
Valentin Khrulkov et.al. |
Sber, Artificial Intelligence Research Institute (AIRI) |
arXiv.org |
pdf / code
|
| 25/30 |
2025-11-16 |
Automated Algorithmic Discovery for Scientific Computing through LLM-Guided Evolutionary Search: A Case Study in Gravitational-Wave DetectionEvo-MCTS introduces a hybrid search architecture where MCTS manages the exploration-exploitation balance of an evolutionary process, using LLMs for node expansion via novel operators like 'Path-wise Crossover' (synthesizing code from full root-to-leaf trajectories). The results are empirically strong, outperforming standard LLM-evolution baselines (ReEvo) by ~150% on a complex signal processing task. We learned that structuring the evolutionary lineage as a tree and using MCTS Q-values to select parents—rather than standard population selection—drastically improves sample efficiency and solution quality. This is a blueprint for the 'RL-infused evolution' and 'persistent memory' features we have been planning for our own framework. |
He Wang et.al. |
Tsinghua University, University of Chinese Academy of Sciences |
|
pdf / code
|
| 20/30 |
2025-11-11 |
AlphaResearch: Accelerating New Algorithm Discovery with Language ModelsAlphaResearch introduces a 'dual environment' for algorithm discovery: it generates natural language research ideas, filters them using a reward model fine-tuned on ICLR peer reviews, and then executes the surviving ideas. While it claims to beat human baselines on Packing Circles, the improvement is marginal (<0.1%) and it fails to improve upon baselines in 6/8 benchmark problems. The key takeaway for us is the mechanism of an 'Idea Critic'—using a learned reward model to filter the search space at the prompt level before wasting compute on execution—which directly addresses our sample efficiency goals in evolutionary search. |
Zhaojian Yu et.al. |
Yale, NYU, Tsinghua, ByteDance |
arXiv.org |
pdf / code
|
| 24/30 |
2025-10-16 |
Programmatic Representation Learning with Language ModelsThe authors propose two algorithms, F2 (Features FunSearch) and D-ID3 (Dynamic ID3), to learn programmatic features for decision trees. D-ID3 is particularly novel: instead of evolving a global heuristic, it calls the LLM at *each split node* to generate a feature that discriminates the specific data subset at that leaf. Results are strong on Chess (matching Transformers trained on 250x more data) and Text, though the Image results (MNIST) are trivial. **Key Takeaway:** The D-ID3 architecture—using the solver's current state (leaf node data) to prompt the LLM for *local* code generation—is a powerful pattern we should steal for our VRP solvers (e.g., evolving local repair operators for specific route bottlenecks) and EvoCut work. |
Gabriel Poesia et.al. |
Harvard University, Stanford University |
arXiv.org |
pdf / code
|
| 28/30 |
2025-10-13 |
Refining Hybrid Genetic Search for CVRP via Reinforcement Learning-Finetuned LLMZhu et al. fine-tune a Qwen-14B model using Reinforcement Learning (DAPO) to generate C++ crossover operators for the state-of-the-art HGS solver. Unlike typical prompting papers, they demonstrate that a small, specialized model can improve upon expert-designed components in a highly optimized solver, achieving superior results on CVRPLIB (up to 1000 nodes) where GPT-4o fails. The most stealable insight is their **AST-based anti-plagiarism reward**, which penalizes the model for generating code structurally identical to the prompt examples, effectively forcing exploration and preventing mode collapse—a technique we should immediately adopt for our evolutionary search agents. This confirms we should pivot from pure prompting to RL-finetuning for our code-generation agents. |
Rongjie Zhu et.al. |
Nanyang Technological University, Singapore, Singapore Management University, Singapore, Nanjing University of Information Science and Technology, China |
arXiv.org |
pdf / code |
| 23/30 |
2025-10-10 |
Barbarians at the Gate: How AI is Upending Systems ResearchThe authors apply OpenEvolve (an AlphaEvolve-style framework) to 11 computer systems problems, achieving significant gains over human baselines, such as a 5.0x speedup in MoE expert placement and 26% cost reduction in cloud scheduling. The results are empirically rigorous, relying on high-fidelity simulators rather than toy problems. For us, the key takeaway is the engineering recipe: using an ensemble of reasoning models (o3) for exploration and fast models (Gemini) for diversity, combined with a specific 'failure taxonomy' to debug search stagnation. This is immediate proof-of-concept for your 'GPUSched' and 'AlgoEvo' projects; we should adopt their ensemble strategy and simulator-first evaluation pipeline. |
Audrey Cheng et.al. |
UC Berkeley |
arXiv.org |
pdf / code |
| 26/30 |
2025-10-09 |
Robust Heuristic Algorithm Design with LLMsKarimi et al. introduce 'Robusta', an enhancement to FunSearch that uses a Heuristic Analyzer (solver-based) to identify adversarial inputs and a Suggester LLM to explain *why* the current heuristic fails before generating new code. They demonstrate a 28x improvement in worst-case performance over FunSearch on traffic engineering tasks, with results backed by rigorous comparison against optimal solvers. The critical takeaway is the 'Suggester' intermediate step: converting raw failure instances into natural language coding strategies significantly improves the LLM's ability to fix logic bugs compared to raw samples alone. We should immediately attempt to replicate this 'Analyzer -> Explainer -> Coder' loop for our VRP work, using small-scale solvers to generate counter-examples for our evolved ALNS operators. |
Pantea Karimi et.al. |
Microsoft, MIT, Microsoft Research, University of Southern California, The University of Texas at Austin |
arXiv.org |
pdf / code |
| 24/30 |
2025-10-07 |
Scientific Algorithm Discovery by Augmenting AlphaEvolve with Deep ResearchDeepEvolve augments the standard evolutionary coding loop (AlphaEvolve) with two critical components: a 'Deep Research' module that searches the web/literature to generate grounded mutation proposals, and an iterative debugging agent that fixes execution errors. While the '666%' improvement on Circle Packing is likely due to a weak baseline (fixed-size vs. generalized), the engineering results are compelling: the debugging agent raises execution success rates from ~13% to ~99% in complex tasks. The key takeaway for our AlgoEvo work is the architecture of generating a text-based 'research proposal' via RAG before attempting code generation, rather than mutating code directly. We should immediately adopt their debugging loop and consider injecting external literature search into our mutation operators to prevent search stagnation. |
Gang Liu et.al. |
MIT-IBM Watson AI Lab, IBM Research, University of Notre Dame |
arXiv.org |
pdf / code
|
| 23/30 |
2025-09-30 |
Experience-Guided Reflective Co-Evolution of Prompts and Heuristics for Automatic Algorithm DesignEvoPH introduces a co-evolutionary framework where both the heuristic code and the LLM prompts are evolved, utilizing an island model for diversity and a 'strategy sampling' mechanism that dynamically selects mutation types (e.g., parameter tuning vs. rewrite) based on feedback. They report dominating performance over FunSearch and ReEvo on TSP and BPP (e.g., reducing Christofides gap from ~20% to ~5%), though the static performance of baselines suggests the gain comes largely from automating prompt engineering. The most stealable insight is the **Strategy Sampling** module: explicitly defining a pool of mutation operators and using an 'experience' buffer to select them is a practical implementation of the 'planner' concept we need for AlgoEvo. We should also adopt their island migration topology to improve diversity in our parallelized search. |
Yihong Liu et.al. |
Tencent, Renmin University of China, City University of Hong Kong |
arXiv.org |
pdf / code
|
| 22/30 |
2025-09-29 |
MAS$^2$: Self-Generative, Self-Configuring, Self-Rectifying Multi-Agent SystemsMAS2 trains a tri-agent system (Generator, Implementer, Rectifier) using offline RL on decision trees to dynamically construct and repair multi-agent workflows. The results are strong, outperforming ADAS and MaAS on standard benchmarks while maintaining Pareto efficiency. The critical takeaway for us is the **Rectifier agent**: rather than discarding failed evolutionary candidates (as we currently do in AlgoEvo), we should implement a dedicated loop to patch runtime errors (e.g., API failures, dimension mismatches). Additionally, their 'Collaborative Tree Optimization' offers a rigorous method to fine-tune the 'Evolver' model using trajectory data, which could replace our current prompt-based meta-heuristics. |
Kun Wang et.al. |
NTU, NUS, USTC, ZJU, BUAA, PKU |
arXiv.org |
pdf / code
|
| 24/30 |
2025-09-27 |
C-Evolve: Consensus-based Evolution for Prompt GroupsC-Evolve modifies island-based evolution to optimize a group of prompts that maximize consensus accuracy (majority vote) rather than individual performance. The authors introduce a 'voting score' fitness function—calculated via Exponential Moving Average (EMA) of an individual's contribution to sampled groups—which successfully drives the population toward diverse, complementary strategies that outperform ensembles of individually optimized prompts (beating AlphaEvolve by ~4% on Qwen3-8B). The single most actionable takeaway is the **EMA voting score mechanism**: we can steal this exact fitness formulation to evolve portfolios of complementary VRP heuristics in AlgoEvo, replacing our current focus on converging to a single 'best' solver. While the benchmarks are standard (MATH, HotpotQA), the method offers a robust solution to the 'single heuristic limitation' we face in OR. |
Tiancheng Li et.al. |
Westlake University |
arXiv.org |
pdf / code |
| 28/30 |
2025-09-26 |
Darwin Godel Machine: Open-Ended Evolution of Self-Improving AgentsDGM implements a population-based evolutionary loop where agents modify their own Python source code (tools, memory, flow) to improve performance on coding benchmarks, rather than just optimizing prompts or parameters. Results are strong and verified: it boosts a base agent from 20% to 50% on SWE-bench Verified, matching handcrafted SoTA, with ablations proving the necessity of the population archive (open-endedness) over single-lineage hill climbing. **Key Takeaway:** The 'self-diagnosis' mechanism—feeding execution logs to a model to propose specific *architectural* code changes (e.g., implementing a 'str_replace' tool to fix granular editing errors)—is the exact mechanism we need to implement for evolving our heuristic searchers. This validates that LLM-driven code evolution is viable for complex logic improvement, not just toy tasks. |
Jenny Zhang et.al. |
Sakana AI, Vector Institute, University of British Columbia, Canada CIFAR AI Chair |
Robotics |
pdf / code
|
| 23/30 |
2025-09-25 |
GeoEvolve: Automating Geospatial Model Discovery via Multi-Agent Large Language ModelsGeoEvolve augments standard LLM-based evolutionary search (OpenEvolve) with an outer 'researcher' loop that queries a domain-specific RAG (textbooks/papers) to inject theoretical constraints into mutation prompts. On geospatial interpolation tasks, they report 13-21% error reduction over standard evolution, with ablations confirming that retrieved domain knowledge—not just iterative feedback—drives the performance gain. The critical takeaway is the architectural pattern of 'Knowledge-Guided Evolution': instead of relying on the LLM's internal weights for domain theory, they explicitly retrieve and inject theoretical priors (e.g., valid variogram definitions) to steer the search. We should adapt this 'Theory-RAG' outer loop for our AlgoEvo pipeline to force evolved VRP heuristics to respect OR theoretical bounds. |
Peng Luo et.al. |
Massachusetts Institute of Technology, Stanford University, Technical University of Munich |
arXiv.org |
pdf / code |
| 22/30 |
2025-09-21 |
Out-of-Distribution Generalization in the ARC-AGI Domain: Comparing Execution-Guided Neural Program Synthesis and Test-Time Fine-TuningOuellette implements an Execution-Guided Neural Program Synthesis (EG-NPS) system for ARC-AGI that conditions the search on the intermediate execution state of every instruction, achieving 80% success on out-of-distribution tasks where TTFT (10%) and standard AlphaEvolve (0-14%) fail. The results are rigorous, using controlled OOD tasks to prove that TTFT relies on in-distribution priors rather than reasoning. The critical takeaway for our AlgoEvo work is the architecture of the 'state-conditioned decoder': instead of blind code generation, we should inject the tokenized execution result of step $t$ into the context for step $t+1$. This is effectively a dense process reward model that solves the sample efficiency bottleneck we face in evolutionary search. |
Simon Ouellette et.al. |
|
arXiv.org |
pdf / code
|
| 26/30 |
2025-09-17 |
ShinkaEvolve: Towards Open-Ended And Sample-Efficient Program EvolutionShinkaEvolve presents an open-source evolutionary framework that drastically improves sample efficiency (e.g., beating AlphaEvolve on Circle Packing with only 150 evaluations vs. thousands) by integrating embedding-based novelty rejection, adaptive parent sampling, and bandit-based LLM selection. The results are credible, backed by code from Sakana AI, and directly target our primary pain point of high API costs/sample inefficiency in evolutionary search. **Key Takeaway:** We must implement their 'novelty rejection sampling' immediately—using a cheap embedding model to filter out semantically similar code mutations (threshold 0.95) before execution is a trivial but high-impact optimization for our AlgoEvo pipeline. This paper proves that smart filtering is superior to the brute-force compute strategies we have been relying on. |
Robert Tjarko Lange et.al. |
Sakana AI |
arXiv.org |
pdf / code
|
| 22/30 |
2025-09-10 |
How Should We Meta-Learn Reinforcement Learning Algorithms?Goldie et al. perform a rigorous empirical benchmark comparing LLM-based algorithm proposal against Black-box Evolution Strategies (ES) and various distillation methods. They find that while LLMs are sample-efficient for simple functions, they catastrophically fail to incorporate high-dimensional input features (e.g., the 20+ inputs in OPEN), where Black-box ES remains superior. The most actionable takeaway is 'Same-Size Distillation': distilling a learned black-box algorithm into a fresh network of identical size using synthetic data consistently improves out-of-distribution generalization with zero additional environment samples. We should implement this distillation step immediately and reconsider using LLMs for feature-heavy heuristic components. |
Alexander David Goldie et.al. |
University of Oxford |
arXiv.org |
pdf / code
|
| 28/30 |
2025-09-09 |
Autonomous Code Evolution Meets NP-CompletenessSATLUTION extends LLM evolutionary search to full-scale C++ repositories, autonomously evolving SAT solvers that outperform 2025 human competition winners using only 2024 training data. The results are highly rigorous, backed by 90k CPU hours of distributed evaluation and strict correctness proofs (DRAT), showing a clear monotonic improvement trajectory. The single most stealable insight is the **self-evolving rule system**: the agent autonomously updates a persistent set of markdown constraints (e.g., forbidden patterns, testing protocols) based on post-cycle failure analysis, effectively creating 'institutional memory' that prevents regression in long-horizon search. We must implement this meta-learning loop in AlgoEvo immediately to move beyond single-file optimization. |
Cunxi Yu et.al. |
NVIDIA Research, University of Maryland |
arXiv.org |
pdf / code |
| 25/30 |
2025-08-20 |
EoH-S: Evolution of Heuristic Set using LLMs for Automated Heuristic DesignEoH-S reformulates Automated Heuristic Design (AHD) to evolve a complementary *set* of heuristics rather than a single robust one, proving the objective is submodular and solvable via a greedy strategy. Results are strong and credible: on TSPLib and CVRPLib, their set of 10 heuristics reduces the optimality gap by ~40-60% compared to the top 10 heuristics from FunSearch or ReEvo. **KEY TAKEAWAY:** We should replace standard elitist selection in AlgoEvo with their 'Complementary Population Management' (CPM). By greedily selecting individuals based on marginal contribution to instance coverage (using instance-wise performance vectors), we can automatically generate diverse operator pools for ALNS instead of relying on hand-crafted diversity metrics. |
Fei Liu et.al. |
Huawei Noah
Ark Lab, City University of Hong Kong
|
arXiv.org |
pdf / code |
| 28/30 |
2025-08-16 |
EvoCut: Strengthening Integer Programs via Evolution-Guided Language ModelsYazdani et al. introduce EvoCut, an evolutionary framework where LLMs generate Python code for MILP cuts, filtered by a 'usefulness check' (does it cut the current LP relaxation?) and an 'empirical validity check' (does it preserve known integer optima?). They report 17-57% gap reductions on TSPLIB and JSSP compared to Gurobi defaults, backed by strong ablation studies on the evolutionary operators. **Key Takeaway:** The reliance on 'acceleration cuts'—constraints verified empirically on small datasets rather than formally proven—bypasses the bottleneck of automated theorem proving while still delivering valid speedups. We should immediately adopt their 'LP separation' check as a cheap, high-signal reward for our own evolutionary search loops. |
Milad Yazdani et.al. |
Huawei Technologies Canada, University of British Columbia, University of Toronto |
arXiv.org |
pdf / code
|
| 23/30 |
2025-08-08 |
LLM-Meta-SR: In-Context Learning for Evolving Selection Operators in Symbolic RegressionZhang et al. develop a meta-evolutionary framework to evolve selection operators for symbolic regression, achieving state-of-the-art results on SRBench by outperforming expert-designed methods like ε-lexicase. The standout contribution is **semantics-aware crossover**: rather than selecting parents based solely on scalar fitness, they compute complementarity scores using performance vectors across instances, explicitly retrieving parents that solve different subsets of the problem. This effectively treats parent selection as a retrieval task based on behavioral signatures, ensuring the LLM combines distinct functional capabilities. We should immediately implement this complementarity-based parent retrieval in AlgoEvo to improve how we merge heuristics. |
Hengzhe Zhang et.al. |
Victoria University of Wellington, Michigan State University |
IEEE Transactions on Evolutionary Computation |
pdf / code
|
| 24/30 |
2025-08-04 |
Algorithm Discovery With LLMs: Evolutionary Search Meets Reinforcement LearningEvoTune augments LLM-based evolutionary search (FunSearch) by iteratively fine-tuning the LLM weights using Direct Preference Optimization (DPO) on the generated programs. The results are robust, consistently outperforming static FunSearch on Bin Packing, TSP, and Hash Code benchmarks by discovering better heuristics faster. The critical takeaway is the use of **Forward KL regularization** in DPO instead of the standard Reverse KL; this prevents the mode collapse that usually kills evolutionary diversity, allowing the model to learn from high-fitness samples while maintaining exploration. This is a direct blueprint for implementing the 'RL-infused evolution' component of our AlgoEvo project. |
Anja Surina et.al. |
EPFL, Apple |
arXiv.org |
pdf / code
|
| 18/30 |
2025-08-03 |
EvoVLMA: Evolutionary Vision-Language Model AdaptationThis paper proposes EvoVLMA, an LLM-based evolutionary framework that searches for Python code to adapt Vision-Language Models (feature selection and logits computation). They demonstrate that **jointly** evolving two coupled algorithmic components fails (worse than random), whereas a **sequential** two-stage evolution strategy yields SOTA results (beating manual baselines by ~1-2%). For our AlgoEvo work, the key takeaway is the infrastructure design: they wrap code execution in restartable web services with a process monitor to handle the high rate of CUDA errors/timeouts in generated code—a practical 'trick' we should adopt to improve our search stability. |
Kun Ding et.al. |
Chinese Academy of Sciences |
ACM Multimedia 2025 (ACM MM 2025) |
pdf / code
|
| 25/30 |
2025-07-21 |
DHEvo: Data-Algorithm Based Heuristic Evolution for Generalizable MILP SolvingDHEvo introduces a 'data-algorithm co-evolution' framework that iteratively evolves heuristic code while simultaneously filtering the training instance set to retain only 'representative' instances (those where current heuristics perform well/stably). Empirical results on SCIP diving heuristics show it outperforms FunSearch and EoH by ~60% on Setcover while significantly reducing performance variance, validating the claim that dynamic data curation prevents overfitting. The key takeaway is the counter-intuitive curriculum strategy: rather than training on the hardest instances, filtering for instances with 'regular' feasible regions (high fitness) stabilizes the evolutionary search for code. We should immediately test this dynamic instance filtering in AlgoEvo to improve sample efficiency and generalization. |
Zhihao Zhang et.al. |
Harbin Institute of Technology, Huawei Noah’s Ark Lab, Nanyang Technological University |
arXiv.org |
pdf / code |
| 23/30 |
2025-07-04 |
Behaviour Space Analysis of LLM-driven Meta-heuristic DiscoveryThe authors introduce a behavioral analysis framework for LLM-driven algorithm discovery, mapping the 'behavior space' of generated heuristics using Search Trajectory Networks (STNs) and Code Evolution Graphs (CEGs). Results on BBOB (5D) show that a simple 1+1 elitist strategy alternating between 'simplify code' and 'random new' prompts significantly outperforms population-based approaches, effectively balancing exploitation and exploration while preventing code bloat. The primary takeaway is the critical role of a 'simplify' mutation operator—without it, LLM-generated code tends to drift into complexity without performance gains. We should immediately adopt their visualization metrics to debug our own evolutionary search trajectories and implement their 'simplify' prompt strategy in AlgoEvo. |
Niki van Stein et.al. |
Leiden University, University of Stirling |
arXiv.org |
pdf / code
|
| 30/30 |
2025-06-16 |
AlphaEvolve: A coding agent for scientific and algorithmic discoveryAlphaEvolve extends FunSearch by evolving entire code files (rather than single functions) using a 'search/replace' diff format and Gemini 2.0, achieving SOTA results across matrix multiplication (beating Strassen), 50+ open math problems, and Google's production scheduling. The results are exceptionally strong and verified, including deployed improvements to Google's Borg scheduler (0.7% resource recovery) and TPU circuits. The critical takeaway is the move to **diff-based full-file evolution** and **meta-prompt evolution** (evolving the prompt instructions alongside the code), which allows the system to modify architecture and logic rather than just heuristics. This is a mandatory blueprint for the next iteration of our AlgoEvo and EvoCut projects. |
Alexander Novikov et.al. |
Google DeepMind |
arXiv.org |
pdf / code
|
| 26/30 |
2025-06-10 |
Can Large Language Models Invent Algorithms to Improve Themselves?: Algorithm Discovery for Recursive Self-Improvement through Reinforcement LearningIshibashi et al. propose 'Self-Developing,' a framework where an LLM generates Python code for model merging, evaluates the results, and uses the performance data to fine-tune the generator via DPO in a recursive loop. The results are empirically strong, outperforming human-designed baselines (Task Arithmetic) by 4.3% on GSM8k and demonstrating that the generator explicitly learns better strategies over iterations. **Key Takeaway:** We can replace the static mutation operators in our evolutionary search with a DPO-trained model that learns from the search history—effectively implementing 'learning to search.' This is a direct, actionable upgrade for our AlgoEvo and AlphaEvolve pipelines. |
Yoichi Ishibashi et.al. |
NEC Corporation |
NAACL 2025 (main) |
pdf / code |
| 22/30 |
2025-06-01 |
EvoGit: Decentralized Code Evolution via Git-Based Multi-Agent CollaborationHuang et al. introduce EvoGit, a framework where LLM agents asynchronously evolve code by treating Git commits as the population and using 3-way merges (based on Lowest Common Ancestor) as crossover. While the experiments (web app, bin packing generator) are largely qualitative and lack rigorous statistical benchmarking against baselines like MetaGPT, the architectural contribution is significant. The key takeaway is using Git's native DAG structure to handle lineage, persistence, and asynchronous concurrency 'for free,' replacing complex custom population managers. This is directly actionable for our AlgoEvo infrastructure to enable massive parallelism and better memory/traceability without reinventing the wheel. |
Beichen Huang et.al. |
The Hong Kong Polytechnic University |
arXiv.org |
pdf / code
|
| 25/30 |
2025-05-22 |
STRCMP: Integrating Graph Structural Priors with Language Models for Combinatorial OptimizationSTRCMP introduces a composite architecture where a GNN encodes CO problem instances (MILP/SAT) into embeddings that condition an LLM (fine-tuned via SFT and DPO) to generate solver-specific heuristics within an evolutionary loop. The results are strong and empirically backed, showing significant reductions in convergence time and timeouts compared to text-only evolutionary methods like AutoSAT and LLM4Solver. The key takeaway is the architectural blueprint for fusing instance-specific structural embeddings (via soft prompting) with LLM code generation to drastically improve the sample efficiency of evolutionary search. This is immediately relevant to our EvoCut and AlgoEvo projects, suggesting we should move beyond pure text prompts for topology-heavy problems. |
Xijun Li et.al. |
Shanghai Key Laboratory of Scalable Computing and Systems, School of Computer Science, Shanghai Jiao Tong University |
arXiv.org |
pdf / code |
| 26/30 |
2025-05-18 |
CALM: Co-evolution of Algorithms and Language Model for Automatic Heuristic DesignCALM introduces a hybrid evolutionary framework that fine-tunes the LLM generator *during* the search process using Group Relative Policy Optimization (GRPO), rather than relying solely on prompt evolution. Using a quantized Qwen-7B model on a single consumer GPU, it outperforms GPT-4o-based baselines (FunSearch, EoH) on Bin Packing and VRP benchmarks. The critical takeaway is their reward function design: instead of absolute performance, they reward the *relative improvement* of the generated code over the specific 'parent' heuristics in the prompt, stabilizing the RL signal. We should immediately test this 'online fine-tuning' approach to reduce our API costs and improve sample efficiency in AlgoEvo. |
Ziyao Huang et.al. |
City University of Hong Kong, Southeast University, University of Victoria, Hon Hai Research Institute |
arXiv.org |
pdf / code
|
| 19/30 |
2025-04-01 |
LLM-Guided Search for Deletion-Correcting CodesWeindel and Heckel adapt FunSearch to discover priority functions for the Maximum Independent Set problem (applied to deletion-correcting codes), achieving new SOTA lower bounds for specific lengths (n=12, 13, 16). The critical takeaway for us is their **functional deduplication** step: they hash function outputs on a small subset of data to discard syntactically unique but logically identical programs, which significantly improves sample efficiency by preventing the evaluator from wasting cycles on 'comment changes' or variable renames. Additionally, they demonstrate that optimizing for the single hardest instance generalizes better than averaging performance across a curriculum—a counter-intuitive finding we should test in our reward modeling. |
Franziska Weindel et.al. |
Technical University of Munich, Munich Center for Machine Learning |
arXiv.org |
pdf / code
|
| 26/30 |
2025-03-13 |
From Understanding to Excelling: Template-Free Algorithm Design through Structural-Functional Co-EvolutionZhao et al. propose CAE, a framework that co-evolves algorithm structure (workflow/call graphs) alongside function implementations, aiming to eliminate the fixed templates required by SOTA methods like FunSearch and EoH. On TSP benchmarks, they report reducing optimality gaps by ~2-5% compared to ReEvo, and in quadratic optimization, the system autonomously discovered numerical stability fixes (e.g., replacing matrix inversion with solvers) that human baselines missed. The critical takeaway is the 'bi-dimensional co-evolution' strategy: explicitly maintaining and mutating a population of control flow graphs separate from the function bodies, which allows the system to escape the local optima imposed by a fixed human-designed harness. We must evaluate if this structural search approach can be integrated into AlgoEvo to automate our harness design. |
Zhe Zhao et.al. |
Princeton University, Nanyang Technological University, City University of Hong Kong, University of Science and Technology of China, The Hong Kong University of Science and Technology (Guangzhou) |
arXiv.org |
pdf / code |
| 24/30 |
2025-02-21 |
QUBE: Enhancing Automatic Heuristic Design via Quality-Uncertainty Balanced EvolutionQUBE replaces FunSearch's naive score-based parent selection with a UCB algorithm that selects parents based on the *average quality of their offspring* (exploitation) plus an uncertainty term (exploration). The authors demonstrate that a parent's own score is a poor predictor of its ability to evolve further; treating parents as 'bandit arms' based on their lineage statistics yields significantly better results on Bin Packing and TSP with fewer samples. While they fail to beat DeepMind's massive-scale Cap Set record, the methodological insight regarding 'offspring-aware' selection is statistically validated and immediately transferable to our evolutionary search frameworks. |
Zijie Chen et.al. |
Westlake University, Zhejiang University, University of Electronic Science and Technology of China |
|
pdf / code
|
| 18/30 |
2025-02-13 |
Explainable AI-assisted Optimization for Feynman Integral ReductionSong et al. apply FunSearch to evolve priority functions for Feynman integral reduction, achieving up to 3058x reduction in seeding integrals compared to standard heuristics. The results are rigorous, enabling previously impossible multi-loop calculations. The critical insight for us is the successful transfer of heuristics evolved on trivial 1-loop instances (fast evaluation) to complex 5-loop problems without retraining. We should adopt this 'evolve-on-toy, deploy-on-giant' evaluation protocol to drastically reduce compute costs in our VRP and SAT solver evolutionary search pipelines. |
Zhuo-Yang Song et.al. |
Peking University, Universit
Z
rich, Beijing Computational Science Research Center |
|
pdf / code |
| 25/30 |
2025-02-04 |
Multi-objective Evolution of Heuristic Using Large Language ModelMEoH extends LLM-based heuristic evolution (like FunSearch/EoH) to multi-objective scenarios (e.g., Gap vs. Runtime) by introducing a 'Dominance-Dissimilarity' mechanism that selects parents based on both Pareto dominance and Abstract Syntax Tree (AST) code distance. The results are credible and strong: on TSP, they find heuristics matching EoH's quality but running 16x faster (1.37s vs 22.4s) by effectively navigating the complexity-performance trade-off. The single most useful takeaway is the **AST-based dissimilarity metric** for population management; we should immediately steal this to prune semantically identical code in our evolutionary loops, thereby forcing exploration and improving sample efficiency. This is a direct upgrade to our current single-objective evolutionary search methods. |
Shunyu Yao et.al. |
City University of Hong Kong, Southern University of Science and Technology |
AAAI Conference on Artificial Intelligence |
pdf / code
|
| 22/30 |
2024-12-19 |
HSEvo: Elevating Automatic Heuristic Design with Diversity-Driven Harmony Search and Genetic Algorithm Using LLMsHSEvo extends LLM-based evolutionary search (LLM-EPS) by integrating a numerical parameter tuning step (Harmony Search) and a token-efficient 'Flash Reflection' mechanism that batches analysis of parent pairs. They report superior results over ReEvo and FunSearch on Bin Packing and TSP, validated by proposed diversity metrics based on code embeddings. **Key Takeaway:** We should implement the hybrid tuning pattern: explicitly parsing LLM-generated code to extract constants and tuning them with a cheap numerical optimizer (rather than asking the LLM to tune parameters), and adopt batched reflections to reduce inference costs. |
Pham Vu Tuan Dat et.al. |
George Mason University, Hanoi University of Science and Technology |
arXiv.org |
pdf / code
|
| 23/30 |
2024-11-29 |
Amplifying human performance in combinatorial competitive programmingDeepMind applies FunSearch (using Gemini 1.5 Flash) to evolve scoring functions within human-written greedy backbones for Hash Code and AtCoder problems, achieving top-1% or rank-1 performance against humans. The results are robust, beating top human teams on 5/8 historical contests using a generic evolutionary setup. The critical takeaway is the 'switching variable' technique: using a single evolved function to handle multiple distinct decision points (e.g., selecting a vehicle vs. selecting a route) by passing a state flag, rather than evolving multiple interacting functions. This validates that generalist models (Flash) are sufficient for high-end OR evolution without code-specific fine-tuning. We should adopt their 'Backbone + Scorer' architecture for our VRP/Scheduling work immediately. |
Petar Veličković et.al. |
Google DeepMind |
arXiv.org |
pdf / code |
| 20/30 |
2024-10-30 |
Automatic programming via large language models with population self-evolution for dynamic job shop scheduling problemThis paper introduces SeEvo, an LLM-based evolutionary search for Dynamic Job Shop Scheduling heuristics that adds an 'individual self-reflection' loop—prompting the LLM to analyze performance differences of a specific rule before and after mutation—alongside standard population-level reflection. While they claim significant improvements over GP/GEP and DRL, the ablation study reveals only a marginal <1% improvement over the existing ReEvo framework on benchmark instances. The primary takeaway for us is the specific prompt engineering technique of injecting an individual's mutation history (previous code vs. current code performance) into the context to guide the next mutation, which could potentially improve sample efficiency in our own evolutionary loops despite their weak empirical validation. |
Jin Huang et.al. |
Huazhong University of Science and Technology |
arXiv.org |
pdf / code |
| 25/30 |
2024-10-14 |
ReEvo: Large Language Models as Hyper-Heuristics with Reflective EvolutionReEvo integrates a 'Reflector LLM' into genetic programming that analyzes pairs of heuristics (better vs. worse) to generate textual 'verbal gradients' for crossover and mutation, maintaining a long-term memory of these insights. The results are strong and relevant: they outperform EoH (Evolution of Heuristics) and NCO baselines on TSP, CVRP, and Bin Packing with significantly higher sample efficiency (only ~100 evaluations). The single most useful takeaway is the 'Short-term Reflection' prompting strategy—explicitly asking the LLM to derive a mutation direction by comparing the logic of high-fitness vs. low-fitness parents—which we should immediately test in our AlgoEvo framework to reduce sample costs. This is a direct methodological upgrade for our current evolutionary search pipelines. |
Haoran Ye et.al. |
Peking University, KAIST, Singapore Management University, Southeast University, PKU-Wuhan Institute for AI |
NeurIPS 2024 |
pdf / code
|
| 20/30 |
2024-07-15 |
Understanding the Importance of Evolutionary Search in Automated Heuristic Design with Large Language ModelsZhang et al. perform a rigorous benchmarking of major LLM-based evolutionary program search (EPS) methods (FunSearch, EoH, ReEvo) against a simple (1+1)-EPS baseline across four problems and nine LLMs. The results are empirically solid and sobering: the simple (1+1)-EPS baseline—iterative improvement via one-shot prompting—frequently matches or outperforms the complex population-based methods, particularly on bin packing, though EoH remains superior on TSP. **Crucial Takeaway:** We are likely over-engineering our search mechanisms; we must implement a (1+1)-EPS baseline in all future experiments (AlgoEvo, EvoCut) because if our multi-agent systems cannot beat this simple hill-climber, our papers will be rejected for unnecessary complexity. Additionally, they find that larger models (GPT-4) do not strictly guarantee better heuristic search performance compared to smaller, code-specialized models like CodeLlama-7B. |
Rui Zhang et.al. |
City University of Hong Kong, Southern University of Science and Technology |
the 18th International Conference on Parallel Problem Solving From Nature (PPSN 2024) |
pdf / code
|
| 23/30 |
2024-07-01 |
FunBO: Discovering Acquisition Functions for Bayesian Optimization with FunSearchFunBO applies FunSearch to evolve Python code for Bayesian Optimization acquisition functions, evaluating fitness by running full BO loops on synthetic functions. The results are empirically strong, showing that evolved AFs generalize well to out-of-distribution functions and outperform standard baselines like EI and UCB. The most stealable insight is their 'few-shot' adaptation strategy, where a general-purpose heuristic is rapidly fine-tuned on a small set of target instances—a technique we should immediately test for our VRP heuristics. While the method is computationally expensive (brute-forcing the inner loop), the interpretable code outputs provide concrete ideas for dynamic exploration-exploitation trade-offs. |
Virginia Aglietti et.al. |
Google DeepMind |
International Conference on Machine Learning |
pdf / code |
| 19/30 |
2024-06-01 |
tnGPS: Discovering Unknown Tensor Network Structure Search Algorithms via Large Language Models (LLMs)The authors propose tnGPS, a FunSearch-style framework that evolves Python code for Tensor Network Structure Search by mimicking human innovation stages (categorization, recombination, diversity injection). While the application (Tensor Networks) is niche, the results outperform standard heuristics like TNGA and TNLS. The critical takeaway for us is the 'Knowledge Categorization' phase: they use the LLM to semantically cluster the population of generated algorithms to manage diversity and guide the 'Diversity Injection' step. We should immediately implement this LLM-based population clustering in AlgoEvo to prevent convergence on similar code patterns. |
Junhua Zeng et.al. |
RIKEN Center for Advanced Intelligence Project, Tencent Inc., Guangdong University of Technology |
ICML2024 |
pdf / code
|
| 25/30 |
2024-06-01 |
Evolution of Heuristics: Towards Efficient Automatic Algorithm Design Using Large Language ModelEoH introduces a dual-track evolutionary framework that evolves both natural language 'thoughts' (heuristic logic) and their corresponding Python code, rather than code alone. On Online Bin Packing, it claims to outperform DeepMind's FunSearch while using only ~2,000 LLM queries (vs FunSearch's millions), and achieves SOTA gaps on TSP and FSSP via Guided Local Search. The critical takeaway is the 'E2' prompt strategy: explicitly asking the LLM to extract common ideas from parent heuristics into a natural language 'thought' before generating code, which acts as a genetic Chain-of-Thought to stabilize mutation. We should immediately implement this 'Thought-then-Code' mutation operator in our AlgoEvo pipeline to address our sample efficiency bottlenecks. |
Fei Liu et.al. |
Huawei Noah’s Ark Lab, City University of Hong Kong, Southern University of Science and Technology |
International Conference on Machine Learning |
pdf / code
|
| 18/30 |
2024-03-18 |
LLM Guided Evolution -- The Automation of Models Advancing ModelsMorris et al. propose 'Guided Evolution,' an LLM-based NAS framework that introduces 'Evolution of Thought' (EoT) and 'Character Role Play' to guide code mutations. While the results are statistically negligible (single trials, ~0.8% gain on CIFAR-10), the EoT mechanism offers a specific, actionable prompt engineering technique: explicitly prompting the LLM to compare a successful elite individual against its original seed to extract 'reasoning' before applying mutations to new individuals. This serves as a lightweight, prompt-based memory/feedback mechanism that could immediately improve sample efficiency in our evolutionary search agents. The 'Character Role Play' (e.g., asking the LLM to act as 'Dr. MaGoo' for unorthodox ideas) is a gimmicky but potentially useful heuristic for maintaining population diversity. |
Clint Morris et.al. |
Georgia Tech Research Institute |
Annual Conference on Genetic and Evolutionary Computation |
pdf / code
|
| 24/30 |
2024-03-05 |
Evolution Transformer: In-Context Evolutionary OptimizationLange et al. introduce the Evolution Transformer, a causal architecture that learns to perform evolutionary strategy updates by attending to optimization history, effectively 'distilling' algorithms like CMA-ES into a neural network. Crucially, they propose 'Self-Referential Algorithm Distillation' (SR-EAD), where the model improves itself by perturbing its own weights, generating trajectories, and filtering for the best ones to retrain on—eliminating the need for a teacher. The results are strong, showing generalization to unseen Brax control tasks and successful (though sometimes unstable) self-bootstrapping. The key takeaway for us is the SR-EAD loop as a mechanism for open-ended optimizer improvement, and their use of Perceiver cross-attention to handle variable population sizes—a technique we should immediately steal for our multi-agent memory architectures. |
Robert Tjarko Lange et.al. |
Google DeepMind, TU Berlin |
GECCO Companion |
pdf / code
|
