Dynamic workflows: wanneer een vloot agents loont en wanneer je er geld in verbrandt

In juni schreef ik een kort stuk over één woord dat veranderde: het trigger-woord voor dynamic workflows in Claude Code werd van “workflow” naar “ultracode” verschoven, omdat een doodgewoon woord ongemerkt een vloot agents opstartte. Dat stuk ging over de knop. Wat eronder zat had ik nog niet uitgezocht.

Anthropic heeft daar nu een cookbook voor gepubliceerd, een notebook in de claude-cookbooks-repo dat een dynamic workflow van begin tot eind laat draaien vanuit de Python Agent SDK. Het is het eerste materiaal dat niet alleen zegt dát het kan, maar laat zien wat het kost, hoe de scripts eruitzien en waar het misgaat. Ik heb het naast de documentatie gelegd en de vuistregel eruit gehaald die ik zelf ga gebruiken.

Wat het is, in één alinea

Normaal is Claude de orkestrator. Jij vraagt iets, Claude besluit per beurt wat de volgende stap is, en alle tussenresultaten belanden in hetzelfde contextvenster. Bij een dynamic workflow schrijft Claude in plaats daarvan een JavaScript-script dat de hele opzet beschrijft: welke agents er starten, in welke volgorde, wat er met hun antwoorden gebeurt. Dat script gaat naar de Workflow-tool en een aparte runtime voert het op de achtergrond uit. Elke agent die zo start is een volwaardige Claude Code-agent met een schone context: hij ziet alleen de prompt die het script hem geeft.

Het verschil zit dus niet in slimmere agents. Het zit in wie het plan vasthoudt. Bij subagents zit dat plan in Claude’s hoofd, bij een workflow in code.

Het voorbeeld in het cookbook is een factcheck. Een concept-investorupdate met tien beweringen moet tegen vier bronbestanden worden gelegd. Het script doet dat in vier fases: één agent haalt de tien beweringen eruit, dan één verifier per bewering die parallel de bronnen leest, dan een scepticus die elke bevestiging probeert onderuit te halen, en tot slot één agent die er een rapport van maakt. De data is verzonnen, met fouten erin gepland.

De voordelen

Het plan wordt afgedwongen door code. Dit is de kern en de rest volgt eruit. “Controleer je bevindingen nog een keer” is een instructie, en instructies sneuvelen onder contextdruk. Een scepticus-fase die na de verifiers staat omdat de regelvolgorde dat zegt, sneuvelt niet.

Elk item krijgt dezelfde behandeling. Een agent die tien beweringen in één context afwerkt, is bij nummer zeven aan het scannen. Tien agents met elk één bewering zijn dat niet. Het cookbook wijst op bewering 6, waar het persbericht “een van de snelstgroeiende” zegt en het concept “de snelstgroeiende” heeft gemaakt. Dat verschil glipt langs een gehaaste lezer en niet langs een verifier die verder niets te doen heeft.

Claude’s context blijft schoon. Alle verdicten en geciteerde bronregels leven in scriptvariabelen. Alleen het eindrapport komt terug in je sessie. Dat is precies andersom dan bij subagents, waar elk resultaat in het contextvenster van de leidende agent landt.

De logica tussen de stappen is gratis. Filteren, dedupliceren, tellen, een lus tot een check groen is: dat is gewone JavaScript, exact en zonder tokens. Alleen de bevestigde verdicten doorsturen naar een scepticus kost nul.

Het script is een bestand. Elke run schrijft zijn script weg onder je sessiemap in ~/.claude/projects/. Je kunt het lezen, vergelijken met de vorige run, aanpassen en opnieuw laten draaien, of opslaan als eigen commando. De orkestratie wordt daarmee iets wat je bewaart, niet iets wat je elke keer opnieuw hoopt te krijgen.

De nadelen

Tokens. Dit is geen voetnoot. De notebook-run met tien beweringen en vier bronbestandjes kost volgens Anthropic zelf ongeveer twee tot vier dollar aan API-verbruik, en meer als een fase faalt en opnieuw begint. Op een abonnement telt het net zo hard mee voor je limieten. Een workflow die alles verifieert kost meer dan een workflow die niets verifieert, en die knop zit in je prompt.

Je kunt er niet tussen komen. Er is geen tussentijdse input mogelijk; alleen een permissievraag van een agent kan een run pauzeren. Wil je akkoord geven tussen twee fases, dan moet elke fase een eigen workflow zijn. De prompt die je vooraf schreef is de enige sturing die je hebt.

Onderbreken is duurder dan het lijkt. Bij hervatten komen afgeronde agents uit cache, maar de cache stopt bij de eerste agent die niet klaar was. Alles wat ná die agent is gestart draait opnieuw, ook als het wel klaar was. Stop je een fan-out van vier terwijl de tweede nog loopt, dan draaien drie van de vier opnieuw. En hervatten werkt alleen binnen dezelfde sessie: sluit je Claude Code af, dan begint de volgende sessie van voren af aan.

