Prompt-evolutie in plaats van RL: onder de motorkap van het GEPA-framework

Het tunen van systeeminstructies en agents verandert meestal in eindeloos handmatig tekstknutselen. Corrigeer je één formulering — verbeter de logica, maar breek de output-opmaak. Het gebruik van reinforcement learning zoals GRPO voor zulke aanpassingen is te duur: algoritmen vereisen tienduizenden runs, en alle feedback komt neer op één enkele score.

Onlangs onderzocht ik de GEPA (Genetic-Pareto) repository. Het project is ontwikkeld door onderzoekers van Berkeley en Stanford en biedt een fundamenteel andere benadering voor het optimaliseren van willekeurige tekstparameters.

Het kernidee achter het project

Klassieke optimizers behandelen het systeem als een black box: ze krijgen een numerieke score aan de output en proberen te raden waar ze vervolgens naartoe moeten. GEPA werkt anders. Het framework voedt het neurale netwerk de volledige uitvoeringslogboek — fouten, profiler output, stack traces en tussenliggende redeneringen.

Het model analyseert deze gegevens op dezelfde manier als een ontwikkelaar dat doet tijdens debugging. Het ziet de specifieke oorzaak van een storing en stelt gerichte oplossingen voor. Vervolgens komt een genetisch algoritme in actie met Pareto-front overwegingen: het systeem bewaart tekstvarianten die het beste presteren over verschillende subsets van taken.

Wat het framework kan doen

Deze benadering maakt automatisch tunen van verschillende elementen mogelijk:

• Prompts voor individuele modellen of chains in DSPy en LangChain
• Agent-architectuur en hun vaardigheidssets
• Taakplanningsregels en configuratiebestanden
• Toolbeschrijvingen voor het MCP-protocol

In de tests van de auteurs verbeterde het GPT-4.1 Mini-model de nauwkeurigheid op de AIME wiskunde-benchmark van 46,6% naar 56,6% na honderd iteraties. Ingenieurs van Databricks gebruikten GEPA om hun agent-operationele kosten met 90x te verlagen zonder kwaliteitsverlies.

Hoe het optimalisatieproces werkt

Het framework werkt in een lus van vijf opeenvolgende stappen:

1. Candidateselectie uit het Pareto-front. Het systeem kiest een variant die het maximale resultaat toonde op een specifieke testgroep.
2. Uitvoering op een kleine dataset. Hierbij worden alle uitvoeringslogboeken en fouten verzameld.
3. Reflectie. Het reflectiemodel leest tekstuele foutenlogboeken en formuleert diagnoses.
4. Mutatie. Er wordt een nieuwe versie van de prompt of code gemaakt, waarbij rekening wordt gehouden met eerdere fouten van alle voorouders.
5. Besluitvorming. De nieuwe kandidaat wordt aan de gedeelde pool toegevoegd als deze echte verbetering heeft aangetoond.

Alle diagnoses worden Actionable Side Information genoemd in de terminologie van de auteurs. Bij tekstoptimalisatie dient het als het equivalent van de gradient uit traditionele machine learning.

Hoe code te schrijven

Je kunt de bibliotheek van PyPI installeren:

pip install gepa

Het project heeft een eenvoudige API genaamd optimize_anything. Hiermee kun je niet alleen prompts tunen, maar elk tekstartefact:

import gepa.optimize_anything as oa
from gepa.optimize_anything import GEPAConfig, EngineConfig, optimize_anything


def evaluate(candidate: str) -> float:
    result = run_my_system(candidate)
    oa.log(f"Output: {result.output}")
    oa.log(f"Error: {result.error}")
    return result.score


result = optimize_anything(
    seed_candidate="Начальный текст инструкции или кода",
    evaluator=evaluate,
    objective="Уменьшить количество ошибок форматирования вывода",
    config=GEPAConfig(engine=EngineConfig(max_metric_calls=100)),
)

Logboeken die via oa.log() worden verzonden, zijn precies wat naar het reflectiemodel gaat voor foutdetectie. Als je al DSPy gebruikt, is de tool out-of-the-box beschikbaar als dspy.GEPA.

Wanneer tunen via GEPA werkelijk de moeite waard is

De methode presteert het beste in de volgende scenario's:

• Agents uitvoeren met veel externe tools
• Kleine trainingsdatasets met slechts 5–10 voorbeelden
• Gesloten modellen zonder gewichtstoegang via API
• Dure of langzame aanroepen, inclusief code-compilatie en simulaties

Waar RL 5.000–25.000 runs nodig heeft om te convergeren, heeft dit algoritme meestal maar 100–500 evaluaties nodig.

De conclusie

Het framework pakt het pijnlijke onderwerp van handmatig tunen van tekstinstructies aan. Het is prettig dat het hulpmiddel al is geïntegreerd in MLflow, Pydantic AI en Google ADK, dus je hoeft geen berg extra code naar je project te slepen. Begin met de korte tutorial in de documentatie of voer optimize_anything uit op een paar van je meest problematische prompts.