Harnessing Agentic Evolution

We formulate agentic evolution as a process for optimizing an artifact through repeated improvement rounds. Let $x\in\mathcal{X}$ denote the object being optimized, such as a program, prompt, workflow, skill, tool, or agent component. We use $r$ to index the evolution round. Each round produces a round context $c_{r}$, which contains the candidates generated in that round, their evaluation results, execution traces, failures, costs, and any intermediate information produced during optimization. The accumulated evolution context after $r$ rounds is denoted as

Finally, let $\Pi$ denote the optimization mechanism that advances evolution:

where $\oplus$ appends the newly produced round context to the accumulated evolution context. $\Pi$ does not have to be a fixed algorithm; it can also be an agentic process that reads the history, reasons over feedback, and decides how to generate the next candidate. Thus, $\Pi$ represents the mechanism by which search is continued from the current evolution context.

Under this formulation, existing agentic evolution methods mainly differ in how $\Pi$ is instantiated. In procedure-based evolution , $\Pi$ is a predefined outer loop whose behavior is mainly determined by selection and optimization: the selection rule chooses previous candidates or contexts from $\mathcal{C}_{r-1}$, while the optimization operator generates new candidates from the selected information. Evaluation assigns scores, traces, and feedback to the generated candidates, providing signals for future selection and update. In agent-based evolution, $\Pi$ is instead implemented by a general-purpose agent. Rather than following fixed selection-and-optimization rules, the agent reads the accumulated context $\mathcal{C}_{r-1}$ and decides what to do next, such as inspecting feedback, comparing candidates, modifying artifacts, writing tools, or generating new attempts. Thus, procedure-based evolution specifies search control explicitly but rigidly, while agent-based evolution leaves search control implicit in the agent’s context-conditioned behavior.

In both cases, evolution proceeds by repeatedly applying $\Pi$ while accumulating context $\mathcal{C}_{r}$. This context records not only the candidates produced by evolution, but also how search has unfolded through evaluation results, traces, failures, costs, and intermediate artifacts. The next subsection uses this accumulated context to define an environment view of evolution.

We treat the evolution process itself as an interactive environment for a meta-agent. At round $r$, the state of this environment is defined by the round index and the accumulated evolution context:

When the optimization mechanism may change across rounds, we write the current mechanism as $\Pi_{r}$. This mechanism specifies the transition of the environment. Without intervention, the next round is produced by applying the current mechanism to the current context:

Thus, $\Pi_{r}$ is the transition rule that determines how the evolution process continues.

To interact with this environment, we introduce a meta-agent $M$. The role of $\Pi_{r}$ is to continue the candidate search, while the role of $M$ is to act on the evolution process that governs this search. Since the full state $s_{r}$ can be large and noisy, the meta-agent receives an observation extracted from the state:

where $\Phi$ summarizes relevant information from the accumulated context, such as progress, repeated failures, invalid attempts, cost patterns, or redundant search directions.

Given this observation, the meta-agent produces an edit action:

The action does not directly become the next candidate. Instead, it modifies the transition rule of the evolution environment:

The edited mechanism is then used to continue evolution:

In this sense, we formulate agentic evolution as an environment in which the state is the accumulated evolution context, the observation is a summary of this context, and the action edits the mechanism that controls future search.

This formulation applies to both forms of agentic evolution. For procedure-based evolution , editing $\Pi_{r}$ changes explicit components such as selection, optimization, feedback use, budget allocation, or update rules. For agent-based evolution, editing $\Pi_{r}$ changes the agentic context that shapes future decisions, such as skills, goals, tools, feedback format, or execution context. In both cases, the meta-agent steers evolution not by proposing one more candidate, but by modifying how subsequent search is carried out. Section 4 describes the system design used to instantiate this formulation.

Meta-editing phase. The meta-editing phase decides both what to change and how to continue. The meta-agent can be any coding-capable agent that can inspect a workspace, edit files, execute commands, and follow the AEvo meta-agent skill specification, such as Claude Code [3], Codex [19], or open-source coding agents [34, 20]. Given the current workspace, it inspects the accumulated history, then produces a meta-action consisting of a workspace edit and a run plan. The workspace edit modifies files that define $\Pi_{r}$, such as procedure code, prompts, skills, goals, tools, feedback formats, validators, notes, or execution context. The run plan specifies how the next evolution segment should proceed, including the allowed iterations, budget use, and stopping conditions.

This design makes the meta-agent a process-level editor rather than a candidate generator: it changes the mechanism and conditions under which future candidates are produced. When evolution is productive, the meta-agent may allocate more iterations to the current mechanism; when it repeatedly produces invalid candidates, redundant attempts, or irrelevant exploration, the meta-agent may stop the segment and revise $\Pi_{r}$ before continuing. The full meta-agent skill specification and pseudocode of the meta-editing loop are provided in Appendix C.2.3.

