MEGA:
Self-Evolving Agent Optimization
Infrastructure via Wisdom Graph

1.1 · Three limitations of current automation

1.2 · MEGA: Evaluation-Driven Agent Development with Self-Evolving Curation

MEGA is an agent development infrastructure that transforms each optimization process into a durable asset, reasons over accumulated assets to compose context-specific execution plans, and evolves the composition logic itself through operational evidence. The key mechanism is a typed Wisdom Graph in which wisdom is decomposed into atomic PCR (Primary-Context-Resultant) units; logical reasoning discovers implicit relations among them; and compositional retrieval assembles plans that include bridging knowledge unreachable by embedding similarity alone. This reasoning substrate is not static—it self-evolves through attributed evidence produced by a multi-agent optimization loop.

The architecture is designed so that, as optimization cycles accumulate across projects, the Wisdom Graph matures toward delivering effective optimization guidance from the first query alone.

2.1 · Agent memory and skill reuse

Recent work has rapidly expanded persistent memory from simple storage toward reflective organization, procedural reuse, and cross-agent transfer. In the skill-reuse line, Voyager built a library in which agents generate and accumulate code-based skills in a Minecraft environment. Memento-Skills generalized this idea to general-purpose agents, automatically generating markdown skill files on the SRDP framework, rewriting skills upon failure, and selecting them via an InfoNCE and offline-RL behavioral router. ProcMEM formalizes reusable procedural Skills as natural-language units with activation, execution, and termination conditions, converting episodic experience into executable procedural memory.

Reflective and adaptive memory is also active. Reflexion proposed verbal reinforcement learning that feeds linguistic self-reflection into subsequent attempts. Self-Refine demonstrated an iterative critique-and-improve loop driven entirely by the model’s own feedback. MemGPT formalized long-term memory architecture through tiered memory and virtual context management. Dynamic Cheatsheet builds self-curated memory at test time to adapt problem-solving strategies; ACE addresses its context-collapse problem—where monolithic rewriting progressively loses accumulated knowledge—by decomposing memory into atomic bullet units with incremental delta updates (ICLR 2026).

A growing body of work extracts reusable experience from trajectories and transfers it across tasks or agents. DS-Agent reuses expert cases through a case-based reasoning pipeline (ICML 2024). Agent KB proposes a shared memory infrastructure across heterogeneous agent frameworks, foregrounding the foundation for collective agent intelligence. Agent Workflow Memory extracts multi-step routines from successful trajectories for reuse. SWE-Exp accumulates both successful and failed trajectories as a multi-layered experience bank for reusing repair expertise in software issue resolution. ReasoningBank distills generalizable reasoning strategies from both successful and failed trajectories into structured memory items, demonstrating agent self-evolution at test time (ICLR 2026).

This line of work has made meaningful progress in agent memory. However, most systems treat accumulated artifacts as independent units retrieved by similarity, without modeling the relations among them—prerequisite dependencies, mutual exclusions, or conditional applicability. Whether the unit is a procedural skill, a reflective strategy, or a cross-agent experience bank, stored items remain structurally isolated: the system knows what it has, but not how those items relate to one another. The authors of ReasoningBank explicitly identify compositional memory as an open direction. The next section examines work that imposes such relational structure.

2.2 · Structured knowledge & skill graphs

A parallel line of work imposes structure on knowledge—ranging from commonsense facts to operational skills—and attempts reasoning or composition over it. ConceptNet and ATOMIC organize commonsense relations in fixed-type node ontologies, while Pearl formalizes the notions of sufficiency and necessity in causal inference, providing theoretical tools for reasoning beyond mere correlation. On the retrieval side, GraphRAG improved answer quality through entity graphs and community-level summaries, LightRAG introduced graph-aware indexing with incremental updates, and HippoRAG 2 unified factual, sense-making, and associative memory through non-parametric continual learning (ICML 2025). These systems demonstrate that imposing structure on factual knowledge enables better retrieval, but they do not address the composition of operational skills and strategies.

More recent work moves beyond storing skills toward orchestrating and curating them. AgentSkillOS organizes skills into a hierarchical capability tree and composes them through task-specific DAG orchestration with three composition strategies (quality-first, efficiency-first, simplicity-first), demonstrating that structured composition substantially outperforms flat invocation. SkillNet connects skills through a typed multi-relational graph with four relation categories (similar_to, belong_to, compose_with, depend_on) and provides a multi-dimensional quality evaluation framework, achieving consistent reward improvements across multiple agent architectures. Together, these systems validate a key premise: the bottleneck in skill-based agents is not skill availability but orchestration—how skills are organized, selected, and composed for a given task.

