💻 computer science

Model-Driven Requirements Configuration with Three-Valued Uncertainty Scoring

Dit artikel presenteert een neuro-symbolische multi-agent architectuur die een Large Language Model combineert met een deterministische symbolische validator en een driewaardig onzekerheidsscoresysteem om structurele inconsistenties in door LLM's gegenereerde eisen te elimineren, terwijl beslissingsonzekerheid formeel wordt gekwantificeerd voor veiligere implementatie in requirements engineering.

Oorspronkelijke auteurs: Ahmed Ibrahim

Gepubliceerd 2026-07-30

📖 8 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Ahmed Ibrahim

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 eigen robot wilt bouwen, maar in plaats van blauwdrukken te tekenen, praat je gewoon met een zeer pratige, superintelligente robotvriend die ervan houdt om dingen te verzinnen. Je zegt: "Ik wil een robot die kan koken en schoonmaken," en je vriend begint enthousiast onderdelen op te sommen. Maar omdat hij zo enthousiast is, kan hij per ongeluk een onderdeel voorstellen dat niet past, of twee onderdelen die ontploffen als je ze bij elkaar zet, of zelfs een onderdeel uitvinden dat helemaal niet bestaat. Dit is de lastige wereld van Requirements Engineering: het proces van uitzoeken wat een stuk software of een machine precies moet doen. Lange tijd hebben experts strikte, wiskundige "regelboeken" (genaamd formele modellen) gebruikt om ervoor te zorgen dat elk onderdeel perfect past, maar deze regelboeken zijn moeilijk te lezen voor mensen. Onlangs zijn we begonnen met het gebruik van Large Language Models (LLM's) — hetzelfde soort AI dat gedichten schrijft en vragen beantwoordt — om ons te helpen beschrijven wat we willen in gewone mensentaal. Het probleem? Deze AI-vrienden zijn geweldig in praten, maar slecht in het volgen van de strikte regels van het regelboek; ze creëren ontwerpen die er goed uitzien, maar uit elkaar vallen zodra je ze probeert te bouwen.

Dit paper introduceert een slimme nieuwe samenwerking om dat probleem op te lossen. De auteurs hebben een systeem gecreëerd waarbij de pratige AI (de LLM) fungeert als een creatieve brainstormer die ideeën voorstelt op basis van jouw beschrijving in natuurlijke taal, terwijl een strikte, onbuigzame "regelcontroleur" (een symbolische validator) de wacht houdt. Denk aan een creatieve chef en een gezondheidsinspecteur die samenwerken in een keuken. De chef stelt wilde, heerlijke recepten voor, maar de inspecteur controleert onmiddellijk of de ingrediënten veilig zijn en of de stappen de wet volgen. Als de chef voorstelt om gif met taart te mengen, stopt de inspecteur dit direct. Het paper laat zien dat deze samenwerking bijna alle fouten die de AI maakt succesvol herstelt, waardoor rommelige, onmogelijke ideeën worden omgezet in solide, bouwbare plannen. Ze hebben ook een nieuwe manier geïntroduceerd om het vertrouwen van de AI te meten, waarbij ze onderscheid maken tussen dingen die de AI moet kiezen, dingen die de AI vrijelijk kan kiezen, en dingen die de AI fout heeft.

Het verhaal van de Creatieve Chef en de Strikte Inspecteur

In de wereld van software moet je, voordat je ook maar één regel code schrijft, precies beslissen wat het programma moet doen. Dit wordt Requirements Engineering genoemd. Stel je voor dat je een "Smart Home" ontwerpt. Je moet beslissen: Heeft het een reservebatterij? Gebruikt het Wi-Fi of Bluetooth? Kun je de lichten met je stem bedienen? Als je deze keuzes fout maakt, werkt het hele huis misschien niet.

Traditioneel gebruikten experts een rigide systeem genaamd OOMRAM (Object-Oriented Method for Requirements Authoring and Management). Zie OOMRAM als een gigantisch, complex stroomdiagram of een boom van keuzes. Het heeft strikte regels: "Als je 'Smart Home' kiest, moet je een energiebron kiezen. Als je 'Wi-Fi' kiest, kun je niet tegelijkertijd 'Bluetooth' kiezen." Het is als een personage-maker in een videogame waarbij je niet een zwaard en een schild kunt uitrusten als de game zegt dat ze wederzijds uitsluitend zijn. Het probleem is dat deze stroomdiagrammen moeilijk te navigeren zijn voor mensen. Je kunt niet gewoon zeggen: "Ik wil een huis dat gezellig en veilig aanvoelt," en verwachten dat het stroomdiagram je begrijpt. Je moet de exacte namen van elke optie kennen.

Hier komt de Large Language Model (LLM) in beeld. Dit is de AI die jouw zin, "Ik wil een gezellig huis met stembediening," kan begrijpen en kan raden welke opties je waarschijnlijk bedoelt. Het is als een supersnelle, creatieve assistent die jouw taal spreekt. Maar hier is de adder onder het gras: de AI is een beetje een dagdromer. Het kan een "Quantum Batterij" uitvinden die niet bestaat, of het kan vergeten dat je niet zowel Wi-Fi als Bluetooth kunt hebben, wat leidt tot een ontwerp dat logisch gezien gebrekkig is.

De Neuro-Symbolische Samenwerking

De auteurs van dit paper hebben een systeem gebouwd om dit op te lossen. Ze hebben een team van vier "agents" (kleine computertjes) gemaakt die samenwerken:

De Navigator: Deze agent kijkt naar het gigantische stroomdiagram (de OOMRAM-lattice) en beslist welk deel het volgende bekeken moet worden. Het is als een gids die naar de volgende deur in een doolhof wijst.
De Interpreter (De AI): Dit is de LLM. Hij luistert naar jouw "projectvisie" (jouw beschrijving van wat je wilt) en stelt voor welke knoppen er op het stroomdiagram ingedrukt moeten worden. Hij probeert te raden welke opties bij jouw beschrijving passen.
De Validator (De Inspecteur): Dit is het strikte, regelvolgende deel. Deze gebruikt geen AI, maar harde wiskunde. Hij controleert elke suggestie van de AI tegen de regels van het stroomdiagram. Heeft de AI twee dingen gekozen die niet samen kunnen gaan? Is de AI een verplicht onderdeel vergeten? Als het antwoord "ja" is, zegt de Validator: "Nee, probeer het opnieuw," en stuurt de AI terug om de fout te herstellen.
De Scribe (De Schrijver): Zodra alles is goedgekeurd, schrijft deze agent de definitieve, perfecte lijst met eisen op.

De magie gebeurt omdat de AI en de Inspecteur in een lus met elkaar communiceren. De AI stelt voor, de Inspecteur controleert, en als er een fout is, probeert de AI het opnieuw. Dit blijft gebeuren totdat het ontwerp perfect is.

De Scorekaart met Drie Waarden: Waarheid, Misschien en Vals

Een van de coolste onderdelen van dit paper is hoe ze het werk van de AI meten. Meestal zeggen we gewoon dat een antwoord "Goed" of "Fout" is. Maar de auteurs realiseerden zich dat dat te simpel is. Soms kiest de AI iets dat weliswaar is toegestaan, maar niet strikt vereist is. Om dit te behandelen, hebben ze een Scorekaart met Drie Waarden uitgevonden:

Waarheid (T): De AI koos iets dat moest worden gekozen. Bijvoorbeeld, als de visie "Smart Home" is, dan moet het systeem een energiebron kiezen. Als de AI dat doet, is dat een Waarheid.
Onbepaaldheid (I): De AI koos iets dat weliswa aanvaardbaar was, maar de visie dwong het niet af. Misschien zei de visie alleen "Smart Home," en koos de AI voor "Wi-Fi" in plaats van "Bluetooth." Beiden zijn geldig, maar de visie zei niet welke. Dit is Onbepaaldheid. Het is een "vrije keuze."
Valsheid (F): De AI koos iets dat de regels overtrad. Zoals het tegelijkertijd kiezen van "Wi-Fi" en "Bluetooth" wanneer de regels zeggen dat dat niet mag. Dit is Valsheid.

Door deze scorekaart te gebruiken, konden de onderzoekers precies zien waar de AI aan het gokken was en waar hij instructies opvolgde.

Wat ze hebben gevonden

Het team heeft hun systeem getest met 37 verschillende projectvisies verspreid over 11 verschillende soorten toepassingen, zoals registratiesystemen, smart homes en auto-entertainment systemen. Ze gebruikten een "lichtgewicht" AI-model (Llama 3.1 8B) voor de meeste tests.

Dit is wat er gebeurde:

Het Herstelpercentage: Zonder de strikte Inspecteur maakte de AI grote fouten. Maar met de Inspecteur herstelde het systeem bijna alle fouten. In 35 van de 37 gevallen (94,6%) had het eindresultaat nul structurele fouten.
De Restjes: In de overige 2 gevallen kwam de AI vast te zitten in een lus en kon hij een specifiek type fout niet oplossen voordat de test werd gestopt. Dit liet slechts 6 kleine fouten over op meer dan 1.500 beslissingen (0,39%).
De "Misschien"-zone: De onderzoekers ontdekten dat ongeveer 24,7% van alle beslissingen die de AI maakte, "Onbepaaldheid" waren. Dit betekent dat de AI zijn vrijheid gebruikte om te kiezen tussen geldige opties, wat eigenlijk een goed ding is! Het laat zien dat het systeem het verschil begrijpt tussen "moeten doen" en "kunnen kiezen."
De Sterkere AI: Toen ze het systeem testten met een veel intelligentere, "frontier" AI-model (NVIDIA Nemotron 3 Ultra), kreeg het 100% van de visies perfect uitgevoerd, met nul fouten.

Waarom dit ertoe doet

Het paper betoogt dat het simpelweg laten schrijven van eisen door een AI gevaarlijk is, omdat het dingen kan verzinnen die niet werken. Maar door een strikte, wiskundige "Inspecteur" de opdracht te geven om de regels te controleren, kun je de AI creatief laten zijn zonder dat je bang hoeft te zijn dat hij de wetten van de logica overtreedt.

De auteurs lieten ook zien dat dit systeem snel is. De "Inspecteur" neemt minder dan 0,4% van de totale tijd in beslag, wat betekent dat het de boel niet vertraagt. Ze bewezen ook dat het systeem goed schaalt: naarmate de lijst met opties groter wordt, neemt het aantal keren dat de AI met het systeem moet communiceren alleen maar lineair toe, en niet met een extreme curve.

Kortom, dit paper bewijst dat je kunt hebben wat je wilt: je kunt de flexibele, natuurlijke taal van AI gebruiken om te beschrijven wat je wilt, terwijl een strikt, onbreekbaar regelboek ervoor zorgt dat wat je krijgt ook daadwerkelijk bouwbaar en correct is. Het verandert de "dagdromende" AI in een betrouwbare ingenieur.

Technisch Samenvatting: Model-gestuurde Requirementsconfiguratie met Drie-waardige Onzekerheidsscoring

1. Probleemstelling

Requirements engineering (RE) is inherent aan hoge kosten en foutgevoeligheid. Hoewel formele domeinmodellen zoals de Object-Oriented Method for Requirements Authoring and Management (OOMRAM) rigoureuze wiskundige structuren bieden voor het beheren van variabiliteit in softwareproductlijnen, lijdt hun traditionele toepassing onder een "exact-match bottleneck". Deze formalismen vereisen dat analisten complexe roosters (lattices) navigeren met behulp van exacte requirement-identifiers of rigide syntaxis, wat het gebruik van natuurlijke taalprojectbeschrijvingen (visies) voor elicitatie verhindert.

Daartegenover bieden Large Language Models (LLM's) de flexibiliteit om natuurlijke taal te interpreteren, maar missen zij garanties op formele correctheid. Bij toepassing op RE genereren pure LLM-benaderingen vaak structureel ongeldige requirements, logische inconsistenties (bijv. het selecteren van wederzijds uitsluitende opties) en gehallucineerde identifiers. Bestaande Neuro-Symbolische benaderingen verifiëren logica vaak ex-post (na generatie) of vertrouwen op heuristische mitigatie, waarbij ze falen om de deterministische handhaving te bieden die vereist is voor high-assurance requirements engineering.

2. Methodologie

Het paper stelt een neuro-symbolische multi-agent architectuur voor die de OOMRAM-lattice operationaliseert om natuurlijke taalvisies te overbruggen met formele structurele beperkingen. Het systeem is ontworpen voor de fase van feature-selectie bij productlijn-requirements elicitatie, waarbij het doel is om te identificeren welke requirements uit een vooraf geconstrueerde lattice gemandateerd of compatibel zijn met een stakeholdervisie.

2.1. Systeemarchitectuur

Het systeem, geïmplementeerd met LangGraph, bestaat uit vier agenten:

Navigator: Voert een depth-first traversatie uit van de OOMRAM-lattice en selecteert de volgende discriminant-node om te verwerken. Het maakt gebruik van een frontier-gebaseerde strategie om lineaire schaalbaarheid te garanderen en redundante verwerking te voorkomen.
Interpreter (LLM): Fungeert als een niet-deterministische heuristiek. Het vertaalt de projectvisie en de huidige context naar een voorgestelde set kind-requirement ID's (output als JSON). Het werkt op temperatuur 0 om stochasticiteit te minimaleren.
Validator (Symbolisch): Een deterministische Python-functie die direct na elke Interpreter-voorstel de structurele beperkingen afdwingt. Het controleert de selectieset $S$ $S$ tegen de globale consistentie-predicaat $\Psi(S)$ $Ψ (S)$ , die vier axiomatische invarianten bevat:
1. Core Invariant: Verplichte selectie van Core-nodes als hun ouder actief is.
2. Single-Adaptor (SA) Invariant: Precies één kind moet worden geselecteerd voor SA-nodes (XOR-logica).
3. Multiple-Adaptor (MA) Invariant: Ten minste één kind moet worden geselecteerd voor MA-nodes (OR-logica).
4. Structurele Integriteit: Geen orphaned nodes; elke geselecteerde niet-root node moet een geselecteerde ouder hebben.
Scribe: Compileert de uiteindelijke gevalideerde set naar een geformatteerde specificatie.

2.2. De Correctieloop

Als de Validator een schending detecteert, wijst het het voorstel af en geeft het een gedetailleerde foutmelding terug aan de Interpreter. De Interpreter reviseert vervolgens zijn voorstel met behulp van deze feedback. Deze lus gaat door totdat de beperkingen zijn voldaan of een "call budget" (beperkt tot 150 LLM-calls per visie) is bereikt.

2.3. Drie-waardige Onzekerheidsscoring

Om de beperking van binaire "correct/incorrect" labeling aan te pakken, introduceren de auteurs een drie-waardig framework $\langle T, I, F \rangle$ toegepast op de Validator-output:

Waarheid ( $T$ ): De selectie is structureel geldig en wordt expliciet gemandateerd door de visie (of een gold-standard specificatie).
Indeterminatie ( $I$ ): De selectie is structureel geldig maar niet expliciet gemandateerd. Dit vertegenwoordigt legitieme discretionaire keuzes (bijv. het selecteren van een specifiek protocol uit een set geldige adapters).
Onwaarheid ( $F$ ): De selectie werd door de Validator afgewezen vanwege een structurele schending.

Deze scoring stelt het systeem in staat om de "legitieme vrijheid" die inherent is aan de requirements-lattice te kwantificeren versus werkelijke fouten.

3. Belangrijkste Bijdragen

Neuro-Symbolische Architectuur: Een systeem dat structurele logica overdraagt aan een deterministische symbolische laag, waardoor formele OOMRAM-lattices praktisch bruikbaar worden voor natuurlijke taal-elicitatie terwijl structurele conformiteit gegarandeerd blijft.
Drie-waardig Evaluatieframework: Een nieuwe metriek om gemandateerde requirements, geldige discretionaire keuzes en structurele fouten van elkaar te onderscheiden, wat een formele manier biedt om neurale onzekerheid te meten.
Empirische Validatie: Een uitgebreide evaluatie over 37 natuurlijke taal projectvisies verspreid over elf applicatiefamilies (bijv. Smart Home, eRecord Keeping, Automotive IVI).
Formeel Bewijs en Baseline Vergelijking: Een formeel bewijs van validator convergentie en een vergelijkende analyse die de superioriteit van het systeem aantoont ten opzien van onbeperkte LLM's en standaard NLP4RE-strategieën (RAG, Self-Consistency, Multi-agent Debate).

4. Resultaten

Het systeem werd geëvalueerd op een Apple M1 Pro machine met het Llama 3.1 8B model, met een replicatie met het NVIDIA Nemotron 3 Ultra frontier model.

Structurele Conformiteit (RQ1): Het systeem elimineerde structurele inconsistenties in 35 van de 37 gevallen (94,6%). De resterende twee gevallen bevatten slechts 6 onopgeloste structurele fouten (0,39% van de totale beslissingen), toegeschreven aan het bereiken van de iteratielimiet voordat convergentie optrad. Onder het frontier model (Nemotron 3 Ultra) bereikte het systeem 100% convergentie met 0% structurele onwaarheid.
Onzekerheidskwantificatie (RQ2): De drie-waardige analyse onthulde dat 24,7% van alle beslissingen Indeterminaat ( $I$ ) was. Dit waren structureel geldige keuzes die niet expliciet gemandateerd werden, geconcentreerd in voornamelijk Multiple-Adaptor (MA) en Optional nodes. Dit bevestigt dat het systeem correct identificeert waar de stakeholderintentie ondergespecificeerd is.
Baseline Vergelijking (RQ3): Zonder de symbolische validator resulteerden onbeperkte LLM-strategieën in structurele onwaarheidscijfers variërend van 62,2% tot 94,6%. Het neuro-symbolische systeem reduceerde dit tot 5,4% (Llama 3.1 8B) en 0,0% (Nemotron 3 Ultra). Opvallend genoeg leed een RAG-baseline aan een onwaarheidscijfer van 94,6% door retrieval anchoring bias, waarbij de LLM blad-nodes selecteerde zonder hun vereiste ouderpaden.
Schaalbaarheid (RQ4): Het aantal LLM-calls schaalt bijna lineair met de lattice-grootte ( $R^2 = 0,69$ ), wat de efficiëntie van de frontier-gebaseerde pruning strategie bevestigt. Echter, de wall-clock latentie wordt gedomineerd door netwerk/model-serving overhead in plaats van lattice-complexiteit. De symbolische validator voegt verwaarloosbare overhead toe (<0,4% van de totale latentie).

5. Betekenis en Claims

Het paper claimt dat het overdragen van structurele integriteit aan een deterministische symbolische laag succesvol de structurele conformiteit garandeert, waardoor inconsistente neurale outputs effectief worden getransformeerd in geverifieerde, structureel gezonde specificaties.

Veiligheid bij Implementatie: De architectuur biedt een algemeen ontwerppatroon voor veilige LLM-implementatie in veiligheidskritische of kwaliteitsgevoelige domeinen door de neurale heuristiek te scheiden van de symbolische constraint checker. Dit zorgt ervoor dat de LLM-component kan worden geüpgraded zonder de formele garanties in gevaar te brengen.
Actiegerichte Feedback: De drie-waardige classificatie biedt practitioners directe feedback. Hoge indeterminatie signaleert ondergespecificeerde visies die verduidelijking door de analist vereisen, terwijl aanhoudende onwaarheid (hoewel zeldzaam) specifieke model-niveau misverstanden of lattice-problemen aanwijst.
Formele Rigor: In tegen tegenover heuristische benaderingen biedt dit systeem een deterministische garantie: voor elke run die convergeert binnen het call budget, is gegarandeerd dat de uiteindelijke output aan alle lattice-beperkingen voldoet.

De auteurs nemen een bescheiden standpunt in door te erkennen dat het systeem geen semantische hallucinaties kan detecteren (structureel geldige maar irrelevante selecties) en afhankelijk is van vooraf geconstrueerde OOMRAM-lattices. Ze merken op dat hoewel de symbolische laag structurele correctheid garandeert, het vermogen van de LLM om foutmeldingen te volgen en te convergeren modelafhankelijk blijft, zoals blijkt uit het verschil in prestaties tussen de 8B en de frontier modellen. Toekomstig werk wordt voorgesteld om lattice-extractie te automatiseren, semantische routing voor familie-selectie te integreren, en over te stappen van crisp drie-waardige scoring naar continue waarschijnlijkheidsgebaseerde onzekerheidsvisualisatie.