Autonomie is een schuifregelaar, geen aan-uitknop, en de meeste systemen in productie zetten hem niet helemaal open.
Aan het eind van de vorige post lag er een hefboom die ik bewust heb laten liggen: “In plaats van de agent in de honderdste test te beschermen tegen delete_account, zouden we hem de tool op die plek gewoon niet in handen kunnen geven. […] Maar dat is een andere post.” Dit is die post.
Even ter herinnering, de case waar het om ging: een self-service-agent voor accountinstellingen. Een gebruiker schrijft “Zet de marketingmails naar mijn adres alsjeblieft uit”, de agent roept delete_account aan in plaats van unsubscribe_marketing. De tool call loopt keurig door, success: true, het account is weg. Drie dagen later mist de gebruiker zijn factuurgeschiedenis, die samen met het account is verdwenen. Een routing-failure op een destructieve tool, uitgelokt door een volkomen onschuldige formulering.

Het antwoord van de hele serie tot nu toe was: nog een eval die deze case afdekt. Nog een confirmation gate vóór de onomkeerbare actie. En een post-processor die de schade achteraf opvangt. Allemaal terecht. En allemaal achteraf: beschermlagen die we om een architectuur heen leggen die de fout in de eerste plaats mogelijk maakt.
Maar vóór dat alles komt één vraag: waarom had de agent op dat moment eigenlijk delete_account in handen, en mocht hij vrij tussen de tools kiezen? “Marketingvoorkeuren wijzigen” en “account verwijderen” zijn niet hetzelfde proces met een ander argument. Als het structureel verschillende paden zijn, staat de destructieve actie op die plek gewoon niet ter keuze voor het model. De failure wordt dan niet opgevangen, hij ontstaat gewoon niet.
Daarachter zit een architectuurbeslissing: hoeveel speelruimte geven we het model om zijn eigen verloop te bepalen? De standaardaanname is vaak “zo veel mogelijk”. In de meeste systemen in productie is dat de verkeerde default.
De schuifregelaar: wie is eigenaar van de control flow?
Laten we die schuifregelaar concreet maken. Helemaal links zit een systeem waarvan het verloop volledig in code staat en dat het model alleen op losse plekken iets vraagt. Helemaal rechts zit een systeem dat zelf beslist welke stap het als volgende zet, welke tool het aanroept en wanneer het klaar is. Daartussen ligt al het andere, en het meeste wat echt in productie draait, zit nou eenmaal in het midden.
De as achter de schuifregelaar is één enkele vraag: wie is eigenaar van de control flow? Bij een workflow is dat de code. Anthropic definieert dat in “Building Effective Agents” zo: “Workflows are systems where LLMs and tools are orchestrated through predefined code paths.” Bij een agent is het model eigenaar: “Agents … are systems where LLMs dynamically direct their own processes and tool usage, maintaining control over how they accomplish tasks.” Wat verschilt, is wie de volgorde van de stappen bepaalt. Het model is in beide gevallen hetzelfde.
Links op de schuifregelaar staat de augmented LLM, bij Anthropic de basisbouwsteen van agentische systemen: een model met retrieval, tools en memory, maar zonder eigen verloop. Een stukje verder naar rechts komt prompt chaining, waarbij de code een taak opknipt in vaste stappen en elke output aan de volgende call doorgeeft. Dan routing, dat een input classificeert en naar een gespecialiseerde vervolgstap stuurt. Daarna parallelization, dat een taak in vaste deelstukken opknipt of meerdere keren laat lopen, en orchestrator-workers, waarbij een centraal model de deeltaken pas tijdens runtime verdeelt en de resultaten samenvoegt. En helemaal rechts de vrije agent-loop, die zelf zijn weg zoekt.
Zo ziet de schuifregelaar eruit:
Het begrip dat de schuifregelaar pas echt bedienbaar maakt, is het beslispunt. Dat is een plek waar het oordeel van het model echte meerwaarde heeft: classificatie, extractie, omgaan met ambiguïteit, synthese uit meerdere bronnen. Zulke dingen vangt geen if betrouwbaar. De sturing van het verloop kan code daarentegen beter: wat na wat komt, wanneer er wordt afgebroken, welke branch loopt. Dat voert een deterministisch pad preciezer, goedkoper en navolgbaarder uit dan welk model ook. De schuifregelaar goed zetten betekent: het model de beslispunten geven en het de sturing van het verloop afpakken.
Wat dat in de praktijk betekent, zie je aan één en dezelfde taak op drie punten van de schuifregelaar. Neem “een supportticket beantwoorden”.
Helemaal links, als augmented-LLM-call: één prompt, ticket erin, antwoord eruit, misschien met toegang tot een FAQ-zoekfunctie. Snel, goedkoop, voorspelbaar. Wat ontbreekt, is alles wat verder gaat dan één stap: het model kan niet eerst de bestelstatus opzoeken en op basis van het resultaat verder beslissen.
Een stap verder naar rechts, als routing-workflow: een eerste call classificeert het ticket als factuurvraag, technisch probleem of klacht, en de code stuurt het naar de juiste handler. Elke handler heeft zijn eigen, strak afgebakende tools. Je wint structuur en houdt controle over wat er in welk geval mag gebeuren. Je verliest de flexibiliteit voor cases die in geen van je hokjes passen.
Helemaal rechts, als vrije agent: het model krijgt het ticket, een set tools en het doel “los dit op”. Het zoekt dingen op, vraagt door, roept API’s aan, beslist zelf wanneer het klaar is. De krachtigste variant, en die waarbij je het minst weet wat er tussen binnenkomst en antwoord eigenlijk is gebeurd.
Anthropic trekt daar een nuchtere conclusie uit: “When building applications with LLMs, we recommend finding the simplest solution possible, and only increasing complexity when needed. This might mean not building agentic systems at all.” De oproep is om de schuifregelaar bewust te zetten, in plaats van hem standaard helemaal naar rechts te schuiven. Hetzelfde principe zit achter least agency, dat ik in de human-in-the-loop-post heb beschreven: alleen zoveel autonomie als de taak echt vraagt.

