Procedural Graphs: zelfevoluerende proceduregrafen voor langlopende AI-agents

Een AI-agent die over lange horizon werkt, verliest zijn doel uit het oog, roept tools in de verkeerde volgorde aan en herhaalt onproductieve acties. Dat is geen modelprobleem, het is een representatieprobleem: de procedurele kennis over wat te doen, in welke volgorde en onder welke voorwaarden, blijft impliciet in de modelgewichten of verspreid over ad-hoc prompttemplates, skill libraries en workflowscripts.

Procedural Graphs (Lu, Chen, Wu, Arık; arXiv v1, 8 september 2026) pakt dit aan met een expliciete, bewerkbare gerichte graaf van procedurele kennis. De symmetrie met knowledge graphs is bewust: net zoals een knowledge graph feiten organiseert in (entiteit, relatie, entiteit)-triplets om what-is-vragen te beantwoorden, organiseert een Procedural Graph procedurele kennis in (procedure, relatie, procedure)-triplets om what-to-do-vragen te beantwoorden. De graaf houdt de procedurele kennis buiten de modelgewichten, waar hij geïnspecteerd, per stap opgehaald en zonder retraining bewerkt kan worden.

De kernbijdrage is niet een nieuw model of trainingsalgoritme, maar een architectuur die procedurele kennis expliciet, lokaal ophaalbaar en zelfevoluerend maakt. Dat is precies de procedurele-memory-quadrant van de CoALA-taxonomie die tot nu toe het minst expliciet behandeld is.

Formele definitie

Een Procedural Graph is een gerichte, geattribueerde graaf:

𝒢 = (𝒱, ℛ, ℰ, Φ), met ℰ ⊆ 𝒱 × ℛ × 𝒱

waarin 𝒱 de verzameling abstracte nodes is, ℛ een vocabulaire van transitierelaties, en elk element van ℰ een gericht, geattribueerd triplet: een edge e = (u, r, v) ∈ ℰ stelt dat node v toelaatbaar is na node u onder relatie r. Elke node abstraheert een toolfunctie, een skill, een interne redeneerstap of een taakstatus. De attribuutafbeelding Φ koppelt elke edge aan een set benoemde attributen; in de implementatie drie tekstuele velden: condition (wanneer de transitie geldt), guidance (hoe te handelen) en pitfalls (wat te vermijden).

Een illustratief voorbeeld uit de paper: een financiële-planningsedge (cash_flow_forecast, LEADS_TO, fund_raising_request) draagt de attributen "condition: projected runway valt onder de veiligheidsbuffer; guidance: dien de aanvraag vroeg in om de financieringsvertraging op te vangen; pitfalls: stapel geen tweede aanvraag terwijl er een loopt."

Twee complementaire fasen

De framework werkt in twee fasen. Tijdens online inferentie is de graaf bevroren. Het framework lokaliseert de actieve node uit de agenttrajectorie, haalt de 2-hop-buurt op (of de volledige graaf als matching faalt), en een guidance-model Ψ vertaalt de omringende subgraaf in hun topologische context naar stapsgewijze situationele guidance g_t. Die guidance wordt aan de solver-prompt toegevoegd, maar dicteert de actie niet: de solver behoudt redeneervrijheid terwijl hij naar de procedurele structuur gestuurd wordt.

Tijdens offline zelf-evolutie draait na elke batch trainingstaken een vierstapslus: (1) diagnostische rollout met de behouden graaf, (2) feedback-gedreven mutatie door een LLM-refiner die faaltrajecten met succesvolle contrasten en een gestructureerde editset Δ𝒢 genereert (nodes/edges toevoegen of verwijderen, attributen herzien), (3) validatie-gating op een onafhankelijke validatieset, en (4) rejection memory als safeguard. Een kandidaat wordt alleen gecommitteerd als de validatiescore gelijk blijft of verbetert; afgewezen kandidaten worden als negatieve constraints bewaard om herhaling te ontmoedigen.

De ablatie is het echte bewijs

De benchmarkcijfers zijn indrukwekkend maar zeggen op zichzelf niets over het mechanisme. Twee controles isoleren de werkelijke verklaring.

De lokale buurt verslaat de volledige graaf. Tabel 3 vergelijkt drie configuraties: ruwe injectie van de volledige graaf, generatieve guidance over de volledige graaf, en generatieve guidance over de gelokaliseerde subgraaf. Ruwe injectie van de volledige graaf verbetert gestructureerde dialoog (MultiChallenge stijgt van 80,27 naar 86,60) maar verlaagt belichaamde uitvoering (ALFWorld daalt van 72,58 naar 70,34). Volledige-graaf generatieve guidance verlaagt ALFWorld verder naar 54,48 terwijl het tokenverbruik stijgt. De gelokaliseerde configuratie haalt de hoogste score op alle drie benchmarks (89,31, 63,99, 81,53) en reduceert het tokenverbruik met 70,9% op ALFWorld, 18,1% op GDPval en 14,8% op MultiChallenge ten opzichte van volledige-graaf generatieve guidance. De winst zit niet in meer context maar in de juiste, lokale context.