However, composition still operates at the whole-skill level—neither system decomposes a compound skill into atomic sub-units whose internal dependencies can be individually reasoned about. Relational structures also remain relatively coarse: a hierarchical tree without cross-branch edges, or a small set of discrete relation types that do not distinguish the strength of association. Nor do these systems perform logical inference to discover relations that were never explicitly recorded, or self-refine through operational evidence—once a skill is registered or a relation labeled, it remains static regardless of whether downstream execution confirms or contradicts it. The next section examines whether optimization systems address these gaps from the other direction.

2.3 · Automatic optimization of agent systems

Research on automatically improving agent system performance is growing rapidly and bifurcating into two tiers defined by the optimization object. The first tier optimizes prompts, instructions, demonstrations, and related settings over fixed LM programs. DSPy frames LM calls as declarative programs whose prompts and examples are automatically optimized by a compiler. MIPROv2 jointly searches instructions and few-shot demonstrations for multi-stage LM programs. GEPA reflectively analyzes trajectories—including tool calls and intermediate outputs—to evolve prompt updates. Feedback Descent generalizes text-level optimization through pairwise comparison with cumulative textual rationale. Optimas optimizes heterogeneous configurations including prompts, hyperparameters, and model parameters while maintaining component-level local rewards for globally aligned optimization of compound AI systems.

The second tier treats the workflow as a mutable optimization target at the code-node level, rather than refining prompts within an LM program. AFlow formalizes agentic workflow optimization as a search problem over code-represented workflows; the core of optimization lies not in better-phrasing prompt chains but in restructuring LLM-invoking nodes, their connections, task decomposition, execution order, and control flow at the code level. Flow represents workflows as activity-on-vertex graphs and performs dynamic subtask allocation and continuous workflow refinement. The defining characteristic of this tier is that it treats agent systems as mutable code/graphs and optimizes node composition, edge structure, task decomposition, and execution policies as first-class optimization variables.

The two tiers share two structural limitations. First, neither accumulates why a particular strategy worked under particular conditions as structured, cross-project transferable knowledge. Second, both tiers assume that evaluation data is externally provided and treat it as fixed input, even though a growing body of work demonstrates that synthetic data meaningfully improves agent capabilities—SWE-Next for coding agents, ProgSearch for web research agents, and SandMLE for ML engineering agents—leaving the evaluation dataset itself outside the optimization loop.

Recent empirical studies independently corroborate the first limitation. Yu et al. demonstrate that test-driven verification is often insufficient—345 erroneous patches passed SWE-bench tests due to inadequate coverage—and Joshi et al. characterize existing SWE bench agents as stateless, treating each issue independently without cross-task experience accumulation. Stateless automation loops such as the Ralph Loop exhibit the same pattern: each cycle does not learn from prior cycles, so productive work and waste are automated equally.

The preceding review reveals a consistent pattern. Memory systems accumulate experience but do not decompose it into compositionally reasonable units (Section 2.1). Graph-based systems and skill orchestration frameworks impose structure but do not decompose skills into atomic reasoning units, discover implicit relations through logical inference, or self-refine through execution evidence (Section 2.2). Optimization systems improve agent performance but do not structure transferable knowledge about why a strategy succeeded, nor do they generate the evaluation data on which optimization depends (Section 2.3).

3.1 · Inter-layer artifact contract

Specifying each layer’s inputs and outputs makes the system boundaries precise. Table 1 summarizes this contract.

3.2 · Four types of wisdom

MEGA accumulates not only skills but also strategies, curation patterns, and optimization trajectories as causal judgments. All four types share PCR semantics within WG-DB and are subject to the same reasoning and curation mechanisms.

Curation patterns, in particular, create substantial value in practice. Many failures stem not from the absence of individual skills but from invoking the right skills in the wrong order, under the wrong conditions, or with premature confidence. Knowing which orderings were stable, which evidence thresholds must be met before proceeding to the next step, and which failure signals should trigger a return to exploration mode—these are Wisdom-level judgments that cannot be captured at the Knowledge level. Optimization trajectories are likewise not mere logs. They encode operational wisdom about “what changes were attempted, what improved, and what broke,” serving as higher-order wisdom that Layer 2 references when determining exploration/exploitation strategies for future tasks.

