LoongFlow: Self-Evolving Agent Framework

• LoongFlow is a self-evolving agent framework that uses a Plan-Execute-Summarize cycle and hybrid memory to search high-dimensional code spaces with directed reasoning.
• It distinctively couples strategic planning with execution and retrospective reflection to overcome brute-force mutation, preserving stepping-stone solutions.
• The framework employs multi-island evolution, MAP-Elites archiving, and adaptive Boltzmann selection to boost search efficiency and maintain solution diversity.

Searching arXiv for the LoongFlow paper and a few related identifiers for citation support. I’ll look up the cited arXiv records relevant to LoongFlow and closely related naming collisions. LoongFlow is a self-evolving agent framework that uses LLMs to discover or improve executable solutions—especially code—through an evolutionary process that is explicitly more structured than prior “LLM-as-random-mutator” approaches. It is presented as a step from static LLM prompting toward self-improving agents that can search high-dimensional program spaces for algorithmic and machine-learning solutions. Its defining move is to couple a cognitive Plan-Execute-Summarize (PES) loop with a hybrid evolutionary memory that combines multi-island evolution, MAP-Elites-style behavioral archiving, and adaptive Boltzmann selection, thereby reframing mutation as directed reasoning rather than blind perturbation (Wan et al., 30 Dec 2025).

1. Conceptual framing and problem formulation

The paper positions LoongFlow within the broader transition from static LLMs to autonomous scientific-discovery agents. In that framing, prior systems cited by the paper, including FunSearch, Eureka, and AlphaEvolve, demonstrated that code-generating LLMs can discover heuristics, mathematical constructions, and reward functions, but open-source evolutionary systems such as OpenEvolve and ShinkaEvolve are argued to hit a “cognitive ceiling” (Wan et al., 30 Dec 2025).

Three bottlenecks motivate the design. First, prior search is described as inefficient in high-dimensional code spaces because it lacks explicit strategic planning and degenerates into brute-force sampling. Second, diversity collapses under top-$k$ or purely reward-driven selection, causing the loss of stepping-stone solutions. Third, reflexive memory is weak: systems know whether a candidate failed, but not why, and therefore revisit similar errors. LoongFlow is introduced specifically to address cost, convergence, and feedback.

The paper formalizes self-evolution as a Markov Decision Process over code,

$$\langle \mathcal{C}, \mathcal{A}, R, \pi_\theta \rangle,$$

where $\mathcal{C}$ is the discrete program space, $\mathcal{A}$ is a semantic action space of code modifications, $R$ is a scalar reward or fitness function, and $\pi_\theta$ is the LLM policy that proposes modifications. The optimization objective is presented as finding the best program,

$s^* = \arg\max_{s \in \mathcal{C}} R(s).$

The paper notes that the printed typesetting is malformed, but the intended objective is clearly to maximize $R(s)$ over $s \in \mathcal{C}$.

This formulation is significant because LoongFlow does not treat the LLM as a primitive mutation operator. Instead, it treats the LLM as a composite semantic operator whose actions are decomposed into planning, implementation, and reflection. This suggests a shift from stochastic code variation toward hypothesis-driven search over program space.

2. The Plan-Execute-Summarize paradigm

The core cognitive mechanism is the Plan-Execute-Summarize paradigm, which decomposes each evolutionary step into three semantically distinct stages (Wan et al., 30 Dec 2025).

In the planning stage, the system generates a natural-language blueprint

$$b \sim \pi_\theta(b \mid s_t, \mathcal{M}_t, \mathcal{I}_{plan}),$$

conditioned on the current parent solution $$\langle \mathcal{C}, \mathcal{A}, R, \pi_\theta \rangle,$$0, current memory $$\langle \mathcal{C}, \mathcal{A}, R, \pi_\theta \rangle,$$1, and planning instructions. The plan is not code. It is a strategic description of what to change and why. The paper emphasizes that this allows the model to reason at a higher abstraction level before committing to implementation details.

In the execution stage, the plan is translated into executable offspring code,

$$\langle \mathcal{C}, \mathcal{A}, R, \pi_\theta \rangle,$$2

The executor is domain-dependent. For algorithmic discovery it may operate as a logic-intensive single-pass coder; for machine-learning tasks it may produce a more elaborate workflow or pipeline. A practical detail is that the executor performs local verification or “fast-fail” checks before expensive global evaluation. Syntax errors, import errors, and obvious implementation failures are filtered early, which the paper identifies as one mechanism for reducing evaluation waste.

In the summarization stage, after evaluation yields reward $$\langle \mathcal{C}, \mathcal{A}, R, \pi_\theta \rangle,$$3, the framework generates a reflection summary

$$\langle \mathcal{C}, \mathcal{A}, R, \pi_\theta \rangle,$$4

and updates memory by

$$\langle \mathcal{C}, \mathcal{A}, R, \pi_\theta \rangle,$$5

The summary is intended to capture causal insight: which parts of the plan worked, which failed, and what subsequent generations should retain or avoid. The paper describes this as an abductive reflection step inspired by Reflexion and long-term memory ideas from generative agents.

