Specification-Driven Generation and Evaluation of Discrete-Event World Models via the DEVS Formalism

Dit paper introduceert een aanpak die de DEVS-formalisme en een gefaseerde LLM-generatiepiplijn combineert om op basis van natuurlijke taal specificaties verifieerbare, aanpasbare en consistente discrete-evenementwereldmodellen te synthetiseren die een middenweg bieden tussen handmatig ontworpen simulatoren en impliciete neurale modellen.

De kern

Stel je voor dat je een reusachtig, ingewikkeld bordspel wilt spelen, maar in plaats van de regels zelf te schrijven, vraag je aan een super-slimme, maar soms wat dromerige AI: "Hé, maak maar een spelletje voor mij over een magazijn met robots."

Deze paper, getiteld "Specification-Driven Generation and Evaluation of Discrete-Event World Models via the DEVS Formalism", gaat precies over dat probleem: hoe maak je zo'n spel (een 'wereldmodel') dat werkt, betrouwbaar is en niet vol zit met rare fouten, terwijl je het laat maken door een AI?

Hier is de uitleg in simpele taal, met een paar leuke vergelijkingen:

1. Het Probleem: Twee Uitersten

Op dit moment zijn er twee manieren om deze digitale werelden te maken, en beide hebben een groot nadeel:

• De Handgemaakte Simulatie (De "Architect"): Dit is als een bouwpakket dat door een mens is ontworpen. Het werkt perfect, is voorspelbaar en je kunt het makkelijk repareren. Maar het is duur en traag om te maken. Als je morgen een nieuw soort robot wilt, moet je alles opnieuw tekenen.
• De "Black Box" AI (De "Dromer"): Dit is een AI die leert door te kijken naar voorbeelden. Het is flexibel en snel, maar vaak onbetrouwbaar. Het kan een wereld simuleren die er op het eerste gezicht goed uitziet, maar na een paar minuten begint de logica te haperen (bijvoorbeeld: een robot verdwijnt uit het niets, of een pakket komt aan voordat het is verzonden). Het is alsof je een droom vertelt: het klinkt logisch, maar als je erin stapt, is de grond soms weg.

De oplossing in deze paper: Een "gouden middenweg". Ze willen een wereldmodel dat snel door AI gemaakt kan worden, maar dat net zo betrouwbaar is als een handgemaakt spel.

2. De Oplossing: DEVS (De "Blokkenkast")

De auteurs gebruiken een bestaand systeem dat DEVS heet. Denk aan DEVS als een gigantische Legokast met strikte regels.

In plaats van de AI te vragen "Maak een heel spel", vragen ze de AI om losse, kleine blokken te maken die perfect in elkaar passen:

• Een blok voor de "Robot".
• Een blok voor de "Lader".
• Een blok voor de "Bestelling".

Elk blok heeft een exacte handleiding (een contract): "Als je een berichtje krijgt van links, doe dan X. Als je klaar bent, stuur dan een berichtje naar rechts."

3. Hoe werkt het? (Het Bouwproces)

De paper beschrijft een slimme bouwstap-voor-stap methode:

1. De Plattegrond (Structuur): Eerst laat je de AI kijken naar de tekstuele beschrijving (bijv. "Robots laden batterijen"). De AI maakt dan een plattegrond: "Oké, we hebben 5 robots en 3 laders. De robots moeten met de laders praten." Dit is het skelet van het spel.
2. De Bouwers (Gedrag): Vervolgens krijgen speciale AI-agenten de opdracht om elk blok apart te bouwen. Omdat ze maar één klein blok hoeven te maken, maken ze minder fouten. Ze bouwen de logica voor de robot, de logica voor de lader, etc., allemaal volgens de strikte regels van de Legokast.
3. De Aansluiting: Ten slotte worden de blokken aan elkaar geklikt. Omdat elk blok zijn eigen handleiding had, weten ze precies hoe ze met elkaar moeten praten.

Het leuke voordeel: Als je een groter spel wilt (bijv. 100 robots in plaats van 5), hoef je niet alles opnieuw te bouwen. Je bouwt gewoon meer van dezelfde blokken. Dat is schaalbaar.

4. De Controle: De "Rekenmeester"

Hoe weet je of het spel werkt zonder dat je urenlang hoeft te spelen?
In plaats van te kijken of de code klopt (wat lastig is omdat er geen "juiste" code bestaat), kijken ze naar de geschiedenis van het spel (de "event trace").