De zelf-evolutie herstelt een foutieve expert-prior. Op MultiChallenge verlaagt de handgemaakte expertgraaf (Mode 1) het succes van 87,50% naar 58,93%. Een enkele offline update (Mode 2) verlaagt het verder naar 53,57%. De iteratieve configuratie (Mode 3), die verse uitvoeringsfeedback met validatie-gating combineert, herstelt naar 92,86%: een winst van 33,93 punten over de expert-initialisatie. De lus herstelt dus van een expert-prior die de prestaties aanvankelijk verlaagt.

De langhorizon-uitslag: anticipatoire fundraising

De meest overtuigende uitslag komt van EnterpriseArena, een simulator waarin de agent maandelijkse financiële beslissingen neemt over maximaal 132 maanden onder strikte liquiditeitsbeperkingen en drie niet-gediscloseerde macro-economische crises. De overlevingskans over de volledige horizon stijgt van 44,0% naar 58,0% (Claude Sonnet 4.6), van 6,0% naar 34,0% (Gemini 3.1 Pro) en van 26,0% naar 40,0% (Grok 4.1 Fast). De gemiddelde levensduur stijgt voor alle vier modellen.

Wat onder guidance verandert is welke tools worden aangeroepen en wanneer, niet simpelweg hoeveel. De ongeleide Gemini 3.5 Flash-baseline bevraagt herhaaldelijk cash en markttoestand binnen één beurt, voegt redundante observaties toe aan zijn context en doet 18,94 toolcalls per maand; de graaf reduceert dat naar 12,53 terwijl de gemiddelde ondernemingsscore verbetert. Het gedrag dat overleving voorspelt is anticipatoire fundraising: omdat kapitaal één tot zes maanden na de aanvraag arriveert, moet de agent ruim vóór het opraken van de liquiditeit vragen. De ongeleide Flash-baseline initieert fundraising niet vroeg genoeg en haalt $0,00M op; de PG-geleide Flash haalt $9,39M en de PG-geleide Grok $30,11M.

Twee concurrerende hypothesen

De centrale vraag is waarom de Procedural Graph werkt. Twee hypothesen concurreren.

Hypothese H1 (structuur): de winst komt van de expliciete procedurele structuur zelf. De graaf maakt toelaatbare transities expliciet, zodat de agent niet hoeft te reconstrueren welke stappen volgen en in welke volgorde. Dit voorspelt dat de winst het grootst is op taken met strikte actievolgorde (ALFWorld, τ-bench) en op langhorizon-taken waar drift en repetitieve lussen optreden.

Hypothese H2 (context): de winst komt van de situationele guidance die de agent per stap extra context geeft, ongeacht de onderliggende structuur. Dit voorspelt dat een vergelijkbare winst haalbaar is met elke vorm van rijke per-stap context, ook zonder expliciete graaf.

Falsificatiecriteria. H1 is falsifieerbaar: de hypothese wordt weerlegd als een niet-graaf-gebaseerde methode met even rijke per-stap context dezelfde winst haalt op strikte-volgorde-taken. H2 is falsifieerbaar: de hypothese wordt weerlegd als de ablatie aantoont dat de winst verdwijnt wanneer dezelfde guidance zonder de graafstructuur wordt gegeven. De ablatiestudie (Tabel 3) is hier doorslaggevend: ruwe injectie van de volledige graaf verlaagt ALFWorld-succes, terwijl gelokaliseerde generatieve guidance het verhoogt. Dat is onverenigbaar met H2 in zijn simpele vorm: meer context is niet beter, de gelokaliseerde structuur is beter. De winst zit in de combinatie van expliciete transities en lokale ophaling, niet in contextvolume.

Counterfactual: wat als de graaf niet zelf-evolueerde?

De zelf-evolutie is de duurste en meest risicovolle component: een LLM-refiner die de graaftopologie muteert, een validatie-gate die elke kandidaat op een onafhankelijke set beoordeelt, en rejection memory die afgewezen kandidaten bewaart. Wat als die component wegviel?

Zonder zelf-evolutie zou de graaf afhangen van handmatig ontwerp. De paper toont dat dit niet volstaat: de handgemaakte expertgraaf (Mode 1) verlaagt MultiChallenge-succes van 87,50% naar 58,93%, en een statische update (Mode 2) verlaagt het verder naar 53,57%. Alleen de iteratieve configuratie (Mode 3) herstelt naar 92,86%. Op HotpotQA haalt Mode 5 (Scratch + Online Evolution) de hoogste score (78,79% Ans F1, 66,30% Ans EM), boven de handgemaakte expertgraaf. Zonder zelf-evolutie zou de graaf dus óf een foutieve expert-prior behouden óf een suboptimale scratch-graaf. De zelf-evolutie is niet een optimalisatie-extra, het is de component die de graaf van een statisch artefact naar een lerend systeem maakt.

