💻 computer science

Causal Past Logic for Runtime Verification of Distributed LLM Agent Workflows

Dit artikel introduceert Causal Past Logic (CPL), een broncode-temporale logica geïntegreerd in het ZipperGen-framework die gedistribueerde LLM-agenten in staat stelt om online runtime-verificatie van controlevloer uit te voeren op basis van causaal zichtbare gebeurtenissen in plaats van sequentiële logs, met gebruik van een vector-klokmonitor om semantische correctheid te waarborgen.

Oorspronkelijke auteurs: Benedikt Bollig

Gepubliceerd 2026-05-21

📖 5 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Benedikt Bollig

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 een team van gespecialiseerde AI-agenten voor die samenwerken aan een groot project, zoals het controleren van een stuk code voordat het wordt samengevoegd in een softwaresysteem. In de oude denkwijze zouden we deze agenten misschien voorstellen als iemand die met elkaar praat in één perfecte lijn van gesprek, zoals een transcript van een telefoongesprek waarbij iedereen alles in exact dezelfde volgorde hoort.

Maar in werkelijkheid zijn deze agenten als mensen in verschillende tijdzones die asynchroon werken. Ze sturen berichten, doen hun eigen werk en nemen beslissingen op verschillende snelheden. Soms neemt Agent A een beslissing op basis van een bericht dat ze hebben ontvangen, zonder te beseffen dat Agent B al een kritieke fout heeft gevonden en een nieuw bericht heeft gestuurd dat nog niet op Agent A's bureau is aangekomen.

Dit paper introduceert een nieuwe manier om deze beslissingen te hanteren, zodat het team geen fouten maakt op basis van onvolledige of verouderde informatie. Hier is de uiteenzetting met eenvoudige analogieën:

Het Probleem: De "Op Verkeerde Volgorde" Postbus

Stel je voor dat je een manager bent (de "Committer") die wacht op rapporten van twee inspecteurs: een "Test Runner" en een "Beveiligingsagent".

De Valstrik: Je ontvangt een rapport met de tekst "Tests Geslaagd". Je staat op het punt het project goed te keuren.
De Realiteit: De Beveiligingsagent heeft eigenlijk een enorme bug gevonden na het slagen van de test, maar hun nieuwe rapport zit nog vast in de post.
De Fout: Als je gewoon kijkt naar een eenvoudige lijst van berichten in de volgorde waarin ze zijn aangekomen, zou je kunnen denken dat alles in orde is. Maar als je kijkt naar de causale realiteit (wat je op dit exacte moment weet), weet je nog niets van de bug.

Het paper stelt dat we de beslissingen van het team niet moeten beoordelen op basis van een "perfect, globaal log" van alles wat is gebeurd. In plaats daarvan moeten we ze beoordelen op basis van wat causaal zichtbaar is voor de persoon die op dit moment de beslissing neemt.

De Oplossing: "Causale Verleden Logica" (CPL)

De auteurs hebben een nieuwe "taal" gecreëerd die de agenten kunnen gebruiken bij het nemen van beslissingen. Denk hierbij aan een slimme checklist die een agent kan lezen voordat ze op "Goedkeuren" klikt.

In plaats van alleen te vragen: "Heb ik een 'Geslaagd'-bericht ontvangen?", vraagt de agent:

"Heeft de Test Runner causaal gezien dat de tests geslaagd zijn, en heb ik causaal gezien een bericht dat zegt dat ze zijn mislukt sindsdien?"

Deze logica stelt een agent in staat om te zeggen: "Ik zie het 'Geslaagd'-bericht, en ik heb nog geen 'Mislukt'-bericht gezien, dus ik kan doorgaan." Het stelt hen ook in staat om specifieke details te controleren, zoals: "Gaat dit 'Geslaagd'-bericht over dezelfde versie van de code waar ik nu naar kijk?"

Hoe Het Werkt: De "Vectorklok" Rugzak

Om dit te laten werken zonder een centrale baas die iedereen in de gaten houdt, draagt elke agent een rugzak (een "Vectorklok" genoemd).

Elke keer dat een agent iets doet of een bericht ontvangt, updatet ze hun rugzak.
Wanneer ze een bericht sturen naar een vriend, doen ze hun rugzak in de envelop.
Wanneer de vriend de envelop ontvangt, haalt ze de rugzak eruit en voegt de rugzak van de afzender samen met hun eigen rugzak.

Deze rugzak vertelt de agent precies: "Ik weet van 3 dingen die de Test Runner heeft gedaan, en 2 dingen die de Beveiligingsagent heeft gedaan." Het maakt niet uit of de berichten laat zijn aangekomen; de rugzak zorgt ervoor dat de agent precies weet welke informatie op dit specifieke moment voor hen beschikbaar is.

Het "Wachter"-Mechanisme

In dit systeem is de "Wachter" geen beveiligingsagent die buiten staat en achteraf een logboek controleert. De Wachter is een regel die direct in de workflow is geschreven.

