Iedereen praat over "AI-agents", maar weinig uitleg laat zien wáárom ze werken — en waaróm ze soms ontsporen. Dit is de korte, werkende mentale-modellen-versie: van "een taalmodel is een functie, geen wezen" tot "meerdere agents die samenwerken". Met de bewegende agent-loop, een diagnose voor waarom agents flaken, het geheugen-spectrum, en een kiezer voor het juiste multi-agent-patroon.
Het meest contra-intuïtieve idee eerst, want al het andere hangt eraan: een taalmodel is een bevroren functie, geen wezen. Tekst erin, een gok over het volgende stukje tekst eruit. Geen bedoelingen, geen geheugen tussen twee aanroepen, geen besef van "gisteren". Elke keer dat je het aanroept is het exact hetzelfde model in exact dezelfde staat. Alles wat intelligent lijkt, komt uit dat ene trucje — heel vaak en heel goed herhaald.
Zodra je het als "iemand die onthoudt en bijleert tijdens het gesprek" ziet, snap je agents verkeerd. Het model leert niets tijdens je sessie. Alle schijnbare continuïteit heeft de software er telkens opnieuw ingestopt.
Je stuurt niet de motor, je stuurt wat de motor ziet.
Een model op zichzelf kan maar één ding: praten. Het kan je vertellen hoe je een bestand zou lezen, maar het kan het niet lezen. Een agent is wat er gebeurt als je twee dingen toevoegt: een lus (roep het model steeds opnieuw aan) en tools (geef het handen om iets in de wereld te doen).
Bij een chatbot ben jíj de lus: jij leest het antwoord en stelt de volgende vraag. Bij een agent mag het model zélf acties ondernemen tussen je vraag en het eindantwoord — en op basis van wat het terugkrijgt zijn volgende stap bepalen. De mens stapt uit de lus voor de tussenstappen. Een agent is dus geen slimmer model — het is hetzelfde model in een lus met gereedschap.
Het belangrijkste inzicht van allemaal:
Het model vraagt, de software doet.
Een tool-aanroep is óók maar tekst. Het model schrijft alleen op wélke hand het zou willen gebruiken; het kán niets uitvoeren. De software eromheen — de harnas (zoals Claude Code) — herkent dat verzoek, doet de echte actie, en plakt het resultaat terug in het venster. Dáárom zitten permissions, sandboxing en die netwerk-firewallpopup precies tussen "model vraagt" en "actie gebeurt".
Druk op Stap (of Auto). Let op het venster rechts: elke observatie wordt teruggeplakt. De agent "weet" wat hij twee stappen geleden deed alleen omdat het nog in het venster staat — niet omdat het model iets onthoudt. Dáárom loopt een lange taak het venster onvermijdelijk vol.
Zodra je een model handen geeft, erf je de risico's van handen. Vier manieren, allemaal direct gevolg van module 1 + "het heeft nu handen":
Geen van de beruchte flake-modi is een teken dat "de AI dom is". Het zijn allemaal voorspelbare eigenschappen van een probabilistisch component. Kies een symptoom — zie de oorzaak, terug te leiden tot één van de vijf begrippen.
Kies hierboven een symptoom om de oorzaak te zien.
Zie je het patroon? Je bouwt rond iets dat per definitie gokt. Je taak is de gok te omkaderen — robuust, met logging, dry-runs, en de bestandsnaam als status. Niet de motor temmen, maar de gok begrenzen.
Het venster is eindig, duur en stateless (module 1) en het groeit bij elke stap (module 2). Daaruit volgt alles: geheugen is de kunst om dat venster slim te vullen — wat bewaar je buiten het venster, en hoe haal je op het juiste moment het juiste stukje terug?
Elk geheugensysteem kiest een positie op dit spectrum, en geen van beide uitersten werkt. "Lost een groter context window dit niet op?" Nee: je betaalt elke beurt om álles opnieuw te verwerken (kosten), én modellen worden slechter naarmate het venster vol raakt (degradatie). Oneindige context is gewoon de extreme versie van het raw-pad.
Bij een vraag zoek je éérst in een externe kennisbron de relevante stukjes, plakt die in het venster, en laat het model antwoorden mét die stukjes erbij. Letterlijk module 1 (het venster vullen) toegepast op kennis. Sterk tegen hallucinatie — je geeft de bron mee in plaats van te hopen dat het model het ware vervolg gokt. Het faalt als de retrieval het verkeerde stukje pakt (semantisch dichtbij, qua betekenis fout) of als de bron zelf niet klopt.
RAG is zoek-en-plak: stateless, en het kent geen veranderende feiten (verhuis je van Mumbai naar Bangalore, dan vindt het vrolijk beide). Het haalt op; het onderhoudt niet. Hieronder vier zwaardere vormen — geen ranglijst met winnaar, maar posities op het raw/derived-spectrum. Tik een vorm aan.
Het kernprincipe rond een probabilistisch model:
Model voor oordeel · code voor determinisme.
Gebruik het model voor classificeren, samenvatten, schrijven, betekenis uit rommelige tekst halen. Gebruik code voor rekenen, routeren, status-codes, transformaties. Elke deterministische beslissing die je door de LLM laat lopen, is een toekomstige flake — een gok waar een garantie hoort. En je kunt een probabilistisch systeem niet bewijzen, alleen meten — met evals: een vaste set testgevallen waar je de agent telkens tegenaan houdt en scoort.
Reasoning-modellen (test-time compute) passen dit principe zélf toe: ze schrijven eerst een "kladblok" vol denk-tokens vóór het antwoord — geen aparte mini-agent, hetzelfde model dat meer tokens aan denken besteedt. Door de tussenstappen in het venster te zetten, conditioneert het zijn eindantwoord op zijn eigen redenering. Op een wiskundeproef ging dat van ~12% naar ~74%. Trager en duurder — zet ze in waar het oordeel echt telt, niet voor bulk.
Eén agent botst onvermijdelijk tegen de grenzen uit module 1 en 3: het venster loopt vol, één taak duurt lang, en een agent die zichzelf nakijkt is een slechte controleur. Meerdere lussen naast of achter elkaar lossen precies dat op — maar je koopt er coördinatie, cascade-fouten en kosten voor terug. Multi-agent is geen sprong, het is vermenigvuldiging — je erft álle eigenschappen uit module 1-3, nu keer N.
Pak je bij: één taak opsplitsen in deeltaken — schoon venster per stuk. Zwakte: de orchestrator is een bottleneck; al het overzicht loopt door dat ene venster.
Pak je bij: een gezamenlijke conclusie nodig (één rapport over alle items). Nadeel: je wacht op de traagste.
Pak je bij: losse, onafhankelijke items zonder gezamenlijk eindpunt — hogere doorvoer. Wel gevoeliger voor cascade-fouten: geen barrier = geen natuurlijk controlepunt tussen stages.
Beide gebruiken meerdere modellen, maar mikken op tegengestelde doelen — ze worden vaak verward.
Beide vereisen dat je model-agnostisch bouwt — je code zit niet vast aan één leverancier. Dat is geen luxe maar een hedge tegen lock-in.
Een extra agent is niet gratis. Default naar één agent; voeg pas een tweede toe als één van de drie redenen echt opgaat. De vier kosten: coördinatie-overhead (bij kleine taken duurder dan de taak zelf), cascade-fouten (A geeft z'n fout door aan B aan C, niemand corrigeert), emergent gedrag (agents getest in isolatie gedragen zich anders als ze interacteren), en kosten/latency (een runaway fan-out kan in minuten een groot budget opeten — een gerapporteerd incident verbrandde 1,7 miljoen tokens met nul bruikbare output). "Het kan parallel" is geen reden als de taak in serie even snel klaar is.
| Situatie | Patroon | Waarom |
|---|---|---|
| Eén taak in deeltaken | Orchestrator / worker | Schoon venster per stuk; de baas voegt samen. |
| Gezamenlijke conclusie nodig | Fan-out + barrier | Wacht tot alle resultaten binnen zijn vóór de samenvatting. |
| Losse, onafhankelijke items | Pipeline | Geen barrier — hogere doorvoer, niemand wacht. |
| Kwaliteit boven één model | Mixture-of-Agents | Proposers + aggregator; accepteer de latency. |
| Kosten drukken | Model-routing | Goedkoopste passende model per vraag. |
| Kleine taak | Eén agent | Coördinatie-overhead is duurder dan de winst. |
| 1 | Een model is een functie, geen wezen — het leert niets tijdens je sessie. |
| 2 | Vloeiend ≠ correct. Correct dwing je af met context, tools en verificatie. |
| 3 | Wat niet in het venster staat, bestaat niet voor het model. |
| 4 | Het model vraagt, de software doet. |
| 5 | Een lange agent-taak loopt het venster onvermijdelijk vol — by design. |
| 6 | Model voor oordeel, code voor determinisme. |
| 7 | Een aparte agent verifieert beter dan een agent die zichzelf nakijkt. |
| 8 | Default naar één agent; voeg er pas een toe als een echte reden opgaat. |