Agent loop (ReAct)

Wat is een agent loop?

Een agent loop is de cyclus die van één modelaanroep een agent maakt. Het model leest het doel en alles wat er tot dan toe gezegd is, bepaalt wat de volgende stap wordt en vraagt om een tool. Het programma rond het model voert die tool uit, zet het resultaat terug in het gesprek en roept het model opnieuw aan. Dat blijft draaien tot het model antwoordt zonder nog iets te vragen, of tot een limiet er een punt achter zet.

Het engineering-team van Anthropic vat het in één zin samen: een agent is doorgaans gewoon een LLM die tools gebruikt op basis van wat de omgeving terugkoppelt, in een loop. De prompts, de rechten en de logging zitten daar allemaal rond.

Eén ronde door die cyclus heet een beurt. De documentatie van de Agent SDK van Anthropic omschrijft een beurt als één keer heen en weer: het model geeft output met tool-aanroepen erin, het programma voert die uit, en de resultaten gaan automatisch terug naar het model, zonder dat jouw eigen code er tussenin aan bod komt. Een simpele vraag kost één of twee beurten. Een set rapporten heropbouwen kost er tientallen.

Je komt diezelfde cyclus onder verschillende namen tegen: als een runner die je instelt in een framework als LangGraph of de OpenAI Agents SDK, als een coding agent die door jouw bestanden werkt, of als een ambient agent die op een trigger vertrekt zonder dat er iemand meekijkt.

Over de kostprijs van die cyclus moet je op voorhand één ding weten. Het model houdt tussen twee aanroepen niets bij, dus elke beurt stuurt het volledige gesprek opnieuw mee, en elke beurt weegt zwaarder dan de vorige. Bij coding agent staat die rekening op een echte sessie uitgewerkt. Wat het hier betekent: een run wordt duur door zijn lengte, niet door de moeilijkheid van de opdracht.

Redeneren en handelen door elkaar

Het patroon heeft een naam en een paper. In oktober 2022 publiceerden onderzoekers van Princeton en Google ReAct, kort voor reason and act, en het voorjaar erna stelden ze het voor op een machine learning-conferentie. Wat zij deden, was twee dingen die tot dan apart bestudeerd werden door elkaar vlechten: het model schrijft een korte gedachte, dan een actie, leest daarna de observatie die terugkomt, en schrijft dan de volgende gedachte.

Die gedachte is geen versiering. Ze laat het model opmerken dat een opzoeking het verkeerde opleverde en bijsturen, terwijl de observatie het redeneren vasthoudt aan iets echts in plaats van aan wat het model verwachtte te vinden. Google zegt het zelf onomwonden: een model dat alleen redeneert, zoals bij chain-of-thought prompting, verzint vrolijk een feit. Het spoor valt achteraf ook te lezen, dus je ziet welke stap fout liep en je herstelt die stap in plaats van de hele opdracht opnieuw te draaien.

Hoe stopt de loop?

Vijf dingen beëindigen een run, en alleen het eerste is de beslissing van het model zelf.

1. Het model antwoordt. Het levert een beurt af zonder tool-aanroep erin. De SDK's van Anthropic en OpenAI omschrijven het einde van de loop allebei precies zo: tekst als output, geen tool-aanroepen, klaar.

2. Een grens op het aantal beurten. De instelling max turns in de Agent SDK telt de rondes met toolgebruik en geeft een resultaat terug dat aangeeft dat de grens gehaald is, niet een afgewerkt antwoord. De OpenAI Agents SDK gooit een fout zodra het maximum overschreden wordt. LangGraph beperkt hoeveel stappen een graph in één run mag zetten, standaard duizend in de huidige versies.

3. Een grens op het budget. Diezelfde SDK neemt een maximumbedrag in dollar aan en stopt zodra de run daaraan zit, inclusief wat subagents verbruiken. Voor alles wat onbewaakt draait is dat de nuttigste grens, want ze staat in de eenheid waar je echt op let.

4. Iemand grijpt in. Je kan de run stilleggen, of een correctie intikken terwijl een tool nog loopt en de agent die laten lezen voor hij zijn volgende stap kiest. Dat is de goedkoopste controle die er bestaat, en ze werkt alleen zolang er iemand meekijkt.

5. Een controle slaagt. Geef de agent iets dat hij zelf kan draaien, een test, een aantal rijen, een totaal dat moet aansluiten, en de loop krijgt een eindstreep die niet het oordeel van het model is. Bij verification loop staat wat zo'n controle bruikbaar maakt.

