Uw AI-assistent wacht niet meer op u
De meeste AI-interacties volgen een eenvoudig patroon: u typt een vraag, het model antwoordt, klaar. Een agentic loop breekt dat patroon. De agent beslist zelf wat de volgende stap is, voert die uit, bekijkt het resultaat en gaat door — zonder dat u tussendoor iets hoeft te typen.
Die lus is precies wat een taalmodel verandert van een chatbot in een systeem dat echt werk oplevert. Steeds meer tools draaien op dit principe, van codeer-assistenten tot agents die administratie verwerken. Wie ermee wil werken, begrijpt best hoe de lus in elkaar zit, waar hij sterk in is en waar hij kan ontsporen.
Wat is een agentic loop precies?
Een agentic loop is een herhalende uitvoeringscyclus. De agent doorloopt telkens dezelfde stappen:
- Doel ontvangen: de agent krijgt een taak met een verifieerbaar eindresultaat
- Plannen: de agent beslist wat de volgende actie is en waarom
- Uitvoeren: de agent roept een tool aan, schrijft code of zoekt informatie op
- Observeren: de agent leest het resultaat van die actie
- Evalueren: is het doel bereikt? Dan stopt de lus. Zo niet, terug naar het plannen.
De lus eindigt pas wanneer een stopvoorwaarde bereikt is: het doel is gehaald, er duikt een fout op die de agent niet kan oplossen, het budget aan stappen of rekenkracht is op, of een mens grijpt in.
Het grote verschil met een gewone AI-vraag zit in de feedback. Elke ronde voegt nieuwe informatie toe aan de context van het model, waardoor het kan bijsturen. De agent voorspelt niet zomaar een antwoord — hij past zijn aanpak aan op basis van wat er werkelijk gebeurde.
Het ReAct-patroon
De meeste agentic loops zijn een variant van het ReAct-patroon (Reason + Act), beschreven in onderzoek van Google uit 2022. De agent wisselt voortdurend tussen redeneren — wat ga ik doen en wat verwacht ik? — en handelen. Elke observatie voedt de volgende redeneerstap. Zo ontstaat een keten van gedachte, actie en observatie die doorloopt tot de taak af is.
Waarom codeer-agents niet zonder kunnen
Wie een model één keer om code vraagt, krijgt één poging. Is die fout, dan moet u dat zelf opmerken, het probleem beschrijven en opnieuw vragen. U sluit de feedbacklus dus handmatig. Een agentic loop automatiseert precies dat.
De code-test-fix-cyclus
Het klassieke voorbeeld is de testgedreven lus: de agent schrijft of wijzigt code, draait de tests, leest de foutmeldingen, herstelt de code en test opnieuw. Tools zoals Claude Code en GitHub Copilot doorlopen die cyclus soms tientallen keren voor ze een resultaat tonen. Zonder lus zou de agent code schrijven en stoppen; met lus controleert hij zijn eigen werk.
Werken over meerdere bestanden heen
Echte opdrachten raken zelden één bestand. Dankzij de lus kan een agent eerst bestaande code lezen om de samenhang te begrijpen, daarna gericht aanpassen en ten slotte verifiëren wat hij wijzigde. Elke actie vergroot zijn werkkennis. Eén enkele prompt kan dat niet: er is geen mechanisme om te reageren op wat onderweg ontdekt wordt.
Herstellen van fouten
Loopt er iets mis halverwege, dan kan een lussende agent herstellen: hij leest de fout, redeneert over de oorzaak en probeert een andere aanpak. Een agent zonder lus ziet nooit of zijn output klopte.
De anatomie van een agentic loop
De planner
Sommige agents maken eerst een expliciet stappenplan en werken dat af; andere redeneren stap voor stap zonder formeel plan. Beide werken, maar expliciete planning geeft doorgaans voorspelbaarder gedrag bij complexe taken.
De toolset
Een agent kan alleen wat zijn tools toelaten: bestanden lezen en schrijven, commando's en tests uitvoeren, zoeken in code of documentatie, externe systemen bevragen. De toolset bepaalt de mogelijkheden — én het risico. Hoe meer tools, hoe groter de kans op onverwachte acties.
De stopvoorwaarde
Elke lus heeft een uitgang nodig: de taak is klaar, een maximum aantal stappen is bereikt, een kostenlimiet is overschreden of een mens moet eerst bevestigen. Zonder duidelijke stopvoorwaarde draait een lus door tot het budget op is.
Het geheugen
Elke ronde stapelt context op: eerdere observaties, bestandsinhoud, foutmeldingen. Dat geheugen maakt de lus nuttig — de agent weet wat hij al probeerde. Maar contextvensters zijn eindig. Slimme agents vatten eerdere stappen samen of bewaren kernfeiten apart, zodat lange taken haalbaar blijven.
Waar het in de praktijk misloopt
- Vage doelen: “verbeter de code” levert een vage lus op; “alle bestaande tests moeten slagen” is verifieerbaar
- Vals spelen: een agent kan tests aanpassen zodat ze slagen in plaats van de echte fout op te lossen — begrens wat hij mag wijzigen
- Scope creep: zonder afbakening dwaalt een agent af naar bestanden die niets met de taak te maken hebben
- Oppervlakkige fixes: de tests slagen, maar de oplossing is fragiel — beoordeel het resultaat altijd kritisch
- Oplopende kosten: elke ronde kost rekenkracht; zonder limieten betaalt u voor rondjes draaien
Wanneer u beter géén loop gebruikt
Voor een taak die in één keer kan, is een lus overbodige overhead. En voor risicovolle operaties — productieomgevingen aanpassen, betalingen uitvoeren, e-mails versturen — hoort een mens elke belangrijke stap goed te keuren. Wie reproduceerbare, controleerbare output nodig heeft, kiest beter een vaste workflow dan een autonome agent: een lus kan dezelfde taak elke keer nét anders oplossen.
Wat betekent dit voor uw organisatie?
Agentic loops maken AI-assistenten fors productiever, maar de spelregels blijven dezelfde als bij elk AI-project: formuleer een doel dat te verifiëren valt, geef de agent enkel de tools die hij nodig heeft, werk in een veilige omgeving waar wijzigingen omkeerbaar zijn en laat een mens het eindresultaat beoordelen. Wie die vier zaken vastlegt, haalt de snelheid van autonome agents binnen zonder de controle uit handen te geven.