🤖 AI

Specifying AI-SDLC Processes: A Protocol Language for Human-Agent Boundaries

Dit artikel stelt een formele domeinspecifieke taal voor voor het specificeren van AI-SDLC-processen die de grenzen tussen mens en agent definieert door middel van structurele handhavingsprimitieven, waarbij beleid van mechanisme wordt onderscheiden om systeemfoutpercentages te begrenzen en de scheiding van taken in multi-agent softwareontwikkeling te formaliseren.

Oorspronkelijke auteurs: Ylli Prifti

Gepubliceerd 2026-06-23

📖 6 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Ylli Prifti

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer

Stel je voor dat je een wolkenkrabber bouwt. In het verleden huurde je een team van menselijke architecten, ingenieurs en bouwvakkers in. Iedereen kende zijn taak en er waren strikte regels: degene die het beton stortte, mocht niet ook degene zijn die de veiligheidsinspectie goedkeurde.

Nu stel je voor dat je de helft van je team vervangt door ongelooflijk slimme, snelle, maar soms onvoorspelbare AI-robots. Ze kunnen code schrijven, blauwdrukken ontwerpen en bugs oplossen in seconden. Maar hier is het probleem: Hoe zorg je ervoor dat deze robots niet per ongeluk je gebouw laten ontploffen, veiligheidscontroles overslaan of hun eigen fouten door de vingers zien?

Momenteel geven teams de robots alleen maar instructies via chatberichten (prompts). Maar robots zijn als studenten die instructies vergeten als je ze niet perfect opschrijft, of die in de war raken en van hun taak afdwalen. Als een robot een fout maakt, merkt hij het misschien niet eens zelf, en kan het hele project instorten.

Dit paper stelt een nieuw regelboek voor (een "Protocol Language") om mens-AI-teams te beheren. In plaats van alleen met de robots te chatten, schrijf je een strikt, machineleesbaar contract dat fungeert als het structurele staal van het gebouw.

Hier is hoe het paper dit onderverdeelt, met behulp van eenvoudige analogieën:

1. Het Probleem: "Driftende" Instructies

Op dit moment, als je wilt dat een robot zijn eigen werk controleert voordat hij verdergaat, moet je dat in een prompt zetten. Maar robots zijn "niet-deterministisch" — ze volgen de regel vandaag misschien wel, maar negeren hem morgen, of interpreteren "controleer dit" anders dan jij bedoelde.

De bewering van het paper: Vertrouwen op het "gedrag" van de robot is als een kind vragen om de handen te wassen zonder dat er een wastafel in de buurt is. Dat is riskant.
De oplossing: In plaats van de robot te vragen het te onthouden, bouw je een slot op de deur. De robot kan fysiek niet naar de volgende stap overgaan, tenzij er een "sleutel" (een validatietoken) wordt ingestoken. Als de robot probeert de controle over te slaan, blijft de deur op slot.

2. De Nieuwe Taal: "Beleid vs. Mechanisme"

De auteurs maken onderscheid tussen twee dingen:

Beleid (De Intentie): "We willen dat de code veilig is." (Dit is slechts een wens).
Mechanisme (De Handhaving): "Het systeem blokkeert fysiek het opslaan van de code, tenzij drie verschillende validators akkoord gaan." (Dit is een harde regel).

Denk aan een bank.

Beleid: "We willen fraude voorkomen."
Mechanisme: "Je kunt niet meer dan $500 opnemen zonder de vingerafdruk van een manager."
Het paper betoogt dat we voor AI het mechanisme (de vingerafdrukscanner) nodig hebben, niet alleen het beleid (het bordje aan de muur).

3. Het "2+N" Teampatroon

Het paper suggereert een specifieke teamstructuur die het beste werkt, genaamd het 2+N Patroon.

De "2" Mensen: Je hebt twee mensen in de leiding, maar zij hebben verschillende taken.
- Mens A (De Producent): Houdt toezicht op de robots die de code schrijven.
- Mens B (De Reviewer): Houdt toezicht op de robots die de code controleren.
- Waarom twee? Eén persoon mag niet zowel de code schrijven als de controle uitvoeren en vervolgens tekenen. Ze moeten gescheiden zijn om fouten of valsspelen te voorkomen.
De "N" Robots: Dit zijn de gespecialiseerde werkers (coders, beveiligingscontroleurs, testers). Zij doen het zware werk, maar worden strikt gecontroleerd door de twee mensen en de regels.