Op dat eerste punt kan je niet bouwen, en daarom bestaan de andere vier. Anthropic zegt het zelf: het is gebruikelijk om stopvoorwaarden in te bouwen, zoals een maximum aantal iteraties, om de controle te houden.

Eén opdracht, beurt per beurt

Een klant mailt met de vraag waarom factuur 2026-0418 640 euro hoger ligt dan de offerte die hij getekend heeft. De agent mag lezen in het facturatiepakket, het CRM en het ERP, en heeft precies één tool die iets wegschrijft: een antwoord als ontwerp in de gedeelde mailbox zetten.

1. Hij leest de mail en vraagt het facturatiepakket om factuur 2026-0418. Daar komen elf lijnen en een totaal uit.

2. Die factuur bewijst op zich niets, dus vraagt hij het CRM om de offerte bij die klant en dat project. Hij krijgt offerte 2026-Q77, negen lijnen.

3. Hij legt de twee naast elkaar. Twee posten zijn nieuw: een tweede plaatsingsdag aan 520 euro en 120 euro transport. Samen zijn dat de 640.

4. Het transport staat in de voorwaarden op de offerte. De extra dag niet, dus vraagt hij het ERP om de werkbonnen van dat project en krijgt er een getekende voor die dag.

5. Hij schrijft het antwoord, benoemt de twee lijnen en het nummer van de werkbon, en roept de ontwerp-tool aan. De mail belandt in de mailbox, niet verstuurd.

6. Hij levert een laatste beurt zonder tool-aanroep: ontwerp klaar, beide verschillen gestaafd, en één ding gemeld, dat de handtekening op de werkbon een scan is en dat hij niet kan zien van wie ze komt.

Zes beurten, zes modelaanroepen, en die zesde sleept alles van de vijf ervoor mee. Het model besliste of het CRM de moeite was, of het ERP een vierde aanroep verdiende, en wanneer hij genoeg had om te schrijven. Of die mail vertrok, besliste hij niet, want versturen zat niet in zijn gereedschapskist.

Eén modelaanroep tegenover een agent loop

Allebei beginnen ze met een vraag en eindigen ze met een antwoord. Het verschil dat bepaalt welke van de twee je wil, is wie mag zeggen dat het werk af is.

Eén modelaanroep. Jij beslist. Het model antwoordt één keer, jij leest het, en als het mager is vraag je opnieuw met meer context erbij. Jouw oordeel is de stopvoorwaarde. Dat is volledig betrouwbaar, en het reikt niet verder dan wat jij bereid bent te lezen.

Een agent loop. Het model beslist. Het blijft tools aanroepen tot het zelf vindt dat het doel bereikt is, en stopt dan uit eigen beweging. Dat is meteen het nut ervan en meteen ook het risico: net die eigenschap waardoor hij een opdracht aankan die jij nooit in stappen gehakt hebt, is de eigenschap waardoor hij twintig minuten aan het verkeerde kan werken.

Daarom zijn die grenzen geen veiligheidsknop die er achteraf bijkomt. Een loop zonder grens heeft de vraag of het werk af is volledig bij het model gelegd en niets teruggehouden.

Waar moet je op letten bij een agent loop

Hij herhaalt de aanroep die faalt. Een tool geeft een fout, het model leest die, probeert iets dat er nauwelijks van verschilt, krijgt dezelfde fout, probeert opnieuw. Anthropic wijst in zijn richtlijnen over tools schrijven voor agents naar de oplossing: foutmeldingen die in gewone taal zeggen wat er anders moet, en geen foutcode of stack trace. Nog erger is een tool die de fout inslikt en een leeg resultaat teruggeeft, want het model gelooft dat en bouwt verder op niets.

Tooluitvoer vult het venster. Eén commando met veel output of één groot bestand kan in één beurt duizenden tokens innemen, en die blijven daar de rest van de run staan. Een tool die standaard pagineert of filtert is meer waard dan een tool die alles teruggeeft en het model laat uitzoeken.

Het doel schuift weg. Tegen beurt dertig ligt de oorspronkelijke instructie ver achter, en compaction heeft ze misschien tot één zin herleid. Herhaal het doel op de momenten waar het telt, en zet de vaste afspraken ergens waar de harness ze bij elke aanroep opnieuw inlaadt.

Niemand kan de run reconstrueren. Als de tool-aanroepen en hun resultaten niet gelogd zijn, valt een run die misliep niet meer na te spelen, en dan blijft alleen over dat het model die dag anders koos. Log elke stap met zijn input en zijn output voor je een loop in de buurt laat van iets waar geld mee gemoeid is.