GEPA (Genetic Pareto optimization, Agrawal et al. 2025) is a text evolution engine that optimizes prompts using LLM-based reflection and Pareto-efficient evolutionary search. In their initial paper, they posted 20-point improvements on several multi-hop QA benchmarks, and larger results have been released since then on their blog - including on ARC-AGI and GSM8k.
The genetic part
GEPA treats prompts the way evolution treats genomes. Start with a population of candidate prompts. Evaluate each one against your dataset. Take the strong performers and mutate them — a reflective language model reads the candidate's failures and proposes targeted revisions, rather than mutating at random. Add the children to the pool, evaluate again, and repeat. Over generations, the population climbs.
The reflective mutation is what separates GEPA from older search methods: each new candidate is informed by why its parent failed, so the search moves with intent instead of stumbling.
The Pareto part
A naive optimizer keeps the single best prompt and discards the rest. GEPA doesn't — it maintains a Pareto frontier: the set of candidates that are each the best at something, even if none is the best at everything. One variant may excel at short factual queries while another wins on multi-hop reasoning.
Keeping the frontier preserves diversity, and diversity is what prevents premature convergence — the failure mode where a search locks onto a local maximum early and never escapes. It also matters because real data is heterogeneous: collapsing to one champion means optimizing for the average case and quietly sacrificing the tails.
What GEPA achieves
Reported results: ~20% improvement on multi-hop QA relative to baseline prompts, with no fine-tuning — all gains from structured search over prompt space. In our own fact-checking experiments, GEPA took prediction accuracy from 91% to 96%.
Where it stops
GEPA optimizes text artifacts, including any prompt or code represented as strings. However, most applications live in a file system and thus GEPA is quite limited in the types of real-world coding changes it can implement. In addition, the ideal optimizer for prompts is not the same as the ideal optimizer for a codebase, and the capabilities required for improving codebases involve many different elements, including memory traces, skills, etc.
This is important because many failures don't live in the prompt space — they live in the code around the prompts: the retrieval strategy, the pipeline structure, the reasoning scaffolding, the tool definitions. An optimizer that can only rewrite instructions can't remove a bad summarization step or add a missing refinement layer.
That's the gap our engine closes: an optimizer tailored to coding, extended to work in a codebase, with a coding agent executing the mutations in an isolated sandbox. In our experiments, that extension allowed us to improve significantly. Our initial GEPA-based coding system that we released in February 2026 had a relative gain of only 18% on PhantomWiki and 30% on HoVer. After months of improvement (and meta self-improvement) of our algorithm and harness, we now score an 80% relative gain on PhantomWiki and 85% on HoVer!