Microsofts Agent Governance Model: De Control Plane die de NSA Mist

Drie Microsoft Learn-modules, over geheugen, multi-agent orkestratie en governance, vormen samen een van de meest concrete operationele frameworks voor agentic AI die ik tot nu toe heb gezien. De modules zijn onderdeel van het certificeringstraject voor de GitHub Copilot Coding Agent. Maar hun werkelijke waarde ligt niet in GitHub Actions of branch protection. Die waarde ligt in vijf onderliggende ontwerpprincipes die een blauwdruk vormen voor elke organisatie die agenten in productie wil nemen.

De kernboodschap van Microsoft is ondubbelzinnig: behandel agenten niet als autonome chatbots, maar als niet-deterministische uitvoerders binnen een deterministische control plane.

Dat is precies het antwoord op de vraag die de NSA drie weken geleden stelde. Waar de NSA waarschuwde dat MCP geen security boundary is, laat Microsoft zien hoe je die boundary wél bouwt, met bestaande infrastructuur als fundament.

GitHub als control plane, niet als versiebeheer

Microsofts architectonische zet is om GitHub niet te behandelen als ontwikkelplatform, maar als control plane voor agentische operaties. Issues, pull requests, branches, workflow-runs, checks en artifacts worden daarmee:

• Toestandopslag, waar staat het proces?
• Werkverdeling, welke agent doet wat?
• Bewijsregistratie, wat is er gebeurd en waarom?
• Policy enforcement, wat mag een agent niet?
• Herstelmechanisme, hoe rollen we terug?
• Human-in-the-loop interface, waar grijpt een mens in?

Dit is architectonisch veel relevanter dan de afzonderlijke GitHub-voorbeelden doen vermoeden. De pull request wordt de centrale state anchor: hij bevat het doel, de commits, de checks, de discussies. Een agent kan zijn werk na onderbreking hervatten zonder opnieuw te beginnen.

De belangrijke implicatie: een agentproces mag verdwijnen, maar de processtatus moet buiten de agent blijven bestaan. Geen enkele agent is de eigenaar van zijn eigen state.

De drie modules als gelaagd raamwerk

De volgorde is geen toeval. Microsoft bouwt op van fundament naar controle:

Laag 1, Memory, State, and Evaluation. De module onderscheidt drie geheugenvormen. Short-term memory voor de actieve taak. Long-term memory voor gecureerde patronen. External memory, issues, PR's, artifacts, als duurzame source of truth. De les: requirements horen in issues, besluiten in pull requests, validatieregels in repository-instructies. Niet in één ondoorzichtige vectorstore die niemand kan auditen.

Laag 2, Multi-Agent Systems and Orchestration. Het sterkste patroon uit deze module: laat agenten niet via verborgen conversaties coördineren, maar via gedeelde, reviewbare artifacts. Een agent produceert een plan met beperkte permissies. Een aparte uitvoeringsstap past alleen vooraf toegestane mutaties toe. Scheiding tussen reasoning en writing, de analyserende agent krijgt niet dezelfde rechten als de uitvoerende.

Laag 3, Governance, Guardrails, and Operations. Hier wordt alles afdwingbaar. Agentacties krijgen een risicoclassificatie. Per niveau worden controles gekoppeld: regelsets, required checks, CODEOWNERS, protected environments. Policy is geen document, policy is een set GitHub-controls die technisch worden afgedwongen.

De drie lagen als architectuurmodel

De echte waarde van de modules wordt zichtbaar als je ze niet als cursusmateriaal leest, maar als architectuur. Er ontstaan drie planes:

Cognitive plane. Hier leven prompts, modelcontext, plannen, analyses. Deze laag is probabilistisch. Een LLM kan hallucineren, misinterpretaties maken, vergeten wat het drie stappen geleden besloot.

Coordination plane. Hier leeft de workflow: branches, artifacts, handoffs, queues, locks, retries. Deze laag organiseert het werk, wie doet wat, in welke volgorde, met welke isolatie.

Control plane. Hier leven identities, permissions, policies, approvals, secrets, kill switches. Deze laag bepaalt wat daadwerkelijk mag gebeuren.

De architecturale hoofdregel: de cognitive plane mag voorstellen, de coordination plane mag organiseren, maar alleen de control plane mag autoriseren.

Een LLM mag nooit zelf de finale autoriteit zijn over of zijn actie is toegestaan. Die beslissing moet worden genomen door een deterministische policy enforcement point, buiten het model.

Autonomie is geen binaire keuze

Een van de sterkste elementen uit de governance-module is de risicoclassificatie van agentacties. Microsoft werkt met low, medium, high en critical. Dat is aanzienlijk sterker dan de binaire keuze tussen "autonoom" en "human approval" die veel organisaties nu hanteren.

