Part1: Self-Evolving Agent Systems: How LLMs Are Becoming Autonomous Optimizers

Large language models are no longer just tools for answering questions.

A new class of systems is emerging: systems that can generate solutions, evaluate them, store what they learn, and keep improving over time. These are often called self-evolving agent systems, program evolution systems, or AI-for-AI frameworks.

The core idea is simple:

Instead of asking an LLM for one answer, we let it participate in a feedback loop that repeatedly improves solutions.

This shift matters because it moves AI from one-shot generation to long-horizon optimization. The system is no longer just a chatbot. It becomes something closer to an autonomous researcher, engineer, or optimizer.

The basic loop

Most self-evolving systems follow the same pattern:

1. Define a task and an evaluator.
2. Generate candidate solutions.
3. Run the candidates.
4. Measure the results.
5. Store the outcomes.
6. Select the best or most promising directions.
7. Repeat.

In pseudocode, the loop looks like this:

task -> candidate generation -> execution -> evaluation -> memory -> selection -> next round

The most important component is not the LLM itself, but the evaluator. If the evaluator is weak, noisy, or misaligned, the system will optimize the wrong thing. A self-evolving system is only as good as the objective it can measure.

Why this matters

Traditional agents are still mostly stateless. They may use tools, but they do not usually build a durable improvement loop.

Self-evolving systems change that by introducing:

• search
• memory
• reflection
• automatic evaluation
• iterative improvement

That makes them useful for tasks where the goal is not just to answer a question, but to discover better solutions over time.

This is especially relevant in:

• code optimization
• machine learning engineering
• model architecture search
• algorithm design
• quantitative research
• scientific experimentation

Five representative frameworks

A useful way to understand this space is to look at five representative frameworks: OpenEvolve, ASI-Evolve, MLEvolve, LoongFlow, and FM-Agent. They all follow the same high-level idea, but they organize the search loop differently.

OpenEvolve

OpenEvolve is the closest to a classic evolutionary coding system. It starts from an initial program, asks an LLM to modify or rewrite it, evaluates the result, and keeps stronger candidates for later rounds.

Its key idea is quality-diversity search. Instead of keeping only the single best solution, it tries to preserve a diverse population of good solutions. That helps avoid premature convergence and gives later generations more useful material to build on.

This makes OpenEvolve a strong fit for:

• algorithm optimization
• performance-critical code
• heuristics search
• evaluator-driven program improvement

Its main limitation is that it is still mostly a code evolution system, not a full research workflow.

ASI-Evolve

ASI-Evolve is designed for AI research automation. Its goal is more ambitious: can AI help accelerate AI development itself?

It combines two kinds of memory:

• a cognition store with papers, heuristics, and domain knowledge
• an experiment database with candidate ideas, metrics, and analysis

The loop is not just “mutate and evaluate.” It is more like:

learn -> design -> experiment -> analyze -> store -> repeat

That makes ASI-Evolve especially useful for:

• architecture search
• data curation
• training algorithm design
• research problems where prior knowledge matters

Its strength is that it does not only evolve solutions, but also evolves the context used to generate future solutions.

MLEvolve

MLEvolve is specialized for machine learning engineering. It is designed for tasks that look like Kaggle or MLE-bench: inspect the data, build a pipeline, train models, debug failures, improve scores, and create submissions.

Its central search method is Monte Carlo Graph Search. Instead of following one linear path, it keeps a graph of solution branches. Each branch can be explored, improved, or fused with another branch.

This is especially powerful because ML work is often branching and iterative. One branch may have better feature engineering, while another has a better model or validation strategy. MLEvolve can combine them.

It is best suited for:

• automated ML workflows
• benchmark competitions
• baseline generation
• iterative model improvement

LoongFlow

LoongFlow is less of a pure evolutionary optimizer and more of an expert-agent framework. Its central loop is:

plan -> execute -> summary

The system is built around disciplined reasoning. The planner decides the direction, the executor carries it out, and the summary step extracts lessons from what happened.

This makes LoongFlow a good fit for long-horizon tasks where reflection matters, such as:

• mathematical reasoning
• coding agents
• ML workflows
• research assistants

Its key strength is structure. It is easier to interpret and control than a pure mutate-select loop.

FM-Agent

FM-Agent is the most productized of the group. It focuses on large-scale evolutionary optimization with distributed evaluation, diversity-driven search, and domain-specific scoring.

Its design is aimed at scalable, enterprise-style workflows where the system needs to run many candidates in parallel and evaluate them reliably.

This makes it useful as a reference for:

• cloud-scale optimization
• distributed evolution
• engineering systems with strong evaluators
• productized program search

Its downside is that it is more of a platform-style reference than a simple standalone framework.

What these systems have in common

Despite their differences, all of these frameworks share the same mental model:

• an LLM proposes changes
• an evaluator measures the outcome
• a search method decides what to try next
• memory preserves useful history

That is the essence of self-evolving systems.

The details differ, but the architecture is always some variation of:

generate -> run -> score -> remember -> select -> improve

How to choose the right one

A simple rule of thumb:

• Use OpenEvolve when you want a clean evolutionary baseline for code or algorithms.
• Use ASI-Evolve when the task depends on prior knowledge, literature, and research analysis.
• Use MLEvolve when the workflow looks like an ML competition with repeated training and evaluation.
• Use LoongFlow when structured planning and reflection matter.
• Use FM-Agent when you care about large-scale orchestration and distributed search.

A practical takeaway for ML and quant work

If you are building a self-evolving system for ML or quantitative research, start small.

A practical path is:

1. Build a strong evaluator.
2. Start with a simple OpenEvolve-style loop.
3. Add memory and experiment tracking.
4. Introduce structured reflection.
5. Scale only after the search loop is stable.

The evaluator should include the real constraints of the problem. For quant research, that means things like:

• out-of-sample performance
• drawdown
• turnover
• transaction costs
• stability across time
• leakage checks

A self-evolving system will optimize exactly what you reward. If the metric is wrong, the system will become very good at the wrong thing.

Final thought

Self-evolving agent systems may be the next major step after chat-based LLM applications.

The big shift is this:

from one-shot generation to continuous improvement.

That changes AI from a tool that answers questions into a system that can gradually become better at solving problems.

The future of AI may depend less on making models larger, and more on making their improvement loops smarter.