3.3 · Wisdom Graph as a reasoning substrate

In the DIKW pyramid of information science, the transition from Knowledge to Wisdom has traditionally been discussed in terms of value judgment and effectiveness. We reinterpret that transition computationally. A Knowledge Graph is a network representation of information. It structures factual relations as nodes and edges — “A is related to B,” “X is a type of Y.” ConceptNet can store “a car runs on a road,” but it cannot derive on its own that “when the road is wet, the car’s braking distance increases.” This is structured storage, not reasoning.

MEGA’s WG-DB operates beyond this representational level. We use the term wisdom to denote a reusable causal judgment of the form “under context v_C, action v_P produces resultant v_R, realized via method m.” Each wisdom asset decomposes into atomic PCR (Primary–Context–Resultant) triplets with typed dependencies — prerequisite, exclusion, conditional branching, and fallback — among sub-units, and four disjoint subtypes (skills, strategies, curation patterns, optimization trajectories) share these PCR semantics.

The Wisdom Graph (WG-DB) is then the directed typed multi-graph G = (V, E) whose nodes are these PCR components and whose edges carry Sufficiency/Necessity scores σ(e) = (S(e), N(e)) ∈ [0, 1]² inspired by Pearl’s causal calculus, with a role-fluid node pool that lets the same concept serve as Primary in one triplet and as Context in another. Over this structure, MEGA performs deduction, abduction, and induction to derive relations that were never explicitly recorded, and operational evidence feeds back to enable the graph to self-refine. Furthermore, WG-DB does not remain a reasoning substrate for a single project. Skills, strategies, curation patterns, and optimization trajectories accumulated across multiple projects mitigate the cold-start problem of new projects, enabling them to begin from previously validated structures.

4.1 · The extraction pipeline

Many memory systems either feed entire sessions back as long context or vectorize session fragments for retrieval. This approach is useful for short FAQ-style problems but reveals three limitations in complex agent workflows. First, raw traces mix signal and noise, making the unit of reuse unclear. Second, when sessions that solved the same problem with different strategies are mixed, retrieval may return conflicting instructions. Third, returning entire sessions blurs the boundaries of privacy filtering and evidence attribution.

Distilled wisdom, by contrast, first determines “what is the essential pattern” before storing it. Layer 1’s task is not text compression but the separation of only those structures from a session that have reuse value. Only by explicitly structuring which error signal was the starting point, which action was the key fix, which result was verified, and which exception conditions apply can Layer 2 accept the output as a reasoning substrate.

4.2 · Two-stage clustering: domain separation + behavioral pattern discovery

The technical core of Layer 1 is two-stage clustering.

This O(1) merge operation enables single-pass O(n) processing over the full session set. Using the radius-based threshold criterion, a new session embedding x is assigned to the closest existing sub-cluster when the resulting radius remains within the threshold T:

where CF′ = CF + (1, x, ‖x‖²). If the condition is violated, a new sub-cluster is created. This mechanism produces an adaptive number of sub-clusters without requiring a pre-specified k — a critical property since the number of behavioral patterns in agent sessions cannot be known a priori. The CF-Tree structure further ensures memory efficiency by bounding tree width through a branching factor.

This two-stage structure transforms Layer 1 from “conversation storage” into behavioral-pattern-based knowledge distillation. Sessions that are semantically similar but behaviorally distinct — sessions that solved the same error with different strategies — are separated and synthesized into independent wisdom assets.

4.3 · Synthesis and structural filtering

Behavioral patterns extracted from clusters are synthesized by an LLM into structured wisdom. This synthesis is not simple summarization but a process of generalizing common patterns within a cluster and specifying exception conditions. Synthesized candidates undergo structural filtering: (1) hash-based exact deduplication (O(n)), (2) LLM-based conflict detection — identifying and resolving contradictory instructions and mutually exclusive candidates, (3) cross-run embedding-similarity deduplication — merging candidates extracted from different sessions that are semantically identical. This structural filtering prevents knowledge-base contamination. For sessions where extraction could not complete, a pending management mechanism preserves partial results, enabling subsequent retries to skip already-completed stages and resume processing.