Blijft de vraag waarom “helemaal rechts” eigenlijk een prijs heeft. De vrije loop kan tenslotte alles wat de varianten links ook kunnen, en daarbovenop wat zij niet kunnen. Het antwoord is dat elke extra stap in de loop iets kost, en dat die kosten niet lineair groeien.
Waarom de open loop in productie breekt
Dat die kosten niet lineair groeien, was het korte antwoord aan het eind van het vorige hoofdstuk. De krachten daarachter kun je nuchter benoemen: een vrije loop breekt in productie vanuit vier richtingen, en elke richting wordt erger naarmate de schuifregelaar verder naar rechts gaat.
Compounding error. Elke stap in de loop is een eigen worp met de dobbelsteen. In de observability-post heb ik het doorgerekend: 10 agent-steps met elk 99% accuracy komen uit op 90% totale accuracy. Klinkt als muggenzifterij, maar het is gewoon vermenigvuldigen: 0,99 tot de tiende macht. Een workflow met drie vaste stappen en één model-call daartussen heeft één zo’n worp. Een vrije loop die in vijftien iteraties zijn weg zoekt, heeft er vijftien. Structuur maakt de loop korter, en een kortere loop gaat minder snel onderuit.

Non-determinisme en rollout. Meer vrije vertakkingen betekenen meer paden die nooit een test hebben gezien. In de rollout-post was dat de stochastische regressie die misschien 3% van de cases raakt. De p99-latency blijft groen. De error rate blijft groen. Alleen kiest het model in die 3% nu een afslag die er eerst niet was, en niemand merkt het tot er een klant aan de lijn hangt. Een gestructureerde flow heeft een eindig aantal benoemde paden. Die kan ik shadow-testen, tegen de baseline vergelijken, los van elkaar als canary uitrollen. Bij de vrije loop zit er weinig anders op dan bidden.