The conceptual distinction from conventional mutation and crossover is explicit. Traditional mutation perturbs code blindly or semi-blindly, while crossover recombines inherited material without reasoning over intent or causality. PES instead inserts semantic planning before generation and retrospective summarization after evaluation. In the paper’s own framing, each offspring becomes less a random perturbation than a hypothesis-driven experiment.

3. Hybrid evolutionary memory and diversity control

The second major contribution is a hybrid evolutionary memory designed to preserve long-term architectural coherence while maintaining broad exploration (Wan et al., 30 Dec 2025). The memory is not merely a score table. It is a structured store of genealogical and behavioral information.

The paper gives a Python-style Solution schema containing the actual code (solution), a unique solution_id, the generate_plan that produced it, a parent_id for lineage tracking, island_id, iteration and generation metadata, timestamps, sample_cnt, sample_weight, the scalar score, raw evaluation logs, the summary, and a generic metadata dictionary. This allows LoongFlow to preserve not only artifacts and rewards, but also intent and retrospective lessons.

Genealogical retrieval is central. Rather than retrieving context by generic semantic similarity, the planner traverses explicit lineage links via parent_id, collecting ancestral plans and summaries. Past plans encode historical intent; past summaries encode retrospective feedback. The paper frames this memory as behaving more like a structured knowledge graph over evolutionary trajectories than a flat archive.

Three mechanisms are combined:

Mechanism	Role	Stated behavior
Multi-island model	Spatial diversity preservation	Islands evolve independently in a ring topology
MAP-Elites	Behavioral niche preservation	Best solution retained per discretized feature cell
Adaptive Boltzmann selection	Exploration-exploitation control	Temperature adapts to entropy/diversity

The archive uses a feature map

$$\langle \mathcal{C}, \mathcal{A}, R, \pi_\theta \rangle,$$6

where $$\langle \mathcal{C}, \mathcal{A}, R, \pi_\theta \rangle,$$7 is a lower-dimensional behavioral descriptor space. Examples given include cyclomatic complexity, code length, and code complexity $$\langle \mathcal{C}, \mathcal{A}, R, \pi_\theta \rangle,$$8 memory usage. For a feature cell $$\langle \mathcal{C}, \mathcal{A}, R, \pi_\theta \rangle,$$9, the archive stores the best solution in that niche: $\mathcal{C}$0

Parent selection uses adaptive Boltzmann sampling: $\mathcal{C}$1 The paper gives both an entropy-proportional form,

$\mathcal{C}$2

and the pseudocode schedule

$\mathcal{C}$3

Qualitatively, when diversity is high, selection becomes more exploitative; when diversity is low, temperature rises and selection becomes flatter, forcing exploration.

Migration occurs between neighboring islands when the diversity difference $\mathcal{C}$4 exceeds a threshold, with the top $\mathcal{C}$5 elites copied to adjacent islands. The paper does not provide a formal definition of $\mathcal{C}$6, the threshold value, or the migration percentage $\mathcal{C}$7. That omission is important for interpreting reproducibility.

4. Operational workflow and agent instantiations

Algorithm 1, “LoongFlow Main Evolutionary Loop,” gives the clearest implementation-level description (Wan et al., 30 Dec 2025). The system begins from a task description $\mathcal{C}$8, an initial solution $\mathcal{C}$9, a maximum number of iterations $\mathcal{A}$0, and $\mathcal{A}$1 islands. Global memory $\mathcal{A}$2 is initialized with $\mathcal{A}$3, and each island receives its own MAP-Elites archive. For each iteration and island in parallel, LoongFlow computes island entropy $\mathcal{A}$4, sets a dynamic temperature, samples a parent via Boltzmann selection, retrieves its lineage, builds planning context from ancestral plans and summaries, generates a new plan, executes code, verifies it locally, evaluates it globally, summarizes the result, packages the offspring into a new Solution object, and updates the island archive. Every $\mathcal{A}$5 iterations, elites migrate between islands. The final output is the best score across island archives.

The paper instantiates this architecture in two agent forms:

Agent	Domain	Execution emphasis
General Agent	Algorithmic discovery	Logic-intensive single-pass coding
ML Agent	ML pipeline optimization	Pluggable workflow-style execution

The General Agent is the direct analogue of AlphaEvolve-style systems for mathematical and algorithmic discovery. The ML Agent is adapted to end-to-end ML engineering tasks such as preprocessing, model choice, and training setup, though the paper does not decompose those steps further. It also mentions executor “Fuse Mode,” which dynamically switches between lightweight Chat mode and more stable but expensive ReAct mode, at least in the ablation discussion. The paper does not fully specify whether this switching applies equally to both agent types.

A plausible implication is that LoongFlow is intended less as a single benchmark-specific system than as a reusable search template in which the PES loop is fixed while the executor and evaluator are domain-specialized.

5. Empirical results and ablations

The evaluation covers algorithmic discovery on the AlphaEvolve benchmark suite and ML engineering on MLEBench/Kaggle-style tasks (Wan et al., 30 Dec 2025). The paper reports task-specific objective values on mathematical problems, evaluations and generations to threshold, correctness, success rates across runs, and ML outcomes such as Gold medals. Efficiency is measured mainly by evaluations and convergence under fixed budgets rather than exact token counts.

