EPOCH: An Agentic Protocol for Multi-Round System Optimization

Het paper introduceert EPOCH, een gestructureerd protocol voor multi-rondige zelfverbetering van autonome agenten dat planning, implementatie en evaluatie scheidt om stabiele en reproduceerbare optimalisatie van systemen in heterogene omgevingen mogelijk te maken.

De kern

Stel je voor dat je een heel groot, complex project hebt, zoals het bouwen van een auto, het schrijven van een roman of het opzetten van een fabriek. In het verleden hadden we vaak slimme robots (AI-agenten) die één ding heel goed konden: bijvoorbeeld alleen de wielen verbeteren of alleen de tekst herschrijven. Maar als je de hele auto wilt optimaliseren, was het een chaos. De ene robot deed de wielen, de andere de motor, en niemand keek of het samen nog wel een auto was.

EPOCH is de oplossing voor dit probleem. Het is geen nieuwe robot die één ding doet, maar een nieuw soort "spelregels" of een protocol dat zorgt dat al die robots samenwerken als een goed georganiseerd bouwteam.

Hier is hoe het werkt, vertaald naar alledaagse taal:

1. Het Probleem: De "Wilde" Verbeteraar

Tot nu toe probeerden AI-systemen vaak zomaar dingen te verbeteren. Ze maakten een wijziging, keken of het beter ging, en deden het weer. Het probleem? Soms maakten ze een fout die ze niet konden terugdraaien, of ze vergeten ze te kijken of de vorige verbetering nog steeds werkte. Het was alsof je een auto rijdt terwijl je blindelings onder de motorkap schroeft zonder te kijken of de banden nog goed zitten.

2. De Oplossing: EPOCH als de "Projectmanager"

EPOCH is een strakke methode om dit proces te regelen. Het verdeelt het werk in twee grote fases, net zoals bij het bouwen van een huis:

Fase 1: De Fundering (Het Baseline)

Voordat je begint met rennen, moet je weten waar je staat.

• De "Seed Planner" (De Architect): Deze kijkt naar je probleem en zegt: "Oké, laten we eerst een werkend prototype bouwen."
• De "Baseline Executor" (De Bouwer): Deze bouwt het eerste versie.
• Het resultaat: Je hebt nu een stabiel startpunt. We weten precies hoe goed het nu werkt, zodat we later kunnen meten of het echt beter wordt.

Fase 2: De Verbeteringsronde (Het Iteratieve Proces)

Nu begint het echte werk. EPOCH laat niet één persoon alles doen. Het verdeelt de taken in vier specifieke rollen, alsof je een team hebt met een strikte hiërarchie om fouten te voorkomen:

1. De Orchestrator (De Regisseur): Deze houdt het overzicht. "We hebben 5 rondes tijd, laten we beginnen."
2. De Investigator (De Detective): Deze kijkt naar de fouten en zegt: "Ik denk dat als we de motor iets kleiner maken, het sneller gaat." (Hij bedenkt een plan).
3. De Executor (De Technicus): Deze voert het plan uit. Hij maakt de motor kleiner. (Hij doet het werk).
4. De Reviewer (De Kwaliteitscontroleur): Dit is het belangrijkste! Deze persoon kijkt niet mee met het bedenken of maken van de motor. Hij kijkt alleen naar het resultaat. "Werkt het nu beter? Is het veilig?" Als het antwoord "nee" is, wordt de wijziging verworpen.

Waarom is die scheiding zo belangrijk?

Stel je voor dat je een chef-kok bent die een nieuw recept probeert. Als jij het recept bedenkt, het kookt én proeft, ben je misschien te enthousiast en proef je niet de fouten.
Bij EPOCH is de Chef (Detective/Technicus) gescheiden van de Proever (Reviewer). De proever is onafhankelijk. Hij proeft alleen of het gerecht daadwerkelijk lekkerder is. Als het niet lekkerder is, wordt het gerecht weggegooid, ook al heeft de chef er hard voor gewerkt. Dit zorgt voor eerlijkheid en voorkomt dat je denkt dat iets beter is terwijl het eigenlijk slechter is.

Hoe werkt het in de praktijk?

Het papier toont dit aan met vier voorbeelden:

• Het Schrijven van Code: Stel je hebt een programma dat te lang duurt om te rekenen. EPOCH maakt eerst een werkend programma. Dan probeert de "Detective" een snellere formule. De "Technicus" past het aan. De "Proever" meet of het nu echt sneller is. Als het sneller is, wordt het opgeslagen. Zo gaan ze stap voor stap van een traag programma naar een supersnel programma.
• Het Instellen van een Auto (Hyperparameters): Stel je hebt een auto die slecht rijdt in de regen. EPOCH past alleen de instellingen van de wielen aan, niet de motor. De "Proever" kijkt of het in de regen nu beter gaat zonder dat het op droog asfalt slechter wordt.
• Het Schrijven van Instructies (Prompt Tuning): Stel je hebt een AI die slechte samenvattingen maakt. EPOCH past alleen de instructies aan die je aan de AI geeft. De "Proever" zorgt ervoor dat de AI niet "cheat" door de antwoorden al te kennen.
• Regelschrijven: Stel je hebt een systeem dat bloemen herkent. EPOCH past de regels aan (bijv. "als de bloem rood is, dan is het een roos"). De "Proever" controleert of de regels niet te streng worden.

Het Grote Voordeel: Sporen en Betrouwbaarheid

Het mooiste aan EPOCH is dat het alles opschrijft.
Elke keer dat er iets wordt veranderd, wordt er een verslag gemaakt:

• Wat was het idee?
• Wie heeft het gedaan?
• Wat was het resultaat?
• Is het goedgekeurd of afgewezen?

Dit betekent dat je later altijd kunt terugkijken en kunt zien: "Ah, in ronde 3 probeerden we X, maar dat werkte niet, dus we gingen terug naar Y." Het maakt het proces herhaalbaar en verantwoordelijk. Je kunt het niet meer "zomaar" doen; het is een wetenschappelijk experiment.

Conclusie

EPOCH is geen magische robot die alles voor je doet. Het is een slimme manier van werken. Het zorgt ervoor dat wanneer we AI gebruiken om systemen te verbeteren, we dat doen met een strak plan, duidelijke rollen en eerlijke controle. Het zorgt ervoor dat we niet in de war raken, dat we weten wat er gebeurt, en dat we uiteindelijk een beter, veiliger en sneller systeem hebben.

Kortom: EPOCH is de bouwplaat en het kwaliteitslabel voor de toekomst van slimme computersystemen.

Technische samenvatting

Hier is een gedetailleerde technische samenvatting van het paper "EPOCH: An Agentic Protocol for Multi-Round System Optimization" in het Nederlands.

Probleemstelling

Autonome agenten worden steeds vaker gebruikt om prompts, code en machine learning-systemen te verbeteren via iteratieve uitvoering en feedback. Echter, bestaande benaderingen zijn doorgaans ontworpen als opdrachtspecifieke optimalisatielussen (bijv. alleen voor prompt-optimalisatie of alleen voor hyperparameter-zoektocht) in plaats van als een unificerend protocol.

De huidige tekortkomingen zijn:

• Gebrek aan een gedeelde protocol-abstractie voor het beheren van meervoudige rondes van zelfverbetering over heterogene omgevingen heen.
• Geen expliciete scheiding van rollen (planning, implementatie, evaluatie) binnen de optimalisatielus.
• Gebrek aan standaardisatie van uitvoeringsinterfaces en ronde-voor-ronde state-tracking, wat reproducibiliteit, traceerbaarheid en de integriteit van evaluaties in productieomgevingen ondermijnt.
• Productiesystemen bestaan uit interlockende componenten (code, configuraties, data-pipelines, prompts); het verbeteren van één onderdeel vereist gecoördineerde wijzigingen zonder de stabiliteit van het hele systeem te verstoren.

Methodologie: Het EPOCH-Protocol

EPOCH (Engineering Protocol for Multi-Round System Optimization) is een agentisch protocol dat iteratieve verbetering behandelt als een gestructureerd, twee-fasen proces met een consistente evaluatie-interface. Het ontwerp volgt het OODA-cyclus-principe (Observe, Orient, Decide, Act) maar maakt elke overgang expliciet en traceerbaar.

Het protocol bestaat uit twee hoofdfasen:

Fase 1: Baseline Constructie

Voordat optimalisatie begint, moet een geldig startpunt worden vastgesteld.

• Seed Planner: Analyseert de taakspecificatie en ontwerpt het initiële systeem, de uitvoeringsentry-points en de evaluatie-interface.
• Baseline Executor: Zet dit ontwerp om in een uitvoerbare implementatie, genereert de eerste configuraties en produceert de initiële meetresultaten (metrics).
• Doel: Een gevalideerde baseline tot stand brengen, zelfs als de starttoestand slechts een losse taakomschrijving is.

Fase 2: Meervoudige Ronde Zelfverbetering

Dit is de kern van het iteratieve proces, georganiseerd rond vier logische rollen die de integriteit van de evaluatie waarborgen:

1. Orchestrator: Beheert de controleflow, het budget (aantal rondes) en de overgangen tussen geaccepteerde staten.
2. Investigator: Analyseert het huidige systeem en bewijsmateriaal om hypothesen voor verbetering te genereren (binnen taakspecifieke beperkingen, zoals train/eval-scheiding).
3. Executor: Implementeert de voorgestelde wijzigingen binnen het toelaatbare actiebereik (bijv. prompt aanpassen, hyperparameters wijzigen, code refactoren).
4. Reviewer: Evalueert de kandidaat-wijziging via de gestandaardiseerde interface en bepaalt of deze geaccepteerd of afgewezen moet worden.

