Voorbij de agentic coding ladder: autonomie zonder epistemische blindheid

De volwassenste agentorganisatie is niet de organisatie met de minste mensen in de lus, maar de organisatie die per taak kan bewijzen hoeveel autonomie verantwoord is.

De discussie over agentic coding wordt vaak gevoerd alsof autonomie een lineaire bestemming is. Eerst helpt een taalmodel bij een foutmelding. Daarna schrijft het functies, bestanden en applicaties. Vervolgens werken meerdere agents parallel, verdwijnen interactieve sessies en resteert een operator die uitsluitend nog dashboards, kosten en gates bewaakt. De impliciete belofte is verleidelijk: wie verder automatiseert, klimt hoger.

Jed Arden geeft deze ontwikkeling in The agentic coding ladder is a list of things you give up een scherpere psychologische formulering. Zijn negen niveaus meten niet primair wat een agent kan, maar wat de mens gaandeweg opgeeft: zoeken, boilerplate schrijven, auteurschap, volledige diff-inspectie, kennis van de interne implementatie, ongedeelde aandacht, bereikbaarheid en uiteindelijk de praktische mogelijkheid om individuele runs te onderzoeken [1].

Dat is een waardevolle omkering. Agentic engineering schaalt inderdaad pas wanneer de mens ophoudt de impliciete runtime-control-loop te zijn. Maar precies daar ontstaat ook het kernprobleem van de ladder: menselijke afwezigheid is nog geen bewijs van systeemvolwassenheid. Zij kan het resultaat zijn van goede architectuur, maar evengoed van verlies aan zicht, controle en aansprakelijkheid.

De relevante vraag is daarom niet: welk niveau hebben we bereikt? De relevante vraag is: welke menselijke controlefunctie is losgelaten, waardoor is zij vervangen, en welk bewijs toont aan dat die vervanging minstens even betrouwbaar is?

Dit artikel ontwikkelt de ladder daarom verder tot een model voor gekalibreerde autonomie. Niet vertrouwen in de agent, maar begrensde handelingsmacht, onafhankelijke verificatie, epistemische integriteit en aantoonbare herstelbaarheid vormen daarin de grondslag.

1. De ladder meet afstand, niet volwassenheid

Ardens model bestaat uit twee bewegingen. In de eerste helft groeit de omvang van het gedelegeerde object: van uitleg en snippets naar functies, bestanden en complete applicaties. Rond niveau vijf stopt de mens in materiële zin met programmeren. De primaire bijdrage verschuift naar intentie, specificatie en beoordeling.

De negen treden, gemeten in wat je opgeeft:

1. De Student: "Ik vraag het de error uit te leggen, maar zou nooit zijn code ongelezen plakken." Opgegeven: Google / Stack Overflow.
2. De Lener: "Ik plak zijn snippets, maar ik assembleer het programma." Opgegeven: boilerplate met de hand schrijven.
3. De Reviewer: "Het schrijft functies in mijn codebase, maar ik lees elke diff voordat hij landt." Opgegeven: de auteur zijn.
4. De Delegerende: "Ik laat het een heel bestand schrijven en ik test de output in plaats van elke regel te lezen." Opgegeven: elke regel lezen.
5. De Regisseur: "Ik schrijf de spec; ik beoordeel de app op of hij draait, niet op hoe hij gebouwd is." Opgegeven: weten hoe je eigen code van binnen werkt.

Drempel 1: je stopt met code schrijven. Boven deze lijn is er geen kleinere eenheid meer om over te dragen.

6. De Jongleur: "Ik heb twee of drie sessies en ik wip ertussen." Opgegeven: onverdeelde focus.
7. De Bottleneck: "Ik verlies bij welke sessie wat doet. Ik ben nu de beperking, niet het model." Opgegeven: het geloof dat aandacht schaalt.
8. De Dispatcher: "Ik start runs waar ik niet in zit en lees daarna de log; ze kunnen me niets meer vragen." Opgegeven: bereikbaar zijn.
9. De Operator: "Het volume betekent dat ik geen enkele individuele run kan inspecteren; ik leef op dashboards, gates en kosten." Opgegeven: de optie om een individuele run te inspecteren.