Uitgewerkt naar een praktisch model:

Niveau	Bevoegdheid	Voorbeeld
A0, Observe	Alleen lezen en analyseren	Inventarisatie, loganalyse
A1, Propose	Plan of patch produceren	PR of herstelvoorstel
A2, Constrained act	Reversibele laagrisicoactie	Formatter, documentatie
A3, Supervised act	Mutatie na expliciete approval	Deployment, configuratie
A4, Emergency act	Vooraf geautoriseerde noodactie	Isoleren workload
A5, Prohibited	Nooit zelfstandig toegestaan	Secret export, audit verwijderen

Autonomie moet bovendien per combinatie worden bepaald: agent identity × actietype × doelresource × omgeving × dataclassificatie × reversibiliteit × blast radius. Een actie die in development laag risico is, kan in productie critical zijn.

Human-in-the-loop, geen governance theatre

Microsoft plaatst menselijke goedkeuring bij high-impact control points: merge, deployment, toegang tot secrets. Laagrisicowerk blijft geautomatiseerd.

Dat is goed, maar alleen als approvals inhoudelijk rijk genoeg zijn. Een operator moet niet alleen "Approve" zien. Minimaal nodig: de gevraagde actie, doelresource, reden, risicoclassificatie, verwachte impact, diff, bewijs, rollbackprocedure, en geldigheidsduur. Anders ontstaat approval fatigue, klikken zonder begrip, en wordt human-in-the-loop slechts governance theatre.

Waar het framework tekortschiet

Het model is sterk voor DevSecOps, maar kent grenzen:

GitHub-centrisch. De implementatie veronderstelt GitHub Actions, CODEOWNERS, branch protection. Organisaties op GitLab of Azure DevOps moeten de principes vertalen naar hun eigen controls.

Geen volwaardig identity-model. Workflow tokens zijn een begin, maar voor enterprise agentic AI zijn workload identity, delegated authority, non-human identities, en attestation nodig. Iedere agentactie moet traceerbaar zijn naar de menselijke principal die de keten in gang zette.

Supply-chain is onderbelicht. Er is aandacht voor dependency review, maar niet voor compromised MCP-servers, malicious skills, prompt-injectie vanuit repositories, tool schema manipulation, of artifact substitution.

Evaluatie blijft softwarecentrisch. Een groene CI-pipeline bewijst niet dat een agent een goede beslissing nam. Semantische evaluatie, klopt het resultaat inhoudelijk? Zijn claims herleidbaar tot bronnen?, ontbreekt.

Geen organisatorische governance. Rollen als accountable owner, model risk management, DPIA, incidentclassificatie en regulatory reporting worden niet behandeld.

Wat Microsoft wél goed ziet, en waarom het ertoe doet

De waarde van dit framework is niet dat het compleet is. De waarde is dat het bestaande infrastructuur herpositioneert als agent control plane. GitHub Actions, branch protection en CODEOWNERS bestonden al. Microsoft laat zien dat je ze kunt inzetten voor iets wat fundamenteel nieuw is: het governen van niet-deterministische AI-agenten met deterministische controls.

De vijf ontwerpprincipes die onder de modules liggen:

1. State moet buiten de agent bestaan. Een PR, een workflow-run, een artifact, niet het geheugen van een model.
2. Agenten moeten via controleerbare artifacts samenwerken. Niet via verborgen conversaties die niemand kan reviewen.
3. Parallelisme vereist harde isolatie. Zonder scope-isolatie veroorzaken parallelle agents instabiliteit, geen snelheid.
4. Autonomie moet per risico en actie zijn begrensd. Niet binaire aan/uit, maar zes niveaus met contextafhankelijke regels.
5. Governance moet technisch worden afgedwongen. Niet aan het model vragen of iets mag, een policy engine beslist.

Voor de Nederlandse publieke sector, die met BIO2 en NIS2 zware compliance-eisen heeft, is dit framework een praktisch startpunt. GitHub Copilot wordt breed geadopteerd. De vraag is niet of agenten code gaan schrijven voor de overheid, maar onder welke controls.

Microsoft geeft het antwoord: bounded autonomy, technisch afgedwongen, met een mens aan de kritieke knoppen.

---

Dit artikel is gebaseerd op drie Microsoft Learn-modules uit het GitHub Copilot Coding Agent traject: Memory, State, and Evaluation; Multi-Agent Systems and Orchestration; en Governance, Guardrails, and Operations. Lees ook onze analyse van de NSA over MCP-security, de twee documenten vullen elkaar aan als waarschuwing en implementatiekader.