Code is de agent-runtime - waarom het 'code as harness'-paper agentic AI herdefinieert

Het paper "Code as Agent Harness, Toward Executable, Verifiable, and Stateful Agent Systems" is geen survey. Het is een architectuurpaper dat een fundamentele verschuiving beschrijft: code is niet langer alleen het artefact dat een LLM genereert, maar wordt de operationele laag waarmee agents redeneren, handelen, toestand representeren, feedback verwerken, zichzelf corrigeren en governance afdwingen.

De auteurs noemen dit "code as agent harness". Hun kernclaim: de bottleneck voor agentische autonomie zit niet alleen in de redeneercapaciteit van het basismodel, maar in de betrouwbaarheid van de harness die model-output verbindt met tools, geheugen, uitvoerbare acties, validators, sandboxes, permission boundaries, telemetry en workflows.

Dit raakt me omdat ik hetzelfde patroon zie bij elke organisatie die agentic AI serieus neemt. Ze beginnen met "welk model gebruiken we?" en eindigen met "hoe zorgen we dat dit ding niet ontspoort?" Het antwoord zit niet in het model. Het zit in de runtime.

Drie lagen, één inzicht

De auteurs formuleren drie gekoppelde lagen. De eerste is de harness interface: code fungeert als interface tussen model en wereld. Redeneren wordt executable, acties worden programmeerbaar, de omgeving wordt inspecteerbaar. Een Python-script is niet alleen output, het is een redeneerobject. Een test is niet alleen kwaliteitscontrole, het is feedback. Een trace is niet alleen logging, het is een waarneming.

De tweede laag is harness mechanisms: planning, memory, tool use, feedback-driven control. Een agent kan pas langlopende taken uitvoeren wanneer de harness bepaalt welke context relevant is, welke tools beschikbaar zijn, welke fouten gerepareerd moeten worden, welke state persistent blijft en wanneer een loop moet stoppen.

De derde laag is scaling the harness. In multi-agent settings wordt code een gedeelde workspace. Manager, planner, coder, reviewer, tester en mens opereren niet primair via chat, maar via gedeelde code-artefacten: repository state, tests, logs, traces, diffs, execution feedback. Multi-agent samenwerking faalt wanneer agents wel berichten delen, maar geen consistente, formele, queryable shared state hebben.

Van prompt engineering naar runtime engineering

Op architectuurniveau beschrijft dit paper een cybernetisch controlesysteem. Agentisch gedrag ontstaat uit een gesloten feedbackloop: model intent → code artefact → execution → observation → verification → memory update → revised plan → next action.

Deze loop is geen accessoire. Het is het systeem. Het basismodel is slechts één component. De harness bepaalt welke signalen zichtbaar zijn, welke acties toegestaan zijn, welke feedback geldt als bewijs, welke state blijft bestaan.

Daarmee is "intelligentie" in deze architectuur niet alleen cognitief, maar infrastructureel. Een zwakker model in een sterke harness kan betrouwbaarder presteren dan een sterker model in een zwakke harness. Dat is een strategische observatie die de meeste AI-adopties missen.

De green-test illusion

Een van de scherpste concepten in het paper is oracle adequacy. De auteurs stellen dat execution feedback een valse zekerheid kan geven: code draait, tests slagen, traces zien er goed uit, maar de oracle kan onvolledig zijn. Unit tests kunnen gaten hebben, static analyzers kunnen over-approximeren, simulators kunnen fysieke risico's verbergen.

De agent ziet een groene test, maar de groene test is niet de volledige specificatie. Tests zijn sensors, geen waarheid. Een sensor is alleen nuttig als je weet wat hij meet, wat hij niet meet en welke foutmarges hij heeft.

Dit is bijzonder relevant voor security en compliance. Veel agent-platforms verkopen "we run tests" als betrouwbaarheid. Dat is onvoldoende. Voor BIO2, NIS2 en de EU AI Act is "tests passed" geen bewijs van conformiteit, het is een signaal met bekende beperkingen.

Niet meer memory, maar memory governance

Het paper maakt een belangrijk onderscheid: bij long-horizon workflows is het probleem niet hoeveel memory je hebt, maar hoe memory wordt bestuurd. De auteurs beschrijven memory growth, compression-induced evidence distortion en long-term drift als problemen.

Memory zonder governance wordt een hallucination amplifier. Vector stores zonder versiebeheer worden semantische vuilnisbelten. Traces zonder compressie worden onbruikbaar. Skills zonder promotiecriteria worden pseudo-ervaring.

De implicatie: memory moet een status hebben, observed, inferred, validated, deprecated, contradicted, retired. Niet alles wat een agent onthoudt is waar. Niet alles wat in een vector store staat is actueel.

Permission tiers, niet tool-based maar effect-based

De paper beschrijft sandboxed execution als operationeel substraat en koppelt dit aan permission tiers. Een read-only tier voor browsing en static inspection. Een sandbox-edit tier voor lokale patching en test execution. Een full-access tier voor netwerk, credentials en deployment, met verplichte human-in-the-loop gates.

Het cruciale inzicht: permissioning moet niet tool-based zijn maar effect-based. Hetzelfde commando kan veilig zijn in een disposable sandbox en onveilig in een productie-repo. Permissies moeten afhangen van tool identity, argumenten, environment state, data sensitivity en expected side effects.

Voor de NIS2-context is dit direct toepasbaar. Artikel 21 van de Cyberbeveiligingswet vereist toegangscontrole op basis van risicoclassificatie. Een agent die productie-infra kan muteren valt onder een ander regime dan een agent die alleen logs leest.

De echte KPI: verified progress per unit of risk

De auteurs stellen dat final task success onvoldoende is. Een agent die een taak voltooit kan alsnog onbetrouwbaar zijn, succes wordt beïnvloed door retrieval, tool exposure, retries, test-executie, verifier-keuze en sandbox-stabiliteit. Het eindresultaat mengt modelkwaliteit, harnesskwaliteit, toolkwaliteit en taakmoeilijkheid tot één onduidelijke score.

Daarom pleiten ze voor harness-level metrics: trajectory efficiency, verification strength, recovery ability, state consistency, safety compliance en replayability. De echte KPI wordt niet "accuracy", maar "verified progress per unit of risk and cost".

Wat dit betekent voor enterprise AI

Dit paper herpositioneert agentic AI van "prompt engineering rond een model" naar "runtime engineering rond een handelend systeem". De volwassenheid van een agent-platform wordt niet bepaald door het aantal modellen, tools of skills, maar door de kwaliteit van de execution loop, state-consistentie, verificatiediepte, policy enforcement en replaybare bewijsvoering.

Voor organisaties die agentic AI inzetten onder BIO2, NIS2 of de EU AI Act is de implicatie helder: stop met optimaliseren op "meer agents" of "betere prompts". Begin met het ontwerpen van een verifieerbare, stateful, permissioned, auditable harness. De harness is niet de verpakking om het model. De harness is het product.

---

Bron: "Code as Agent Harness, Toward Executable, Verifiable, and Stateful Agent Systems", arXiv pre-print, juni 2026. Analyse gebaseerd op de architecturale claims, taxonomie en evaluatieraamwerk zoals beschreven in het paper.