Drempel 2, de beslissende overgang: het gesprek wordt een dispatch. De agent kan niet langer terugvallen op een beschikbare mens wanneer intentie, context of werkelijkheid ambigu blijkt. Een dialoog wordt een opdracht.

Deze overgang kan formeel worden beschreven. Voor een taak (t) definiëren we:

D(t) = afstand tussen menselijke intentie en operationele uitvoering

Ardens ladder ordent taken hoofdzakelijk op een toenemende D(t). Maar afstand is niet hetzelfde als autonomievolwassenheid. Een bruikbaar volwassenheidsbegrip vereist minimaal vier aanvullende eigenschappen:

M(t) = f(S_t, A_t, V_t, R_t)

waarbij:

• S_t staat voor de kwaliteit en toetsbaarheid van de specificatie;
• A_t voor de begrenzing van bevoegdheden en het potentiële effect;
• V_t voor onafhankelijke verificatie en observeerbaarheid;
• R_t voor aantoonbare herstelbaarheid.

Een taak kan dus een grote afstand D(t) hebben en toch een lage volwassenheid M(t). Een headless agent met brede productiebevoegdheden, een onvolledige opdracht en een zelfgeschreven test is geen niveau-acht-succes. Het is een onbeheerst experiment.

De renunciatie-test: zoek je band, niet je trede

Arden voegt hier een streng criterium aan toe dat de ladder eerlijk houdt: zoek niet je trede, zoek je band. Lees van trede 1 omhoog. Elke trede noemt iets dat je hebt opgegeven. Blijf klimmen zolang de renunciatie echt en permanent waar is van jou, niet "ik zou kunnen" maar "ik heb". De eerste trede waarvan je de renunciatie niet echt hebt gemaakt, waar je eerlijk zou zeggen "nee, dat doe ik nog", is je plafond. Je woont op de trede eronder.

Dat is streng met opzet. De infrastructuur voor een trede bezitten zet je er niet op. Arden: "Ik heb een fleet-orchestrator gebouwd; ik kan trede 9 elke middag bereiken. Maar ik heb niet opgegeven om in individuele runs te duiken; ik doe dat nog steeds, constant, dus ik woon niet op 9. Ik woon lager en reik hoger." Niemand staat op één trede; de renunciatie-test houdt je alleen eerlijk over welke.

Hoger is niet beter, het is zwaarder

Een ladder nodigt uit om hem als ranking te lezen: kom bovenaan. Deze niet. Elke trede hoger koopt capability, maar voegt ook overhead toe: specificatie, planning, scaffolding, verificatie. Die overhead betaalt zich alleen terug boven een bepaalde taakgrootte. Dus elke trede heeft een break-even: het kleinste stuk werk dat de moeite waard is om erheen te brengen, en die break-even stijgt naarmate je klimt.

Arden draait headless fleets, maar zou er nooit een op een one-line typo richten. Die fix zo goed specificeren voor een worker die niets kan vragen, en dan wachten op orchestration en gates om het te bevestigen, kost meer dan het bestand openen en het karakter zelf typen op trede 3. Het is een goederentrein charteren om een brief te sturen. De vaardigheid die de ladder bovenaan beloont is dus niet hoog wonen, maar per taak de trede kiezen, en eerlijk blijven dat veel werk klein is en klein werk op een lage trede hoort.

2. De fundamentele verdienste: aandacht schaalt niet

Arden identificeert terecht dat menselijke aandacht de eerste harde schaalgrens vormt. Eén agent kan interactief worden gecorrigeerd. Twintig gelijktijdige agents maken van die correctie een wachtrijprobleem. Iedere nieuwe worker produceert niet alleen code, maar ook claims, uitzonderingen, conflicten, reviewwerk en mogelijke herstelacties.

De marginale opbrengst van een extra agent is daarom niet gelijk aan zijn bruto-uitvoer:

ΔW = O_a − (C_c + C_v + C_r + C_x)

Hier staat O_a voor agentoutput, C_c voor coördinatiekosten, C_v voor verificatiekosten, C_r voor herstelkosten en C_x voor kosten van contextwisseling en conflicten. Zodra de som van deze kosten sneller groeit dan de output, neemt de feitelijke throughput af terwijl het dashboard meer activiteit toont.

