Large Language Model (LLM)-guided evolutionary optimization has successfully improved prompts, programs, and even entire AI systems. Most optimization methods select a candidate from the search frontier, then mutate it in one LLM pass based only on its failures. This focus on the frontier can stall on production AI systems, where isolated failures reveal little about complex, hidden interactions. We introduce CoCoEvolve (Cortex Code Evolve), an evolutionary optimizer built around what we call meta-reflection, wherein an agentic mutator (Cortex Code) selectively retrieves evidence from the entire evolutionary history and probes the live system before verifying and proposing mutations. We apply CoCoEvolve to optimize three classes of production AI systems: data agents, LLM-powered data pipelines, and data engineering workflows. On DABStep, CoCoEvolve tops the public leaderboard, reaching 92.8% held-out hard accuracy compared to 78.4% for Meta-Harness and 30.4% for GEPA under matched conditions. Across six LLM data pipeline workloads, it outperforms every evaluated baseline. On data-eng-bench, CoCoEvolve lifts test-set solve rate from 59.1% to 77.4%, past the best baseline of 73.6%. It also has 11 percentage points higher accuracy than GEPA on HotpotQA while remaining competitive with specialized optimizers on established mathematical and systems benchmarks. Matched ablations confirm that each component of CoCoEvolve contributes to these gains, demonstrating the value of meta-reflection for optimizing production AI systems.
Figures & tables
Figure 1: Left: given under-determined feedback, the parent-local mutator guesses a repair in one call and makes no progress. Right: a meta-reflective mutator queries the evolutionary history and reads the trace of a previously evaluated program to determine that all matching fees stack . It also reads documentation to refine which fees match, and synthesizes the two observations. It tests the resulting hypothesis before commit and raises training accuracy from 28/300 to 95/300 .
Figure 2: CoCoEvolve proposes a new candidate in each iteration by selecting a parent from the archive, curating evidence from the search history to include in the prompt, and equipping a coding-agent mutator with on-demand tools for querying prior lineages and the live target environment. A coding agent investigates, edits, and self-tests a child; the evaluator scores it, records the resulting observations in the history, and, under the default MAP-Elites policy, either discards it or admits it to the archive if it improves its niche. This loop combines compact prompt-visible evidence with environment feedback while preserving diverse programs for future selection.
Table 8: Parent-selection setups on HotpotQA and IFBench. One 100-iteration search per arm; entries are single held-out test evaluations. HotpotQA uses exact match; IFBench uses its per-constraint score. Each Δ is the score difference from OpenEvolve’s default map-elites arm on the same task. The lp row uses p=2 . Bold marks the highest observed score in each task.
Roster exponent
Validation EM
Test EM
Δ test
p=0.5
0.6033
0.5867
−0.0733
p=1
0.7100
0.6600
0
p=1.5
0.5967
0.5700
−0.0900
p=2
0.7300
0.6933
+0.0333
Appendix
Table 9: HotpotQA validation and held-out test exact match across ℓp roster exponents. Δ is the test-EM difference from p=1 ; bold marks the highest observed score.
Arm
Injected ledger
Structured history tools
overall_score
B1 parent-only
off
off
0.6614
B2 ledger-only
on
off
0.7074
B3 tools-only
off
on
0.7487
B4 full
on
on
0.7681
Appendix
Table 11: History-access interface ablation, Signal Processing. One 100-iteration Sonnet-5 trial per arm, reflector/proposer off throughout. Best overall_score reached within the 100-iteration budget (iterations 73, 97, 99, and 75 respectively).
Arm
Injected ledger
Structured history tools
Train (of 300)
Test (of 150)
B1 parent-only
off
off
234 ( 0.780 )
116 ( 0.773 )
B2 ledger-only
on
off
210 ( 0.700 )
99 ( 0.660 )
B3 tools-only
off
on
242 ( 0.807 )
119 ( 0.793 )
B4 full
on
on
286 ( 0.953 )
137 ( 0.913 )
Appendix
Table 12: History-access interface ablation on DABStep. One primary 100-iteration Sonnet-5 trial per arm; each champion is freshly scored on the full 300-question training and 150-question test pools. Rows follow B1–B4 arm order.
Arm
Train (of 300)
Δ
Test (of 150)
Δ
A1 seed (no evolution)
101
–
47
–
C1 uniform (matched)
95
−6
42
−5
C2 shuffled similarity
113
+12
51
+4
C3 information-gain (flagship)
286
+185
137
+90
Appendix
Table 13: Similarity-manifold targeting on DABStep. C1 and C2 each use one 100-iteration Sonnet-5 search; C3 reuses the published flagship and A1 the seed. All four champions are freshly scored on the full 300-question training and 150-question test pools. Δ is relative to A1. The flagship’s in-run trace reached 293 on train, while its independent full-pool re-score here is 286 .
Method
Easy (%)
Hard (%)
CoCoEvolve
87.50
95.24
MotherDuck, full-context + data modeling ( Döhmen et al., 2026 )
93.10
93.20
NVIDIA KGMON (NeMo Agent Toolkit) Data Explorer
87.50
89.95
DataPilot
86.11
87.57
Meta-Harness
84.72
77.25
gg-agent-gpt5-1104-1
88.89
62.96
Appendix
Table 15: Accuracy on the combined 450-question DABStep suite, ranked by hard-split accuracy.
Figure 3: DABStep best-so-far train accuracy ( /300 ) versus iteration. CoCoEvolve and Meta-Harness (self-test) are running-best curves from their evolution logs. GEPA has no per-iteration full-pool trace because its search evaluates small subsamples, sometimes only one question per step, so its final post-hoc score appears as a dashed reference line. The second dashed line shows CambioML energent.ai DS Agent, an external combined-pool leaderboard submission without a matched budget or train-300 trajectory. Its easy and hard accuracies are 94.44% and 57.67% , respectively (Table 15 ). Appendix F.3 analyzes Meta-Harness’s post-iteration-53 stall.
Method
GEPA
OpenEvolve
AdaEvolve
CoCoEvolve
Correct / 50
41
27
45
50
Accuracy
0.82
0.54
0.90
1.00
Appendix
Table 16: Accuracy on Lockpicking with Interference after 50 iterations.
Figure 4: Heilbronn Convex ( N=13 ) on Sonnet-5. Point sets in the unit square: hull vertices (navy), interior points (lighter), hull outlined, smallest triangle in red. Seed is unstructured. OpenEvolve reaches a weaker 13 -gon ( 0.02900 ); GEPA, AdaEvolve, and CoCoEvolve all reach structured 13 -gons at their Best-cell scores.
Figure 5: Heilbronn Convex best-so-far on Sonnet-5, cropped just below the first rewrite. Solid traces are each method’s Best-cell run; Human/SOTA is the dashed green line. The dotted navy trace is a second retained CoCoEvolve trial: it stalls near 0.0281 and recovers to 0.03078 . Solid CoCoEvolve reaches Human/SOTA at iteration 9 . The claim is Avg, not the tied Best.
Figure 6: Circle Packing (Square, N=26 ) on Sonnet-5. Circles in the unit square, labeled 0 – 25 . The seed is a two-ring heuristic ( 0.96 ); OpenEvolve, GEPA, AdaEvolve, and CoCoEvolve are size-biased ceiling packings at Human/SOTA ( 2.63598 ).
Figure 7: Circle Packing (Square, N=26 ) best-so-far on Sonnet-5, cropped near the ceiling. Solid traces are each method’s Best-cell run; Human/SOTA is the dashed green line. GEPA first reaches 2.63598 at iteration 8 , CoCoEvolve at iteration 24 , AdaEvolve at iteration 91 . OpenEvolve is at 2.6298 at iteration 100 and only hits the ceiling at iteration 111 , outside the shared window.
Evaluator
Train
Val
Test
Full pool, every iteration (Appendix J.1 )
0.800
0.783
0.793
Sim-graph target + P0/P1/P2 cascade
0.800
0.790
0.767
Appendix
Table 20: HotpotQA, Sonnet-5, CoCoEvolve: the published full-pool-every-iteration search versus the sim-graph-targeted/cascaded-evaluation variant of this appendix. Both rows are a single 100 -iteration search, freshly re-scored against the identical train/val/test pools.