# LoongFlow: Directed Evolutionary Search via a Cognitive Plan-Execute-Summarize Paradigm
**Authors**: Chunhui WanXunan DaiZhuo WangMinglei LiYanpeng Wang, Yinan MaoYu LanZhiwen Xiao, Baidu Inc
> Equal contributions. E-mail: {daixunan,
## Abstract
The transition from static Large Language Models (LLMs) to self-improving agents is hindered by the lack of structured reasoning in traditional evolutionary approaches. Existing methods often struggle with premature convergence and inefficient exploration in high-dimensional code spaces. To address these challenges, we introduce LoongFlow, a self-evolving agent framework that achieves state-of-the-art solution quality with significantly reduced computational costs. Unlike "blind" mutation operators, LoongFlow integrates LLMs into a cognitive "Plan-Execute-Summarize" (PES) paradigm, effectively mapping the evolutionary search to a reasoning-heavy process. To sustain long-term architectural coherence, we incorporate a hybrid evolutionary memory system. By synergizing Multi-Island models with MAP-Elites and adaptive Boltzmann selection, this system theoretically balances the exploration-exploitation trade-off, maintaining diverse behavioral niches to prevent optimization stagnation. We instantiate LoongFlow with a General Agent for algorithmic discovery and an ML Agent for pipeline optimization. Extensive evaluations on the AlphaEvolve benchmark and Kaggle competitions demonstrate that LoongFlow outperforms leading baselines (e.g., OpenEvolve, ShinkaEvolve) by up to 60% in evolutionary efficiency while discovering superior solutions. LoongFlow marks a substantial step forward in autonomous scientific discovery, enabling the generation of expert-level solutions with reduced computational overhead.
Code: https://github.com/baidu-baige/LoongFlow
## 1 Introduction
The progression from static prompting—where humans manually engineer instructions—to autonomous, self-evolving agents marks a fundamental shift in artificial intelligence. While static approaches rely on fixed inference patterns, self-evolving agents utilize Large Language Models (LLMs) as mutation operators to iteratively modify their own code or parameters. Pioneering works have validated this paradigm in specific domains: FunSearch [romera2024mathematical] utilizes LLMs to discover novel mathematical constructions, Eureka [ma2024eureka] optimizes reward functions via evolutionary search, and AlphaEvolve [novikov2025alphaevolve] automates the discovery of heuristic algorithms. that LLMs, building on foundational code-generation capabilities [chen2021codex, li2022alphacode], can discover novel mathematical algorithms and reward functions that surpass human baselines. This "Darwinian shift" has established automated scientific discovery as a vibrant research frontier.
However, as the complexity of tasks increases, current frameworks face severe cognitive and architectural limitations. Leading open-source baselines, such as OpenEvolve and ShinkaEvolve [sakana2025shinkaevolve], effectively treat the LLM as a stochastic black box. OpenEvolve relies on high-volume random mutations, leading to a "random walk" behavior that is computationally prohibitive. ShinkaEvolve improves efficiency via novelty search but operates purely at the execution level, lacking a mechanism to analyze why a mutation failed. Consequently, these methods hit a "cognitive ceiling," struggling to maintain structural coherence over long evolutionary horizons. Specifically, they encounter three critical bottlenecks:
- Inefficient Exploration (The Cost Bottleneck): Existing agents lack a strategic planning layer. They engage in brute-force sampling in high-dimensional code spaces, resulting in excessive token consumption and unstable convergence rates.
- Diversity Collapse (The Convergence Bottleneck): Without explicit diversity management, population-based agents tend to converge prematurely to local optima. Traditional "Top-K" sampling fails to preserve diverse but potentially high-reward "stepping stone" solutions.
- Absence of Reflexive Memory (The Feedback Bottleneck): Unlike deep learning, where backpropagation provides a precise gradient for improvement, most existing evolutionary agent frameworks lack a structured reflection mechanism [shinn2023reflexion]. They function as "memory-less" searchers, repeating similar errors across generations rather than accumulating "evolutionary wisdom" through structured summarization.
<details>
<summary>LoongFlow-overview.jpg Details</summary>
### Visual Description
## Diagram Type: Flowchart
### Overview
The image is a flowchart that illustrates a process involving a planner, executor, evaluator, and a database. The flowchart is labeled "Implicit Feedback & Guidance" at the top.
### Components/Axes
- **Planner**: Represented by a brain icon, this is the starting point of the process.
- **Executor**: Represented by a wrench icon, this is the next step after the planner.
- **Evaluator**: Represented by a scale icon, this is the step where the solution is evaluated.
- **Summary**: Represented by a document icon, this is the final step where the summary of the process is provided.
- **Database (Evolutionary Memory)**: Represented by a stack of coins, this is the storage area for the process data.
### Detailed Analysis or ### Content Details
- The planner generates a parent solution and plan.
- The executor implements the solution and evaluates the results.
- The evaluator assesses the evaluation results and metrics.
- The summary is created based on the evaluation results.
- The structured solution is added to the database.
### Key Observations
- The flowchart shows a cyclical process where the planner generates a solution, the executor implements it, the evaluator evaluates it, and the summary is created.
- The database is used to store the process data, indicating that the process is being tracked and analyzed over time.
### Interpretation
The flowchart suggests a structured approach to problem-solving and decision-making. The planner generates a plan, the executor implements it, the evaluator assesses the results, and the summary is created. The database is used to store the process data, indicating that the process is being tracked and analyzed over time. This approach ensures that the process is systematic and that the results are documented for future reference.
</details>
Figure 1: Overview of LoongFlow.
To overcome these barriers, we introduce LoongFlow, a framework designed to bridge the gap between reasoning agents and evolutionary computation. LoongFlow distinguishes itself through two core architectural innovations. First, we propose the "Plan-Execute-Summarize" (PES) paradigm. This cognitive loop transforms random mutation into a directed hypothesis-testing process (addressing Bottleneck 1 & 3), as illustrated in the Agent Loop of Figure 1. Second, to resolve the exploration-exploitation dilemma (Bottleneck 2), we design a Hybrid Evolutionary Memory. By fusing the spatial isolation of Island Models with the behavioral diversity of MAP-Elites [mouret2015illuminating] and entropy-regularized Boltzmann selection, LoongFlow dynamically maintains diverse behavioral niches. This ensures that the system can escape local optima and continuously discover novel solution architectures.
We demonstrate the versatility of LoongFlow by instantiating two domain-specific agents: a General Agent for algorithmic tasks and an ML Agent for machine learning pipelines. Experimental results on the AlphaEvolve benchmark and Kaggle competitions confirm that LoongFlow significantly surpasses OpenEvolve and ShinkaEvolve, breaking theoretical performance barriers with superior sample efficiency.
The primary contributions of this work are as follows:
- Structured Evolutionary Paradigm: We propose the “Plan-Execute-Summarize” paradigm, which integrates expert-level planning and retrospective summarization to reduce generation randomness and establish a sustainable feedback loop.
- Advanced Memory Architecture: We design a domain-adaptive evolutionary memory that combines multi-island parallel evolution with MAP-Elites [mouret2015illuminating] and adaptive Boltzmann selection, effectively solving the premature convergence and “catastrophic forgetting” problems inherent in traditional LLM agents.
- Superior Performance & Efficiency: We provide open-source, pre-built agents (GeneralAgent and MLAgent) that achieve state-of-the-art results on NP-hard mathematical problems and complex ML pipelines, surpassing existing frameworks in both stability and evolutionary speed.
## 2 Related Work
The development of LoongFlow is situated at the intersection of LLM-based Evolutionary Optimization and Cognitive Agent Architectures. In this section, we review the progression of these fields and identify the specific gap that LoongFlow addresses.
### 2.1 LLM-Based Evolutionary Optimization
The paradigm of utilizing LLMs for evolutionary optimization has shifted from simple solution generation to iterative refinement. Pioneering work such as FunSearch [romera2024mathematical] demonstrated that LLMs, when coupled with an evolutionary evaluator, could solve open problems in mathematics (e.g., the Cap Set problem) by searching for "functions" rather than parameters. Similarly, AlphaEvolve [novikov2025alphaevolve] orchestrates an autonomous pipeline of LLMs to improve an algorithm by making direct changes to the program, achieving human-level performance on robot manipulation tasks. While recent methods like OPRO [yang2023opro] and PromptBreeder [fernando2023promptbreeder] have explored using LLMs as optimizers, they often treat the model as a black-box operator to mutation. They typically treat the LLM as a stochastic operator—randomly mutating code without a high-level strategy—which leads to high token costs and inefficient exploration in complex search spaces.
### 2.2 Evolutionary Agent Frameworks
To engineeringly scale LLM-based evolution, several open-source frameworks have emerged. These serve as the primary baselines for our work:
- OpenEvolve: As a standard implementation of the AlphaEvolve algorithm, OpenEvolve utilizes an "Island Model" to maintain population diversity. However, it treats code generation as a single-step translation task. The mutation process is largely reactive, where the agent fixes errors or makes random local changes without understanding the global algorithmic structure. This often leads to a "random walk" behavior in high-difficulty tasks.
- ShinkaEvolve: ShinkaEvolve [sakana2025shinkaevolve] improves sample efficiency by integrating "code-novelty rejection" to filter out redundant solutions before execution. While it reduces computational waste, it still operates primarily at the execution level. The framework lacks a structured reflection mechanism to analyze why a specific architectural change failed, preventing the system from learning abstract principles over long evolutionary horizons.
### 2.3 Cognitive Architectures and The Reasoning Gap
While evolutionary methods excel at population-based search, they often lack the depth of semantic reasoning found in autonomous agents.
Reasoning Agents: Frameworks like ReAct [yao2023react] and Reflexion [shinn2023reflexion] have demonstrated that interleaving reasoning traces (Thought) with actions significantly improves problem-solving capabilities. These methods enable agents to perform multi-step planning and self-correction. Similarly, Voyager [wang2023voyager] utilizes an iterative curriculum to learn complex skills in embodied environments.
The Gap: A critical gap exists in merging these two paradigms. Standard reasoning agents (like AutoGPT [richards2023autogpt] or Voyager [wang2023voyager]) generally focus on single-instance problem solving rather than population-based evolutionary search. Conversely, traditional evolutionary algorithms (like MAP-Elites [mouret2015illuminating]) excel at maintaining diverse populations but lack the semantic reasoning capabilities of ReAct-style agents.
LoongFlow bridges this gap by introducing the "Plan-Execute-Summarize" paradigm. This paradigm allows LoongFlow to maintain the diversity benefits of MAP-Elites [mouret2015illuminating] while leveraging the reasoning depth of ReAct-style agents [yao2023react], effectively moving the evolutionary process from "random mutation" to "directed evolution".
## 3 Background
In this section, we formally frame the open-ended evolutionary process as a sequential decision-making problem and establish the mathematical foundations of the LoongFlow framework. We model the self-evolution of agents as a Markov Decision Process (MDP [sutton2018reinforcement]) over a discrete code space, guided by a parameterized Large Language Model (LLM).
### 3.1 Problem Formulation as MDP
We define the problem as a tuple $\langle\mathcal{C},\mathcal{A},R,\pi_{\theta}\rangle$ :
- State/Code Space ( $\mathcal{C}$ ): Let $\mathcal{C}$ be the infinite, discrete space of all valid programs in a specific language (e.g., Python). A state $s_{t}\in\mathcal{C}$ represents the solution code at evolutionary generation $t$ .
- Action Space ( $\mathcal{A}$ ): The action space consists of semantic modification operations (e.g., rewrite, debug, optimize) applied to the code.
- Reward Function ( $R$ ): $R:\mathcal{C}\to\mathbb{R}$ is a scalar fitness function (e.g., accuracy on test cases). The environment is characterized by a sparse reward signal, where valid solutions are rare.
- Policy ( $\pi_{\theta}$ ): The agent is an LLM parameterized by weights $\theta$ . It acts as a stochastic policy $\pi_{\theta}(a|s)$ , generating the next code state $s_{t+1}$ based on the current state $s_{t}$ and context.
Our objective is to find an optimal solution $s^{*}$ that maximizes the reward:
$$
s^{*}=\mathop{\arg\max}_{s\in\mathcal{C}}R(s) \tag{1}
$$
### 3.2 LLM as a Composite Semantic Operator
Unlike traditional Evolutionary Algorithms (EA) that use fixed, random mutation operators (denoted as $\mathcal{T}_{mut}$ ), LoongFlow utilizes the LLM as a learnable Semantic Operator.
We formalize the "Plan-Execute-Summarize" (PES) paradigm as a composite transition kernel decomposing the policy $\pi_{\theta}$ into three sub-steps. Let $\mathcal{M}_{t}$ be the evolutionary memory at generation $t$ , and $\mathcal{I}$ be the set of system instructions (prompts). The transition from parent $s_{t}$ to offspring $s_{t+1}$ proceeds as follows:
1. Planning: The Planner generates a natural language blueprint $b$ (an intermediate latent variable) conditioned on the parent code $s_{t}$ and retrieved insights from memory $\mathcal{M}_{t}$ :
$$
b\sim\pi_{\theta}(b\mid s_{t},\mathcal{M}_{t},\mathcal{I}_{plan}) \tag{2}
$$
1. Execution: The Executor generates the executable offspring code $s^{\prime}$ (a candidate for $s_{t+1}$ ) based on the blueprint $b$ :
$$
s^{\prime}\sim\pi_{\theta}(s^{\prime}\mid b,s_{t},\mathcal{I}_{exec}) \tag{3}
$$
1. Summarization & Update: The Summarizer generates a reflection insight $z$ based on the execution feedback $r=R(s^{\prime})$ , and updates the memory:
$$
z\sim\pi_{\theta}(z\mid s^{\prime},r,b,\mathcal{I}_{sum}) \tag{4}
$$
$$
\mathcal{M}_{t+1}\leftarrow\mathcal{M}_{t}\cup\{z\} \tag{5}
$$
### 3.3 Feature Space and Archive Management
To manage population diversity beyond raw fitness, we map the high-dimensional code space $\mathcal{C}$ to a lower-dimensional Feature Space $\mathcal{F}\subseteq\mathbb{R}^{k}$ .
Feature Mapping.
Let $\Phi:\mathcal{C}\to\mathcal{F}$ be a mapping function that projects a solution $s$ to a feature vector $\mathbf{v}=\Phi(s)$ . In this work, $\mathbf{v}$ consists of interpretable dimensions, for example, $\mathbf{v}=(\text{Cyclomatic Complexity},\text{Code Length})$ .
MAP-Elites Archive.
We maintain a structured archive (Memory) $\mathcal{A}_{rchive}$ , discretized into a grid of cells in $\mathcal{F}$ . Each cell, indexed by a feature vector $\mathbf{v}$ , stores only the single best solution found so far for that specific behavior:
$$
\mathcal{A}_{rchive}(\mathbf{v})=\{s\in\mathcal{C}\mid\Phi(s)\in\text{Cell}(\mathbf{v})\land R(s)=\max_{s^{\prime}\in\text{Cell}(\mathbf{v})}R(s^{\prime})\} \tag{6}
$$
This mechanism ensures behavioral diversity, preventing the policy from collapsing into a single local optimum.
### 3.4 Adaptive Boltzmann Selection
To select the parent $s_{t}$ for the next generation from the archive $\mathcal{A}_{rchive}$ , we replace static greedy selection with Adaptive Boltzmann Selection.
Let $\{s_{1},s_{2},\dots,s_{N}\}$ be the set of solutions currently stored in the archive. The probability $P(s_{i})$ of selecting solution $s_{i}$ as the parent is:
$$
P(s_{i})=\frac{\exp(R(s_{i})/\tau)}{\sum_{j=1}^{N}\exp(R(s_{j})/\tau)} \tag{7}
$$
where $\tau$ is a temperature parameter dynamically modulated by the population entropy. This allows LoongFlow to shift smoothly between exploration (high $\tau$ ) and exploitation (low $\tau$ ).
## 4 LoongFlow Overview
Designing an evolutionary agent capable of solving high-difficulty, open-ended tasks requires overcoming two fundamental systemic contradictions: the tension between search space complexity and sampling efficiency, and the trade-off between population diversity and convergence speed.
Algorithm 1 LoongFlow Main Evolutionary Loop
1: Input: Task Description $T$ , Initial Solution $s_{0}$ , Max Iterations $N_{max}$ , Islands $K$
2: Output: Best Solution $s^{*}$
3: // Initialization phase
4: Initialize Global Memory $\mathcal{M}\leftarrow\{s_{0}\}$
5: Initialize $K$ Islands with MAP-Elites Archives $\mathcal{A}_{1},\dots,\mathcal{A}_{K}$
6: for $iteration=1$ to $N_{max}$ do
7: for $k=1$ to $K$ do $\triangleright$ Parallel Evolution on Islands
8: // 1. Adaptive Selection (Sec. 4.2.3)
9: $H_{k}\leftarrow\text{CalculateEntropy}(\mathcal{A}_{k})$
10: $\tau\leftarrow\tau_{base}\cdot(1+\alpha e^{-\beta H_{k}})$ $\triangleright$ Dynamic Temperature
11: $s_{parent}\leftarrow\text{BoltzmannSelect}(\mathcal{A}_{k},\tau)$
12: // 2. Lineage-Based Planning (Sec. 4.1.1)
13: $chain\leftarrow\text{GetLineage}(s_{parent}.\text{id})$
14: $context\leftarrow\{\text{p.plan},\text{p.summary}\mid p\in chain\}$
15: $plan\leftarrow\text{Planner}(s_{parent},context,T)$
16: // 3. Execution & Evaluation (Sec. 4.1.2)
17: $code\leftarrow\text{Executor}(plan,s_{parent})$
18: if $\text{Verify}(code)$ is False then
19: continue $\triangleright$ Fast-fail on syntax errors
20: end if
21: $score,logs\leftarrow\text{Evaluator}(code)$
22: // 4. Reflection & Storage (Sec. 4.1.3)
23: $summary\leftarrow\text{Summarizer}(plan,code,logs)$
24: $s_{new}\leftarrow\text{Solution}(code,score,summary,parent=s_{parent}.\text{id})$
25: $\text{UpdateMAPElites}(\mathcal{A}_{k},s_{new})$
26: end for
27: // 5. Migration Strategy (Sec. 4.2.1)
28: if $iteration\mod M==0$ then
29: MigrateElites ( $\mathcal{A}_{1},\dots,\mathcal{A}_{K}$ )
30: end if
31: end for
32: return $\max_{s\in\cup\mathcal{A}_{k}}s.score$
To resolve these, LoongFlow introduces a hierarchical architecture that decouples “Cognitive Reasoning” from “Evolutionary Dynamics”. The framework consists of two coupled subsystems: the Agent Loop, which implements the “Plan-Execute-Summarize” (PES) paradigm, and the Hybrid Evolutionary Memory, which governs population management. The overall procedure is outlined in Algorithm 1.
### 4.1 The “Plan-Execute-Summarize” (PES) Paradigm
Standard LLM-based evolutionary methods (e.g., genetic programming with LLMs) typically treat the model as a “black-box mutation operator”, randomly perturbing solutions in hopes of improvement. This approach suffers from extreme sample inefficiency and a lack of directional guidance. To address this, LoongFlow formalizes the evolutionary iteration as a structured cognitive process composed of three specialized stages.
<details>
<summary>LoongFlow-frame.jpg Details</summary>
### Visual Description
## LoongFlow: A Comprehensive Overview
### Overview
LoongFlow is a sophisticated system designed for iterative planning, execution, and summarization. It utilizes a combination of agents, a toolkit, and a database to facilitate a continuous cycle of improvement. The system is structured to ensure that each component works in harmony to achieve its objectives.
### Components/Axes
- **Planner**: Responsible for generating plans based on the current state and goals.
- **Executor**: Executes the plans generated by the Planner.
- **Summary**: Provides a summary of the execution, highlighting key outcomes and areas for improvement.
- **Plan Agent**: A sub-component of the Planner that focuses on generating specific plans.
- **Execute Agent**: Executes the plans generated by the Plan Agent.
- **Summary Agent**: Provides a summary of the execution, highlighting key outcomes and areas for improvement.
- **Toolkit**: A collection of functions and tools that assist in planning and execution.
- **Evaluator**: Evaluates the performance of the execution and provides feedback.
- **Database**: Stores the evolution memory, which is used to track changes and improvements over time.
- **ReActAgent**: A component that refines the execution based on feedback and evaluation.
- **AgentSDK**: Provides a framework for integrating LoongFlow with other systems.
### Detailed Analysis or ### Content Details
- **Iteration**: The process of generating a plan, executing it, and summarizing the results.
- **Read**: The process of reading data from the database.
- **Sample**: The process of selecting a sample of data for evaluation.
- **Score-Sort**: The process of scoring and sorting the data based on evaluation metrics.
- **MAP-Elites**: A method for selecting the best solutions based on the evaluation scores.
- **Parallel Generation**: The process of generating multiple solutions simultaneously to improve efficiency.
### Key Observations
- **Continuous Improvement**: LoongFlow is designed to continuously improve its performance through iterative cycles.
- **Data-Driven Decision Making**: The system relies heavily on data and evaluation metrics to make informed decisions.
- **Flexibility**: The toolkit and AgentSDK provide flexibility in integrating LoongFlow with other systems.
### Interpretation
LoongFlow is a powerful tool for iterative planning and execution. By continuously generating, executing, and summarizing plans, the system can adapt to changing conditions and improve its performance over time. The use of data-driven decision making and the MAP-Elites method ensures that the best solutions are selected based on evaluation metrics. The parallel generation process enhances efficiency and allows for the exploration of multiple solutions simultaneously. Overall, LoongFlow is a comprehensive system that can be used in a variety of applications to achieve continuous improvement.
</details>
Figure 2: Expanded view of the LoongFlow evolutionary process. The framework iterates through a Planner-Executor-Summarizer loop. The Planner retrieves historical insights to prune the search space; the Executor generates and verifies code; the Summarizer extracts causal knowledge to update the Evolutionary Memory.
#### 4.1.1 Planner: Strategic Search Space Pruning
In infinite solution spaces, navigating via stochastic mutation often devolves into a “random walk,” wasting vast computational resources on invalid or redundant trials. To mitigate this, the Planner functions as a strategic architect employing Lineage-Based Context Retrieval.
Unlike RAG [lewis2020rag] systems that rely on fuzzy semantic similarity, LoongFlow utilizes the explicit genealogical links inherent in the evolutionary process. As defined in the Solution data structure (see Listing 1), each individual preserves its lineage via parent_id.
For a given parent solution $s_{t}$ , the Planner traverses the ID chain (retrieving ancestors $s_{t-1},s_{t-2}...$ and potential descendants). It extracts the historical generate_plan (Original Intent) and summary (Retrospective Feedback) from this lineage.
- Intent Tracking: By reading past plans, the Planner understands the “research trajectory” intended by previous generations.
- Course Correction: By reading past summaries (which contain specific advice for the next generation), the Planner identifies verified pitfalls to avoid.
This structured recall allows the Planner to construct a context-aware blueprint $b$ , leveraging the Chain-of-Thought [wei2022chain] reasoning capabilities of modern LLMs, ensuring that the new plan is a logical continuation and refinement of the parent’s strategy, rather than a random jump.
#### 4.1.2 Executor: Polymorphic Implementation & Robust Verification
The translation from a high-level strategic blueprint to an executable solution is inherently non-deterministic and error-prone. The Executor acts as a robust translation engine that converts the Planner’s intent ( $b$ ) into verified artifacts ( $r$ ).
Polymorphic Execution Strategies.
The framework decouples the “What” (Plan) from the “How” (Execution). The Executor supports Pluggable Execution Flows tailored to the problem domain. For algorithmic tasks, it may instantiate as a logic-intensive single-pass coder; for system tasks, it may operate as a multi-stage workflow engine. This design ensures that LoongFlow is not limited to a single class of problems but is adaptable to any domain with a definable action space.
Local Verification Loop (Fast-Fail).
Before submitting to the global Evaluator, the Executor interacts with the Environment Interface to perform “Pre-Evaluation Checks”. This local feedback loop allows the Executor to self-correct minor errors (such as syntax typos or import errors) immediately, acting as a filter that prevents low-quality candidates from consuming expensive global evaluation resources.
#### 4.1.3 Summary: Closing the Feedback Loop
Traditional evolutionary algorithms are “memory-less” regarding causality—they know that a solution failed, but not why. This leads to “Cyclical Errors,” where the population repeatedly explores the same invalid dead-ends. The Summary module introduces a retrospective learning mechanism.
After evaluation, the Summarizer performs Abductive Reflection [shinn2023reflexion]. It compares the Planner’s intent ( $b$ ) with the execution result ( $r$ ) to infer causal relationships and generates a structured Insight ( $z$ ). These insights are stored in the Evolutionary Memory. This establishes a Long-Term Cognitive Memory, inspired by the memory architectures in Generative Agents [park2023generative], but adapted for evolutionary lineage.. By feeding these insights back to future Planners, LoongFlow achieves Meta-Learning, where the system becomes “smarter” about the domain constraints over generations.
### 4.2 Hybrid Evolutionary Memory System
A critical failure mode in evolutionary agents is Premature Convergence. LoongFlow addresses this via a multi-layered memory architecture rooted in a structured data schema.
Solution Data Structure.
To support the genealogical retrieval described above, LoongFlow maintains a rigorous data schema for every individual in the population. As shown in Listing 1, the Solution class encapsulates not only the code but also the full evolutionary metadata (lineage IDs, plans, summaries, and metrics).
Listing 1: The Solution Data Structure in Evolutionary Memory
⬇
class Solution:
"" "Represent a solution in the memory." ""
# Solution identification
solution: str = "" # The executable code
solution_id: str = "" # Unique UUID
# Evolution information
generate_plan: str = "" # The blueprint that created this solution
parent_id: Optional [str] = "" # Pointer to ancestor (Lineage Chain)
island_id: Optional [int] = 0
iteration: Optional [int] = 0
timestamp: float = field (default_factory = time. time)
generation: int = 0
# Sampling Control
sample_cnt: int = 0 # Visit count for bandit selection
sample_weight: float = 0.0
# Performance metrics
score: Optional [float] = 0.0
evaluation: Optional [str] = "" # Raw execution logs
summary: str = "" # Critical: Advice for the next generation
# Metadata
metadata: Dict [str, Any] = field (default_factory = dict)
This comprehensive schema transforms the memory from a simple “High Score List” into a Structured Knowledge Graph, enabling the Planner to query causal relationships (Why did parent X fail?) rather than just outcomes.
#### 4.2.1 Multi-Island Distributed Topology
Single-population models are prone to “dominance,” where one successful strategy outcompetes all others. LoongFlow employs a Multi-Island Model [whitley1994cellular] with a Ring Topology. The population is partitioned into $N$ isolated islands. Each island evolves independently, allowing distinct algorithmic “species” to cultivate. Migration occurs only when the diversity difference $\Delta D$ between neighbors exceeds a threshold. The top $k\$ elites are copied to adjacent islands, acting as “invasive species” to shake up stagnation. This spatial isolation ensures Global Diversity Maintenance, preventing the system from getting stuck in local optima.
#### 4.2.2 MAP-Elites with Feature Grids
Objective-based selection often discards novel but unpolished solutions (“stepping stones”). Within each island, LoongFlow utilizes a MAP-Elites [mouret2015illuminating] container. Solutions are mapped to a feature grid $\mathcal{A}$ based on behavioral descriptors $\Phi(s)$ (e.g., Code Complexity $\times$ Memory Usage). The system preserves the best individual for each cell in the grid, not just the global best. This guarantees Niche Preservation, providing a diverse “gene pool” for the Planner to cross-pollinate.
#### 4.2.3 Adaptive Boltzmann Selection
The balance between Exploration and Exploitation is dynamic. LoongFlow implements Entropy-Regularized Boltzmann Selection [thierens1999scalability]. The selection temperature $\tau$ is dynamically adjusted based on the population entropy $H(\mathcal{P})$ :
$$
\tau(t)\propto\exp(-\lambda\cdot H(\mathcal{P}_{t})) \tag{8}
$$
When the population is diverse (High $H$ ), $\tau$ lowers to encourage Exploitation (Greedy). When the population converges (Low $H$ ), $\tau$ rises to force Exploration (Random). This achieves Self-Adaptive Control, automatically transitioning between “searching for new ideas” and “polishing existing ones” without human intervention.
## 5 Experiments
To empirically validate the Eadfent framework, we conducted a comprehensive evaluation focusing on Effectiveness (Solution Quality) and Efficiency (Convergence Speed).
### 5.1 Experimental Setup
Benchmarks: We instantiated two domain-specific agents— General Agent for algorithmic discovery and Machine Learning Agent for machine learning engineering—and compared them against state-of-the-art open-source baselines.
- AlphaEvolve Suite (General Agent): A suite of challenging open-ended mathematical problems derived from the AlphaEvolve paper [novikov2025alphaevolve].
- MLEBench [chan2024mle] (ML Agent): Real-world machine learning competitions requiring end-to-end pipeline optimization, spanning Computer Vision, NLP, and Tabular data.
Baselines: We compared General Agent against two primary evolutionary agent frameworks:
- OpenEvolve: A standard implementation of the AlphaEvolve algorithm using Island Models.
- ShinkaEvolve: A recent framework emphasizing sample efficiency via novelty search.
Models: Experiments were conducted using both open-weights models (DeepSeek-r1-0528, etc.) and commercial models (Gemini-3-Pro-Preview, etc.) to ensure the results are framework-dependent rather than model-dependent.
### 5.2 Effectiveness
#### 5.2.1 Algorithmic Discovery (General Agent)
We compared the best solutions found by LoongFlow against the baselines and known theoretical bounds. As shown in Table 1, LoongFlow achieved state-of-the-art (SOTA) results across multiple problems in the benchmark suite.
Table 1: LoongFlow Performance on AlphaEvolve Suite (Grouped by Metric Direction)
| Problem | Metric | LLM | AlphaEvolve | LoongFlow |
| --- | --- | --- | --- | --- |
| Higher is Better ( $\uparrow$ ) | | | | |
| Autocorrelation II | Bound ( $\uparrow$ ) | DeepSeek-R1 | 0.8962 | 0.9027 |
| Circle Packing (Square) | Radius ( $\uparrow$ ) | DeepSeek-R1 | 2.6358 | 2.6359 |
| Circle Packing (Rectangle) | Radius ( $\uparrow$ ) | DeepSeek-R1 | 2.3658321 | 2.3658322 |
| Lower is Better ( $\downarrow$ ) | | | | |
| Hexagon Packing | Side Length ( $\downarrow$ ) | DeepSeek-R1 | 3.93 | 3.92 |
| Max-to-Min Ratios | Ratio ( $\downarrow$ ) | DeepSeek-R1 | 12.88926 | 12.88924 |
| Uncertainty Inequality | Bound ( $\downarrow$ ) | DeepSeek-R1 | 0.352099104422 | 0.352099104421 |
| Erdős’ problem | Bound ( $\downarrow$ ) | DeepSeek-R1 | 0.380924 | 0.380913 |
Notably, in the Autocorrelation II problem, LoongFlow discovered a solution with a score of 0.9027, significantly outperforming the AlphaEvolve baseline (0.8962). This indicates that the Planner’s ability to enforce global structural constraints allows LoongFlow to navigate high-dimensional spaces more effectively than random mutation.
#### 5.2.2 Machine Learning Engineering (ML Agent)
In the Machine Learning domain, MLAgent demonstrated the ability to construct robust pipelines without human intervention. As shown in Table 2, LoongFlow achieved 14 Gold Medals.
Table 2: LoongFlow Performance on MLE Bench
| Predict-volcanic-eruptions-ingv-oe | Gemini-3.0-flash | Gold |
| --- | --- | --- |
| Stanford-covid-vaccine | Gemini-3.0-flash | Gold |
| The-icml-2013-whale-challenge-right-whale-redux | Gemini-3.0-flash | Gold |
| Aerial Cactus Identification | Claude-Opus-4.5 | Gold |
| Nomad2018-predict-transparent-conductors | Claude-Opus-4.5 | Gold |
| Denoising Dirty Documents | Gemini-3 | Gold |
| Detecting-insults-in-social-commentary | Gemini-3.0-flash | Gold |
| Dogs-vs-cats-redux-kernels-edition | Gemini-3.0-flash | Gold |
| Histopathologic-cancer-detection | Gemini-3.0-flash | Gold |
| Plant-pathology-2020-fgvc7 | Gemini-3.0-flash | Gold |
| Tabular-playground-series-dec-2021 | Gemini-3.0-flash | Gold |
| Google-quest-challenge | Gemini-3.0-flash | Gold |
| Plant-pathology-2021-fgvc8 | Gemini-3.0-flash | Gold |
| Us-patent-phrase-to-phrase-matching | Gemini-3.0-flash | Gold |
### 5.3 Efficiency and Stability Analysis
To quantify efficiency, we analyzed the Circle Packing (Square) task under strict compute budgets.
#### 5.3.1 Evolve Efficiency (DeepSeek-R1-0528)
We set a time limit of 24 hours with a target score $\geq 0.99$ . As shown in Table 3, LoongFlow demonstrated a $>60\$ improvement in evolutionary efficiency compared to OpenEvolve.
- Convergence: LoongFlow required an average of 258 evaluations to reach the target threshold (0.99), whereas OpenEvolve required 783 evaluations.
- Success Rate: Across 3 independent runs, LoongFlow achieved a 100% success rate in reaching the high-score region ( $>0.99$ ). In contrast, OpenEvolve only succeeded once (33% rate), and ShinkaEvolve failed to break the 0.99 barrier in all attempts.
Table 3: Efficiency Comparison (Sorted by Best Score)
| LoongFlow | 2 | 0.998 | 51 | 484 | 484 | 100% |
| --- | --- | --- | --- | --- | --- | --- |
| 1 | 0.996 | 13 | 147 | 147 | 100% | |
| 3 | 0.994 | 28 | 145 | 145 | 100% | |
| OpenEvolve | 2 | 0.994 | 783 | 783 | 783 | 29.54% |
| 3 | 0.962 | 1000 | 1000 | 1000 | 48.5% | |
| 1 | 0.950 | 1000 | 1000 | 1000 | 37.9% | |
| ShinkaEvolve | 3 | 0.952 | 454 | 510 | 454 | 80.84% |
| 1 | 0.856 | 469 | 568 | 469 | 82.05% | |
| 2 | 0.804 | 300 | 360 | 300 | 77% | |
#### 5.3.2 High-Difficulty Breakthrough (Gemini-3-Pro)
Under a constrained budget of 100 iterations, we evaluated the agents’ ability to break theoretical barriers. As shown in Table 4, LoongFlow completed the task three times consecutively.
- LoongFlow: Successfully broke the theoretical barrier (Score $>1.0$ ) in 3 out of 3 runs.
- Baselines: Both OpenEvolve and ShinkaEvolve failed to reach a score of 1.0 within the budget. This confirms that LoongFlow’s PES paradigm not only finds solutions faster (6 vs 100 calls) but accesses solution subspaces that are unreachable for standard evolutionary methods under limited budgets.
Table 4: High-Difficulty Breakthrough (Top-100 Iterations)
| LoongFlow | 1 | 1.000 | 6 | 20 | 20 | 100% |
| --- | --- | --- | --- | --- | --- | --- |
| 2 | 1.000 | 14 | 72 | 72 | 100% | |
| 3 | 1.000 | 8 | 26 | 26 | 100% | |
| OpenEvolve | 1-3 | < 0.998 | 100 | 100 | 100 | 81% (Avg) |
| ShinkaEvolve | 1-3 | < 0.999 | 100 | 116 | 100 | 94% (Avg) |
### 5.4 Ablations
To validate the necessity of the "Plan-Execute-Summarize" (PES) paradigm, we conducted an ablation study using General Agent—the representative instantiation of the LoongFlow framework. We evaluated the contribution of the Planner, Executor, and Summary modules on the Circle Packing task.
<details>
<summary>ablation1.png Details</summary>
### Visual Description
## Evolutionary Effect (Top Score & Stability)
### Overview
The image displays two bar charts comparing the evolutionary effects of different experimental modes on top scores and stability. The charts are labeled (a) and (b) and are titled "Evolutionary Effect (Top Score & Stability)" and "Evolutionary Efficiency (Time to Reach Top1 Score)" respectively.
### Components/Axes
- **Labels**: The x-axis of both charts lists the experimental modes: Full Fuse Mode, Executor Chat Mode, Executor React Mode, Summary Ablation, and Planner Ablation.
- **Scales**: The y-axis of chart (a) measures top scores on a scale from 0.94 to 1.00, while the y-axis of chart (b) measures the time to reach the top1 score in hours, ranging from 0 to 35 hours.
- **Legends**: A common legend at the bottom of the charts indicates the meaning of the colors: Full Fuse Mode (red), Executor Ablation (orange), Executor Chat Mode (yellow), Summary Ablation (green), and Planner Ablation (blue).
### Detailed Analysis or ### Content Details
- **Chart (a)**: The Full Fuse Mode consistently has the highest top score, followed by Executor Chat Mode and Executor React Mode. Summary Ablation and Planner Ablation have lower scores.
- **Chart (b)**: The Full Fuse Mode reaches the top1 score the fastest, followed by Executor Chat Mode and Executor React Mode. Summary Ablation and Planner Ablation take longer to reach the top1 score.
### Key Observations
- The Full Fuse Mode shows the highest top scores and the fastest time to reach the top1 score.
- Summary Ablation and Planner Ablation have the lowest top scores and the longest time to reach the top1 score.
- The Executor Chat Mode and Executor React Mode show intermediate performance.
### Interpretation
The data suggests that the Full Fuse Mode is the most effective in terms of both top scores and efficiency. Summary Ablation and Planner Ablation are less effective, with Summary Ablation having the lowest scores and Planner Ablation taking the longest time to reach the top1 score. The Executor Chat Mode and Executor React Mode show a balance between top scores and efficiency. The visual trends indicate that the Full Fuse Mode is the most efficient and effective experimental mode.
</details>
Figure 3: Evolutionary Effect & Efficiency.
<details>
<summary>ablation2.png Details</summary>
### Visual Description
## Heatmap: Current Top Score Evolution
### Overview
The heatmap illustrates the evolution of the current top score over time, categorized by different modes and ablations. The x-axis represents the cumulative evolutionary time in hours, while the y-axis shows the current top score.
### Components/Axes
- **X-Axis**: Cumulative Evolutionary Time (Hours)
- **Y-Axis**: Current Top Score
- **Legend**:
- Full Fuse Mode
- Executor Ablation - React Mode
- Summary Ablation (No Summary)
- Executor Ablation - Chat Mode
- Planner Ablation (No Planner)
### Detailed Analysis or ### Content Details
The heatmap shows that the Full Fuse Mode consistently maintains the highest current top score across all time periods. The Executor Ablation - React Mode and Summary Ablation (No Summary) show a gradual increase in the current top score, with the Executor Ablation - React Mode slightly outperforming the Summary Ablation. The Executor Ablation - Chat Mode and Planner Ablation (No Planner) exhibit a more stable performance, with the Executor Ablation - Chat Mode showing a slight decline over time.
### Key Observations
- The Full Fuse Mode has the highest current top score throughout the time period.
- The Executor Ablation - React Mode and Summary Ablation (No Summary) show a steady increase in the current top score.
- The Executor Ablation - Chat Mode and Planner Ablation (No Planner) have more stable performance with minor fluctuations.
### Interpretation
The data suggests that the Full Fuse Mode is the most effective in maintaining a high current top score. The Executor Ablation - React Mode and Summary Ablation (No Summary) show a positive trend, indicating that these modes may be improving over time. The Executor Ablation - Chat Mode and Planner Ablation (No Planner) have more stable performance, which could be due to their simpler design or less reliance on complex ablations. The slight decline in the Executor Ablation - Chat Mode over time might indicate that it is reaching its optimal performance level.
</details>
Figure 4: Score Convergence over Time. Note: Faint lines represent individual runs ( $N=3$ ), and bold lines represent the average trajectory.
#### 5.4.1 Planner: The Compass of Evolution
The Planner provides global expert guidance. Removing it forces the agent into a "blind search" mode. As shown in Figure 4, the Planner-ablated agent stagnated below 0.96. The lack of search pruning increased the average time to reach Top-1 solutions from 9.67 hours to 14.67 hours.
#### 5.4.2 Executor: Balancing Speed and Depth
The Executor employs an adaptive "Fuse Mode", switching between Chat (single-turn) and ReAct (multi-turn).
- Chat Mode: Computationally lightweight but highly unstable.
- ReAct Mode: Stable but inefficient.
- Fuse Mode: By dynamically allocating compute, Fuse Mode achieved the highest asymptotic score (0.998) with optimal sample efficiency.
#### 5.4.3 Summary: The Evolutionary Feedback
The Summary prevents the loss of historical insights. Without it, the agent suffered from cyclical errors. One trial ran for 35 hours yet failed to break the 0.95 threshold (as shown in Figure 4, see the "No-Summary" trajectory). The absence of retrospective analysis degraded the Planner’s decision-making, confirming that the summary module is essential for breaking performance bottlenecks.
## 6 Conclusion
In this work, we introduced LoongFlow, a cognitive evolutionary framework that fundamentally transcends the "blind watchmaker" limitations of traditional LLM-based optimization. By identifying the critical "cognitive ceiling" in existing methods—specifically their reliance on stochastic mutation and lack of historical reflection—we proposed a paradigm shift from random search to Directed Cognitive Evolution.
Our core contributions, the "Plan-Execute-Summarize" (PES) paradigm and the Hybrid Evolutionary Memory, effectively bridge the gap between reasoning agents and evolutionary computation. Theoretical analysis and extensive experiments demonstrate that LoongFlow not only preserves the diversity benefits of population-based methods but also injects the strategic depth of reasoning agents, achieving state-of-the-art results with significantly reduced computational overhead. LoongFlow establishes a new standard for sample-efficient, autonomous scientific discovery.
Future work will focus on extending LoongFlow towards fully autonomous "Meta-Agents" that can self-configure their evolutionary strategies and learning unsupervised diversity metrics for novel domains.