Agentic Delivery Control Plane — waarom software engineering niet eindigt, maar verschuift naar control discipline

Op 4 juni 2026 verscheen op arXiv de paper The End of Software Engineering: How AI Agents Are Fundamentally Restructuring the Software Paradigm. De auteur, Zhenfeng Cao van het Chinese Lingxi Intelligent Investment, stelt dat agentic systems niet zomaar een nieuw gereedschap zijn, maar een fundamentele herstructurering van software zélf. Code wordt niet langer het primaire persistente artefact. Beslissingslogica ontstaat pas tijdens runtime. De persistente waarde verschuift van broncode naar het agent-systeem: het model, de tools, het geheugen, de planning, de observability en de governance.

De paper is strategisch sterk, maar architectonisch onvolledig. Hij identificeert de paradigmaverschuiving, maar levert niet de productie-architectuur. De juiste vraag is niet: "heeft deze paper gelijk dat software engineering eindigt?" De juiste vraag is: welk operating model, welke architectuur, welke controls en welke executiebacklog heb je nodig om agentic engineering veilig, meetbaar en productiewaardig te maken?

Dit artikel geeft het antwoord. Het bouwt voort op mijn eerdere analyse van agent-governance in de Microsoft-stack, de vierlagen MCP-security control plane, en de digitale autonomie-referentiearchitectuur voor de Belastingdienst. Samen vormen deze artikelen een groeiend lichaam van operationele architectuurkennis voor autonome systemen in gereguleerde omgevingen.

De kernthese, gecorrigeerd

De paper stelt dat agentic systems A = (M, T, M, Π), bestaande uit een LLM als redeneerkern, externe tools, geheugen en een planningsmechanisme, fundamenteel anders zijn dan traditionele software S = (C, D, E) waarbij D de statische, vooraf door mensen geschreven beslislogica is. In agentic systems wordt code gegenereerd, uitgevoerd, gevalideerd en weer irrelevant verklaard, alles tijdens runtime.

Dat klopt als denkkader. Maar de conclusie "software engineering eindigt" is onjuist.

Software engineering eindigt niet, het primaire object verschuift. Het object was "correcte code". Het wordt: correcte, begrensde, observeerbare actie-trajecten van agents. Dat is een fundamenteel ander assurance-probleem. En dat probleem vraagt om een nieuwe architectuurlaag: de Agentic Delivery Control Plane.

De paper erkent zelf dat benchmarks zoals EvoClaw laten zien dat agent-performance klapt van ＞80% op geïsoleerde taken naar maximaal 38% op continue software-evolutie, juist door context drift, error propagation, technical debt blindness en verification fidelity. De correcte conclusie is dus niet "laat agents autonoom software bouwen", maar: bouw een gecontroleerd agentic execution system dat autonomie gradueel toekent op basis van bewijs, risico en observability.

Het assurance-probleem: van artefactcontrole naar trajectory assurance

Traditionele software assurance vraagt: voldoet deze code aan requirements, security, performance en onderhoudbaarheid?

Agentic assurance vraagt iets diepers: voldoet de volledige actiegeschiedenis van een agent aan intentie, beleid, bevoegdheid, dataclassificatie, budget, veiligheidsinvarianten en acceptatiecriteria?

Formeel modelleer je een agentic delivery run als:

Run R = (W, C, M, T, P, E, G, L)

Component	Betekenis
W	Work order: doel, scope, constraints, acceptatiecriteria
C	Context: repo, tickets, documentatie, logs, policies, architectuurbesluiten
M	Model: LLM of ensemble van modellen
T	Tools: shell, GitHub, cloud APIs, databases, scanners
P	Policy: toegestane acties, verboden acties, approvals, budgetten
E	Evaluation: tests, scans, semantic checks, human review
G	Governance: rollen, risicoacceptatie, audit, compliance
L	Learning layer: memory, skills, post-run verbeteringen

Een agent produceert geen enkelvoudige output, maar een traject:

τ = [(observe, reason, plan, act, verify, update_state)]

Het assurance-probleem: voor elke actie in traject τ moet gelden dat de actie bevoegd, noodzakelijk, proportioneel, observeerbaar, terugdraaibaar of expliciet geaccepteerd is, en dat het eindresultaat voldoet aan business, security en compliance criteria. Dat is de stap die de paper onvoldoende uitwerkt. En precies daar zit de operationalisering.

Code verdwijnt niet, code zakt naar lagere lagen

Een hardnekkige misvatting die de paper voedt: code wordt onbelangrijk. Dat is onjuist. Code verschuift:

