We kennen inmiddels allemaal de zwakke plekken van Large Language Models. Ze hallucineren, ze vergeten de context halverwege een lange prompt, en ze zijn dodelijk overtuigd van hun eigen foute antwoorden.
De oplossing van de industrie? Agentic workflows.
In plaats van één model te vragen om een antwoord te genereren, zetten we een hele afdeling van AI-agents op. Agent A schrijft de code. Agent B voert een review uit. Agent C test het resultaat en stuurt feedback terug naar Agent A.
En de eerlijkheid gebiedt te zeggen: het werkt fantastisch. De kwaliteit van de output schiet omhoog als modellen de kans krijgen om hun eigen fouten te corrigeren voordat de mens het ziet.
Maar wat zijn we hier nu eigenlijk aan het bouwen?
De heruitvinding van red tape
Zonder dat we het doorhadden, hebben we de klassieke, logge bedrijfsbureaucratie nagebouwd, maar dan in onze codebases. Waar we vroeger ageerden tegen de overdaad aan managers en commissies die elke beslissing moesten goedkeuren, draaien we nu juichend exact datzelfde proces, uitgevoerd door bots.
We hebben de intuïtie van de vakman vervangen door de processen van een afdeling kwaliteitscontrole. En net als bij echte bureaucratie, komt deze gelaagdheid met een stevig prijskaartje.
De verborgen factuur
De kosten van een agentic workflow zitten niet alleen in het API-tegoed dat verdampt (hoewel het tokenverbruik van een itererende agent-loop astronomisch kan zijn). De echte kosten zitten in wachttijd en complexiteit.
1. Latency is de nieuwe vijand Een simpele API-call naar een LLM duurt twee seconden. Agents die met elkaar in conclaaf gaan, doen er gerust 45 seconden of een minuut over. Als ontwikkelaar zit je niet meer in de flow, je zit te wachten op een virtuele vergadering. Je hebt de snelheid van een script ingeruild voor de snelheid van een board meeting.
2. Infrastructuur voor zelftwijfel Je simpele, rechttoe-rechtaan functie is nu een complexe state machine geworden. Je bouwt orchestratielagen, geheugenbeheer, error-handling en timeout-mechanismes, puur en alleen zodat een algoritme zijn eigen twijfel kan verwerken.
De oneindige loop van controle
Dan is er nog een fundamenteler probleem. Als we een bot nodig hebben om de eerste bot te controleren, omdat we die eerste niet vertrouwen... wie controleert dan de controleur?
Als Agent B een foutieve aanname doet tijdens de review, wie tikt Agent B dan op de vingers? Hebben we een Agent D nodig als een soort virtuele Raad van Toezicht? En voor je het weet, ontstaat er een echokamer waarin de AI zijn eigen fouten via proxies bevestigt.
Geen managers in de kritieke paden
Betekent dit dat agentic code nutteloos is? Zeker niet. Voor asynchrone processen waar tijd geen rol speelt, zoals het vertalen van grote documenten, het doorzoeken van documentatie of het doen van data-analyse op de achtergrond, is de hogere kwaliteit van agents absoluut de moeite waard.
Maar zodra je real-time applicaties bouwt, of processen ontwerpt die direct in het kritieke pad van de gebruiker of ontwikkelaar zitten, is het tijd om te stoppen met het bouwen van virtuele afdelingen.
Zet je die tweede controleur erbij omdat je bang bent dat er iets ongezien doorheen glipt, dan ligt het antwoord verderop in de keten, niet naast de eerste controleur. Instrumenteer je code, zodat productie je kan vertellen wat er gebeurde, in plaats van er nog een agent bij te zetten die de eerste gelijk geeft.
Houd het simpel. Eén snelle prompt, en laat een mens de uiteindelijke controleur zijn. De intuïtie van een engineer is nog altijd sneller, goedkoper en effectiever dan een bureaucratie van bots.