🤖 AI

From Sequence to Structure: Relational Uncertainty Propagation for LLM Agents

Dit artikel introduceert RUPA, een framework voor onzekerheidskwantificering op trajectniveau dat executiegeschiedenissen modelleert als gerichte grafen om onzekerheid te propageren over relationele afhankelijkheden, waardoor het bestaande methoden overtreft in het detecteren van foutaccumulatie op lange termijn en de betrouwbaarheid van LLM-agenten in complexe interactieve omgevingen verbetert.

Oorspronkelijke auteurs: Zhengzhao Ma. Boxi Cao, Yaojie Lu, Hongyu Lin, Xianpei Han, Le Sun

Gepubliceerd 2026-08-18

📖 5 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Zhengzhao Ma. Boxi Cao, Yaojie Lu, Hongyu Lin, Xianpei Han, Le Sun

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

In de snel evoluerende wereld van kunstmatige intelligentie is een nieuwe generatie software opgekomen die meer doet dan alleen vragen beantwoorden of tekst schrijven. Deze systemen, bekend als autonome agenten, zijn ontworpen om zelfstandig te handelen. Ze kunnen een complex doel opdelen in kleinere stappen, digitale hulpmiddelen gebruiken om informatie te verzamelen en interageren met computeromgevingen om problemen op te lossen die tientallen of zelfs honderden beslissingen vereisen. Denk aan hen als digitale werknemers die in staat zijn om het internet te navigeren, code te schrijven of gegevens te beheren zonder constante menselijke supervisie. Echter, naarmate deze agenten moeilijkere taken op zich nemen, rijst een kritische vraag: hoe kunnen we weten of ze op het punt staan een fout te maken? In tegenstelling tot een eenvoudige tekstgenerator die misschien één verkeerde zin produceert, is het falen van een agent vaak een traag proces. Een kleine fout die vroeg in een lange keten van redeneringen wordt gemaakt, kan vooruit rimpelen, latere stappen vervormen en leiden tot een volledige ineenstorting van het uiteindelijke resultaat. Om deze systemen in de echte wereld te kunnen vertrouwen, hebben ontwikkelaars een manier nodig om het risico op falen te meten terwijl het gebeurt, en niet pas achteraf.

Onderzoekers proberen al lang systemen te bouwen die kunnen aangeven wanneer een model onzeker is. Traditionele methoden kijken meestal naar de directe output van de computer, waarbij gecontroleerd wordt hoe zelfverzekerd het model lijkt over het eerstvolgende woord dat het gaat genereren. Deze aanpak werkt goed voor korte taken, maar faalt wanneer de taak zich over een lange tijdlijn uitstrekt. Het probleem is dat deze methoden elke stap als een geïsoleerde gebeurtenis behandelen, waarbij ze de geschiedenis negeren van hoe de agent daar terecht is gekomen. Ze missen de subtiele verbindingen tussen een beslissing van tien stappen geleden en de huidige actie. Als een agent een verzoek van een gebruiker aan het begin verkeerd begrijpt, ziet die initiële verwarring er op dat moment misschien niet uit als een fout, maar het kan het hele project later uit koers brengen. Huidige instrumenten zijn als een bestuurder die alleen naar de weg direct voor de auto kijkt, en daarbij mist dat er mijlen terug een verkeerde afslag is genomen die uiteindelijk tot een doodlopende weg zal leiden.

Om dit op te lossen, heeft een team onderzoekers van de Chinese Academy of Sciences een nieuw framework ontwikkeld genaamd RUPA. In plaats van het werk van een agent te zien als een eenvoudige lijst met stappen, brengen zij het hele proces in kaart als een netwerk van verbonden gebeurtenissen. In dit systeem is elke actie, elk gebruik van een hulpmiddel en elke feedback een knooppunt in een grafiek, en de lijnen die hen verbinden vertegenwoordigen de logische relaties tussen hen. De onderzoekers ontdekten dat fouten vaak langs deze specifieke verbindingen reizen. Door deze kaart te bouwen, kan het systeem traceren hoe onzekerheid groeit en door de geschiedenis van de agent beweegt. Het berekent een risicoscore voor het huidige moment door niet alleen te kijken naar het onmiddellijke vertrouwen van het model, maar ook naar de betrouwbaarheid van het pad dat tot dit moment heeft geleid. Als een vroege stap wankel was, herkent het systeem dat de huidige stap gebouwd is op een zwakke fundering, zelfs als de huidige stap zelf zelfverzekerd oogt.

Het team testte deze aanpak op een verscheidenheid aan uitdagende taken, waaronder complexe software engineering-problemen, terminal-gebaseerde computing-uitdagingen en open eind probleemoplossende scenario's. Ze voerden deze tests uit met zes verschillende grote taalmodellen, variërend van kleinere tot zeer grote systemen. De resultaten toonden aan dat deze nieuwe methode aanzienlijk beter was in het opsporen van problemen dan bestaande technieken. In één reeks tests verbeterde het nieuwe systeem het vermogen om fouten te detecteren met een merkbare marge vergeleken met de beste eerdere methoden. Belangrijker nog, het kon potentiële fouten veel eerder in het proces identificeren. Terwijl oudere methoden vaak pas aan het einde van het proces beseften dat er iets mis was, kon deze nieuwe aanpak gevaar al na slechts enkele stappen signaleren, waardoor het systeem de kans kreeg om koers te corrigen voordat de taak werd verpest.