4.4 · Behavioral A/B validation

Evaluating extracted knowledge typically relies on proxy signals — metadata quality, LLM-generated ratings, or structural completeness. These signals assess the artifact itself rather than its effect on downstream agent behavior. MEGA Layer 1 introduces behavioral A/B validation, which directly measures the causal impact of each wisdom candidate on task performance. Test cases are generated alongside each wisdom candidate using an automated teacher-student evaluation protocol: a high-capability model produces both the wisdom document and its associated test suite; the same or a stronger model then executes the test suite under treatment and control conditions. For each wisdom candidate that passes synthesis and structural filtering, these test cases are executed in parallel under two conditions:

The outputs of the two runs are compared to empirically measure performance lift (accuracy improvement) and token efficiency (cost change). These two ROI axes form the basis for accept/reject decisions. Three key differentiators define this design. First, the evaluation criterion is observable behavioral change, not subjective quality judgment. Second, the two axes of performance lift and token efficiency are independently valuable — wisdom that significantly reduces cost even at equivalent accuracy can still pass. Third, this validation runs automatically for all candidates, maintaining wisdom quality at the operational stage without human review.

Consequently, Layer 1’s quality assurance comprises three tiers: structural filtering (deduplication and conflict removal), self-evaluation scoring, and behavioral A/B validation (empirical ROI measurement). Self-evaluation scoring collects factual, countable properties of the generated document — such as the ratio of rules backed by concrete commands or code examples — and aggregates them via a weighted harmonic mean that naturally penalizes any single weak dimension. Only wisdom that passes this entire pipeline enters Layer 2’s reasoning substrate.

5.1 · Compositional retrieval, not skill selection

On the surface, MEGA may appear similar to a skill combination system in that it bundles multiple skills into a plan. However, the essence of a combination engine is scoring and combining a given candidate pool. In MEGA, by contrast, Layer 2 extends the graph through reasoning before combination. The system does not stop at selecting already-stored items; it infers bridge, prerequisite, exclusion, and fallback relations among stored items that have not yet been made explicit.

A combination engine typically selects “three similar skills” and lists them in a prompt. MEGA, however, first identifies which types of wisdom are jointly needed, then decomposes the role each wisdom plays within the plan. Some items become direct execution targets, others become conditionals, and still others become fallback rules activated only upon failure. Plan generation in MEGA is therefore not the construction of a candidate set but the placement of role-differentiated artifacts into an execution graph. Through trajectories and verdict feedback, MEGA produces conditional wisdom about “when not to invoke,” learning the boundaries of success and failure simultaneously.

5.2 · PCR atomic decomposition

Each wisdom asset undergoes hierarchical PCR decomposition: a compound skill is factored into atomic sub-skill units, each represented as a PCR triplet. The logical dependencies among sub-skills — prerequisite ordering, mutual exclusion, and conditional branching — are captured as typed edges within the PCR graph. This decomposition enables Layer 2 to reason about the internal structure of complex skills, not merely their external interfaces, thereby supporting compositional retrieval at sub-skill granularity.

WG-DB uses a Role-Fluid node pool: the same node can serve as P in one triplet and as C in another. Unlike structures such as ConceptNet or ATOMIC that assign fixed types to nodes, this design allows the same concept (e.g., “Git branching strategy”) to function naturally as an action to perform (Primary) in one context and as a precondition (Context) in another. This role fluidity naturally generates cross-skill connections and forms a richer relational network while reducing the node count compared to fixed-type graphs.

5.3 · PCR reasoning: three classical modes

PCR triplets are not merely a storage format. They are what transforms Layer 2 from “a knowledge graph with retrieval preprocessing” into a logical inference layer. The directional relations among P, C, and R provide the structural basis for three classical modes of reasoning.

Figure 3 · PCR Reasoning. The directional P→C→R structure of PCR provides the structural basis for three classical modes of reasoning. Solid lines denote observed edges; dashed lines denote inferred edges.

5.4 · PCST-based compositional retrieval

Embedding similarity search returns only knowledge directly similar to the query. It cannot discover “bridging knowledge” — knowledge essential for connecting multiple skills but exhibiting low similarity to the query — which is critical for complex tasks.

WG-DB formalizes this as a Prize-Collecting Steiner Tree (PCST) problem over the undirected projection Ḡ of WG-DB, obtained by retaining the maximum causal strength for each undirected node pair:

π(v; q) is a prize proportional to query relevance, and c(e) is a cost proportional to causal weakness. Since c(e) ≥ 0, any optimal connected solution is a tree. Non-seed nodes in the PCST solution — those with low query similarity but essential for connecting seeds — constitute the bridging wisdom.

Crucially, PCST does not retrieve only skill-type wisdom. Since all wisdom types coexist in the same graph, PCST performs mixed-type subgraph assembly that cross-composes heterogeneous wisdom types including strategies, curation patterns, and trajectories.

• Seed (high sim)
• Bridge (low sim, essential)
• Excluded

5.5 · From subgraph to execution

The output of PCST is not an immediately executable script. It is a reasoning subgraph representing “what should be considered together.” Here, Layer 2 performs a second transformation: converting the mixed-type subgraph into a plan artifact with execution ordering. Skill nodes become execution candidates; strategy nodes become gating rules and priority constraints; curation patterns provide topological constraints and dependency ordering; and trajectories provide initial bias in conservative/exploratory branches. The output Π(q) of Layer 2 is therefore not a simple top-k list but the linearization of a plan graph with assigned execution rules.

5.6 · ROI-based curation: self-evolution, not ranking

The second core role of Layer 2 is to continuously evaluate and refine the effectiveness of accumulated wisdom. This is not simple ranking — it is a self-evolution mechanism in which the system calibrates its own judgments against historical performance.

5.7 · Wisdom self-evolution: a system that improves with use

After each curation session completes, per-wisdom attributions are extracted from the session outcome, decomposing the session-level result into individual contribution levels, observed effects, and optional revision suggestions. These attributions drive self-evolution along three axes: individual-level calibration of the transfer function τ, compositional-level reinforcement that promotes frequently successful combinations to curation strategies, and content-level evolution that flags wisdom items accumulating revision suggestions for the maintenance pipeline.

When a pattern group accumulates sufficient members, an offline synthesis step — executed in batch, outside the live curation loop — compresses them into a single best-practice pattern capturing the common successful structure and weighted average performance. All learned state feeds into the next curation cycle.

5.8 · Wisdom maintenance: auto graph hygiene

Self-evolution improves wisdom over time, but without active maintenance the graph can degrade through duplication, contradiction, and staleness. Layer 2 performs three maintenance operations directly on the PCR structure.

6.1 · The Adapt pipeline

The optimization target of Layer 3 is not a single prompt but an entire heterogeneous workflow encompassing code nodes, LLM calls, tool-using agents, orchestration logic, and evaluation pipelines. Given an existing agent system, Layer 3 inventories its assets, reverse-engineers a formal specification, generates evaluation data where absent, and initiates iterative optimization against the resulting baseline. The principle throughout is to respect the existing code structure while making targeted improvements, with mandatory user interaction gates at critical decisions.

1. 1

   Asset Scan — inventories source code, LLM call structure, evaluation metrics and any available data; characterizes the optimization baseline.

2. 2

   Adaptive Entry — chooses the starting point (code only / PRD only / data only / any combination) and skips stages whose outputs are already present.

3. 3

   Research Agents (conditional) — when evaluation data or code is missing, parallel agents survey SOTA techniques and identify public datasets to ground synthesis decisions.

4. 4

   Reverse PRD / Data Synthesis — reconstructs a Pipeline Requirement Document; when no dataset exists, derives a category–difficulty matrix and generates stratified train/val sets (with mandatory human approval at the seed scenario gate).

5. 5

   Shared Optimization Loop — Seed-Epoch iterative optimization; central optimization agent coordinates Scientist, Code Reviewer, and Redesign sub-agents through diagnosis → hypothesis → execution → measurement.

6. 6

   Meta-learning Agent — extracts which strategies worked under which conditions as structured wisdom and registers them in Layer 2; surfaced capability gaps become new atomic skills.

6.2 · Multi-agent collaboration inside the optimization loop

Layer 3 employs over a dozen specialized agents, each with strictly bounded responsibilities. Table 3 summarizes the key agents by phase.

The optimization loop proceeds in two stages. In Iteration 0 (Baseline Analysis), the initial system is evaluated and the scientist agent performs multi-faceted diagnostics: error pattern classification by fixability (prompt-fixable, code-fixable, architecture-required), per-node root-cause analysis that distinguishes genuine failure sources from downstream victims, and ROI-based prioritization. A five-signal architectural verdict — error concentration, context loss ratio, error type diversity, uniform failure rate across LLM nodes, and user goal gap — determines whether incremental improvement or full architectural redesign is warranted.