Complexiteitsanalyse

De online guidance is computationeel goedkoop. De 2-hop-buurt van een node in een graaf met |𝒱| nodes en |ℰ| edges wordt opgehaald in O(|ℰ|) in het slechtste geval (elke edge wordt hooguit eenmaal bezocht bij de expansie), en in de praktijk veel sneller omdat de buurt lokaal is. De guidance-modelaanroep Ψ is één extra LLM-call per beslissingsstap, wat de tokenoverhead verklaart die de paper eerlijk rapporteert: guidance verhoogt het tokenverbruik zelfs wanneer het het aantal solverstappen verlaagt. De tijdcomplexiteit van de lokale ophaling is daarmee lineair in het aantal edges, O(n) met n = |ℰ|.

De offline zelf-evolutie is duurder. Elke ronde vereist een diagnostische rollout over een batch trainingstaken, een validatie-rollout over de validatieset voor elke kandidaat, en een refiner-aanroep. De validatie-gating is de dominante kostenpost: elke kandidaat die de structurele checks passeert, vereist een volledige validatie-rollout. De rejection memory voorkomt dat de refiner equivalente onsuccesvolle edits herhaalt, maar de kosten van een afgewezen kandidaat zijn al gemaakt. De paper rapporteert dat rondes 3-6 geen gecommitteerde update produceren; één kandidaat faalt de structurele verificatie vóór de rollout. Dit is een inherente eigenschap van validatie-gated zoeken: de kosten zitten in de evaluatie, niet in de mutatie.

De representatie zelf is eenvoudig te implementeren. Een minimale Procedural Graph is een gerichte graaf met geattribueerde edges:

from dataclasses import dataclass, field

@dataclass
class Edge:
    u: str            # bronnode (procedure)
    r: str            # relatie: LEADS_TO, TRIGGERS, ...
    v: str            # doelnode (procedure)
    condition: str = ""
    guidance: str = ""
    pitfalls: str = ""

@dataclass
class ProceduralGraph:
    nodes: set = field(default_factory=set)
    edges: list = field(default_factory=list)

    def add(self, e: Edge) → None:
        self.nodes.update({e.u, e.v})
        self.edges.append(e)

    def neighborhood(self, node: str, hops: int = 2) → list:
        """2-hop-buurt: alle edges bereikbaar vanuit `node` in ≤ hops stappen."""
        seen, frontier, out = {node}, {node}, []
        for _ in range(hops):
            nxt = set()
            for e in self.edges:
                if e.u in frontier and e.v not in seen:
                    out.append(e); seen.add(e.v); nxt.add(e.v)
            frontier = nxt
        return out

De neighborhood-methode is de kern van de lokale ophaling: hij retourneert alleen de transities die vanuit de actieve node bereikbaar zijn, niet de volledige graaf. Dat is precies het verschil dat de ablatiestudie (Tabel 3) als doorslaggevend aantoont.

Praktijkvoorbeeld: langhorizon-agents in de publieke sector

De EnterpriseArena-uitslag is geen academische curiositeit. Langhorizon-agents met financiële beslissingen, strikte volgorde en vertraagde feedback zijn precies het profiel van publieke-sectorprocessen: begrotingsplanning, aanbestedingstrajecten, subsidiebeoordeling en casusafhandeling.

Neem een fictieve maar representatieve casus bij een uitvoeringsorganisatie zoals de Belastingdienst of het UWV. Een agent die een subsidieaanvraag over meerdere weken afhandelt, moet een strikte volgorde respecteren: eerst de aanvraag valideren, dan de rechtmatigheid controleren, dan pas een besluit genereren, en nooit een besluit vóór de controle. Zonder expliciete procedurele structuur kan de agent de volgorde door elkaar halen, een besluit genereren vóór de controle, of een onproductieve lus herhalen waarin hij dezelfde status herhaaldelijk bevraagt. Een Procedural Graph maakt die volgorde expliciet en conditioneel: de edge (valideer_aanvraag, LEADS_TO, controleer_rechtmatigheid) met condition "alleen als de aanvraag compleet is" en pitfalls "genereer geen besluit vóór de controle". De validatie-gated zelf-evolutie kan die graaf vervolgens verbeteren op basis van uitvoeringsfeedback, zonder dat een mens elke edge handmatig hoeft te onderhouden.

De governance-kant: wie keurt de graaf-edits goed?