4. De "Zelfcontrole"-lus (Kleene Closure)

Stel je een lopende band in een fabriek voor. Normaal gesproken stopt de band als een onderdeel defect is. Maar in dit AI-systeem stopt het niet alleen bij het vinden van een probleem; het creëert automatisch een nieuw, kleiner robotteam om dat specifieke probleem op te lossen, volgens exact dezelfde regels.

De bewering van het paper: Dit gebeurt automatisch. Het systeem is zo ontworpen dat het oplossen van een probleem simpelweg een andere "taak" is die door dezelfde strikte controles gaat. Het is als een Russische matroesjka-pop waarbij elke laag dezelfde veiligheidsregels volgt.

5. De "Zelfregulerende" Bewaker

Het meest slimme deel van het ontwerp is dat het systeem een robot kan bevatten wiens enige taak het is om de andere robots in de gaten te houden.

Deze "Bewaker-robot" schrijft geen code; hij kijkt of de andere robots de regels volgen.
Hij controleert: "Heeft de coder toestemming gevraagd voordat hij iets aanpaste?" "Heeft de reviewer akkoord gegeven?"
Als de Bewaker ziet dat een regel wordt overtreden, stopt hij het proces. Het is als een scheidsrechter die de spelers in de gaten houdt om te zien of ze niet valsspelen.

6. Waarom dit ertoe doet (Het "Commoditisering"-argument)

Het paper betoogt dat AI-modellen (de "hersenen") steeds meer op elkaar gaan lijken en goedkoop worden. Binnenkort zal het er niet meer toe doen of je Model A of Model B gebruikt; ze zullen allemaal goed zijn in de basis.

De werkelijke waarde: De waarde zal niet liggen in welke robot je gebruikt, maar in hoe je hen organiseert.
Een team met een geweldig "regelboek" (protocol) zal overleven en floreren, ongeacht welke robots ze inhuren. Het regelboek wordt hun meest waardevolle bezit, zoals een geheim recept, terwijl de robots slechts de ingrediënten zijn.

Samenvatting

Het paper zegt: Stop met erop vertrouwen dat AI de regels "onthoudt". Bouw in plaats daarvan een systeem waarbij de regels hard gecodeerd zijn in de machines. Als de robot probeert een regel te breken, stopt de machine het proces fysiek. Door de "schrijvers" te scheiden van de "controleurs" en een strikt, onbreekbaar proces te gebruiken, kunnen we veilig AI gebruiken om complexe software te bouwen zonder dat het uit elkaar valt.

Wat het paper NIET beweert:

Het beweert niet dat dit AI perfect of foutloos maakt. De robots kunnen nog steeds fouten maken, maar het proces van het overslaan van stappen wordt geëlimineerd.
Het beweert niet dat dit al voor elke denkbare baan werkt; het is een voorstel voor softwareontwikkeling.
Het beweert niet dat het al op duizenden bedrijven is getest; ze hebben alleen hun eigen systeem getest om te bewijzen dat het werkt.

Technische Samenvatting: Specificatie van AI-SDLC-processen

1. Probleemstelling

De opkomst van AI-SDLC (AI-geïntegreerde softwareontwikkelingslevenscyclus) heeft AI-agenten gevestigd als volwaardige teamleden in planning, codering, review en deployment. Er bestaat echter een kritieke specificatiekloof: hoewel industrieel rapporten en praktijkliteratuur de noodzaak identificeren voor expliciete mens-agent verantwoordelijkheidsmapping, goedkeuringspoorten en governance-beperkingen, bestaat er geen formele specificatietaal om deze vereisten te coderen als uitvoerbare protocollen.

Huidige benaderingen lijden onder drie primaire beperkingen:

Gedragsdrift (Behavioral Drift): Proceslogica wordt vaak gecodeerd in agent-prompts, wat onderhevig is aan interpretatiedrift en een gebrek aan structurele handhaving heeft.
Domein-mismatch: Bestaande workflowtalen (bijv. BPMN-extensies) richten zich op aangrenzende domeinen of mens-tool interacties, en falen in het inherent modelleren van autonome agent-deelnemers, geschilbeslechting of agent-specifieke foutmodi.
Ad-hoc Implementatie: Teams vertrouwen momenteel op gefragmenteerde tooling en impliciete normen, wat leidt tot operationele risico's, audit-tekortkomingen en technische schuld.