Ardens eigen ervaringen met ongeveer twintig headless agents ondersteunen dit. De dominante incidenten ontstonden niet primair in het taalmodel, maar in de seams rondom het model: worker-startup, queues, retries, leases, deployment, state, testisolatie en hostinfrastructuur [2]. Dat patroon is herkenbaar uit gedistribueerde systemen. Op schaal verandert falen van karakter. Een individuele fout wordt een systemische interactie tussen op zichzelf plausibele componenten.

Dit leidt tot onze eerste hypothese.

H1, de assurance-substitutiehypothese. Een stijging in agentautonomie verbetert de netto engineeringprestatie alleen wanneer de weggenomen menselijke controlefunctie wordt vervangen door een aantoonbaar sterkere, schaalbare systeemcontrole.

H1 is falsifieerbaar. Wanneer teams menselijke review verminderen zonder een stijging in escaped defects, security findings, herstelduur of semantisch onjuiste acceptaties, kan de vervangende controle effectief worden genoemd. Stijgen deze indicatoren wel, dan was geen sprake van volwassen delegatie, maar van assurance debt.

3. "Loslaten" zonder substitutie is georganiseerde blindheid

Iedere trede van de ladder impliceert het verdwijnen van een menselijke activiteit. Die activiteit had echter een functie. Code lezen detecteerde inconsistenties. Beschikbaar zijn loste ambiguïteit op. Implementatiedetails kennen maakte architectuurafwijkingen herkenbaar. Individuele runs inspecteren onthulde zeldzame fouten die in gemiddelden verdwijnen.

Een verantwoorde transitie vereist daarom functionele substitutie:

Losgelaten menselijke functie	Vereiste systeemvervanging
Zelf code schrijven	Expliciete intentie en toetsbare acceptatiecriteria
Iedere regel lezen	Risicogerichte review, SAST, tests en invarianten
Internals volledig kennen	Architectuurcontracten, provenance en traceerbaarheid
Live vragen beantwoorden	Ambiguïteitsclassificatie en formele stopcondities
Agents handmatig corrigeren	Begrensde retries, circuit breakers en replanning
Individuele runs standaard bekijken	Sampling, anomaly detection, replay en forensics
Uitkomsten beoordelen	Onafhankelijke evaluator buiten het generatiepad
Herstel handmatig uitvoeren	Geteste rollback of compensating transaction

Dit levert H2 op.

H2, de non-equivalentiehypothese. Menselijke afwezigheid en operationele volwassenheid zijn niet equivalent.

Een systeem mag pas als volwassener worden geclassificeerd als niet alleen minder menselijke interventie optreedt, maar ook de foutdetectiekans, bewijssterkte en herstelbaarheid minstens gelijk blijven. De ladder beschrijft dus een noodzakelijke organisatorische verschuiving, maar niet de voldoende voorwaarden voor veilige autonomie.

4. Vertrouwen is geen eigenschap van het model

In een vervolgartikel formuleert Arden een sterker principe: vertrouwen is geen maatstaf voor hoe goed een agent waarschijnlijk oordeelt, maar voor hoe goedkoop het is wanneer hij ongelijk heeft [3]. Dat verschuift de discussie van psychologische betrouwbaarheid naar systeemontwerp.

Deze correctie is essentieel. Modelbenchmarks zijn populatiestatistieken. Zij zeggen weinig over de concrete fout van een specifieke agent in een specifieke repository, met specifieke tools, privileges, data en downstream-effecten. Zelfs een model met hoge gemiddelde prestaties kan bij één zeldzame combinatie een catastrofale handeling voorstellen.

Voor handeling (a) kan het risico vereenvoudigd worden weergegeven als:

Risk(a) = P(F_a | C_a) × I(F_a) × E_a

waarbij P(F_a | C_a) de conditionele foutkans binnen de context is, I(F_a) de impact van die fout en E_a de blootstelling of blast radius. Agentautonomie mag niet rechtstreeks uit een modelschatting volgen. Zij moet worden afgeleid uit de combinatie van foutimpact, bevoegdheid, detecteerbaarheid en herstelbaarheid.

