77 recent papers · updated 2026-09-03 · sources deduplicated from arXiv, OpenAlex and Semantic Scholar
2026-09-02 | Huawei, The Hong Kong University of Science and Technology Method: Hierarchical method with LLM-assisted automatic evolutionary algorithm for skill repository, combiner and repositioner design | LLM role: evolutionary_search
This 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.
2026-08-25 | Princeton University, Stanford University, University of Oxford, NUS Method: Recursive Experiential-Working Memory (EM-WM) architecture with state-grounded skill invocation, evidence-grounded state updates and validation-gated component-specific memory evolution. | LLM role: research_agent, decomposition_guide, code_writer
Recuris 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.
2026-08-25 | Zhejiang University, Meituan LongCat Team Method: Reinforcement Learning with a two-pass judge-checker mechanism, interface decoupling and Pairwise Advantage Validity (PAV) for early stopping | LLM role: judge_and_auditor
RECURSE 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.
2026-08-24 | Tsinghua University, Nanyang Technological University, Singapore Management University Method: LLM-guided evolutionary optimization over the symbolic space of MIP formulations, represented as executable modeling programs, via iterative generation, evaluation and selection with LLM-driven crossover, mutation and repair operations. | LLM role: generates formulations, diagnoses solver feedback, repairs code, abstracts experience, distills knowledge
FormuEvo 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.
2026-08-24 | University of Cambridge, University of California San Diego, University of Hong Kong, DualverseAI Method: Open-world multi-agent environment (The Station) simulating a scientific community with autonomous agents | LLM role: research_agent
This 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.
2026-08-21 | Advanced Micro Devices, Inc. (AMD), Southern University of Science and Technology Method: Long-horizon agentic search driver for assembly transformations under external correctness-gated verification | LLM role: heuristic_generator
AsmEvo 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.
2026-08-19 | Duke University, Shanghai Jiao Tong University, Hokkaido University, South China Normal University, Guangdong University of Technology, ManXis Method: Task-conditioned Meta-Agent architecture with dynamic obligation graph, receding-horizon planning, architecture promotion, minimal sufficient architecture compilation and governed evolution | LLM role: semantic_decomposition
ManXis 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.
2026-08-17 Method: Evolutionary meta-agent (RoboPhD) evolving agent Python programs using Elo-based selection over head-to-head batch tournaments with a cost-penalized objective | LLM role: evolutionary_search, code_writer, evaluator
Borthwick 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.
2026-08-17 | Google DeepMind, MIT, Carnegie Mellon University, Columbia University Method: Gradient descent with optimal transport techniques and AlphaEvolve for algorithm refinement | LLM role: evolutionary_search
This 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.
2026-08-17 | Fudan University Method: Goal-driven source-code evolution framework with LLM-based Teacher-Student agents and mechanism memory | LLM role: decomposition_guide
GoalEvolve 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.
2026-08-12 Method: LLM-based program evolution augmented with a Tactic Memory Bank for natural-language strategy summaries and an Adaptive Injection Gate using contextual Thompson Sampling. | LLM role: program_generator, strategy_summarizer, prompt_augmenter
ε-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.
2026-08-11 | megacode.ai Method: Three-layer self-evolving architecture (MEGA) with typed Wisdom Graph, PCR decomposition, PCST-based compositional retrieval and multi-agent collaborative optimization under Seed-Epoch regime | LLM role: Multi-agent coordination, knowledge synthesis, conflict resolution, test case generation, evaluation, root-cause analysis, code review, architectural redesign, meta-learning
MEGA 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.
2026-08-09 | HKUST Method: Hierarchical Self-Improvement (HSI) framework with layered self-modification of agent harnesses and evolution strategies | LLM role: code_writer
Zhou 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.
2026-08-07 | Southern University of Science and Technology, Shenzhen University Method: Primitive-Aware Code Evolution (PACE) using Executable Algorithmic Primitives (EAPs) with Thompson Sampling for EAP selection and primitive-aware variation operators | LLM role: code_writer
Xie 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.
2026-08-06 | Carnegie Mellon University, The University of Hong Kong, City University of Hong Kong, JIUTIAN Research, China Mobile Method: Training-free adaptive population handoff framework using a Grow–Deepen bandit scheduler and greedy submodular selection for candidate curation | LLM role: mutation_operator, exploration, refinement
RelayEvolve 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.
2026-08-04 | Southern University of Science and Technology, The Hong Kong University of Science and Technology Method: LLM-driven co-evolutionary framework combining Dynamic Component Management (short-budget probing, reversible lifecycle) with LLM-Driven Co-Evolution (Multi-Ensemble Evaluation, Cross-Component Information Sharing, Relation-Guided Pair Evolution, Adaptive Budget Allocation) for heuristic ensembles. | LLM role: evolutionary_search
MuEvo 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.
2026-08-01 | Beihang University Method: LLM-driven automated algorithm design using a directed graph representation for operator evolution and a first-order path-dependent credit assignment mechanism | LLM role: code_writer, decomposition_guide, evolutionary_search
DGA2D 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.
2026-07-31 | Institute of Automation, Chinese Academy of Sciences, University of the Chinese Academy of Sciences, Goethe University Frankfurt Method: Multi-Objective Tool-augmented Symbolic Regression (MOT-SR) framework | LLM role: Guides evolutionary search and generates equations based on data analysis and structural priors
Wang 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.
2026-07-30 | Horizon Research, Frontis.AI, Tsinghua University, Zhejiang University, Shanghai Jiao Tong University, Georgia Institute of Technology Method: Meta-evolution agent (Frontis-MA1-35B) trained with execution-grounded supervised fine-tuning (SFT) and reinforcement learning (RL) on atomic program-evolution operators (Draft, Improve, Debug, Crossover), deployed in an experience-driven long-horizon evolutionary search (OpenMLE-Evo). | LLM role: meta_evolution_agent
Yang 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 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.
2026-07-29 | Mohamed bin Zayed University of Artificial Intelligence (MBZUAI), City University of Hong Kong, International Digital Economy Academy (IDEA) Method: Cost-calibrated adaptive controller (CostAda) using cost-calibrated frontier utility with remaining-budget conditioning | LLM role: heuristic_generator
This 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.
2026-07-29 | Institute of Automation, Chinese Academy of Sciences, University of Chinese Academy of Sciences Method: LLM-guided evolutionary search with module-wise evolution, UCB-style adaptive scheduling and diagnosis-guided program generation | LLM role: evolutionary_search
EvoPINN 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.
2026-07-29 | IBM Research, University of Southern California, University of Wisconsin–Madison, Michigan State University Method: LLM-driven program evolution in a FunSearch-style loop | LLM role: code_writer
FunL2O 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.
2026-07-28 Method: Sample-efficient reinforcement learning (ϵ-greedy contextual bandit and REINFORCE) | LLM role: agent_executor
This 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.
2026-07-26 | Guangdong University of Technology Method: Coupled bilevel AHD framework using LLM-guided evolutionary search to co-evolve region exposure policies and repair heuristics, with submodular repertoire selection and a response archive for region-conditioned routing. | LLM role: evolutionary_search
SpecAHD 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.
2026-07-24 | University of Illinois Urbana-Champaign Method: Reinforcement Learning with Group Relative Policy Optimization (GRPO) on synthesized evolution trajectories | LLM role: evolutionary_search
Wu 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.
2026-07-27 | Arizona State University Method: Multi-agent LLM-driven algorithm evolution for VPR source code | LLM role: heuristic_generator, code_writer, evaluator
Wu 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.
2026-07-26 | China University of Geosciences Method: Generative Meta-Black-Box Optimization (MetaBBO) framework using an attention-based Transformer encoder (PCE) and an MLP-based Elite Synthesis Decoder (ESD) trained with a Quality–Diversity (QD) loss | LLM role: none
NeurGO 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.
2026-07-20 | UC Berkeley, MIT, MIT-IBM Watson AI Lab, Weizmann Institute of Science Method: Systematic decomposition and statistical evaluation of LLM-guided discovery harnesses (evolutionary search and tree-based search) with adaptive online allocation | LLM role: heuristic_generator
Gupta 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.
2026-07-20 | NVIDIA Method: LLM-driven evolutionary search with agentic code generation and multi-objective Pareto optimization | LLM role: evolutionary_search
Aï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).
2026-07-15 | The Hong Kong Polytechnic University, Nankai University, South China Agricultural University Method: Dual-Surrogate Guided Search (DGS) for operator-parent action selection, using a transition surrogate to predict child latent distribution and an instance-conditioned utility surrogate to estimate expected performance, combined with an uncertainty-aware acquisition rule. | LLM role: program_generator
Wang 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.
2026-07-15 | Accenture Method: Replacing per-step scalar task reward with a training-free pairwise LLM validator | LLM role: evaluator
Liu 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.
2026-07-11 | Georgia Institute of Technology, Shanghai Academy of AI for Science Method: Graph-Augmented Evolutionary Search with GNN-based RL Meta-Controller and Online LLM Fine-tuning | LLM role: mutation_operator_with_adaptive_policy
Chen 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.
2026-05-21 | MIT, Sakana AI, Improbable AI Lab, MIT-IBM Computing Research Lab Method: Vector Policy Optimization (VPO) combining multi-answer autoregressive generation with stochastic reward scalarization within a GRPO framework | LLM role: solution_generator_for_search
Bahlous-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.
2026-05-19 | UC Berkeley, MIT Method: Pareto-based reflective evolutionary search with LLM proposer and diagnostic Side Information (SI) | LLM role: evolutionary_search
Agrawal 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.
2026-05-18 | University of Oxford, Linköping University, Federal University of Rio Grande do Sul Method: Property-guided LLM program synthesis with counterexample-driven repair loop (CEGIS-style) | LLM role: synthesizer
This 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.
2026-05-14 | Amazon AGI, UCSD, Oregon State University, Pennsylvania State University, AG2AI, Inc. Method: End-to-end reinforcement learning with Group Relative Policy Optimization (GRPO), Executor-Designer Hierarchical Rollout and Stagewise Co-evolution | LLM role: LLM acts as a self-designing meta-agent (Designer) and a self-executing agent (Executor)
MetaAgent-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.
2026-05-14 | Google DeepMind, Google, Georgia Institute of Technology Method: AlphaEvolve, an agentic framework combining LLMs with evolutionary search for hardware-aware code optimization | LLM role: code_writer
This 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.
2026-05-13 | 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 Method: Harnessed meta-editing framework with a two-phase loop (meta-editing phase and evolution segment) | LLM role: process_level_editor
Zhang 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.
2026-05-11 | Massachusetts Institute of Technology, University of California, Berkeley Method: Graph-based search for automatic algorithm design using LLM-generated code corrections | LLM role: code_writer
This 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.
2026-05-11 | Shanghai Jiao Tong University, Shenzhen Technology University, Shanghai Polytechnic University Method: Teacher-aware evolutionary framework for LLM-based heuristic evolution, using sampled on-policy teacher alignment and teacher-guided reflection for program revision | LLM role: heuristic_generator, code_writer, decomposition_guide
This 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.
2026-05-11 | Google Cloud AI Research, University of Illinois Urbana-Champaign Method: Meta-Reinforcement Learning with Rubric-guided Policy Decomposition and Reflection-based Meta-Policy Training (using Stage-Structured GRPO) | LLM role: agent_policy, rubric_generator, reflection_generator, judge
Li 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.
2026-05-10 | Independent Researcher Method: CVT-MAP-Elites with bootstrapped diverse initialization, role-aware LLM routing and rank-preserving proxy benchmark selection | LLM role: heuristic_generator
LEVI 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.
2026-05-13 | UNC-Chapel Hill, UC Berkeley, UCSC Method: LLM-driven closed-loop diagnosis and self-evolution of retrieval configuration via AutoResearch | LLM role: diagnosis_guide, proposal_generator, answer_generator, query_decomposer, verifier
EVOLVEMEM 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.
2026-05-12 | Argonne National Laboratory Method: Autonomous agentic harness combining multi-round generate-tune-evolve search with lineage-aware stochastic candidate sampling and tool use | LLM role: evolutionary_search, code_writer, evaluator, decomposition_guide, research_agent
CVEvolve 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.
2026-05-10 | Carnegie Mellon University, University of Science and Technology of China, National University of Singapore, Shanghai AI Lab Method: Two-time-scale replicator-mutator process for co-evolving agent capabilities and communication topology in LLM-based multi-agent systems | LLM role: evolutionary_search_and_prompt_optimizer
TacoMAS 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.
2026-05-13 | Samyama.ai Method: Graph-grounded optimization paradigm using Cypher queries to source decision variables, constraints and objectives from property knowledge graphs, solved by a portfolio of Rao-family metaheuristics and OR-tools. | LLM role: none
This 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.
2026-05-09 | National University of Singapore Method: Evolutionary Ensemble (EvE) with two co-evolving populations (functional code solvers and agent guidance states) and Elo-based agent scoring | LLM role: evolutionary_search
Yu 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.
2026-05-08 | University of California, San Diego, Georgia Institute of Technology Method: Asynchronous stage orchestration with workers and queues, staleness-aware data handling, speculative stage completion and adaptive workflow control | LLM role: artifact generator, reflector, evaluator, patcher
FlashEvolve 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.
2026-05-08 | Westlake University Method: Heterogeneous Multi-Agent Collaborative Evolution (HMACE) with CVT-MAP-Elites archive and behavior-aware retrieval | LLM role: evolutionary_search
HMACE 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.
2026-05-07 | Karlsruhe Institute of Technology Method: LLM-driven evolutionary search for Large Neighborhood Search (LNS) destroy operators | LLM role: heuristic_generator
CoupleEvo 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.
2026-05-07 | Google Cloud AI Research, Massachusetts Institute of Technology, University of Illinois Urbana-Champaign Method: Experience-driven Reinforcement Learning with Grouped Reward Policy Optimization (GRPO) for skill curator | LLM role: skill_curator_and_agent_executor
SkillOS 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.
2026-05-07 | Google DeepMind Method: User Interface Design and Qualitative User Study for AI-assisted Scientific Discovery | LLM role: experiment_configuration_assistant, critique_agent
Bä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.
2026-05-01 | Tsinghua University, Boston College, Shanghai Jiao Tong University, The Chinese University of Hong Kong, Shenzhen, Shanghai University of Finance and Economics Method: LLM-guided evolutionary search with GRPO and confidence-interval-based certification | LLM role: evolutionary_search
AlphaInventory 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.
2026-04-30 | Friedrich Schiller University Jena Method: Multimodal transformer architecture for sequence-to-sequence program synthesis | LLM role: code_writer
Voigt 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.
2026-04-27 | National University of Defense Technology, University of Electronic Science and Technology of China, Academy of Military Medical Sciences Method: Tree-structured evolutionary search with hybrid selection, hierarchical operators and a program-maintenance loop for feedback-driven repair | LLM role: system-level algorithm architect
A2DEPT 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.
2026-04-27 | The University of Hong Kong, City University of Hong Kong, JIUTIAN Research, China Mobile Method: LLM-driven evolutionary search augmented with a modular strategy-space layer (SEAEVO) comprising Strategy Articulation, Stratified Experience Retrieval and Strategic Landscape Navigation | LLM role: mutation_operator, decomposition_guide, research_agent
SeaEvo 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.
2026-04-24 | Arizona State University Method: LLM-driven code evolution framework for global routing algorithms | LLM role: evolutionary_search, code_writer
GR-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.
2026-04-22 | Future Living Lab of Alibaba Method: Textual Parameter Graph Optimization (TPGO) with Group Relative Agent Optimization (GRAO) meta-learning | LLM role: decomposition_guide, diagnostic_feedback_generator, optimization_proposal_generator, meta_learner
He 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.
2026-04-06 | Independent Researchers Method: Elo tournament selection for evolutionary optimization with comparative error reports and Deep Focus refinement | LLM role: evolutionary_search
RoboPhD 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.
2026-04-01 | IBM Research Method: LLM-agent-instantiated evolutionary computation over structured scientific artifacts (theory+code or code_only) | LLM role: evolutionary_search
CliffSearch 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.
2026-03-30 | Örebro University Method: Co-evolutionary framework leveraging LLMs to generate environments and policies as executable Python code, modeled as a two-player zero-sum game and solved using Policy Space Response Oracles (PSRO) to compute a mixed-strategy Nash equilibrium (MSNE) over policy populations. | LLM role: llm_evolutionary_agent
COvolve 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.
2026-03-30 | Machine Perception and Interaction Lab, Örebro University, Sweden Method: Evolutionary search over executable learning update rules using LLM-guided macro mutation and diversity-aware crossover | LLM role: evolutionary_search
This 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.
2026-03-15 | Carnegie Mellon University, MBZUAI, Hong Kong Baptist University, The University of Sydney Method: CausalEvolve with causal scratchpad leveraging LLMs to identify and reason about guiding factors for evolution, incorporating outcome-level and procedure-level factors, multi-arm bandit for intervention and abductive reasoning. | LLM role: heuristic_generator
CausalEvolve 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.
2026-03-18 | University of Oxford, University College London, University of California, Santa Barbara, University of Wisconsin–Madison, Delft University of Technology Method: Procedural generation of algorithm discovery tasks using configurable parameters for domains, modules and datasets | LLM role: research_agent, prompt_optimizer
This 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.
2026-03-12 | 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 Method: Automated benchmark construction via reverse engineering and self-play; EvoRePE: Inference-time representation engineering for latent space steering. | LLM role: code_writer, constraint_generator, evaluator, prompt_optimizer, decomposition_guide, evolutionary_search
Wang 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.
2026-03-12 | Intel Corporation Method: MAP-Elites quality-diversity search with kernel-specific behavioral dimensions, meta-prompt evolution and template-based parameter optimization | LLM role: code_writer, prompt_optimizer
KernelFoundry 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.
2026-03-11 | Google DeepMind, Google, University of California, Berkeley Method: AlphaEvolve, an LLM-based code mutation agent | LLM role: evolutionary_search
Nagda 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.
2026-03-09 | Nanjing University, Huawei Noah’s Ark Lab Method: Evolutionary Stagewise Algorithm Design (EvoStage) with multi-agent system and global-local perspective mechanism | LLM role: decomposition_guide, code_writer, reflection_agent, evolutionary_search
EvoStage 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.
2026-03-10 | Google DeepMind Method: Policy-Space Response Oracles (PSRO) with Large Language Model (LLM) as a code-generating oracle, enhanced by iterative refinement or evolutionary search (AlphaEvolve) | LLM role: code_writer
This 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.
2026-03-05 | Argonne National Laboratory, Rice University Method: LLM-guided evolutionary search for regularization algorithms combining LLM-driven code generation with semantically-guided crossover and mutation | LLM role: evolutionary_search
This 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. Second, the LLM autonomously discovered the benefit of embedding stateful optimizers (like Adam) and iterative sub-loops directly inside a single heuristic step.
2026-03-03 | City University of Hong Kong Method: BehaveSim, a method for measuring algorithmic similarity based on problem-solving trajectories (PSTrajs) quantified using Dynamic Time Warping (DTW) | LLM role: heuristic_generator
Zhang 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.
2026-03-03 | The Hong Kong Polytechnic University, The University of Hong Kong Method: Bilevel meta-optimization with stability-inducing neural unrolling, using a structured Mamba-based neural operator and a gradient-derived composite solver. | LLM role: none
Gao 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.
2026-02-23 | University of California, Berkeley, Bespoke Labs Method: LLM-driven evolutionary algorithm with hierarchical adaptive optimization using an accumulated improvement signal to dynamically modulate local exploration intensity, global resource allocation via multi-armed bandit and meta-level solution tactics generation | LLM role: semantic_mutation_operator
AdaEvolve 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.
2026-02-18 | Google DeepMind Method: AlphaEvolve, an LLM-powered evolutionary coding agent | LLM role: code_writer
DeepMind 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.
2026-02-17 | Massachusetts Institute of Technology Method: Language-Guided Optimization (LaGO) framework decomposing heuristic discovery into forward, backward and update stages, utilizing LLMs for reasoned evolution, code-writing analysis, co-evolution of constructive and refinement heuristics and diversity-aware population management. | LLM role: evolutionary_search
LaGO 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.
2026-02-17 | University of Wisconsin-Madison Method: LLM-driven evolutionary optimization with nested parameter tuning | LLM role: code_writer, mutation_operator, report_generator
MadEvolve 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.
2026-02-18 | Walmart Global Tech, Santa Clara University, Independent Researcher Method: LLM-guided program evolution based on AlphaEvolve | LLM role: evolutionary_search
RankEvolve 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.
Same pipeline, pointed at whatever you're working on — with relevance scored to how you read.
Request access →