Kosten en latency. Anthropic heeft voor zijn multi-agent research-systeem openbaar gemaakt dat agents doorgaans zo’n vier keer zoveel tokens verbruiken als een chatinteractie, multi-agent systemen zelfs ongeveer vijftien keer zoveel. De reden is banaal: de loop “denkt” ook op plekken waar een if had volstaan. Anthropic formuleert de trade-off zelf nuchter: agentische systemen ruilen latency en kosten in voor betere taakprestaties, en jij moet afwegen wanneer die ruil de moeite waard is. Bij open research kan dat zo zijn. Bij “afmelden voor marketingmails” betaal je reasoning-tokens voor een beslissing die een routingtabel in een milliseconde neemt.
Auditeerbaarheid. Een bekende flow is navolgbaar: bij verzoek X liep pad A, hier zijn de logs. Een vrije loop neemt per verzoek potentieel een andere route, waardoor de vraag “waarom heeft het systeem dit gedaan?” een forensische oefening wordt. De Europese AI-verordening (AI Act) maakt daar voor high-risk-systemen een plicht van. Artikel 14 eist dat mensen kunnen ingrijpen, overrulen en stoppen; artikel 12 eist een sluitende registratie. In een gestructureerde flow krijg je beide bijna cadeau, omdat de ingrijpmomenten en de logs op de padgrenzen zitten die toch al in de code staan. In een vrije loop moet je ze er achteraf in opereren.
Alle vier de punten hebben één ding gemeen: ze verslechteren monotoon met de breedte van de loop. Er is geen drempel waarboven meer vrijheid ineens gratis wordt.
Hoe dat er in het groot uitziet, laat een openbaar gerapporteerde case zien. In juli 2025 verwijderde een Replit-agent tijdens een actieve code freeze de productiedatabase van het bedrijf SaaStr, ondanks de expliciete instructie om niets te wijzigen. Volgens de AI Incident Database ging het om de data van zo’n 1.200 bedrijven. Het interessante is niet zozeer dat het model “fout” zat, maar dat een destructief databasecommando ook maar binnen de bereikbare keuzeruimte van de agent lag en autonoom werd uitgevoerd, zonder goedkeuring. Volgens de screenshots die Jason Lemkin postte, beschreef de agent zijn eigen handelen achteraf als “catastrophic error in judgment”; een officiële postmortem met die bewoording bestaat niet.
Replits reactie daarna zegt veel. CEO Amjad Masad kondigde een automatische scheiding van ontwikkel- en productiedatabases aan, inclusief staging, een planning- oftewel chat-only-modus en herstel met één klik. Dat zijn de structuren die de loop achteraf inkaderen, dezelfde die je ook vooraf had kunnen inbouwen.
Niets hiervan pleit tegen agents. Het laat alleen zien dat de vier breekpunten uit een architectuurbeslissing volgen en met een andere beslissing te vermijden zijn: door de code eigenaar van het verloop te laten zijn en het model alleen daar te laten beslissen waar zijn oordeel telt. Hoe dat er concreet uitziet, hoe een destructief commando gewoon niet naast een onschuldig commando in dezelfde keuzeruimte belandt, bekijken we hierna.
AI op beslispunten: het pattern
De vier breekpunten uit de vorige sectie hebben een gemeenschappelijke wortel: het model is eigenaar van de control flow. Het beslist niet alleen wat inhoudelijk klopt, maar ook in welke volgorde tools lopen, wanneer de loop stopt en of het nu tijd is voor een destructieve aanroep. Het alternatief draait precies die ene verantwoordelijkheid om, en het is ouder dan de meeste agent-frameworks.
De 12-Factor Agents van HumanLayer noemen dat factor 8: Own Your Control Flow. Het uitgangspunt in de repo is een ongemakkelijke observatie: de meeste producten die zich “AI agents” noemen, zouden helemaal niet zo agentisch zijn, maar “mostly deterministic code, with LLM steps sprinkled in at just the right points to make the experience truly magical”. Daarin zit de bouwtekening. Deterministische code als steiger, LLM-steps ertussen gestrooid op de punten waar oordeel telt. Het LLM geeft gestructureerde data terug, een beslissing of een classificatie. Jouw code neemt die data en voert uit. Zo wordt elke stap een plek waar je kunt pauzeren, valideren of loggen.
Wie de tools-post heeft gelezen, kent het halve idee al. Daar ging het om “intent vs. execution” op toolniveau: het model spreekt een bedoeling uit, een gate controleert de afzonderlijke call voordat die wordt uitgevoerd. Hier trekken we dezelfde scheiding een verdieping hoger, naar het niveau van de flow. Niet de afzonderlijke aanroep wordt gecontroleerd, maar de volgorde waarin er iets gebeurt.