Het script mag zelf niets. Geen bestandssysteem, geen shell, en import() laat de run al voor de start falen. Alle echte handelingen gebeuren in de agents. Dat is een verstandige grens, maar het betekent dat je “even een bibliotheek gebruiken” in het script vergeet.

Het schaalt sneller dan je denkt. De runtime draait tot 16 agents tegelijk en maximaal 1000 per run. Claude Code waarschuwt vanaf versie 2.1.203 als een run boven de 25 agents of 1,5 miljoen geprojecteerde tokens uitkomt, maar dat is een melding en geen rem. Zet je /effort ultracode aan, dan verdwijnt die waarschuwing zelfs, want dan heb je grote runs al aangezet.

Meer agents is niet meer zekerheid. Een scepticus die een verifier controleert is nog steeds hetzelfde model dat naar dezelfde tekst kijkt. Het cookbook is daar eerlijk over: de scepticus-fase komt soms strenger terug dan het antwoordblad, en dat noemen ze een succes. Voor een investorupdate klopt die afweging. Voor iets waar strengheid ook kosten heeft, klopt hij misschien niet.

Hoe je het wel gebruikt

• Beschrijf de vorm, niet alleen de taak. De prompt in het cookbook gaat grotendeels over de opzet: extract, verifieer per item, laat een scepticus erop los, compileer. Wat je aan structuur vraagt is wat je krijgt.
• Draai eerst een dun plakje. Eén map in plaats van de hele repo, één smalle vraag in plaats van een brede. Daarna weet je wat de volle run kost.
• Stuur goedkope fases naar een klein model. Elke agent draait op je sessiemodel, tenzij het script een fase anders routeert. Mechanisch extraheren hoeft niet op je zwaarste model.
• Zet de maatvoering bewust. Vanaf versie 2.1.219 staat de instelling voor workflow-omvang standaard op medium, wat neerkomt op minder dan vijftien agents. Draai je een oudere versie, dan staat hij op unrestricted en bepaalt Claude de omvang zelf. Voor de meeste taken is small genoeg.
• Kies veel kleine agents boven een paar lange. Niet alleen voor parallellisme, ook omdat er bij onderbreken meer werk overeind blijft.
• Lees het script. Het staat op schijf en het is de eerlijkste samenvatting van wat er is gebeurd. Klopt het, sla het op als commando en dan is de orkestratie herbruikbaar.
• Begin met wat er al is. /deep-research is een ingebouwde workflow. Die laat het patroon zien zonder dat je zelf iets hoeft te beschrijven.

Hoe je het niet gebruikt

• Niet voor werk dat in één context past. Dit is de belangrijkste. Een enkele agent blijft het juiste gereedschap voor verreweg de meeste taken. Een workflow eromheen bouwen maakt het duurder en niet beter.
• Niet als sneller-knop. De winst zit in gelijke behandeling van veel items en in afgedwongen verificatie, niet in doorlooptijd.
• Niet voor iets waar je halverwege wilt bijsturen. Er is geen tussentijdse input. Wil je tussen twee stappen kijken, dan zijn het twee workflows.
• Niet met /effort ultracode als standaardstand, tenzij je de rekening bewust accepteert. Die modus plant een workflow voor elke substantiële taak in de sessie en zet de grootte-waarschuwing uit.
• Niet als vervanging van je eigen oordeel over de bron. Een gecompileerd rapport is prettig en het is ook precies de plek waar het lezen van het materiaal uit je handen glijdt.
• Niet zonder te weten waar de agents mogen komen. De subagents erven je tool-allowlist en draaien in acceptEdits. Wat je in de allowlist zet geldt dus voor de hele vloot.

Waar ik dit in mijn eigen werk zou inzetten

Dit is het deel dat ik eerlijk moet afbakenen: ik heb dit patroon nog niet in productie op mijn eigen materiaal losgelaten. Wat hieronder staat zijn de drie plekken in mijn werk waar de vorm past, geschreven als kandidaten en niet als verslag.

Redactionele controle over de hele corpus. Deze site heeft inmiddels tientallen artikelen in twee talen, met gates die overlap tussen stukken en ontbrekende kanttekeningen afvangen. Die gates zijn deterministisch: ze tellen woordgroepen en zoeken koppen. Wat ze niet kunnen is beoordelen of een bewering in een artikel nog klopt met de bron waarnaar het verwijst. Dat is precies de factcheck-vorm uit het cookbook, met mijn artikelen als beweringen en de bronregels als bronnen. Eén verifier per artikel, een scepticus erachter, één rapport terug.

Wijnbeweringen tegen de bron. Wijncontent zit vol getallen die net verschuiven: hectares, oogstjaren, appellatieregels, alcoholpercentages op een etiket. Dat is een claims-tegen-bronnen-probleem in zijn zuiverste vorm, en het is ook het soort fout dat een lezer wel opmerkt en een spellingchecker niet.

Beleidsdocumenten die naar elkaar verwijzen. In innovatiewerk bij de overheid is de moeizame taak zelden het lezen van één document, maar het naast elkaar leggen van een stuk of tien die elkaar aanhalen en soms tegenspreken. De vorm past. De vraag of dat materiaal door een model heen mag is een andere en die staat los van de techniek.