Oude wereld	Nieuwe agentic wereld
Applicatiecode is primaire waarde	Agent capability is primaire waarde
Requirements worden handmatig vertaald naar code	Intent contracts sturen agents
Tests valideren code achteraf	Evals sturen uitvoering continu
CI/CD bouwt en deployt artefacten	Agentic pipeline plant, voert uit, test, verklaart en leert
Engineers schrijven implementatie	Engineers ontwerpen constraints, evaluaties, policies en tool boundaries
Governance zit rond SDLC	Governance zit in de runtime control plane

De strategische waarde verschuift naar zeven nieuwe primitieven: contracts (wat mag het systeem doen?), tools (welke real-world acties zijn mogelijk?), memory (welke context wordt hergebruikt?), evals (hoe weet je dat het goed is?), policy (wat mag nooit gebeuren?), observability (kun je achteraf bewijzen wat er gebeurde?), en skills (welke procedures worden herbruikbaar en evolueerbaar?).

Dit is waarom een agentic platform zonder control plane gevaarlijk is: je geeft runtime beslissingscapaciteit aan een systeem zonder dezelfde governance-rijpheid als je SDLC.

De Agentic Delivery Control Plane: tien lagen

De operationele vertaling van de paper is geen losse agent, geen enkel model, en geen IDE-plugin. Het is een gelaagde architectuur:

Laag	Doel	Minimale implementatie	Volwassen implementatie
Intent layer	Werk expliciet maken	Work-order template	Contractschema met risico, policy, DoD, rollback
Context layer	Betrouwbare context leveren	Repo docs en tickets	Context graph, provenance, freshness score
Planning layer	Taken decomponeren	Single-agent plan	DAG met checkpoints, approvals en retries
Orchestration layer	Agents coördineren	Eén coding agent	Leader-worker agents met gescheiden rollen
Tool gateway	Acties begrenzen	Handmatige toolkeuze	Policy-bound tools, OIDC, allowlists, audit
Execution layer	Veilig uitvoeren	Lokale sandbox	Ephemeral containers, egress control, secrets isolation
Evaluation layer	Kwaliteit meten	Unit tests	Unit, integration, SAST, SCA, IaC, semantic evals
Governance layer	Risico sturen	Human review	Risk-based autonomy, approvals, AI register
Observability layer	Herleidbaarheid	Logs	Full traces, immutable audit, decision provenance
Learning layer	Verbetering borgen	Prompt snippets	Signed skills, versioning, promotion pipeline

De workflow: een mens of systeem maakt een work order → de control plane classificeert risico, data, impact en autonomieklasse → de context layer haalt geprovenanceerde context op → de planner maakt een plan met expliciete stappen en checkpoints → de policy engine bepaalt welke tools, bestanden, netwerken en secrets toegankelijk zijn → de agent voert uit in een sandbox → elke actie wordt gelogd als trace event → de evaluation layer draait de volledige test- en security-harness → de agent levert een diff, bewijsset en risicoverklaring → menselijke review of automatische gate beslist over merge, deploy of rollback.

Cruciaal: de learning layer mag pas na promotie skills of memory aanpassen. Self-improvement zonder promotiepijplijn is governance bypass.

Het work-order contract: de ontbrekende schakel

Zonder expliciete work orders blijven agent-taken prompt-fragmenten, ongeschikt voor productie. Een minimaal schema:

work_order:
  id: WO-2026-0001
  title: "Fix failing OAuth token refresh test"
  business_intent: "Restore stable CI for authentication module"
  repository: "example/auth-service"
  scope:
    allowed_paths: ["src/auth/**", "tests/auth/**"]
    denied_paths: [".github/workflows/**", "infra/**", "secrets/**"]
  data_classification: "internal"
  risk_tier: "medium"
  autonomy_level: "L2_PR_ONLY"
  constraints:
    - "No dependency upgrades unless explicitly justified"
    - "No production configuration changes"
    - "No network calls except package registry read-only"
  required_evidence:
    - "Unit tests pass"
    - "Relevant integration tests pass"
    - "No new high or critical SAST findings"
    - "Diff explanation"
    - "Rollback instructions"
  approval_gates:
    plan_approval: true
    merge_approval: true
    production_deploy: false
  budget:
    max_runtime_minutes: 30
    max_model_cost_eur: 5
  memory_policy:
    read_project_memory: true
    write_project_memory: false
    write_skill_registry: false