De kernuitdaging is het definiëren van een taal die specificeert wie (mens of agent) wat doet, wanneer goedkeuring vereist is, hoe meningsverschillen worden opgelost en welke beperkingen niet overridable zijn, zonder uitsluitend te vertrouwen op de naleving (compliance) van de agent.

2. Methodologie

De auteurs stellen een Domein-Specifieke Taal (DSL) voor om AI-SDLC-processen te specificeren als formele protocollen. De methodologie maakt onderscheid tussen beleid (verklaarde intentie) en mechanisme (structurele handhaving).

2.1 Formele Taalspecificatie

De taal definieert een protocol $P$ als een tupel $\langle M^*, V^*, D, C^* \rangle$ :

Modi ( $M$ ): Operationele fasen (bijv. producer, reviewer) met gedefinieerde permissies. Modi worden afgedwongen op het niveau van de infrastructuur.
Rollen ( $R$ ): Actoren binnen modi, gedefinieerd door identiteit en toegankelijke tools.
Validators ( $V$ ): Onafhankelijke evaluatoren die taken beoordelen tegen criteria en ernstniveaus emitteren.
Geschilbeleid ( $D$ ): Regels voor het oplossen van validator-uitkomsten (bijv. unanimous_pass, split $\to$ require_human, any_blocker $\to$ hard_stop).
Constraints ( $C$ ): Structurele verboden en vereisten (bijv. negative(producer_mode calls merge)).

2.2 Structurele Handhaving versus Gedragsnaleving

Het artikel betoogt dat beleid alleen onvoldoende is. De DSL introduceert handhavingsinvarianten (INV1–INV4) die proces-niet-determinisme begrenzen:

Token Integriteit: Validatie-tokens zijn onvervalsbare credentials uitgegeven door validators; agents kunnen deze niet zelf creëren.
Capabiliteitsgrenzen: Tools worden alleen blootgesteld aan specifieke modi op het niveau van de infrastructuur (bijv. een producer mode heeft geen toegang tot merge tools).
Niet-overridable Blockers: Als een validator een blocker ernstniveau emitteert, stopt het systeem structureel de uitvoering; geen enkele agent kan dit overriden.
Audit Volledigheid: Alle statusovergangen en dispatches worden onveranderlijk gelogd.

2.3 Het 2+N Team Patroon

Het artikel formaliseert een referentieconfiguratie genaamd het 2+N patroon:

2 Human-in-Control (HI-CTRL) Rollen: Eén in de producer mode (bezit executie-autoriteit) en één in de reviewer mode (bezit merge-autoriteit). Dit dwingt Separation of Duties af, wat zelf-goedkeuring voorkomt.
N Gespecialiseerde Agents: Inclusief orchestrators, coders en validator-quorums met orthogonale criteria.
Infrastructuur Grenzen: De twee modi zijn gescheiden door disjuncte toolsets en aparte MCP (Model Context Protocol) servers.

2.4 Emergente Eigenschappen

Kleene Sluiting: De orchestratie-loop is geen vaste sequentie maar een Kleene sluiting ( $L^*$ ). Taken kunnen recursief subtaken genereren, die elk hun eigen governance en validatiecyclus vereisen, allemaal onder dezelfde protocolrestricties.
Zelfversterkende Naleving: De taal staat protocol-naleving validators toe—agents die evalueren of het systeem zelf de protocolregels volgt. Dit creëert een zelfreferentiële structuur waarbij het protocol zichzelf auditeert zonder dat een aparte meta-taal nodig is.

3. Belangrijkste Bijdragen

Formele Specificatietaal: Een DSL met abstracte syntaxis, welgevormdheidscondities (WF1–WF5), operationele semantiek en handhavingsinvarianten voor AI-SDLC.
Beleid-Mechanisme Onderscheid: Een framework waarbij protocollen intentie verklaren, terwijl implementaties gebruikmaken van structurele primitieven (tokens, capabiliteitsgrenzen) om niet-determinisme te begrenzen.
2+N Team Patroon: Een geformaliseerde referentieconfiguratie voor AI-SDLC die Separation of Duties codificeert voor mens-agent samenwerking.
Foutpercentage Analyse: Een wiskundige afleiding die aantoont dat structurele handhaving de systeemfoutpercentages begrenst op een gewogen product van agent- en validatorpercentages, terwijl gedragsnaleving toestaat dat fouten cumulatief of bijna verzadigend groeien.
Quasi-Determinisme: De claim dat hoewel agent-outputs niet-deterministisch blijven, het proces quasi-deterministisch wordt omdat agents stappen in het protocol niet kunnen overslaan of ervan kunnen afwijken.
Implementatie: Een werkend systeem dat de uitvoerbaarheid van de taal en de onderhoudbaarheid van handhavingsinvarianten demonstreert, inclusief de zelfontwikkeling van de eigen codebase van het systeem.