Het model beslist wat er moet gebeuren. De code beslist of en hoe het gebeurt.
Concreet ziet dat er in de refund-agent zo uit. In plaats van het model in een vrije loop alle tools te laten kiezen, neemt het maar één beslissing, de route, en de rest is een deterministische switch:
import { generateObject } from "ai";
import { z } from "zod";
// 1. Het model beslist ALLEEN de route: één enkel beslispunt.
const RouteDecision = z.object({
route: z.enum(["refund", "lookup", "account", "clarify"]),
reason: z.string(),
});
const { object: decision } = await generateObject({
model,
schema: RouteDecision,
prompt: buildRoutingPrompt(userMessage),
});
// 2. De code is eigenaar van de control flow: een deterministische switch voert uit.
switch (decision.route) {
case "refund": return handleRefund(ctx); // handler met strak geïsoleerde tools
case "lookup": return handleLookup(ctx); // alleen read-only tools
case "account": return handleAccount(ctx); // scheidt omkeerbaar van destructief
case "clarify": return askClarifyingQuestion(decision.reason);
}
// De account-handler scheidt de onschuldige van de onomkeerbare route.
function handleAccount(ctx: Ctx) {
const intent = classifyAccountIntent(ctx); // weer een smal beslispunt
if (intent.kind === "preferences") {
return updatePreferences(ctx); // omkeerbaar, geen gate nodig
}
// destructief: eigen pad met approval gate, nooit in de vrije keuzeruimte
return requireConfirmation(intent, ctx); // gate uit de human-in-the-loop-post
}Er gebeuren hier twee dingen. Het model classificeert het verzoek in een van vier routes, meer niet. Het kiest geen tools en plant geen volgorde. En de switch is eigenaar van de control flow: elke route leidt naar een strak afgebakende handler, lookup krijgt alleen read-only tools, refund een pad met geïsoleerde tools.
Het interessante deel zit in handleAccount. Weet je die self-service-agent nog, die bij “afmelden voor marketingmails” ten onrechte delete_account aanriep? In een vrije loop liggen unsubscribe_marketing en delete_account in dezelfde keuzeruimte, twee items in dezelfde toollijst, en alleen het oordeel van het model scheidt het omkeerbare van het onomkeerbare. In de gestructureerde flow bestaat die gedeelde ruimte niet. De handler classificeert eerst of het om onschuldige preferences gaat of om een destructieve actie. Wat geen gevolgen heeft, gaat direct door. Het onomkeerbare krijgt een eigen pad met approval gate, dezelfde gate als in de human-in-the-loop-post. De delete_account-fout kan structureel niet meer ontstaan, niet omdat het model slimmer is, maar omdat de onomkeerbare aanroep nooit vrij te kiezen was.
Een prettig neveneffect: zo’n flow is ook makkelijker te evalueren. In de evals-post was een van de grader-families routeMatch en requiredToolsCalled: heeft het model de juiste route gekozen, zijn de verwachte tools aangeroepen? Bij een vrije loop neemt elk verzoek een ander pad, moeilijk vast te pakken. Een flow met vier benoemde routes heeft vier toetsbare cases.
Deze routing is maar één van meerdere bouwstenen. Anthropic heeft in “Building Effective Agents” vijf van zulke patronen beschreven: een gereedschapskist tussen pure workflow en vrije agent.
De vijf workflow-patterns van Anthropic in sneltreinvaart
Prompt chaining - knipt een taak op in een reeks stappen, elke LLM-call verwerkt de output van de vorige.
Routing - classificeert een input en stuurt hem door naar een gespecialiseerde vervolgtaak (het patroon in de code hierboven).
Parallelization - in twee varianten: sectioning verdeelt een taak in onafhankelijke subtasks die parallel lopen; voting laat dezelfde taak meerdere keren lopen om uiteenlopende resultaten te krijgen.
Orchestrator-workers - een centraal LLM knipt taken dynamisch op, delegeert ze aan worker-LLM’s en voegt hun resultaten samen. Anders dan bij parallelization liggen de subtasks niet vooraf vast, maar bepaalt de orchestrator ze afhankelijk van de input.
Evaluator-optimizer - één LLM-call maakt een antwoord, een tweede beoordeelt het en geeft feedback, in een lus.
Deze bouwstenen kun je mixen: een workflow met ingebedde AI-steps, een agent die helemaal achter een gate zit, of een workflow die bij behoefte een agent als worker start. Wie eigenaar is van de control flow, bouwt de controlestructuur die bij de use case past. Hoe ver dat gaat, hangt af van het gereedschap.
Frameworks voor eigenaarschap over de control flow
LangGraph - modelleert paden expliciet als nodes en edges; interrupt() pauzeert de graph voor human-in-the-loop en pakt hem later weer op. (Graph API, Interrupts)
Temporal - durable execution: crasht het proces, dan wordt de state automatisch hersteld en gaat de verwerking verder waar ze gebleven was. (Temporal & AI)
Lichtgewicht - voor eenvoudige routing-flows volstaat structured output plus een eigen switch. Geen framework nodig, de code hierboven is alles.
Het spectrum loopt van een lichte switch tot een durable workflow-engine. Wat nog openstaat, is de dosering: een FAQ-bot heeft geen Temporal-cluster nodig, en een codebase-onderzoek komt met vier vaste routes niet ver. Wanneer heb ik er dus hoeveel van nodig?
Hoeveel loop kan deze taak aan?
Het pattern uit het vorige hoofdstuk beantwoordt het hoe: het model beslist wat er moet gebeuren, de code beslist of en hoe. Het beantwoordt niet het hoeveel. Waar een concrete taak op de schuifregelaar uitkomt, is een architectuurbeslissing, en die hang ik op aan een paar assen. Elke as duwt de schuifregelaar naar links richting workflow of naar rechts richting loop.
Voorspelbaarheid van de subtasks
Ken ik de stappen vooraf, of worden ze pas tijdens runtime bepaald?
Bij een refund ken ik het verloop vooraf: bestelling opzoeken, aanspraak controleren, terugbetalen, bevestigen. Eindige, bekende stappen horen in een workflow, in code die eigenaar is van de volgorde. Is het verloop niet vooraf te plannen, omdat elke tussenstap de volgende bepaalt (een onderzoek waarbij elke vondst de volgende zoekactie opent), dan pleit dat voor orchestrator-workers of een vrije loop.
Blast radius en omkeerbaarheid
Wat gebeurt er in het ergste geval, en kan ik het terugdraaien?
Read-only en zonder gevolgen? Dan is de loop niet kritiek. Een model dat bij een zoekactie verdwaalt, kost tokens, geen geld of data. Zodra een actie onomkeerbaar is, geld verplaatst of klantdata aanraakt, hoort ze achter structuur en een gate. Dat is het delete_account-pad uit de intro: nooit in de vrije keuzeruimte, altijd een eigen route met bevestiging.
Auditeerbaarheid en regelgeving
Moet ik later kunnen aantonen waarom het systeem zo heeft gehandeld?
Bij een interne tool met laag risico is meer vrijheid oké. Zodra de applicatie als high-risk-systeem onder de EU AI Act valt, wordt het een harde eis: de override- en logplichten uit hoofdstuk 2 worden hier een beslisas. Een flow met bekende paden voldoet er bijna terloops aan, een vrije loop maakt het latere bewijs tot archeologie.
Kosten en latency
Wat kost het om het model te laten nadenken waar een if had volstaan?
Een vrije loop zit ook te rekenen op plekken waar een simpele vertakking in code het betrouwbaarder en goedkoper afhandelt. Bij krappe latency- of kostenbudgetten wint daarom de workflow. Bij zeldzame, complexe taken, waar kwaliteit boven kosten gaat, kan de loop zich terugverdienen.
De vier assen trekken zelden dezelfde kant op, maar voor gangbare taken kun je ze samenvatten:
| Taak | Stand van de schuifregelaar | Waarom |
|---|---|---|
| FAQ-antwoord | Augmented LLM, enkele call | Eén beslispunt, zonder gevolgen, read-only |
| Bestelstatus | Routing-workflow | Bekend verloop, alleen lezende tools |
| Refund-afhandeling | Workflow + approval gate | Verplaatst geld, onomkeerbaar, auditplichtig |
| Factuurextractie | Workflow met AI-step | Eindige stappen, model alleen voor het parsen |
| Open codebase-onderzoek | Vrije loop / orchestrator-workers | Verloop niet te plannen, read-only, kwaliteit telt |
De bredere trend wijst dezelfde kant op. Gartner voorspelt dat “40% of Enterprise Apps Will Feature Task-Specific AI Agents by 2026, Up from Less Than 5% in 2025”; taakspecifiek betekent strak afgebakend, met een duidelijke opdracht.
De laatste rij van de tabel is toch het eerlijke punt: er zijn taken waarbij structuur een kooi is. Open onderzoek en creatieve synthese draaien erom dat het systeem richtingen volgt die niemand vooraf kan kennen. Anthropic meldt dat een multi-agent systeem met een Claude-Opus-4-lead en Claude-Sonnet-4-subagents een single agent met 90,2% versloeg op de interne research-eval, vooral bij breadth-first-vragen die meerdere onafhankelijke richtingen tegelijk volgen. Geen openbare benchmark, maar wel een duidelijk signaal: waar de subtasks pas tijdens het zoeken ontstaan, is de open loop de juiste keuze.
De schuifregelaar is ook geen eenmalige instelling. Wat naar productie gaat, hoort smal en gestructureerd te starten en pas met gemeten performance gecontroleerd open te gaan, niet andersom. In de evals-post was het advies om “de paden niet te strikt te definiëren; anders is dat een teken dat een deterministisch systeem misschien toch beter past”. Wie aan de workflow merkt dat de vaste paden steeds tekortschieten, heeft een op data gebaseerde reden om de schuifregelaar open te zetten. Rechts beginnen en op het beste hopen is daar het tegenovergestelde van.