Dit contract maakt intentie uitvoerbaar. Zonder dit contract kan een agent niet veilig autonoom handelen, het systeem weet dan niet waar "goed" eindigt en "onbevoegd" begint.

Autonomieniveaus: risicogestuurde bevoegdheid

Autonomie is geen feature toggle. Het is een risicogestuurde bevoegdheid met zes niveaus:

Niveau	Agent mag	Agent mag niet	Geschikte workflows
L0 Advisory	Analyseren, samenvatten, aanbevelen	Files wijzigen	Architectuurreview, threat modeling
L1 Draft	Patches voorstellen	Committen of PR openen	Documentatie, testvoorstellen
L2 PR-only	Branch maken, tests draaien, PR openen	Mergen	Low-risk bugfixes, test gaps
L3 Non-prod change	Mergen naar dev/test na gates	Productie raken	Dependency hygiene, interne tools
L4 Production bounded	Beperkte prod-acties uitvoeren	Buiten expliciete runbooks	Incident response met break-glass
L5 Self-evolving	Skills aanpassen en promoten	Direct in productie wijzigen	Alleen na governance maturity

L0 tot L2 zijn direct operationaliseerbaar. L3 pas na sterke evals en audit. L4 alleen voor zeer smalle runbooks. L5 uitsluitend als gecontroleerde skill pipeline, EvoClaw bewijst dat continue autonome evolutie nu nog fragiel is.

Skill governance: van feature naar supply-chain artefact

De paper noemt self-evolving skills als belangrijk patroon. Hermes Agent realiseert dit met een closed learning loop, autonome skill creation, self-improving skills, en FTS5 session search. Dat is krachtig, maar ook precies waar de supply-chain en runtime-risico's ontstaan.

OWASP heeft in 2026 expliciet aandacht voor Agentic Skills Top 10. De kernobservatie: MCP bepaalt hoe een model met tools praat, maar skills bepalen wat die tools in workflowvorm doen. Een production-grade skill lifecycle:

Fase	Doel	Gate
Draft	Agent stelt skill voor	Geen uitvoering buiten sandbox
Static review	Manifest, permissies, dependencies scannen	Policy pass
Behavioral test	Skill uitvoeren op synthetische taken	Geen verboden acties
Security review	SAST, secret scan, dependency scan	Geen high/critical
Human approval	Beoordeling door eigenaar	Vier-ogenprincipe
Signed release	Hash, signature, version pinning	Registry promotion
Staged rollout	Alleen geselecteerde agents	Telemetry watch
Continuous monitoring	Drift en misbruik detecteren	Auto-disable bij afwijking

Een skill manifest moet expliciete permissies bevatten: welke files mogen gelezen en geschreven worden, welke shell commands zijn toegestaan, welk netwerkverkeer is toegestaan, en welke dependencies (pinned met hashes) zijn vereist. Geen wildcards. Geen unsigned skills. Geen directe promotie vanuit een succesvolle agent-run.

Security: AgentSecOps bovenop DevSecOps

Agentic engineering zonder security by design creëert een nieuw aanvalsvlak. OWASP bracht eind 2025 de Top 10 for Agentic Applications uit, gebaseerd op input van meer dan 100 security researchers. De kern: bij traditionele software bescherm je applicatiegrenzen. Bij agents bescherm je besluitvorming plus side effects.

De tien kritieke risico's en hun controls:

Risico	Realistisch scenario	Control
Prompt injection	Agent leest malicious GitHub issue en volgt verborgen instructies	Untrusted-content isolation, instruction hierarchy, taint labels
Tool misuse	Agent gebruikt legitieme tool voor ongewenste actie	Tool-specific policy, allowlisted commands
Excessive agency	Te brede repo, cloud of database rechten	Least privilege, scoped credentials, JIT access
Memory poisoning	Kwaadaardige context wordt persistente projectkennis	Memory provenance, write gates, expiry
Skill supply-chain	Malicious skill of dependency	Signed skills, pinned hashes, registry scanning
Data exfiltration	Agent combineert private data met externe egress	Default-deny network, DLP, egress proxy
Repo config hijack	Repository-instructies beïnvloeden agentgedrag	Trust prompts, config approval, signed agent policies
Runaway cost	Agent blijft plannen, testen of tool calls doen	Budget caps, step limits, rate limits
Audit gap	Achteraf niet bewijsbaar wat agent deed	Immutable traces, action logs, provenance
Semantic regression	Tests slagen, gedrag klopt niet	Property tests, scenario evals, human review