On the AlphaEvolve suite, the paper reports improved best-known scores on several tasks. In Autocorrelation II, the bound improves from 0.8962 to 0.9027 using DeepSeek-R1. Circle Packing (Square) improves from 2.6358 to 2.6359, and Circle Packing (Rectangle) from 2.3658321 to 2.3658322. For minimization-style tasks, Hexagon Packing improves from 3.93 to 3.92, Max-to-Min Ratios from 12.88926 to 12.88924, Uncertainty Inequality from 0.352099104422 to 0.352099104421, and Erdős’ problem from 0.380924 to 0.380913. Some of these gains are numerically small, which the paper treats as typical for frontier mathematical optimization.

The strongest efficiency result is on Circle Packing (Square) with DeepSeek-R1-0528 under a 24-hour budget. LoongFlow required an average of 258 evaluations to reach score $\mathcal{A}$6, versus 783 for OpenEvolve. Across three runs, LoongFlow reached the $\mathcal{A}$7 region in all three runs, while OpenEvolve succeeded once out of three and ShinkaEvolve never crossed 0.99. The reported LoongFlow per-run best scores were 0.998, 0.996, and 0.994, with 484, 147, and 145 evaluations, respectively. This is the basis for the paper’s “up to 60%” evolutionary-efficiency claim.

Under a tighter budget with Gemini-3-Pro and only 100 iterations, LoongFlow reportedly exceeded score $\mathcal{A}$8 in all three runs, doing so in 6, 14, and 8 iterations with 20, 72, and 26 evaluations. Both OpenEvolve and ShinkaEvolve failed to reach 1.0 within that budget. The paper interprets this as evidence not only of faster search but of access to solution regions that baseline methods do not reach under constrained compute.

For ML engineering, the reported result is 14 Gold medals on MLE Bench tasks, including Predict Volcanic Eruptions, Stanford COVID Vaccine, Whale Challenge, Aerial Cactus Identification, Nomad2018 Transparent Conductors, Denoising Dirty Documents, Detecting Insults in Social Commentary, Dogs vs Cats Redux, Histopathologic Cancer Detection, Plant Pathology 2020, Tabular Playground Series Dec 2021, Google Quest Challenge, Plant Pathology 2021, and US Patent Phrase to Phrase Matching. The paper does not provide baseline medal counts or exact leaderboard scores, so the relative improvement is less tightly quantified than in the algorithmic-discovery experiments.

The ablations directly support the architectural decomposition. Removing the Planner caused Circle Packing to stagnate below 0.96 and increased average time to reach top-1 solutions from 9.67 hours to 14.67 hours. In the Executor ablation, Chat mode is described as light but unstable, ReAct mode as more stable but inefficient, and Fuse Mode as achieving the highest asymptotic score, 0.998, while preserving efficiency. The Summary ablation is especially strong: without summarization, one run lasted 35 hours yet still failed to break 0.95. This suggests that retrospective reflection is not ornamental but functionally important for long-horizon improvement.

6. Limitations, interpretation, and nomenclature

The paper’s strongest evidence concerns algorithmic-discovery tasks; the ML-agent results are broad but less controlled because comparable baselines and exact scores are not shown (Wan et al., 30 Dec 2025). It also leaves several implementation details underspecified, including exact behavioral descriptors per domain, entropy calculation, migration thresholds, migration percentage, and concrete hyperparameter values for $\mathcal{A}$9, $R$0, $R$1, $R$2, $R$3, $R$4, and $R$5. The method also depends on high-quality LLM planning and summarization, and its memory architecture adds engineering complexity through lineage tracking, summaries, feature descriptors, and multi-island archives. These are not always framed as weaknesses in the paper, but they delimit the current evidence.

At a conceptual level, LoongFlow’s central contribution is to fuse two traditions often kept separate: reasoning agents and population-based evolutionary search. Its three claimed contributions are the PES paradigm, the memory architecture that integrates genealogical memory with multi-island evolution, MAP-Elites, and adaptive Boltzmann selection, and the concrete GeneralAgent and MLAgent instantiations. The overall technical picture is that evolutionary discovery with LLMs should reason before acting and reflect after acting, while the outer population dynamics preserve diversity over long search horizons.

The name should also be distinguished from several unrelated arXiv works with similar titles. “Loong” has been used for minute-level autoregressive video generation (Wang et al., 2024), verifier-driven long chain-of-thought synthesis (Huang et al., 3 Sep 2025), and a long-document translation agent (Wang et al., 28 May 2026). “LoongRL” refers to reinforcement learning for long-context reasoning (Wang et al., 22 Oct 2025). “LongFlow” denotes KV-cache compression for reasoning models (Su et al., 12 Mar 2026). Those works do not define the LoongFlow framework discussed here. In the present usage, LoongFlow specifically denotes a directed evolutionary search framework for self-improving code agents built around planning, execution, reflection, and diversity-aware memory (Wan et al., 30 Dec 2025).