Oude Manier: De workflow draait, is klaar, en dan controleert een monitor: "Hé, je hebt een fout gemaakt omdat je een bericht hebt gemist!" (Te laat om het te herstellen).
Nieuwe Manier (CPL): De workflow pauzeert op het beslispunt. De agent controleert hun "Causale Verleden Logica"-regel. Als de regel zegt: "Ik heb de laatste mislukking niet gezien", stopt de workflow automatisch en vraagt om een nieuwe controle. Het voorkomt de fout voordat deze gebeurt.

Het Wereldvoorbeeld: De Code Review

Het paper gebruikt een code-reviewscenario om te bewijzen dat dit werkt:

De Opstelling: Een "Committer" wacht op een "Test Runner" en een "Beveiligingsagent".
Het Scenario: De Test Runner zegt "Geslaagd". De Committer is klaar om te samenvoegen.
De Twist: De Test Runner vindt later een mislukking, maar dat bericht is de Committer nog niet bereikt.
Het Resultaat: Omdat de Committer CPL gebruikt, kijken ze naar hun "causale verleden". Ze zien het "Geslaagd"-bericht en zien het "Mislukt"-bericht niet (omdat het nog niet is aangekomen). Dus, ze gaan door.
- Wacht, is dat niet gevaarlijk? Het paper zegt: Nee. Het beleid is: "Voeg samen als je geen mislukking hebt gezien." Als de mislukking was aangekomen, zou de wachter de samenvoeging hebben geblokkeerd. Als de mislukking later arriveert, is het systeem ontworpen om dat aan te kunnen (misschien door later opnieuw te controleren), maar de Committer mag niet de schuld krijgen voor het niet kennen van de toekomst.

Samenvatting

Dit paper geeft gedistribueerde AI-agenten een manier om slimme, veilige beslissingen te nemen op basis van wat ze op dit moment daadwerkelijk weten, in plaats van wat een perfecte waarnemer later zou weten. Het gebruikt een "rugzak"-systeem om de informatieflow bij te houden en een speciale "logica-taal" om ervoor te zorgen dat agenten alleen vooruit gaan wanneer het causale bewijs dit ondersteunt. Hierdoor verandert runtime-monitoring van een "post-mortem" (kijken naar het lichaam na de misdaad) in een "verkeerslicht" (de auto stoppen voordat het ongeluk gebeurt).

Technische Samenvatting: Causale Verleden Logica voor Runtime-Verificatie van Gedistribueerde LLM-Agent Workflows

Probleemstelling
Gedistribueerde workflows van Large Language Model (LLM)-agenten, waarbij meerdere agenten asynchroon interageren zonder gedeeld geheugen, kunnen niet effectief worden gemonitord alsof ze één sequentieel logboek produceren. Bij asynchrone uitvoeringen hangt een beslissing genomen door een agent (een "levenslijn") uitsluitend af van gebeurtenissen die causaal voor die agent zichtbaar zijn. Een gebeurtenis die eerder in een globaal sequentieel logboek verschijnt, is lokaal mogelijk nog niet bekend, terwijl een lokaal recente gebeurtenis mogelijk niet de nieuwste staat van een externe agent weerspiegelt.

Bestaande benaderingen voor runtime-verificatie vertrouwen vaak op sequentiële traces of loganalyse achteraf. Voor agent-workflows is dit echter onvoldoende, omdat monitoring de uitvoering moet beïnvloeden op het moment van de beslissing. Als een besluitnemer (bijvoorbeeld een Committer) causaal geen schoon testresultaat heeft gezien, mag het systeem niet later samenvoegen en een overtreding rapporteren; het moet de samenvoeging blokkeren of onmiddellijk een nieuwe uitvoering aanvragen. Bovendien behandelen standaard beveiligingsmechanismen in LLM-toepassingen uitvoering vaak als een sequentieel logboek, waarbij de causale structuur die nodig is voor correcte gedistribueerde besluitvorming wordt genegeerd.

Methodologie
De auteurs breiden het ZipperGen-kader uit, een choreografisch programmeerstelsel voor gedistribueerde LLM-agenten, door Causale Verleden Logica (CPL) in te voeren.