De minimale technische baseline: geen persoonlijke PATs (gebruik GitHub Apps, OIDC, short-lived tokens), secrets nooit in promptcontext (alleen brokered runtime access), default deny egress (expliciete allowlist per task), ephemeral containers zonder privileged mode, command allowlists (geen vrije shell voor L2+), OPA/Rego voor actie-policy, structured traces (actor, tool, input hash, output hash, decision), en een agent kill switch.

NIST SSDF blijft relevant: agentic engineering vervangt SSDF niet, maar maakt SSDF machine-enforceable in de pipeline.

Evaluation architecture: de echte bottleneck

EvoClaw toont dat agents falen bij lange, afhankelijke software-evolutie. De investering moet niet primair naar "betere prompts" gaan, maar naar evals als productiesysteem. Acht evaluatielagen:

Eval-type	Vraag	Voorbeeld
Syntactisch	Bouwt het?	compile, lint, typecheck
Functioneel	Werkt het?	unit en integration tests
Security	Is het veilig?	SAST, SCA, secret scan, IaC scan
Semantisch	Doet het wat bedoeld was?	scenario evals, golden tests
Architecturaal	Past het in ontwerpprincipes?	dependency rules, ADR checks
Governance	Was het bevoegd?	policy trace, approval evidence
Operational	Is het beheerbaar?	logging, metrics, rollback
Economic	Was het efficiënt?	cost per accepted change

De belangrijkste regel: een agent mag alleen autonomer worden als de eval coverage sterker wordt. Autonomie zonder evals is gokken. Evals zonder policy zijn kwaliteitscontrole zonder bevoegdheidscontrole. Policy zonder observability is papier. Observability zonder enforcement is forensics na schade.

Memory governance: een database met risico

Veel agent-frameworks behandelen memory als productiviteitsfeature. In werkelijkheid is memory een persistence layer met governance-impact. Vijf tiers:

Memorytype	Voorbeeld	Vertrouwen	Schrijfbeleid
System memory	Organisatieprincipes, security baselines	Hoog	Alleen platform owner
Project memory	Architectuurkeuzes, repo-conventies	Middel	PR-review of architect approval
Episodic memory	Vorige gesprekken, runs, observaties	Laag/middel	TTL, provenance vereist
External context	Web, issues, docs, tickets	Laag	Nooit direct promoveren
Skill memory	Geleerde procedures	Hoog risico	Alleen via skill pipeline

Harde regels: untrusted input overschrijft nooit system policy, memory krijgt provenance en TTL, project memory wordt versiebeheerd, sensitive memory wordt niet in modelcontext geladen zonder expliciet doel en autorisatie, memory writes zijn aparte audit-events, en agents mogen memory voorstellen maar niet stilzwijgend promoveren. Dit is het verschil tussen demo en productie.

Operating model: van DevSecOps naar Agentic Delivery

Agentic engineering vraagt om een nieuwe operating model-laag. Tien rollen:

Rol	Verantwoordelijkheid
Business owner	Waarde, prioriteit, risicoacceptatie
Product owner	Intent en acceptatiecriteria
AI architect	Agentic workflow, memory, evals, toolgebruik
Platform engineer	Sandbox, tool gateway, orchestration
Security architect	Threat model, least privilege, policy, incident response
Data/privacy officer	Data classificatie, DPIA, retention
Model risk owner	Modelkeuze, evals, drift, limitations
Skill curator	Skill registry, signing, promotion, deprecation
Auditor	Bewijs, traceability, compliance
Engineer reviewer	Diffs, architectuurimpact, maintainability

Voor compliance in de Europese context is de mapping naar bestaande frameworks essentieel. NIST AI RMF levert Govern, Map, Measure, Manage voor het AI risk register. NIST SSDF biedt secure development practices die in de agentic pipeline machine-enforceable worden. OWASP LLM Top 10, Agentic Top 10 en Agentic Skills Top 10 dekken de specifieke risicolagen. ISO 42001 biedt het AI management systeem. De EU AI Act vereist AI inventory, high-risk assessment, transparency en logging, en is sinds 1 augustus 2024 van kracht, met volledige toepassing vanaf 2 augustus 2026.

Dit betekent concreet: elk agentic systeem hoort in een AI/application register met model, data, tools, bevoegdheden, risico, owner, evals, logs, incidentroute en lifecycle status.

Workflowselectie: begin waar agents sterk zijn

Niet iedere workflow is agent-ready. Goede startkandidaten: CI failure diagnosis (L1-L2), test gap closure (L1-L2), documentation drift fix (L2), dependency vulnerability PRs (L2), IaC policy scan remediation (L2), root-cause analysis (L1), en ADR draft generation (L1).