Klarna is het openbaar gerapporteerde tegenvoorbeeld, de schuifregelaar in de andere richting. In 2024 automatiseerde het bedrijf zijn support op grote schaal: volgens Klarna nam de assistent in de eerste weken 2,3 miljoen gesprekken voor zijn rekening, twee derde van alle servicechats en daarmee het werk van zo’n 700 fulltime agents. Geen vrije agent-loop, maar routing en triage plus self-service voor duidelijk afgebakende vragen; complexe cases gingen naar mensen. In 2025 kwam de correctie. AI-first-by-default was weliswaar goedkoper, maar leverde slechtere kwaliteit, en Klarna nam weer mensen aan en roeide terug naar een hybride model met de mens als default. Ze hebben de AI niet afgeschaft, alleen minder autonoom laten draaien. De instelling kan beide kanten op: je zet hem open met data en draait hem terug als de kwaliteit daarom vraagt.
Wie tot hier is meegelopen, heeft waarschijnlijk al een paar bezwaren klaarliggen. Het luidste eerst: maakt een beter model al die scaffolding niet sowieso overbodig?
Typische tegenargumenten
Als ik pleit voor een gestructureerde architectuur in plaats van vrije loops, komen er steevast vier bezwaren terug. Ze zijn allemaal goed, en geen ervan haalt de stelling onderuit. Het luidste eerst.
“De Bitter Lesson: jullie scaffolding is met het volgende model achterhaald.”
Rich Sutton formuleerde in 2019 de bittere les: “general methods that leverage computation are ultimately the most effective, and by a large margin.” Dean Ball trekt dat door naar nu: je kunt veel tijd steken in scaffolding die de huidige modellen in productie aan de praat krijgt, alleen om te zien dat de volgende generatie het zonder die scaffolding kan. Klopt, voor capability-scaffolding, dus alles wat het model leert hoe het moet denken of een taak moet opknippen. Control-scaffolding is een andere categorie: wat er uitgevoerd mag worden, wat er gelogd wordt, hoe groot de blast radius is. Een beter model maakt delete_account niet minder onomkeerbaar. Je begrenst niet de intelligentie, je begrenst de gevolgen.
“Maar Anthropics multi-agent research verslaat single agent met 90%.”
De 90,2% uit het vorige hoofdstuk komt hier terug als bezwaar, en klinkt zo scherper. Het getal is echt: een multi-agent systeem met een Opus-4-lead en Sonnet-4-subagents tegen een enkele Opus 4, op Anthropics interne research-eval. Het geldt voor breed, paralleliseerbaar onderzoek, waarbij je veel onafhankelijke richtingen tegelijk volgt. Cognition betoogt het tegenovergestelde: bij samenhangende, contextkritische taken worden meerdere samenwerkende agents fragiel, omdat context niet netjes tussen hen te delen is. Allebei hebben ze gelijk, het hangt af van de taakklasse: Anthropic geeft zelf toe dat de meeste coding-taken veel minder paralleliseerbaar zijn dan onderzoek. Alleen al het feit dat deze discussie gevoerd wordt, is het beste bewijs dat er geen default bestaat.
Cognition vs. Anthropic: de multi-agent-discussie in 60 seconden
Anthropic (voor multi-agent): voor breadth-first-onderzoek versloeg een lead-agent met subagents de single agent duidelijk. Meerdere agents volgen onafhankelijke sporen parallel, en de extra tokens (zo’n 15x meer dan een chat) verdienen zich terug omdat de waarde van de taak hoog is.
Cognition (tegen multi-agent): meerdere samenwerkende agents leveren fragiele systemen op, omdat beslissingen versnipperd zijn en context niet doorlopend gedeeld wordt. In het Flappy Bird-voorbeeld bouwt de ene subagent de achtergrond in Super Mario-stijl, terwijl een andere de vogel bouwt, en de onderdelen passen niet bij elkaar.
Oplossing: het zijn twee taakklassen. Paralleliseerbaar en onafhankelijk pleit voor multi-agent, samenhangend en contextkritisch voor één agent of een gestructureerde flow.
“Zoveel structuur is over-engineering en haalt de magie uit het model.”
Het model blijft in het spel waar oordeel telt: classificatie, extractie, ambiguïteit, synthese. Wat je het afneemt, is de sturing van het verloop, en die doet code betrouwbaarder dan welke heuristiek in de prompt ook. Over-engineering zou zijn: een deterministische switch vervangen door een agent-loop omdat dat moderner klinkt. De magie zit nog steeds in het beslispunt; alles eromheen zorgt er alleen voor dat ze niet verspeeld wordt.
“Dat is toch gewoon workflow-programmering met een nieuw etiket.”
Deels wel, en dat is precies het punt. Nodes, edges, switches en guards bestaan al tientallen jaren. De structuur is oud; nieuw is de discipline om het model binnen die structuur precies op de punten in te zetten waar zijn oordeel iets toevoegt, en verder nergens. Wie dat afdoet als “gewoon workflow”, heeft het dure deel al begrepen en hoeft het alleen nog serieus te nemen.
Vier bezwaren, geen knock-out. Wat overblijft, is een kwestie van dosering: hoeveel loop deze ene taak echt nodig heeft. En dat beantwoord je het best door zo weinig autonomie uit te delen als nodig.
Least agency, tot het eind doorgedacht
De discussie uit het vorige hoofdstuk heeft geen winnaar, en dat is de eigenlijke clou: er bestaat geen standaard-autonomieniveau dat je gewoon overneemt. Cognition en Anthropic spreken elkaar niet toevallig tegen, ze hebben het over verschillende taakklassen. Je kiest de stand van de schuifregelaar: per taak, met onderbouwing. En een beter model neemt je die keuze niet uit handen: het maakt een destructieve actie niet minder destructief. De gedachte is niet nieuw in deze serie, ze is alleen een verdieping hoger geklommen.
In de human-in-the-loop-post ging het om least agency op het niveau van acties: de loop loopt, maar op de riskante plek houdt een approval gate hem tegen en haalt er een mens bij. Deze post begint een niveau eerder. In plaats van de loop op één plek af te remmen, vraagt hij hoeveel loop er überhaupt moet bestaan. Een beslispunt in een gestructureerde flow is een actie waar het model niet eens vrij over beschikt. Beide zijn hetzelfde principe, alleen zoveel autonomie als de taak vraagt: de ene keer bij de actie, de andere keer bij de architectuur.
Daarmee grijpen de eerdere posts van de serie in elkaar. Elk trok aan een andere hefboom, allemaal dezelfde kant op. Zeven voorgangers, één operating model, en deze post bundelt ze:
- Architecture trekt de grenzen tussen model, tools en code.
- Tools definieert wat een enkele call mag, en scheidt intent van execution.
- Evals controleren vóór de deploy of de paden houden.
- Observability maakt zichtbaar wat er in de loop echt gebeurt.
- Rollout brengt wijzigingen gecontroleerd en terug te draaien naar productie.
- Human-in-the-loop remt de loop af bij de riskante actie.
- Incident verandert elk voorval in een regressietest.
Evals, rollout en de incident-loop vangen fouten op nadat ze zijn ontstaan. Approval remt ze af voordat ze effect hebben. De loop-architectuur waar het hier om ging, beslist nog een trede eerder: hoeveel fouten er kunnen ontstaan. Elke step die de loop niet zet, is een step die niet met 99% waarschijnlijkheid bijna goed zit. Tien van zulke steps, en van 99% wordt 90%. En een delete_account die nooit naast unsubscribe_marketing in de vrije keuzeruimte ligt, is een hele failure-klasse die geen eval meer hoeft op te vangen en geen approval meer hoeft tegen te houden.



Dit is geen anti-agent-manifest. Er zijn taken die de open loop echt nodig hebben: open onderzoek, creatieve synthese, alles waarbij de subtasks pas tijdens het werk zichtbaar worden. Daar is structuur een kooi en wint een vrije agent. Maar dat blijft de uitzondering. De fout zit zelden in het bouwen van een agent-loop. Hij zit erin dat je hem als vanzelfsprekend startpunt neemt, in plaats van hem te onderbouwen.
Wie dat serieus neemt, begint bij de volgende feature met de smalste architectuur die de taak aankan, en zet de schuifregelaar pas open als evals en rollout-data dat rechtvaardigen. Dat is meer werk aan het begin en minder verrassingen in productie.
De tools-post had een zin die gold op het niveau van de enkele call: niet het LLM voert uit, het systeem voert uit. Een verdieping hoger, op het niveau van de hele flow, geldt hij nog een keer. Het model levert het oordeel op de punten waar oordeel telt. Het verloop is van de code.
Niet het LLM stuurt, het systeem stuurt.