Harnessed evolution segment. An evolution segment is the interval executed after a meta-edit. It runs the current mechanism $\Pi_{r}$ under the run plan produced by the meta-agent. Depending on the setting, this segment may consist of several rounds of a procedure, or an inner-agent session that produces multiple candidate attempts. Each candidate submitted for official evaluation passes through the harness-controlled evaluator, and the resulting artifact, score, trace, failure information, cost, and provenance are appended to the candidate history.

The harness provides the stable boundary needed for reliable meta-editing. It organizes candidates, logs, traces, evaluation records, meta-agent instructions, and editable evolution components into a fixed workspace layout. To prevent reward hacking, the evaluator is isolated from both the evolution agent and the meta-agent: agents can submit candidates, but they cannot inspect evaluator internals, access hidden benchmark artifacts, or directly write official scores. The harness further exposes a command-line interface for initializing workspaces, launching evolution segments, inspecting recent status and candidate history, and continuing the current process. Thus, the harness does not decide how evolution should improve; it provides the protected and inspectable interface through which evolution can be observed, edited by the meta-agent, recorded, and resumed.

AEvo applies the same two-phase loop to both forms of agentic evolution. The outer loop is unchanged: the meta-agent edits the current mechanism $\Pi_{r}$ and specifies how the next evolution segment should run. The difference lies in what $\Pi_{r}$ consists of.

Procedure-based evolution. For procedure-based evolution, $\Pi_{r}$ is an explicit evolution procedure. It defines how previous candidates or contexts are selected, how new candidates are generated, how evaluation feedback is used, and how candidate history is updated. A meta-action therefore edits the procedure itself, such as revising the selection strategy, changing the optimization operator, altering the feedback summary, adding local filtering or retry logic, adjusting budget use, or repairing candidate management. The edited procedure then controls the next evolution segment, which may run for multiple rounds before the next meta-agent intervention.

Agent-based evolution. For agent-based evolution, $\Pi_{r}$ is the operating context of a general-purpose evolution agent, including goals, skills, tools, memory files, shared notes, validators, and execution setup. A meta-action therefore edits the conditions under which the next inner-agent session will evolve, such as revising a skill, rewriting the session goal, changing how evaluator feedback is presented, or reorganizing shared notes. The inner agent remains responsible for generating candidates, while AEvo revises the context that shapes future evolution.

Tasks. We evaluate AEvo on two standard benchmarks, Terminal-Bench [25] and ARC-AGI-2 [5], and three open-ended optimization tasks, circle_packing_26 (CP26)[21], autocorrelation_second (AC2)[4], and Anthropic’s Kernel optimization task [2]. Together, these tasks cover agentic problem solving, abstract reasoning, and code-evolving open-ended optimization. Detailed task definitions and evaluation protocols are given in Appendix C.1.

Baselines. We group baselines into three families: single-agent inference, agent-based evolution, and procedure-based evolution. On Terminal-Bench and ARC-AGI-2, we compare against one-shot ReAct [35] and five procedure-based evolution baselines: ADAS [9], DGM [40], AFlow [42], SPO [30], and GEPA [1]. On the three open-ended tasks, we compare against two agent-based evolution baselines, Codex and Claude Code, and two procedure-based evolution baselines, OpenEvolve [24] and HyperAgents [41]. This setup lets us compare both variants of AEvo against systems that either keep a fixed search procedure or rely on an agent to improve artifacts directly.

Implementation Details. AEvo is instantiated in two forms. In the procedure-based setting, a meta-agent edits the evolution procedure while leaving the task evaluator fixed. In the agent-based setting, the meta-agent steers a coding-agent harness through prompts, notes, and reusable utilities. We use Claude Code and Codex as the meta-agent interfaces, backed by Claude-Opus-4.7 and GPT-5.4 as the optimization models. For Terminal-Bench and ARC-AGI-2, candidate execution uses Gemini-3-Flash. All models are accessed through APIs. Full hyperparameter settings, round budgets, early-stopping criteria, and initialization details are given in Appendix B.

Metrics. For Terminal-Bench and ARC-AGI-2, we report task score and the first optimization round that reaches the best score. Results are summarized with Avg@3 over three independent runs. For the open-ended tasks, we report the task-native objective with Best@3 over three runs, together with the first round that reaches the best result (Best R.) and the average dollar cost per optimization round ($/R). Exact task-specific objectives and cost computation are provided in Appendix C.1.

Overall performance. Tables 1 and 2 show that AEvo consistently improves agentic evolution across both open-ended optimization and fixed benchmarks. On the open-ended tasks, AEvo achieves the best or tied-best result on all three tasks, while also improving the speed or stability with which strong candidates are found. In particular, on the Kernel optimization task, AEvo achieves 1138 cycles within 100 iterations, which is, to our knowledge, the best reported result under the same iteration budget. This suggests that the harnessed meta-editing loop improves how evolution uses feedback over time, rather than merely increasing the number of candidate attempts. On standard agentic and reasoning benchmarks, AEvo also improves procedure-based evolution over strong fixed-loop baselines. The gains are consistent across both Terminal-Bench and ARC-AGI-2, yielding a 26% relative improvement over the strongest baseline on average. Together, these results support the central claim that mechanism-level intervention can benefit both open-ended optimization and benchmark-driven agentic evolution.