Slechte startkandidaten: productie database mutaties (hoog blast radius), IAM policy wijzigingen (privilege escalation), security exception approvals (belangenconflict), juridische besluiten (menselijke accountability vereist), grote refactors zonder testdekking (EvoClaw-probleem), en self-modifying production agents (governance bypass).

Executieroadmap: van baseline naar measured autonomy

Fase 0 (week 1-2): Agentic Baseline. Agent inventory, tool permission matrix, data classification map, initieel risk register, work-order template v0, autonomy policy v0. Exit: geen agent met onbeperkte shell + onbeperkte egress + private data.

Fase 1 (week 3-6): Control Plane MVP. Sandbox runner, policy gate, trace schema, eval harness, PR-only workflow, evidence bundle. Exit: één repo draait L2 PR-only agent-runs met volledige bewijsset.

Fase 2 (week 7-10): Workflow Portfolio. 3-5 workflows industrialiseren (CI diagnosis, test gap closure, documentation drift, dependency PRs, IaC remediation). Exit: minimaal 30 runs, metrics gemeten, trace completeness ＞95%.

Fase 3 (week 11-16): Multi-Agent Orchestration. Rolgebaseerde samenwerking met planner, context, developer, test, security, reviewer en release agents, cross-validation verplicht, geen blind vertrouwen tussen agents.

Fase 4 (Q2): Gecontroleerde Skills. Skill registry, scanner, promotion en deprecation workflow, metrics. Exit: geen unsigned skills, geen wildcard permissions.

Fase 5 (Q3): Measured Autonomy. Autonomie verhogen op basis van bewijs, alleen als policy violations laag blijven, eval pass rate stabiel is, review rejection rate daalt, escaped defects niet stijgen, en audit evidence compleet is.

Metrics: wat je wél en niet moet meten

Meet geen "regels code gegenereerd". Meet outcome, risk en control:

Metric	Betekenis
Agent acceptance rate	% agent PRs geaccepteerd zonder grote herwerking
Review rejection rate	Hoe vaak menselijke review fundamentele fouten vindt
Escaped defect rate	Fouten na merge of deploy
Policy violation rate	Hoe vaak agent verboden actie probeert
Trace completeness	% acties met volledige auditdata
Eval coverage	Hoeveel acceptance criteria machine-checkable zijn
Mean time to safe outcome	Tijd tot gevalideerd resultaat
Cost per accepted change	Model + compute + reviewkosten
Skill failure rate	Hoe vaak skills incorrect, unsafe of stale blijken
Human cognitive load	Reviewtijd en aantal escalaties

Stop of downgrade autonomie als agent PRs ＞25% fundamenteel worden afgewezen, security findings stijgen, policy violations herhaald voorkomen, traces incompleet zijn, reviewers "rubber stamping" doen, of evals vooral syntactisch blijven.

De zes Architecture Decision Records

Leg deze vast:

• ADR-001: Agents mogen niet direct naar productie deployen (EvoClaw is de hardste empirische waarschuwing)
• ADR-002: Elke agent-run vereist een work order (zonder contract geen toetsbare intentie)
• ADR-003: Skills zijn supply-chain artefacten (OWASP Agentic Skills)
• ADR-004: Memory promotion is gated (memory poisoning is persistente aanvalsvector)
• ADR-005: Human review verschuift van code-only naar evidence review
• ADR-006: Autonomie is risk-based, toegekend per workflow, niet per agent

De operationele formule

De paper geeft het paradigma. De executie vereist een control plane. De eindformule voor agentic productiewaarde:

Agentic value = capability × context quality × eval strength × policy enforcement × observability ÷ autonomy risk

Zonder evals en policy is agentic engineering een demo. Met de tien-laags control plane, work orders, sandboxing, signed skills, memory governance en risk-based autonomy wordt het een uitvoerbaar enterprise operating model.

De nieuwe kerncompetentie is niet prompt engineering. Het is: intent engineering, agent orchestration, policy engineering, eval engineering, memory governance, skill supply-chain management, agent observability, risk-based autonomy, en human accountability.

Software engineering eindigt niet, het verschuift van implementatiediscipline naar control discipline.

---

DjimIT ontwerpt Agentic Delivery Control Planes voor organisaties die agentic engineering productiewaardig willen maken. Van work-order contracten tot skill supply-chain governance, van eval architecture tot compliance mapping, neem contact op voor een architectuursessie.