Agentics 2.0: Logical Transduction Algebra for Agentic Data Workflows

Het paper introduceert Agentics 2.0, een Python-framework dat een logische transductie-algebra gebruikt om betrouwbare, schaalbare en observeerbare agente data-workflows te bouwen door LLM-inferenties te formaliseren als getypeerde semantische transformaties die in parallelle Map-Reduce-programma's worden samengesteld.

De kern

Stel je voor dat je een team van zeer slimme, maar soms wat onvoorspelbare assistenten (de "AI-agenten") hebt. Tot nu toe werkten deze assistenten voornamelijk op basis van gesprekken: je gaf ze een opdracht in gewone taal, en ze probeerden het te doen door met elkaar te "praten". Het probleem? Soms vergeten ze wat ze moesten doen, maken ze fouten die niemand ziet, of raken ze in de war als de taak te groot wordt.

Dit paper introduceert Agentics 2.0, een nieuwe manier om met deze slimme assistenten te werken. In plaats van ze te laten "praten", geven we ze een strenge, logische bouwplaat om hun werk te doen.

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

1. Van "Kletsen" naar "Bouwen met Blokken"

Stel je voor dat je een lego-constructie maakt.

• De oude manier (Conversatie): Je zegt tegen je assistent: "Maak een mooi huis." Hij pakt dan willekeurige blokken en bouwt iets. Soms is het huis mooi, soms valt het dak er af, en je weet niet precies waarom.
• De nieuwe manier (Agentics 2.0): We gebruiken een Logische Transductie Algebra (een heel moeilijke naam voor een simpel idee). Dit is als een lego-instructieboekje met kleurcodes.
  • Elke stap moet een specifiek blok (een "type") hebben.
  • Als je een rood blok probeert te plakken waar een blauw blok moet zitten, zegt het systeem direct: "Fout! Dit past niet." Het bouwt niet verder met een fout.
  • Dit zorgt ervoor dat de resultaten altijd betrouwbaar en veilig zijn.

2. De "Receptuur" met Bewijslast

In de oude wereld kon een AI zeggen: "Ik denk dat de klant rijk is," zonder te weten waarom.
Met Agentics 2.0 moet elke AI-assistent een recept volgen.

• De Transduceerbare Functie: Dit is een stap in het proces. Stel, je hebt een stapel papieren (invoer) en je moet er een samenvatting van maken (uitvoer).
• Het Magische: De AI moet niet alleen de samenvatting geven, maar ook een lijstje met bewijs (provenance). Het moet zeggen: "Ik heb dit getal uit regel 3 van het document gehaald, en dat woord uit regel 7."
• Waarom is dit cool? Als de AI een fout maakt, kun je direct zien welk stukje bewijs ze verkeerd hebben gelezen. Geen giswerk meer, alles is traceerbaar.

3. Het Fabrieksconcept: Map-Reduce

Stel je voor dat je 10.000 brieven moet lezen en samenvatten.

• De oude manier: Je geeft één assistent de hele stapel. Die wordt moe, raakt in de war en maakt fouten.
• De Agentics 2.0 manier: We gebruiken een Map-Reduce systeem.
  • Map (Verdelen): We geven 100 verschillende assistenten elk 100 brieven. Ze werken allemaal tegelijk (parallel) en onafhankelijk van elkaar. Omdat ze "type-safe" werken, weten ze precies wat ze moeten doen.
  • Reduce (Samenvoegen): Een hoofdaannemer pakt de 100 samenvattingen en maakt er één grote, perfecte samenvatting van.
  • Omdat elke stap logisch is opgebouwd, blijft de kwaliteit hoog, zelfs bij duizenden taken.

4. Wat hebben ze getest? (De Proefjes)

De auteurs hebben dit systeem getest op twee moeilijke uitdagingen:

• Ontdekking (DiscoveryBench): Hier moesten de AI's data uit grote Excel-lijsten halen om een nieuwe wetenschappelijke theorie te bedenken.
  • Resultaat: De nieuwe AI's (Agentics 2.0) waren beter dan de oude methoden. Ze konden de data beter "lezen" en maakten minder fouten in het verbinden van feiten.
• Talenvertaling naar SQL (Archer): Hier moesten de AI's gewone zinnen (zoals "Wie heeft de meeste verkopen in januari?") omzetten in complexe database-opdrachten (SQL).
  • Resultaat: Ze deden het bijna net zo goed als de allerbeste systemen in de wereld, maar dan met meer controle en minder "hallucinaties" (dromen die niet waar zijn).

Conclusie: Waarom is dit belangrijk?

Voor bedrijven is het niet genoeg dat een AI "slim" klinkt. Ze moeten betrouwbaar zijn.

• Agentics 2.0 maakt AI-robots die niet alleen praten, maar die werken als een goed georganiseerd bouwteam.
• Ze weten precies wat ze doen.
• Ze kunnen fouten direct opsporen.
• Ze kunnen duizenden taken tegelijk aan zonder in de war te raken.

Kortom: Het is de overstap van "AI die een gesprek voert" naar "AI die een betrouwbare, controleerbare machine is".

Technische samenvatting

Probleemstelling

Agentic AI-systemen evolueren snel van onderzoeksprototypen naar enterprise-deployments. Echter, de huidige workflows voor agente data draaien vaak rondom prompt-chaining, state-graph-orkestratie of schema-gedwongen functie-aanroepen. Deze benaderingen hebben moeite om de vereiste softwarekwaliteitskenmerken te leveren die nodig zijn voor enterprise-werklasten:

• Betrouwbaarheid: Bestaande systemen vertrouwen vaak op "zwarte doos"-planners of onbetrouwbare conversaties tussen agenten, wat leidt tot stilzwijgende corruptie van tekst in plaats van duidelijke fouten bij ongeldige output.
• Observabiliteit: Het is moeilijk om te traceren hoe output is gegenereerd op basis van input (evidence tracing), wat hallucinaties in de hand werkt.
• Schaalbaarheid: Workflow-orkestratie wordt vaak overgelaten aan lage-niveau LLM-API-aanroepen in plaats van op een hoger abstractieniveau te worden gedefinieerd.

De auteurs stellen dat deze beperkingen voortkomen uit een antropomorf perspectief dat LLM-aanroepen ziet als conversaties tussen persona's, in plaats van als gestructureerde transducties.

Methodologie: Logische Transductie Algebra

Het paper introduceert Agentics 2.0, een lichtgewicht, Python-natief framework dat LLM-inferentie formaliseert als een transduceerbare functie binnen een logische transductie-algebra.

Kernconcepten:

1. Transduceerbare Functies: Een LLM-aanroep wordt gemodelleerd als een getypeerde semantische transformatie $f: X \to Y$. Deze functie moet vier eigenschappen bezitten:
   • Getypeerd: De output moet een goed getypeerde staat zijn (gevalideerd door schema's zoals Pydantic).
   • Verklaarbaar: Er moet een uitleg ($e$) zijn die de transformatie van input naar output beschrijft.
   • Lokale Evidentie: Een subset van de input-slots moet expliciet zijn gebruikt om een specifieke output-waarde te berekenen.
   • Provenance: Er moet een mapping zijn die elke output-slot koppelt aan de specifieke input-slots die erbij betrokken waren.
2. Algebraïsche Operatoren:
   • Samenstelling: Transduceerbare functies kunnen worden gecombineerd ($f_2 \circ f_1$) om grotere programma's te vormen.
   • Map-Reduce Semantiek: Het framework ondersteunt parallelle verwerking (map) en gestructureerde aggregatie (reduce). Dit maakt schaalbaarheid mogelijk via stateless, asynchrone uitvoering.
   • Type Operatoren: Operatoren zoals @ (samenstelling van types), & (samenvoegen van types) en ≪ (transductie) worden overbelast in Python om Pydantic-types en asynchrone functies te combineren.
3. Implementatie (Agentics 2.0):
   • Het framework gebruikt Pydantic-modellen voor type-definities.
   • Het introduceert de @transducible decorator om asynchrone Python-functies om te zetten in transduceerbare functies.
   • Het combineert deterministische code en LLM-transducties via getypeerde asynchrone coroutines.

Belangrijkste Bijdragen

1. Getypeerde, samenstelbare functiaalgebra: Een formele basis voor LLM-berekeningen die semantische betrouwbaarheid garandeert door strikte input/output-contracten.
2. Agente AI-programmeermodel: Een model dat deterministische code en LLM-transducties doorweeft, waarbij bewijslast (evidence) en herkomst (provenance) worden behouden.
3. Semantische Observabiliteit: In plaats van alleen te kijken naar de LLM-aanroep, wordt observabiliteit opgeheven naar het semantische niveau, waarbij de herkomst van elke output-slot wordt getraceerd.
4. Empirische Validatie: Uitgebreide evaluatie op uitdagende benchmarks (DiscoveryBench en Archer) die state-of-the-art prestaties aantoont.

Resultaten

De auteurs evalueerden Agentics 2.0 op twee benchmarks:

1. DiscoveryBench (Data-gedreven ontdekking):

• Doel: Hypothesen afleiden uit CSV-bestanden en metadata.
• Resultaat: Agenten gebouwd met Agentics 2.0 (specifiek de configuratie agentics-both, die zowel gestructureerde data als ReAct-agent-generaties combineert) behaalden een gemiddelde finale score van 37,27. Dit is hoger dan de best gerapporteerde score van 33,7 voor de baseline ReAct-agent op de leaderboard.
• Inzicht: Het framework presteerde goed bij het extraheren van context en variabelen, maar had nog moeite met het correct vaststellen van relaties tussen variabelen. Het framework bleek effectief bij het aggregeren van kleine tot middelgrote tabellen zonder complexe ML-modellen te hoeven fiten.

2. Archer (NL-naar-SQL):

• Doel: Natuurlijke taal vertalen naar SQL met redeneervermogen (rekenen, gezond verstand, hypothetisch redeneren).
• Resultaat: De Agentics 2.0-implementaties presteerden concurrerend met alle leaderboard-inschrijvingen, met uitzondering van de gespecialiseerde OraPlan-SQL (die een domeinspecifieke strategie gebruikt).
• Inzicht: De "reasoning-validation" agent, die meerdere iteraties van generatie, verificatie en validatie doorloopt, leverde sterke resultaten, vooral bij redeneringstaken die rekenen en gezond verstand vereisten.

Betekenis en Conclusie

Agentics 2.0 biedt een paradigmaverschuiving in de ontwikkeling van agente systemen:

• Van Conversatie naar Transductie: Door LLM-aanroepen te behandelen als getypeerde functies in plaats van conversaties, wordt de betrouwbaarheid drastisch verhoogd. Ongeldige output triggeren nu fouten in plaats van stilzwijgende corruptie.
• Enterprise-klare Kwaliteit: Het framework lost de problemen van schaalbaarheid (via Map-Reduce), observabiliteit (via provenance tracing) en betrouwbaarheid (via type-validatie) op, wat essentieel is voor enterprise-deployments.
• Herbruikbare Patronen: Het algebraïsche fundament maakt het mogelijk om complexe workflows te bouwen uit herbruikbare, samenstelbare componenten.

De studie concludeert dat het combineren van de flexibiliteit van agente systemen met de striktheid van getypeerde semantiek en logische bewijslast leidt tot systemen die niet alleen theoretisch robuust zijn, maar ook concurreren met de beste gespecialiseerde benchmarks.