Alle drie zijn kandidaten. Geen ervan heb ik gedraaid, dus er staat hier geen agent-aantal, geen bedrag en geen verhaal over wat er misging. Dit stuk is uitleg, geen praktijkverslag. Draai ik er een, dan schrijf ik dat apart op, met de rekening erbij.

De kanttekening

De sturing verschuift naar voren. Bij een gesprek stuur je bij. Bij een workflow schrijf je de opzet vooraf en kijk je toe. Er is geen tussentijdse input, alleen stoppen. Dat maakt het resultaat reproduceerbaar en het maakt jouw prompt de enige plek waar jouw oordeel nog in het proces zit. Wie de opzet slordig beschrijft, krijgt een slordig proces netjes en consequent uitgevoerd.

De verantwoordelijkheid landt bij de allowlist. Eén beslissing over toegestane tools geldt straks niet voor één agent maar voor honderd, allemaal in acceptEdits, allemaal in dezelfde werkmap. Dat is dezelfde vraag als bij auto mode, alleen vermenigvuldigd. De runtime begrenst het aantal agents; wat die agents mogen aanraken begrens jij.

Wat er wegstroomt is het lezen zelf. De opbrengst van een factcheck-workflow is één rapport in plaats van vier bronbestanden. Dat is de bedoeling en het is de winst. Het is ook het moment waarop je oordeel over het bronmateriaal uit de keten verdwijnt, want je hebt dat materiaal niet gezien. Daar komt het verbruik bovenop: honderden agents die parallel dezelfde documenten lezen zijn geen gratis grondigheid, ze zijn grondigheid waar iemand energie en geld voor betaalt.

Wat ik zelf doe: small als maatvoering, /effort ultracode uit, en de vraag “past dit in één context” eerst stellen. Zegt het antwoord ja, dan is een workflow verspilling.

Veelgestelde vragen

Heb ik hier de Agent SDK voor nodig?

Nee. Dynamic workflows zitten in de Claude Code-runtime en werken in de CLI, de desktop-app, de IDE-extensies, non-interactief met claude -p en via de Agent SDK. Het cookbook gebruikt de Python-SDK omdat het laat zien hoe je een run vanuit code start en de voortgang streamt.

Hoe start ik er een?

In je prompt vragen is genoeg: “gebruik hier een workflow voor” werkt, net als het sleutelwoord ultracode. Met /effort ultracode plant Claude er een voor elke substantiële taak in die sessie. Vanuit de Agent SDK zet je Workflow in je allowed_tools en vraag je het in gewone woorden.

Wat kost een run?

Het cookbook noemt twee tot vier dollar voor het factcheck-voorbeeld met tien beweringen en vier bronbestanden, en meer als een fase faalt en opnieuw draait. Op een abonnement telt het verbruik mee voor je limieten. De voortgangsweergave in /workflows toont per agent het tokenverbruik terwijl de run loopt.

Wat gebeurt er als ik een run stopzet?

Hervatten kan binnen dezelfde sessie. Afgeronde agents komen uit cache, maar alleen tot de eerste agent die niet klaar was; alles wat daarna is gestart draait opnieuw. Sluit je Claude Code af, dan begint de volgende sessie de workflow vers.

Kan ik dit uitzetten?

Ja, op drie manieren: de schakelaar in /config, "disableWorkflows": true in ~/.claude/settings.json, of de omgevingsvariabele CLAUDE_CODE_DISABLE_WORKFLOWS=1. Voor een hele organisatie kan het via managed settings. Uit betekent ook dat het sleutelwoord niets meer doet en dat ultracode uit het /effort-menu verdwijnt.

Waarin verschilt dit van subagents?

In wie het plan vasthoudt. Bij subagents besluit Claude per beurt wat er wordt gedelegeerd en landt elk resultaat in zijn contextvenster. Bij een workflow bepaalt het script de volgorde, staan tussenresultaten in scriptvariabelen en komt alleen het eindantwoord terug.

Bronnen

• Anthropic, Orchestrate subagents at scale with dynamic workflows, claude-cookbooks, geraadpleegd 11 augustus 2026
• Claude Code Docs, Orchestrate subagents at scale with dynamic workflows, geraadpleegd 11 augustus 2026
• Eigen eerder werk: Eén woord startte een vloot AI-agents, 5 juni 2026

Gecontroleerd op 11 augustus 2026 tegen het cookbook en de documentatie. Het notebook heb ik gelezen, niet uitgevoerd: het kostenbedrag van twee tot vier dollar en de uitkomsten van de factcheck-run komen uit de tekst van Anthropic en niet uit eigen waarneming. De harde grenzen (16 gelijktijdige agents, 1000 per run, geen tussentijdse input, geen bestandssysteem vanuit het script) staan in de documentatie en spreken het cookbook niet tegen. De versie-eis wordt op twee plekken anders geformuleerd: het cookbook noemt CLI 2.1.154 of hoger via claude-agent-sdk 0.2.90, de documentatie noemt alleen Claude Code 2.1.154 of hoger. De drie use cases in dit stuk zijn kandidaten, geen verslag van uitgevoerde runs.