Improvement through optimization-time reasoning. The gains on Table 2 come with a higher per-round optimization cost. AEvo costs about three times as much as procedure-based baselines on these benchmarks. This means that AEvo improves performance by scaling the reasoning and deliberation used during optimization, and supports our view that increasing the budget of the evolution process is a useful axis for improving agentic evolution.

Cost analysis and agentic behavior. The open-ended tasks reveal that cost is not solely determined by whether a method is agent-based or procedure-based. Agent-based evolution can remain cost-competitive when implemented through coding-agent interfaces with prompt caching and persistent contexts. AEvo ${}_{\texttt{Agent}}$ maintains low per-round cost: 0.34–0.32 on circle_packing_26, 1.40–1.31 on autocorrelation_second, and 1.27–1.23 on Kernel optimization. By contrast, procedure-based methods can become expensive in long-horizon optimization by repeatedly constructing large prompts over an expanding search history without comparable caching, as visible in HyperAgents’ higher per-round cost on Task 1 and Task 2.

At the same time, direct coding agents show why agent freedom alone is insufficient for reliable evolution. Even with prompts encouraging long-horizon search, coding agents often stop early once local improvements become difficult, as seen in the early best rounds of Codex on Task 1 and Task 3. This suggests that an agent’s internal stopping decision can conflict with the external evolution budget. AEvo addresses this by placing the coding agent inside an explicit evolution harness, where rounds, candidate records, and evaluation feedback are maintained outside the agent’s local decision loop.

Revising evolution after plateaus. As shown in Figure 3, procedure-based methods such as OpenEvolve and HyperAgents tend to flatten once their current selection or mutation strategy stops producing useful candidates. In contrast, AEvo can revise the mechanism that drives subsequent evolution. When progress stalls or repeated failures appear, these signals become process-level feedback: the meta-agent can adjust the procedure, directive, or reusable search context, producing step-wise improvements after plateaus. This is visible in the late-stage jump that leads to the best 100-round result.

Using the evolution budget effectively. Direct coding agents can obtain strong early gains through internal simulation, execution, and debugging, but they may stop early once local progress becomes difficult. AEvo avoids tying progress to the agent’s local stopping decision by maintaining explicit rounds, candidate records, and evaluation feedback outside the agent context. This allows the external evolution budget to be used more consistently.

Scaling beyond early gains. The right panel extends Codex-based AEvo from 100 to 200 iterations. The best result improves from 1138 to 1121 cycles, showing that AEvo continues to benefit from additional rounds rather than saturating after an early strong candidate. Overall, the trajectories suggest that agent flexibility is useful, but reliable long-horizon improvement requires a harness that preserves global evidence and enables mechanism-level correction.

Table 3 (Appendix) ablates two key components of AEvo ${}_{\texttt{Agent}}$ on the Kernel optimization task. The full system completes the 100-round budget without reward hacking and reaches the best valid result of 1138 cycles. Removing meta-agent skills does not lead to reward hacking, but it substantially weakens long-horizon search: the best run only reaches 1407 cycles, and the runs do not consistently sustain the full budget. Removing the evolution harness is even less reliable. Although one run finds a strong 1167-cycle solution, two of the three runs enter reward-hacking trajectories and fail to produce valid cycle results. These results suggest that the skills mainly support sustained and effective meta-intervention, while the harness provides the protected evaluation boundary and structured evolution context needed to keep agentic search aligned with the true objective.

Figure 4 illustrates how AEvo performs meta-intervention during procedure-based evolution on an ARC-AGI-2 task. Starting from $P_{0}$, the meta-agent initializes a best-parent rewrite procedure that selects candidate agents by validation accuracy. This first produces an initial breakthrough candidate $C_{1}$, but subsequent variants expose several failure modes in observation parsing and refinement. The meta-agent then revises the procedure rather than continuing the same search blindly: $P_{1}$ adds Pass@K sampling and local scoring for verifier-guided generation, $P_{2}$ fixes observation parsing to activate feedback-guided refinement, and $P_{3}$ extends the refinement horizon to use more pass/fail feedback before submission. When the search becomes stuck, $P_{4}$ drops stale feedback and samples more diverse alternatives, leading to a stronger candidate. Later interventions $P_{5}$–$P_{6}$ explore stronger de-anchoring through task-profile and skeleton prompts, but these regress from $P_{4}$. This example shows that failed candidates are not merely discarded; they become process-level evidence that helps the meta-agent decide how to revise the future evolution procedure. Additional evolved procedures, optimized agent harnesses, and task-level analyses are provided in Appendix C.3.1 and Appendix C.3.2.