De zelf-evolutie is ook een governance-risico. Een LLM-refiner die de graaftopologie muteert, verandert effectief het beleid van de agent: welke acties toelaatbaar zijn, in welke volgorde, onder welke voorwaarden. In een publieke-sectorcontext is dat een beslissing met juridische en audit-implicaties. Een agent die leert dat een besluit vóór de controle toelaatbaar is, omdat dat de validatiescore op een trainingsset verhoogt, heeft een procedurele drift die een menselijke auditor moet kunnen zien en terugdraaien.

De validatie-gate is hier de cruciale safeguard: een kandidaat wordt alleen gecommitteerd als de validatiescore op een onafhankelijke set gelijk blijft of verbetert. Maar de paper is eerlijk over de grenzen: met 20 episodes per split draaien individuele accept/reject-beslissingen op één of twee episodes en moeten ze als zoektrace worden gelezen, niet als significantietests. De testuitslag (85,0% overleving tegen 0,0% baseline, Fisher's exact p = 2,6 × 10⁻⁸) is significant, maar de per-ronde beslissingen zijn dat niet. Voor productie betekent dit: de validatie-gate is een noodzakelijke maar niet voldoende governance-laag. Een menselijke of onafhankelijke autorisatie van graaf-edits blijft nodig, zeker in domeinen met juridische gevolgen.

Beperkingen

De paper is methodologisch sterk maar kent duidelijke grenzen, en de onzekerheid over de generalisatie is reëel. Ten eerste is de guidance-modelaanroep een extra LLM-call per beslissingsstap, wat het tokenverbruik verhoogt zelfs wanneer het het aantal solverstappen verlaagt; de paper noemt dit expliciet als toekomstig werk (guidance hergebruiken over stappen of selectief genereren). Ten tweede is de transfer over solvers en toolinterfaces niet geëvalueerd: het is onbekend hoe breed de geleerde procedures herbruikbaar zijn. Ten derde is de validatie-gating statistisch fragiel bij kleine validatiesets, zoals de paper zelf toegeeft. Ten vierde is de zelf-evolutie computationeel duur vanwege de validatie-rollouts per kandidaat. Ten vijfde is de evaluatie op EnterpriseArena beperkt tot één domein (financiële besluitvorming); de generalisatie naar andere langhorizon-domeinen is niet aangetoond en blijft speculatief.

Synthese: de procedurele-memory-quadrant wordt expliciet

De grotere consequentie, die niet rechtstreeks in de paper staat maar een implicatie is die buiten de auteursclaims valt, is architectonisch. De CoALA-taxonomie onderscheidt werkgeheugen, episodisch geheugen, semantisch geheugen en procedureel geheugen. Retrieval-augmentatie (GraphRAG en varianten) opereert op semantisch geheugen; reflectie-methoden (Reflexion, ExpeL) op episodisch geheugen. Procedureel geheugen is de quadrant die het minst expliciet behandeld is: hij blijft grotendeels impliciet in modelgewichten of verspreid over ad-hoc artefacten.

Procedural Graphs implementeren de procedurele-memory-module van CoALA door state-geconditioneerde actietransities op te slaan in een structuur die opgehaald en bijgewerkt kan worden. Dat is een principeakkoord, geen productkeuze. De specifieke implementatie (LLM-refiner, validatie-gate, rejection memory) is experimenteel en vereist aanvullende assurance-, security- en governancelaag vóór productie. Maar het architectuurprincipe, procedurele kennis expliciet, lokaal ophaalbaar en validatie-gated evolueerbaar maken, is overdraagbaar naar elke agentic architectuur.

Dit sluit aan op eerdere analyses op dit kanaal. WikiSkill compileert agentervaring in een persistente wiki van skills en kennisclaims; Procedural Graphs organiseren procedurele kennis in een expliciete graaf met conditionele transities. Harness-of-Harness scheidt planning, productie en acceptatie via een deterministisch runtime-contract; Procedural Graphs voegen een validatie-gated evolutielus toe die de procedurele structuur zelf verbetert. Engram is een lokale episodische/semantische memory sidecar; Procedural Graphs richten zich op de procedurele quadrant. En de langhorizon-les van AutoLab, dat persistentie de echte agent-capability is, krijgt hier een concrete invulling: de graaf maakt die persistentie expliciet en bewerkbaar.

De juiste conclusie is niet dat organisaties Procedural Graphs direct moeten implementeren. De juiste conclusie is: adopteer het architectuurprincipe, expliciete en validatie-gated procedurele kennis, maar niet de experimentele implementatie zonder een aanvullende assurance-, security- en governancelaag. Voor een omgeving met juridische en audit-implicaties is de validatie-gate een noodzakelijke maar niet voldoende verdediging; de autorisatie van graaf-edits blijft een menselijke of onafhankelijke beslissing.