Dit sluit aan op Zero Trust: geen impliciet vertrouwen op basis van identiteit, reputatie of eerdere prestaties. Iedere taak en iedere toolcall moet expliciet worden geautoriseerd op basis van identiteit, context, beleid en minimaal noodzakelijke bevoegdheid.

H3, de bounded-authority-hypothese. De schade van agentfouten wordt effectiever gereduceerd door begrensde bevoegdheden dan door marginale verbeteringen in modelnauwkeurigheid.

H3 kan worden getoetst met fault injection. Geef vergelijkbare agents eerst brede en daarna taakgebonden capabilities. Meet niet alleen het aantal fouten, maar vooral maximale blast radius, time-to-containment en herstelkosten. Wanneer dezelfde modelkwaliteit bij fijnmazige capabilities structureel minder schade produceert, wordt H3 ondersteund.

5. Waarom Git en GitOps geen universele undo-knop zijn

Ardens herstelbaarheidsprincipe is krachtig, maar zijn indeling van code en declaratieve infrastructuur als vrijwel kosteloos omkeerbaar is te optimistisch. Versiebeheer herstelt repositorytekst. Het herstelt niet automatisch alle effecten die door die tekst zijn veroorzaakt.

Een gereverte codewijziging kan ondertussen:

• gegevens hebben geëxfiltreerd;
• een schadelijke dependency of artifact hebben gepubliceerd;
• een databaseschema onomkeerbaar hebben gemigreerd;
• een autorisatierelatie hebben uitgebreid;
• persoonsgegevens naar een externe verwerker hebben gestuurd;
• onjuiste beslissingen of communicatie hebben veroorzaakt;
• andere repositories of consumers op een fout contract hebben laten voortbouwen.

Hetzelfde geldt voor GitOps. Een controller kan configuratie terugbrengen naar een gewenste toestand. Hij kan niet zonder meer data, vertrouwen, geheimhouding, juridische positie of externe verwachtingen herstellen.

We moeten daarom onderscheid maken tussen drie vormen van reversibiliteit:

• Syntactische reversibiliteit: de bron of configuratie kan worden teruggezet.
• Operationele reversibiliteit: de runtime kan aantoonbaar naar een bekende toestand worden hersteld.
• Semantische reversibiliteit: alle relevante effecten op data, mensen en externe systemen kunnen worden gecompenseerd.

Alleen de derde vorm is voldoende voor een brede autonomieclaim.

H4, de effectgerichte herstelhypothese. De herstelbaarheid van een agenthandeling wordt bepaald door haar volledige causale effectketen, niet door het type artifact waarop de agent schrijft.

Een restore-test die uitsluitend bevestigt dat een repository of manifest teruggezet kan worden, falsifieert H4 niet. Daarvoor moet worden aangetoond dat ook state, externe afhankelijkheden, audit trail, vertrouwelijkheid en downstream-consumers correct zijn hersteld.

6. Niveau negen en de epistemologie van dashboards

Op niveau negen is de hoeveelheid werk volgens Arden zo groot dat de operator individuele runs niet meer kan volgen. De operator leeft op dashboards, gates en kosten. Dat is operationeel begrijpelijk, maar epistemisch gevaarlijk.

Aggregaten comprimeren werkelijkheid. Iedere compressie verwijdert informatie. Een gemiddelde succesratio kan tegelijkertijd samengaan met:

• een zeldzame catastrofale fout;
• systematische benadeling van een kleine gebruikersgroep;
• silent fallback naar een verboden provider;
• een evaluator die dezelfde blinde vlek als de generator heeft;
• een false green waarbij het bewijs technisch geldig maar semantisch irrelevant is;
• ontbrekende temporal validity, terwijl oude bronnen correct geciteerd blijven;
• een identity mismatch achter een correct ogende taakstatus.

Dit is het verschil tussen observability en assurance. Observability vertelt wat het systeem rapporteert. Assurance onderzoekt of die rapportage de relevante werkelijkheid correct representeert.

Daarom moet niveau negen worden geherformuleerd:

De operator hoeft niet iedere run te inspecteren, maar het systeem moet iedere materiële beslissing reproduceerbaar, herleidbaar en onafhankelijk toetsbaar houden.