Stel je voor dat elk blok een dagboek bijhoudt.

• Robot: "Ik ben vertrokken om 10:00."
• Lader: "Ik heb de robot om 10:05 ontvangen."

De computer kijkt naar deze dagboeken en controleert of ze logisch zijn: "Wacht, de robot vertrok om 10:00, maar de lader zag hem pas om 10:05? Dat kan niet, ze moeten elkaar zien!"

Als er een fout is, weet de computer precies welk blok de fout heeft gemaakt en waar in de tekst de regel werd overtreden. Het is alsof je een spoorzoeker bent die precies weet waar de trein ontspoord is, in plaats van het hele spoor opnieuw te moeten leggen.

5. Waarom is dit belangrijk?

• Betrouwbaarheid: Je kunt langdurige simulaties doen (bijv. "Wat gebeurt er met dit magazijn over 10 jaar?") zonder dat de logica uit elkaar valt.
• Snelheid: Het is veel sneller en goedkoper dan mensen alles handmatig te laten programmeren.
• Flexibiliteit: Je kunt de regels online aanpassen. Wil je morgen 10 robots in plaats van 5? De AI past de blokken direct aan.

Samenvatting in één zin

Deze paper leert AI om complexe digitale werelden te bouwen door ze op te splitsen in kleine, goed gedefinieerde Legoblokjes (DEVS), zodat je snel een betrouwbaar spel krijgt dat je kunt controleren door naar de dagboeken van de blokjes te kijken, in plaats van naar de hele code.

Het is de overgang van "AI droomt een wereld" naar "AI bouwt een wereld met een strikt bouwplan".

Technische samenvatting

1. Probleemstelling