4. Resultaten en Analyse

4.1 Foutpercentage Grenzen

Het artikel presenteert een vergelijkende analyse van foutpercentages:

Gedragsnaleving (Behavioral Compliance): Fouten stapelen zich op door de workflow. Als een agent opereert op een gecorrumpeerde tussenliggende staat, neemt het foutpercentage toe. In worst-case scenario's met cascadefouten nadert het systeemfoutpercentage saturatie (nabij 100%).
Structurele Handhaving: Fouten zijn begrensd. Het systeemfoutpercentage is een gewogen product van individuele agent-foutpercentages ( $p_i$ $p_{i}$ ) en validator miss-rates ( $p_{quorum}$ $p_{q u or u m}$ ), gemoduleerd door herstelkosten.
- De analyse suggereert dat voor realistische parameters (bijv. $N=5$ , validator quorum $K=3$ ), structurele handhaving de foutpercentages met een orde van grootte kan verlagen ten opzichte van gedragsmatige baselines.
- Cruciaal is dat deze reductie rust op de aanname dat processtappen niet overgeslagen kunnen worden (INV3) en dat er herstel-loops bestaan.

4.2 Implementatie Haalbaarheid

De auteurs hebben de specificatie geïmplementeerd met behulp van:

Een protocol engine voor parsing en welgevormdheidscontroles.
Twee MCP servers om de scheiding van modi af te dwingen.
Een token subsystem voor validatie.
Een event-sourced audit log.
Het systeem heeft succesvol de eigen codebase uitgebreid onder het 2+N protocol, wat initieel bewijs levert voor de levensvatbaarheid.

5. Betekenis en Positionering

Het artikel positioneert de bijdrage niet als de uitvinding van nieuwe primitieven (DSL's, capability tokens en rolgebaseerde workflows bestaan al), maar als de specifieke integratie daarvan in een coherente specificatietaal voor AI-SDLC.

Differentiatie van Prior Art:
- In tegenstelling tot MetaGPT, dat SOP's in prompts codeert (onderhevig aan drift), biedt deze taal een machine-uitvoerbare specificatie die onafhankelijk is van de agent-implementatie.
- In tegenstelling tot BPMN-extensies, die mens-agent workflows modelleren maar geen infrastructuur-niveau handhaving missen, behandelt deze DSL mode-grenzen als een first-class concept.
- In tegenstelling tot SAGA (capability-based security), dat zich richt op inter-agent autorisatie, richt deze taal zich op validatie-naar-executie autorisatie.
Het Commoditisering Argument:
De auteurs stellen dat naarmate foundation models convergeren in capaciteit, de differentiërende asset voor organisaties zal verschuiven van modelselectie naar procesontwerp. Een goed ontworpen protocol fungeert als "institutioneel geheugen" dat modeltransities overleeft, terwijl modellen worden behandeld als commodity infrastructuur.

6. Beperkingen en Toekomstig Werk

Het artikel is bescheiden in zijn claims en erkent enkele beperkingen:

Enkele Implementatie Bewijs: Het bewijs voor de haalbaarheid rust op één implementatie ( $N=1$ ). Vergelijkende evaluatie tegen baselines is toekomstig werk.
Wiskundige Aannames: De foutpercentage grenzen nemen constante foutpercentages en stabiele correlatiestructuren aan, wat in de praktijk mogelijk niet standhoudt.
Implementatie Afhankelijkheid: Token integriteit (INV1) is een verantwoordelijkheid van de implementatie; de specificatie schrijft de cryptografische primitieven niet voor.
Validator Kwaliteit: Structurele handhaving kan de kwaliteit van de validators zelf niet overtreffen.
Geen Formele Verificatie: Het artikel definieert welgevormdheidscondities, maar verifieert niet formeel of een protocol de gestelde temporele doelen bereikt.

De auteurs concluderen dat de specificatietaal de "vorm" biedt voor het duurzame engineering-asset van procesontwerp in een tijdperk van gecommoditiseerde AI-modellen.