H5, de replayability-hypothese. Fleet-scale autonomie is alleen verantwoord wanneer individuele runs niet routinematig worden bekeken, maar wel volledig reconstrueerbaar blijven.

De falsificatiecriteria zijn concreet. H5 faalt wanneer bij een incident niet kan worden vastgesteld: welke identiteit handelde, op basis van welke input, met welk model en beleid, via welke tools, met welke artifacts, welke evaluator de uitkomst accepteerde en welke downstream-effecten ontstonden.

"Niet inspecteren" kan een rationele operationele keuze zijn. "Niet kunnen inspecteren" is verlies van bestuurbaarheid.

De mist boven trede 9

Arden weigert te benoemen wat trede 10 is, en dat is geen ontwijking maar de meest rigoureuze claim op de pagina. Kijk naar het patroon: elke trede geeft iets op dat de trede eronder als niet-onderhandelbaar beschouwde. Vraag de Reviewer op trede 3 om zich voor te stellen de diff niet meer te lezen en hij zegt dat dat de hele baan is. Vraag de Bottleneck op trede 7 om zich onbereikbaar voor te stellen en hij kan het niet eens parsen. Vanuit elke trede is de volgende overgave onzichtbaar, omdat je nog op het ding staat dat je gaat opgeven.

Trede 10 is dus gedefinieerd door zijn vorm, niet zijn inhoud: het is wat op trede 9 nog load-bearing voelt, het ding dat je het hardst zou weerstaan om op te geven. "Fleets die hun eigen werk toewijzen" of "fleets die zichzelf tunen" zijn het niet, want die kan hij zich al voorstellen. Het is misschien menselijke intentie aan de wortel van het werk, menselijke aansprakelijkheid voor de output, of de mens als degene die nog beslist wat "goed" betekent. Hij wil het niet noemen, want als hij het correct kon benoemen, zou het geen 10 zijn.

Voor de publieke sector is die mist geen speculatieve futuristische trede, maar een governance-vraag die al besloten wordt door elke organisatie die stilzwijgend een trede hoger klimt zonder de renunciatie expliciet te maken.

7. Van één ladder naar een multidimensionaal autonomiemodel

Eén niveau voor een volledig agentsysteem is te grof. Dezelfde agent kan zelfstandig unit tests schrijven, maar mag niet zelfstandig productie-IAM wijzigen of een juridisch relevante boodschap publiceren. Autonomie moet daarom per taak, capability en effect worden bepaald.

Voor DjimIT stellen we vier onafhankelijke assen voor:

As	Centrale vraag
Delegation	Hoe groot is de gedelegeerde werkeenheid en afstand tot de mens?
Authority	Welke resources en effecten kan de agent daadwerkelijk bereiken?
Assurance	Hoe sterk en onafhankelijk wordt de uitkomst geverifieerd?
Recoverability	In welke mate zijn de volledige effecten aantoonbaar herstelbaar?

Een taak krijgt daarmee geen flatterend enkel niveau, maar een profiel:

TASK_PROFILE
delegation=D8
authority=A3
assurance=V4
recoverability=R5
external_effect=HIGH
human_authorization=REQUIRED

Een agent kan dus op niveau acht worden gedispatcht, terwijl zijn handelingsmacht op niveau drie blijft. Dat is geen beperking van agentic engineering, maar de kern van secure-by-design autonomie.

H6, de calibrated-autonomy-hypothese. Een dynamisch autonomieniveau per taak levert een betere verhouding tussen snelheid, kwaliteit en risico dan één statisch autonomieniveau voor een team, agent of fleet.

H6 kan worden getoetst door taakportfolio's te vergelijken. Meet doorlooptijd, escaped defects, menselijke interventies, herstelkosten, policy violations en bewijscompleetheid bij statische en dynamische autorisatie. De hypothese faalt wanneer dynamische selectie structureel meer overhead veroorzaakt zonder aantoonbare risicoreductie of kwaliteitswinst.

8. Threat model voor agentic coding op fleet-schaal

Een volwassen ontwerp moet niet alleen rekening houden met een "domme" agent, maar met fouten en aanvallen over de volledige keten.

Beschermde assets:

• broncode, modellen en build-artifacts;
• credentials, signing keys en workload identities;
• productie- en trainingsdata;
• software supply chain en dependency graph;
• beslislogs, claim ledgers en assurance-evidence;
• reputatie, compliancepositie en publieke communicatie;
• kostenbudget en schaarse compute-capaciteit.

Dominante dreigingen:

• Intent drift: de uitvoering blijft lokaal plausibel maar wijkt semantisch af van het doel.
• Prompt- en contextinjectie: repository-inhoud, documentatie of tooloutput manipuleert het agentbeleid.
• Capability escalation: een worker verkrijgt meer rechten dan de taak vereist.
• Identity confusion: acties zijn niet aantoonbaar aan de juiste agent, taak of menselijke opdrachtgever gekoppeld.
• Supply-chain compromise: gegenereerde code introduceert kwaadaardige packages, artifacts of buildstappen.
• Evaluator collusion: generator en grader delen model, context of foutpatroon en produceren een false green.
• State corruption: retries, dubbele claims of onjuiste recovery beschadigen de autoritatieve toestand.
• Silent fallback: een ongewenste provider, model of tool wordt gebruikt zonder zichtbare beleidsbreuk.
• Resource exhaustion: structureel onuitvoerbare taken blijven tokens, tijd en compute consumeren.
• Irreversible externality: publicatie, verwijdering, betaling of communicatie veroorzaakt effecten buiten de herstelgrens.

De systeemgrens moet daarom breder zijn dan het model en zijn prompt. De orchestrator, registry, queue, identity provider, policy engine, tool gateways, evaluators, artifact store, telemetry en menselijke autorisatielaag behoren allemaal tot de trusted computing base. Hoe groter die basis, hoe meer bewijs nodig is om autonomie te rechtvaardigen.

9. Referentiearchitectuur voor gekalibreerde autonomie

Voor het DjimIT-ecosysteem volgt hieruit een assurance-first architectuur met gescheiden verantwoordelijkheden:

Intent and Specification Plane. Zet menselijke intentie om in claims, constraints, acceptatiecriteria, verboden uitkomsten en stopcondities. Ambiguïteit wordt niet verborgen in prose, maar geclassificeerd als oplosbaar, escaleerbaar of blokkerend.

Identity and Capability Plane. Iedere agent en workload ontvangt een verifieerbare identiteit. Tooltoegang verloopt via kortlevende, taakgebonden capabilities met least privilege, budget, TTL en expliciete resource scope. OAuth 2.0 en OIDC kunnen identiteit en delegatie ondersteunen, mits token audience, sender constraint, rotatie, intrekking en volledige lifecycle worden afgedwongen.

Orchestration Plane. Verzorgt capability-aware dispatch, leases, idempotency, concurrency control, retrybudgetten en circuit breakers. Een structurele fout wordt niet behandeld als een tijdelijke fout. NOT_PROVEN en BLOCKED zijn terminale veiligheidsstaten totdat nieuw bewijs beschikbaar is.

Execution Plane. Workers opereren in geïsoleerde workspaces, met afgeschermde netwerken, gescheiden testdata en immutable baselines. Directe productietoegang is niet de standaardroute. Wijzigingen passeren policy-controlled pipelines.

Evidence and Provenance Plane. Legt input, modelversie, policies, toolcalls, code, dependencies, tests, evaluatoruitspraken en downstream-effecten vast. Evidence wordt gekoppeld aan concrete claims, inclusief authority, temporal validity, polarity en source completeness.

Independent Assurance Plane. Scheidt generator, verifier en autorisator. De evaluator krijgt niet automatisch dezelfde context of hetzelfde model als de generator. Deterministische gates, adversarial canaries en onafhankelijke challengers reduceren gecorreleerde fouten en Goodhart-effecten.

Policy Decision and Enforcement Plane. Een Policy Decision Point bepaalt het toegestane autonomieniveau. Een afzonderlijk Policy Enforcement Point begrenst de feitelijke toolcall. Een rapport met REJECT dat de handeling technisch niet stopt, is observatie en geen enforcement.