De onderzoekers demonstreerden ook dat dit betere begrip van risico gebruikt kon worden om de agenten beter te laten werken. Wanneer het systeem de keuze kreeg tussen verschillende mogelijke acties, kon het de risicoscores gebruiken om de veiligste optie te kiezen. In deze proeven voltooiden de agenten die door deze nieuwe methode werden geleid meer taken succesvol dan die geleid door traditionele vertrouwensmaten. De studie suggereert dat de sleutel tot betrouwbare kunstmatige intelligentie niet alleen het kijken naar het huidige moment is, maar het begrijpen van de structuur van de reis. Door de relaties tussen elke stap die een agent neemt in kaart te brengen, kunnen we zien hoe kleine onzekerheden uitmonden in grote problemen. Deze aanpak biedt een praktische manier om agenten te bouwen die niet alleen bekwaam zijn, maar ook betrouwbaar, in staat om complexe omgevingen te navigeren zonder hun weg kwijt te raken.

Technische Samenvatting: Relational Uncertainty Propagation for LLM Agents (RUPA)

Probleemstelling

Betrouwbare onzekerheidskwantificering (Uncertainty Quantification, UQ) is een cruciale voorwaarde voor de inzet van Large Language Model (LLM) agents in complexe, langdurige interactieve omgevingen. Hoewel bestaande UQ-methoden effectief vertrouwen inschatten voor geïsoleerde voorspellingen of korte-context generatie, hebben ze moeite met autonome agents die stappen in redeneren, gereedsjes gebruiken en interacties met de omgeving uitvoeren over langere tijd.

Huidige benaderingen vertrouwen voornamelijk op lokale signalen, zoals token-waarschijnlijkheden, predictieve entropie of vertrouwen per stap. Deze methoden negeren grotendeels de langetermijnafhankelijkheden waardoor fouten accumuleren en voortplanten door een executie-traject. Bijgevolg falen ze vaak in het identificeren van agent-fouten waarvan de grondoorzaken enkele redeneer- of interactiestappen vóór het uiteindelijke antwoord liggen. Bovendien modelleren bestaande agent-georiënteerde UQ-methoden die wel geschiedenis meenemen trajecten doorgaans als lineaire sequenties, waardoor ze de inherent relationele aard van afhankelijkheden tussen agent-stappen niet kunnen vatten (bijvoorbeeld hoe een vroege fout invloed heeft op de daaropvolgende tool-gebruik of hoe een feedbackloop het redeneepad verandert).

Methodologie: RUPA-framework

De auteurs stellen RUPA (Relational Uncertainty Propagation for Agents) voor, een traject-niveau UQ-framework dat de executie van een agent modelleert als een gestructureerde afhankelijkheidsgraaf in plaats van een lineaire sequentie. De methodologie bestaat uit drie kerncomponenten:

1. Constructie van de Relationele Traject-graaf

RUPA zet de geschiedenis van de executie van een agent om in een gerichte graaf $G = (V, E)$ :

Knopen ( $V$ ): Vertegenwoordigen executie-events, inclusief instructies van de gebruiker, redenering/acties van de assistent, aanroepen van tools en observaties uit de omgeving.
Randen ( $E$ ): Legen de logische afhankelijkheden vast tussen historische events en de huidige stap. Het framework identificeert zeven specifieke relatietypes:
- Sequential (Sequentieel): Direct voorafgaande executie.
- Latest (Nieuwste): Meest recente omgeving- of gebruikersinstructies.
- Repetition (Herhaling): Acties met vergelijkbare redeneerpatronen of tool-gebruik.
- Progression (Progressie): Redeneerstappen die bestaande oplossingen uitbreiden.
- Parallel (Parallel): Alternatieve redeneervertakkingen onder dezelfde context.
- Feedback (Feedback): Signalen die wijzen op executiefouten of instabiele outputs.
- Goal Alignment (Doeluitlijning): Semantische afhankelijkheid tussen de huidige redenering en het oorspronkelijke taakdoel.

2. Relatie-bewuste Onzekerheidsproperagatie

In tegenstelling tot sequentiële aggregatie, propageert RUPA onzekerheid door de grafenranden op basis van hun structurele belang:

Lokale Onzekerheid ( $U_t$ ): Berekend vanuit predictieve entropie voor assistent-knopen of observeerbare interactiesignalen (bijv. executiefouten, lege responsen) voor omgeving-knopen.
Randgewichten ( $w_{i,t}$ ): Geleerde propagatiegewichten bepaald door de betrouwbaarheid, sterkte en temporele afstand van de relatie. Structureel belangrijke afhankelijkheden oefenen een grotere invloed uit, terwijl verouderde staten worden gediskonteerd.
Goal Alignment Score ( $Q_{i,t}$ ): Een specifieke score die de semantische uitlijning tussen de huidige stap en het taakdoel schat.
Propagatiemechanisme: De structurele risico ( $G_t$ ) wordt berekend door de onzekerheid van naburige historische knopen te aggregeren, gewogen door hun randgewichten. Dit wordt gecombineerd met een exponentieel vervalende onzekerheidsmomentum ( $m_t$ ) om langetermijntrends te behouden.
Definitieve Schatting: De traject-niveau onzekerheid ( $R_t$ ) is een gewogen som van de lokale onzekerheid en de gepropageerde historische onzekerheid ( $H_t$ ):
$R_t = \lambda_u U_t + \lambda_h H_t$

3. Integratie met Agent-executie

Het gepropageerde signaal wordt gecombineerd met traject-niveau gedragskenmerken en doeluitlijningsinformatie om een betrouwbaarheidsschatting voor het volledige traject van de agent te produceren. Deze schatting kan worden gebruikt voor risicodetectie, adaptieve resampling en beslissingsoptimalisatie.

Belangrijkste Bijdragen

Identificatie van Relationele Afhankelijkheden: Het werk identificeert dat onzekerheid in LLM-agents een traject-niveau eigenschap is die evolueert over relationele structuren, wat de beperkingen onthult van methoden die trajecten behandelen als onafhankelijke voorspellingen of lineaire sequenties.
RUPA-framework: De voorstel van een graaf-gebaseerd UQ-framework dat de executie van een agent representeert als een gerichte relationele graaf en relatie-bewuste onzekerheidsproperagatie uitvoert om executierisico te schatten.
Empirische Validatie: Uitgebreide experimenten over drie benchmarks en zes LLM's demonstreren dat het expliciet modelleren van structurele afhankelijkheden cruciaal is voor betrouwbare UQ in langdurige agents.

Experimentele Resultaten

De auteurs evalueerden RUPA op drie representatieve benchmarks: $\tau$ -2, Terminal-Bench-2, en GAIA, met behulp van zes open-source LLM's variërend van 26B tot 230B parameters (inclusief Qwen3.5/3.6, Gemma4-26B, Gemma4-31B, GPT-OSS-120B, en MiniMax-M2.7).

Superieure Onzekerheidsschatting: RUPA presteerde consequent beter dan bestaande UQ-methoden (inclusief Entropy, Sequence Probability, SAUP, Tracer, en UProp) over alle modelfamilies heen. Bijvoorbeeld, op het MiniMax-M2.7 model verbeterde RUPA de gemiddelde AUROC van 0.694 (sterkste baseline) naar 0.718.
Vroege Foutdetectie: In prefix-gebaseerde evaluaties identificeerde RUPA potentiële executiefouten aanzienlijk eerder dan bestaande methoden. Het voordeel was het meest uitgesproken wanneer slechts een klein deel van het traject werd waargenomen, wat aangeeft dat gepropageerde onzekerheidssignalen vroeg in het executieproces verschijnen.
Verbetering van Downstream Prestaties: Wanneer gebruikt om agent-executie te sturen (het selecteren van acties met een lagere voorspelde onzekerheid tijdens multi-sample decoding), verbeterde RUPA consequent de succesratio's van taken. Bijvoorbeeld, op Terminal-Bench-2 met Qwen3.5-27B verbeterde de nauwkeurigheid van 0.105 (bij willekeurige selectie) naar 0.213 wanneer gestuurd door RUPA.
Complementaire Informatie: Een entropie-gematchte analyse toonde aan dat graaf-gebaseerde modellering onzekerheidssignalen levert die verschillen van token-niveau vertrouwen, met name in gebieden met lage entropie waar traditionele methoden er niet in slagen om succesvolle en gefaalde trajecten te onderscheiden.

Betekenis en Claims

Het artikel betoogt dat het expliciet modelleren van relationele afhankelijkheid cruciaal is voor betrouwbare onzekerheidskwantificering in langdurige LLM-agents. De auteurs beweren dat RUPA een praktisch fundament biedt voor betrouwbare agent-executie door:

Te vatten hoe executierisico's accumuleren en overdragen tussen interactiestappen, in plaats van stappen als geïsoleerde gebeurtenissen te behandelen.
Het mogelijk maken van vroegtijdige detectie van fouten die voortkomen uit tussenliggende redeneer- of interactiestappen.
Het verbeteren van de betrouwbaarheid van autonome agents in diverse taken, van software engineering tot complexe besluitvorming, door meer accurate onzekerheidsschattingen te bieden die downstream strategieën zoals zelfcorrectie en risicomitigatie kunnen sturen.

Het werk concludeert dat het falen van traditionele UQ-methoden in agent-omgevingen niet louter een kwestie is van datavolume, maar een structurele beperking in de wijze waarop de executiegeschiedenis wordt gerepresenteerd, en dat de overstap van lineaire sequenties naar relationele grafen een noodzakelijke stap is naar robuuste autonome agents.