Belangrijke principes:

• Scheiding van taken: De entiteit die een wijziging voorstelt of implementeert, is niet dezelfde die deze evalueert. Dit voorkomt data-lekkage en overfitting.
• Ronde-niveau tracking: Elke ronde wordt geregistreerd als een gestructureerde eenheid met een kandidaat-wijziging, onderbouwing, metrics en het besluit (accepteren/afwijzen).
• Canonieke interfaces: Uitvoering gebeurt via gestandaardiseerde commando's om evaluatie-drift te voorkomen.

Belangrijkste Bijdragen

1. EPOCH Protocol: Een agentisch protocol dat een probleemspecificatie omzet in een uitvoerbare baseline en vervolgens getrackte, meervoudige rondes van zelfoptimalisatie beheert over heterogene verbeteringsmodaliteiten heen.
2. Twee-fasen Orkestratie: Een raamwerk dat baseline-constructie scheidt van iteratieve verbetering, en binnen elke ronde hypothesegeneratie, implementatie en evaluatie scheidt.
3. Unificerende Abstractie: Een industriële oplossing met canonieke uitvoeringsinterfaces, configureerbare evaluatie-pipelines en traceerbaarheid van systeemwijzigingen per ronde.
4. Empirische Validatie: Demonstratie van het protocol in vier verschillende domeinen: prompt tuning, hyperparameter fine-tuning, regelgebaseerde optimalisatie en code-improvement.

Resultaten (Empirische Evaluatie)

Het paper presenteert experimenten in vier verschillende domeinen om de robuustheid van het protocol te testen:

1. Code Improvement (Fibonacci Calculator):

   • Het systeem begon met een trage iteratieve implementatie.
   • EPOCH identificeerde eerst correctheid (alle tests laten slagen) en schakelde daarna automatisch over op performance-optimalisatie.
   • Het protocol accepteerde wijzigingen zoals het gebruik van "fast doubling" en native GMP-bibliotheken, en stopte automatisch wanneer verdere verbetering onmogelijk was binnen de gegeven budgetten.

2. Hyperparameter Fine-Tuning (MNIST):

   • Het systeem paste optimizer-keuzes en leer-snelheden aan.
   • Het protocol weigerde een agressieve leer-snelheidswijziging omdat deze leidde tot instabiliteit (overfitting), en probeerde vervolgens een alternatieve strategie (SGD met momentum) via een "retry"-mechanisme.
   • Dit illustreert de strikte scheiding tussen train- en evaluatie-data en de capaciteit om fouten te herkennen en te corrigeren.

3. Prompt Tuning (SST-2 Sentiment Classificatie):

   • Het systeem verfijnde prompts voor een vast model (gpt-4.1-nano).
   • Het protocol zorgde voor strikte scheiding tussen train- en testdata om data-lekkage te voorkomen.
   • Het bereikte perfecte hold-out nauwkeurigheid in drie rondes en stopte vroegtijdig toen de criteria waren voldaan.

4. Rule-Based Optimization (Iris Classificatie):

   • Het systeem verfijnde handgemaakte beslissingsregels.
   • Het protocol wees verdere verfijningen af die alleen de trainingsnauwkeurigheid verhoogden maar geen meerwaarde boden voor de hold-out evaluatie (vermijding van overfitting op regels).

Gemeenschappelijke bevindingen:

• EPOCH transformeert optimalisatie naar een reeks expliciete staten-overgangen.
• Het ondersteunt afwijzingen en retry-mechanismen zonder de controlestructuur te breken.
• Het kan automatisch stoppen wanneer de "diminishing returns" (afnemende meerwaarde) worden bereikt.

Betekenis en Conclusie

EPOCH biedt een cruciale laag voor industriële implementatie van autonome agenten. In plaats van te focussen op het vinden van de beste specifieke optimizer voor één taak, biedt EPOCH een reproduceerbaar, auditbaar en veilig kader voor het beheren van complexe, meervoudige optimalisatiecycli in heterogene systemen.

De belangrijkste waarde ligt in de traceerbaarheid en integriteit: door elke wijziging te koppelen aan een specifieke ronde, een onderbouwing en een onafhankelijke evaluatie, wordt het mogelijk om productie-systemen continu te verbeteren zonder de stabiliteit of betrouwbaarheid te riskeren. Toekomstig werk richt zich op het uitbreiden van EPOCH naar multi-agent coördinatie in complexe, gelaagde productiesystemen.