Formeel Model (MSC's): Uitvoeringen worden gemodelleerd als Message Sequence Charts (MSC's), waarbij gebeurtenissen over levenslijnen zijn verdeeld. De causale orde wordt gedefinieerd door de reflexieve transitieve sluiting van lokale opvolging en berichtbezorging. Elke gebeurtenis draagt een waardering van lokale variabelen.
Causale Verleden Logica (CPL): CPL is een kleine tijdslogica voor het verleden, ontworpen als een broncode-niveau bewaaktaal.
- Syntaxis: Formules omvatten standaard modaliteiten voor het verleden (Vorige $Y$ , Sinds $S$ ) geïnterpreteerd langs een enkele levenslijn, en een causale modus $@A(\phi)$ die $\phi$ evalueert bij de laatste gebeurtenis van levenslijn $A$ die causaal zichtbaar is voor de huidige gebeurtenis.
- Toegang tot Variabelen: De logica ondersteunt termen zoals $@A.x$ , die de waarde van variabele $x$ lezen bij de laatste causaal zichtbare gebeurtenis van levenslijn $A$ .
- Semantiek: Een bewaker $\phi@A$ wordt lokaal geëvalueerd door de eigenaar-levenslijn $A$ op een beslissingspunt (tak of lus). De waarheidswaarde bepaalt de controlestroom. De logica is niet-streng: als er geen gebeurtenis van $A$ zichtbaar is, evalueert de formule tot onwaar.
Online Monitoringalgoritme:
- De auteurs stellen een gedistribueerd monitoringalgoritme voor waarbij elke levenslijn een vector-klok en laatste-waarde-weergaven bijhoudt.
- Staat: Elke agent houdt een vector-klok bij om het aantal gebeurtenissen te volgen dat van elke andere levenslijn is gezien. Het houdt ook een gedeeltelijke kaart bij van "laatste-waarde-weergaven" voor booleaanse formules en variabele-waarden van andere levenslijnen.
- Propagatie: Wanneer een agent een bericht stuurt, voegt het zijn huidige vector-klok en laatste-waarde-weergaven toe. Bij ontvangst van een bericht voegt de agent deze weergaven samen met zijn lokale staat, werkt de vector-klok bij en evalueert alle bewakers opnieuw van onderop.
- Correctheid: Het algoritme zorgt ervoor dat de lokaal berekende monitorwaarde overeenkomt met de denotationele semantiek van de bewaker over de MSC.

Belangrijkste Bijdragen

Causale Verleden Logica (CPL): Een nieuwe logica voor gedistribueerde agent-workflows die standaard operatoren voor het verleden combineert met causale toegang tot de laatst zichtbare staat van andere agenten. Het stelt bewakers in staat om voorwaarden uit te drukken zoals "de vereiste tests zijn geslaagd en er is sindsdien geen enkele mislukking gezien, in het causale verleden."
Bewaakregels op Broncode-niveau: In tegenstelling tot externe monitors die logboeken achteraf controleren, zijn CPL-formules geïntegreerd in de broncode van de workflow. Ze worden online geëvalueerd door de besluitnemer om de controlestroom direct te beïnvloeden.
Gedistribueerde Monitoring met Vector-klokken: Een efficiënt online monitoringalgoritme dat vector-klokken en laatste-waarde-weergaven gebruikt om causale zichtbaarheid te volgen zonder een centrale waarnemer of een globaal sequentieel logboek te vereisen.
Formele Verificatie: De definities van MSC's, CPL-tevredenheid, de lokale evaluator en de monitor-correctheidstheorema zijn gemechaniseerd en geverifieerd in Lean 4. Het artikel bewijst dat de lokale runtime-evaluatie van een bewaker overeenkomt met zijn denotationele semantiek bij de huidige gebeurtenis.
Prototype-implementatie: Een prototype-implementatie in het ZipperGen-kader (Python) toont de haalbaarheid van de aanpak, waarbij wordt getoond hoe bewakers variabelen over levenslijnen kunnen vergelijken (bijvoorbeeld ervoor zorgen dat een testresultaat overeenkomt met de huidige samenvoegingskandidaat).

Resultaten

Theoretisch: Het artikel bewijst Lemma 1 (Correctheid van lokale evaluatie) en Lemma 2 (Invarianten van monitor-staat), wat leidt tot Theorema 1 (Monitor-correctheid). Deze bewijzen stellen vast dat het gedistribueerde algoritme de waarheidswaarde van elke CPL-formule correct berekent op basis van het causale verleden dat zichtbaar is voor de eigenaar-levenslijn.
Praktisch: De prototype-implementatie in ZipperGen behandelt succesvol het voorbeeld van een gedistribueerde code-review, waarbij een Committer besluit een patch alleen te samenvoegen als het causaal slagen van tests en beveiligingsscans ziet voor de specifieke kandidaat, en de samenvoeging blokkeert als een mislukking zichtbaar is in het causale verleden.

Betekenis
Het artikel betoogt dat runtime-verificatie voor gedistribueerde LLM-agent-workflows verder moet gaan dan analyse van sequentiële logboeken. Door monitoring te behandelen als een integraal onderdeel van de coördinatie-taal (via bewaakregels op broncode-niveau), kan het systeem correcte beslissingen nemen op basis van de causaal zichtbare informatie die beschikbaar is op het beslissingspunt, in plaats van te wachten op een globaal logboek of een centrale waarnemer. Deze aanpak adresseert het fundamentele probleem van gedistribueerd programmeren waarbij lokale beslissingen afhankelijk zijn van gedeeltelijke causale inzichten. Het werk overbrugt de kloof tussen choreografisch programmeren (globale specificaties geprojecteerd op lokale agenten) en runtime-handhaving, zodat veiligheids- en coördinatieregels dynamisch en causaal correct worden afgedwongen.