Recovery and Accountability Plane. Rollback, restore en compensatie worden vooraf ontworpen en periodiek getest. Niet-herstelbare externe effecten vereisen expliciete menselijke autorisatie. Accountability blijft menselijk en organisatorisch verankerd, ook wanneer uitvoering volledig geautomatiseerd is.

10. Tien minimale gates voor headless uitvoering

Een taak mag pas zonder bereikbare mens worden uitgevoerd als minimaal de volgende claims bewezen zijn:

Gate	Te bewijzen eigenschap
G1, Intent	Doel, scope en verboden uitkomsten zijn expliciet
G2, Specification	Acceptatiecriteria zijn onafhankelijk toetsbaar
G3, Identity	Opdrachtgever, agent, model en workload zijn herleidbaar
G4, Capability	Bevoegdheden zijn minimaal, tijdgebonden en taakgebonden
G5, Isolation	Werkruimte, netwerk en testdata zijn aantoonbaar afgeschermd
G6, Verification	Deterministische tests en onafhankelijke evaluatie bestaan
G7, Provenance	Claims, evidence, dependencies en artifacts zijn traceerbaar
G8, Recoverability	Rollback of compensatie is daadwerkelijk getest
G9, Failure safety	Timeouts, retrybudget, circuit breaker en fail-closed gedrag werken
G10, Externality	Externe en niet-herstelbare effecten zijn vooraf geautoriseerd

Voor herstelbare taken kan headless uitvoering worden toegestaan wanneer G1 tot en met G9 aantoonbaar PASS zijn. G10 blijft een afzonderlijke autorisatiegrens. Bij FAIL, BLOCKED, UNKNOWN of NOT_PROVEN daalt het systeem automatisch af naar een lager autonomieniveau of stopt het volledig.

Dit is een belangrijk verschil met menselijke escalatie als standaardoplossing. Een agent die geen antwoord kan krijgen, hoeft niet vrij te improviseren. Hij kan ook veilig begrenzen, bewijs verzamelen, een checkpoint produceren en stoppen.

11. Operationele KPI's die autonomie niet belonen om haarzelf

Fleet-throughput, aantal gesloten taken en kosten per run zijn nuttig, maar gemakkelijk te gamen. Zij meten activiteit, niet noodzakelijk waarde of waarheid. Een volwassen scorecard combineert daarom:

• first-pass verified success rate;
• escaped-defect-rate;
• critical false-green count;
• policy-violation rate;
• evidence-completeness en provenance-integriteit;
• mean time to detect en mean time to safe state;
• successful restore rate;
• retry amplification en token waste;
• percentage taken met correct gekalibreerd autonomieniveau;
• downstream impact van onjuiste maar geaccepteerde claims.

De belangrijkste metriek is niet hoeveel mensen uit de lus zijn verwijderd, maar hoeveel taken zonder menselijke runtime-interventie aantoonbaar correct, beleidsconform en herstelbaar zijn afgerond.

12. Wat dit betekent voor leiderschap en governance

Agentic coding is geen toolingvraagstuk dat uitsluitend bij ontwikkelteams hoort. Vanaf het moment dat agents zelfstandig taken claimen, capabilities gebruiken en artifacts produceren, ontstaat een nieuw operationeel systeem. Daarmee verschuiven verantwoordelijkheden:

• Software engineering specificeert architectuurcontracten en tests.
• Platform engineering bouwt identity, isolation en policy enforcement.
• SRE beheert leases, retries, telemetry, capacity en recovery.
• Security modelleert capabilities, supply-chainrisico's en aanvalspaden.
• Privacy en legal bewaken data- en externe-effectgrenzen.
• AI governance bepaalt bewijsstandaarden, menselijke autorisatie en accountability.
• Management stelt risk appetite vast en voorkomt dat throughput als surrogaat voor waarde fungeert.

Het agentsysteem moet daarbij als productie-infrastructuur worden behandeld, ook wanneer het "alleen ontwikkelwerk" uitvoert. Een fleet die twintig repositories kan wijzigen, dependencies kan ophalen en pipelines kan starten, bezit een materiële aanvalsvlakte en een substantiële blast radius.

De publieke-sector-translatie

Voor de Nederlandse overheid is dit raamwerk geen abstractie maar een assurance-verplichting. Elke trede van de ladder is een assurance die je verliest zonder expliciete beslissing, en de governance-vraag is wat die verloren assurance moet opvangen:

• Trede 3 (auteurschap opgeven) is waar de code in je repository niet meer door een mens is geschreven. Voor een auditor is dat een provenance-verandering: de vraag "wie heeft dit geschreven?" wordt "welke prompt, welke agent, welk model, welke dataset?". Zonder provenance-integriteit in agentic workflows is die vraag niet beantwoordbaar.
• Trede 5 (weten hoe je eigen code werkt opgeven) raakt direct de governed AI-assisted engineering: als je niet meer weet hoe het werkt, kan de review-laag niet langer op inhoudelijke kennis vertrouwen en moet ze op gedwongen menselijke oversight overschakelen.
• Drempel 2 (het gesprek wordt een dispatch) is de kritieke governance-crossing. Zodra de agent je niets meer kan vragen, verdwijnt de laatste ingebouwde human-in-the-loop. Alle controles die eerder impliciet waren moeten nu expliciet geconstrueerd worden. Dit is precies de agentic delivery control plane: verifieerbare gates die de afwezige mens vervangen.
• Trede 9 (individuele run inspecteren opgeven) is waar je alleen nog op aggregaten leeft. Voor de publieke sector is dat een aansprakelijkheidsdrempel die vereist dat je per taakklasse bepaalt welke trede acceptabel is, zoals in een governance-raamwerk voor autonomieniveaus.

En net als in Ardens raamwerk geldt: hoger is niet beter, het is zwaarder. Voor de publieke sector is de overhead van elke hogere trede (specificatie, planning, verificatie, audit-trails, assurance-gates) niet alleen technisch maar ook juridisch. De break-even van een trede is het kleinste stuk werk dat de extra governance-kosten waard is. De vaardigheid die de overheid nodig heeft is niet "zo hoog mogelijk klimmen", maar per taakklasse de laagste trede kiezen die de governance-verplichting nog klaart. Een eenmalige configuratiefix op een laag risico systeem op trede 8 of 9 brengen is een goederentrein charteren om een brief te sturen, met aansprakelijkheid erbovenop.

Conclusie: het hoogste niveau is kunnen afdalen

Ardens ladder benoemt scherp wat veel organisaties nog niet onderkennen: de mens kan niet tegelijk opdrachtgever, contextprovider, reviewer, exception handler en herstelmechanisme blijven wanneer agents op schaal werken. De operator moet uit de directe control-loop verdwijnen.

Maar de lege plek die daardoor ontstaat, moet architectonisch worden ingevuld. Anders wordt menselijke aandacht niet vervangen, maar verwijderd. En dan is niveau negen geen volwassen autonome operatie, maar epistemische blindheid met een dashboard.

De volgende generatie agentic engineering moet daarom niet vragen hoeveel autonomie een model verdient. Zij moet per taak bewijzen:

• welke intentie normatief leidend is;
• welke bevoegdheid strikt noodzakelijk is;
• welke claims onafhankelijk zijn geverifieerd;
• welke onzekerheid en contradictie nog bestaan;
• welke effecten werkelijk herstelbaar zijn;
• welke beslissing menselijk moet blijven.

De volwassenste organisatie opereert niet permanent op het hoogste niveau. Zij beschikt over alle niveaus en kiest per taak het laagste niveau dat voldoende uitvoeringskracht biedt, en het hoogste niveau dat het beschikbare bewijs verantwoord maakt.

De werkelijke top van de agentic coding ladder is daarom niet dat de mens steeds verder verdwijnt. Het is dat het systeem weet wanneer menselijke aanwezigheid essentieel blijft, en automatisch afdaalt zodra het bewijs voor autonomie ontbreekt.

Gerelateerd: governed AI-assisted engineering met gedwongen menselijke oversight, de agentic delivery control plane, provenance-integriteit in agentic workflows, en OpenEnv als agentic RL-infrastructuur.

Bronnen

1. Jed Arden, The agentic coding ladder is a list of things you give up, 23 mei 2026.
2. Jed Arden, What breaks when you run twenty agents at once, 22 juli 2026.
3. Jed Arden, Trust is a property of the system, not the agent, 26 juli 2026.