De opkomst van Large Language Models (LLM's) als algemene agenten heeft de behoefte aan wereldmodellen (modellen die hypothetische roll-outs van omgevingsdynamiek ondersteunen) vergroot. Bestaande benaderingen bevinden zich echter op twee uitersten met elk ernstige beperkingen:

• Handmatig ontworpen simulators: Deze bieden consistentie en reproduceerbaarheid, maar zijn kostbaar aan te passen en moeilijk te schalen naar nieuwe omgevingen, vooral in online settings.
• Impliciete neurale modellen: Deze zijn flexibel en kunnen online worden aangepast, maar zijn moeilijk te construeren, verifiëren en debuggen over lange tijdsperiodes. Kleine fouten stapelen zich op (drift), en de onderliggende aannames over timing en causaliteit zijn vaak vaag.

Er is een gebrek aan een principiële middenweg: wereldmodellen die consistent zijn over lange roll-outs, reproduceerbaar en verifieerbaar zijn op basis van waarneembaar gedrag, en toch efficiënt op aanvraag kunnen worden gegenereerd of aangepast tijdens de uitvoering.

2. Methodologie

De auteurs stellen een nieuwe aanpak voor die zich richt op een specifieke klasse van omgevingen: die waarin de dynamiek wordt gedomineerd door de volgorde, timing en causaliteit van discrete gebeurtenissen (bijv. wachtrijen, serviceoperaties, netwerkprotocollen, multi-agent coördinatie).

De kern van de methodologie bestaat uit drie pijlers:

A. Formalisme: DEVS (Discrete Event System Specification)

In plaats van een monolithische simulator te genereren, gebruiken de auteurs het DEVS-formalisme. Dit decomposeert systemen in hiërarchische composities van:

• Atomaire modellen: Bevatten lokale staat, event-handling logica en timing-semantiek.
• Gekoppelde modellen: Definieren hoe atomaire modellen met elkaar communiceren via gebeurtenismessages.
  Dit zorgt voor een expliciete, uitvoerbare representatie van de wereld die consistentie garandeert en drift voorkomt.

B. Staged LLM-Generatiepijplijn (DEVS-Gen)

De auteurs introduceren een gefaseerde generatiepijplijn die de complexiteit van codegeneratie reduceert door deze te ontkoppelen van de schaal van de omgeving:

1. Structurele Synthese: Een LLM-analyseert de natuurlijke taal-specificatie en genereert een PlanTree. Dit bepaalt de componenthiërarchie, de interactiegrafieken en de interfacecontracten (input/output-poorten) zonder direct code te schrijven.
2. Gedragsmatige Synthese: Op basis van de PlanTree worden atomaire componenten parallel gegenereerd. Een "Summarizer"-agent analyseert de gegenereerde code van sub-componenten om de "ground-truth" interfaces te extraheren. Dit voorkomt integratiefouten door kleine afwijkingen in de implementatie en past de koppeling van de bovenliggende modellen dynamisch aan.

C. Trace-gebaseerde Evaluatie

Omdat er geen unieke "ground truth" implementatie is voor natuurlijke taal-specificaties, evalueren de auteurs de gegenereerde modellen niet op code-equivalentie, maar op gedragsconformiteit:

• De gegenereerde simulator emiteert gestructureerde gebeurtenistraces (in JSONL-formaat).
• Een verificatieframework controleert of deze traces voldoen aan temporele en semantische constraints afgeleid van de specificatie (bijv. volgorde van gebeurtenissen, tijdsbepalingen, behoudswetten).
• Bij schendingen worden lokale diagnoses gegenereerd die de specifieke constraint en verantwoordelijke entiteit identificeren.

3. Belangrijkste Bijdragen

• DEVS als Operationele Representatie: Het formaliseren van wereldmodellen als uitvoerbare DEVS-simulators die direct uit natuurlijke taal worden gegenereerd, wat expliciete interfaces en traceerbaarheid biedt.
• Modulaire Generatiepijplijn: Een architectuur die structurele planning en gedragsmatige implementatie scheidt, waardoor parallelle generatie mogelijk is en de contextuele last voor LLM's wordt verminderd.
• Specificatie-gedreven Evaluatie: Een nieuw evaluatiekader dat zich richt op trace-conformiteit in plaats van code-identiteit, wat robuustheid biedt tegen de variabiliteit in LLM-generatie.
• Dataset en Benchmark: Een curated dataset van 7 complexe scenario's (van bankzaken tot netwerkprotocollen en biologische modellen) die zijn afgeleid van bestaande, hoogwaardige DEVS-modellen, maar vertaald naar natuurlijke taal.

4. Resultaten

De auteurs evalueren hun methode (DEVS-Gen) tegen state-of-the-art LLM-software-engineering agents (zoals OpenHands en SWE-Agent) over 7 benchmarks.

• Effectiviteit: DEVS-Gen bereikt vergelijkbare prestaties op operationeel succes (SOSS) en gedragsconformiteit (BCS) als iteratieve agents, maar zonder de mogelijkheid om code uit te voeren en zichzelf te corrigeren. Bijvoorbeeld, met GPT-5.2 behaalde DEVS-Gen een SOSS van 0,86, dicht bij de iteratieve OpenHands (0,96), terwijl deze wel toegang had tot uitvoeringstools.
• Efficiëntie: DEVS-Gen is aanzienlijk efficiënter. Het verbruikt ongeveer 10x minder tokens en is sneller dan iteratieve agents, vooral bij kleinere modellen. Iteratieve agents lopen vaak vast in "doom loops" van debuggen, terwijl DEVS-Gen een gestructureerde, eenmalige generatie volgt.
• Schaalbaarheid: Door de modulaire aard van DEVS kan de generatie van atomaire componenten parallel worden uitgevoerd. Dit verlaagt de theoretische tijdcomplexiteit van lineair $O(N)$ naar logaritmisch $O(\log N)$ voor diep geneste systemen.
• Robuustheid: Bij kleinere LLM's presteert DEVS-Gen aanzienlijk beter dan baselines, omdat de taak wordt opgesplitst in beheersbare, lokaal gedefinieerde subproblemen.

5. Betekenis en Impact

Dit werk biedt een schalbare, discrete-event basis voor lange-termijn redenering in agentic systemen.

• Betrouwbaarheid: Het lost het probleem van "drift" op in impliciete wereldmodellen door expliciete, uitvoerbare logica te forceren.
• Verifieerbaarheid: Het introduceert een nieuwe standaard voor het evalueren van gegenereerde simulaties via trace-conformiteit, wat essentieel is voor kritieke toepassingen.
• Toekomstperspectief: De framework legt de basis voor hybride systemen waarin LLM's zelf kunnen worden ingebed als gebeurtenisgenererende entiteiten binnen DEVS-componenten, wat leidt tot gecoördineerde multi-agent systemen en sociale simulaties die volledig via natuurlijke taal worden gespecificeerd.

Kortom, het artikel demonstreert dat het combineren van formele simulatietheorie (DEVS) met moderne LLM-generatie een praktische middenweg biedt tussen de stijfheid van handmatige simulatoren en de onbetrouwbaarheid van pure neurale wereldmodellen.