Iteration 1+ (Delta Mode): The central optimization agent directly performs delta analysis and repeats fixed-seed evaluation under the Seed-Epoch structure. At each iteration, the agent applies up to three targeted fixes (prompt improvement, structural code fix, or parameter tuning), submits them to the code reviewer for validation, and measures the result. The architectural principle is centralized deliberation with specialized execution: the central optimization agent directly decides “what is the problem, what should be tried, and how should the results be interpreted,” while specialized agents perform only well-bounded tasks.

6.3 · Data-aware optimization

Most agent optimization systems treat training data as fixed and optimize only the workflow. Layer 3 extends the optimization scope to include the data itself: before entering the workflow optimization loop, the system analyzes whether observed failures stem from workflow limitations or from gaps in training data coverage, and intervenes accordingly.

Layer 3 addresses this through a conditional data augmentation step that executes between baseline evaluation and the optimization loop. The system first classifies the evaluation structure into one of three types: discrete checkers, rubric-based evaluation, or continuous metrics. Each discovered dimension is assessed along three axes: density (how many training examples cover it), diversity (how varied those examples are), and baseline performance.

The critical insight is the distinction between data gaps and workflow problems: a dimension with sufficient, diverse training data but low performance indicates a workflow problem that augmentation cannot solve, while a dimension with absent or sparse data indicates a genuine coverage gap. Augmentation targets only the latter.

6.4 · Seed-Epoch: overfitting regulation

Even when multiple agents iteratively improve a system, whether those improvements are genuine is a separate question. If evaluation data is resampled at every iteration, it becomes impossible to determine whether observed performance gains result from strategy changes or simply from drawing easier samples. This “meaningless delta” problem structurally undermines the reliability of optimization.

The core idea is “changing only the strategy while keeping the same test problems.” This discipline ensures that instead of merely an impression that performance improved, there is a record of which changes produced which differences under identical conditions. When |Δᵢ| < ε for m consecutive iterations, optimization within the current epoch is deemed saturated, and the epoch advances to a new seed ξₑ₊₁. The new epoch evaluates on fresh data, thereby naturally validating whether strategies overfitted to the previous epoch.

6.5 · Optimization safeguards

Seed-Epoch ensures that performance deltas are attributable. Three additional safeguards ensure that the improvements themselves are genuine.

6.6 · Cross-layer compounding cycle

Most optimization systems improve performance on the current project and stop. When the same type of problem is encountered in a subsequent project, there is no structural mechanism to reuse insights. Layer 3 closes this gap by feeding structured evidence back to Layer 2 after each optimization cycle.

Furthermore, the meta-learning agent extracts patterns discovered during the optimization process itself — which strategy combinations worked under which conditions, which trajectories reduced failures — as structured optimization trajectories and registers them in Layer 2. These trajectories enable the system, when encountering a similar situation in a future project, to start from a validated path rather than exploring from scratch. This is what makes Layer 3 not a one-shot optimizer but a self-reinforcing optimization engine that drives the compounding cycle of the entire MEGA framework.

7.1 · Wisdom curation quality on SkillsBench

SkillsBench — 84 tasks across 11 domains, deterministic pytest assertions in isolated Docker containers. All conditions share the same agent (Gemini 3 Flash), 4,207-asset skill pool, tasks, verifiers, and Docker environment; only the skill discovery and orchestration method varies.

MEGA (WG) achieves the highest pass rate (46.5%) with the best efficiency (0.566 score/Mtok). PCST retrieval requires no LLM calls during the retrieval phase itself, yielding the lowest curation latency (11.8s vs. 37.8s and 403.4s).

7.2 · Optimization performance on GPT-4.1 Mini

Compared against MIPROv2, TextGrad, GEPA, and Feedback Descent on four GEPA benchmarks. All baselines and MEGA share identical evaluation checkers and grading criteria.

MEGA outperforms GEPA by +7.03 aggregate and Feedback Descent by +9.99. The largest absolute gain is on HoVer (+18.00 over GEPA), where multi-hop retrieval benefits most from compositional wisdom that chains retrieval strategies across hops.