Agentics 2.0: Logical Transduction Algebra for Agentic Data Workflows

Le papier présente Agentics 2.0, un framework Python natif léger qui formalise les inférences de modèles de langage comme des transformations sémantiques typées via une algèbre de transduction logique, permettant ainsi de construire des flux de travail agentic fiables, observables et évolutifs pour des tâches complexes telles que la découverte de données et le parsing NL-to-SQL.

L'essentiel

Imaginez que vous dirigez une grande équipe de traducteurs très intelligents, mais un peu étourdis, qui doivent transformer des données brutes en réponses utiles. C'est ce qu'on appelle l'IA "agente". Le problème, c'est que souvent, ces agents s'embrouillent, inventent des faits (on appelle ça des "hallucinations") ou perdent le fil de leur raisonnement, un peu comme un groupe d'élèves qui discutent trop et oublient la consigne.

Les auteurs de ce papier, de chez IBM, proposent une nouvelle façon de gérer ces agents, qu'ils appellent Agentics 2.0. Voici comment cela fonctionne, expliqué simplement avec des images du quotidien :

1. Le Problème : La "Conversation" vs La "Transformation"

Actuellement, on fait souvent travailler les agents en leur donnant des instructions sous forme de conversation (comme un chat). C'est flexible, mais c'est comme demander à un cuisinier de préparer un plat en lui disant juste "Fais quelque chose de bon". Le résultat est imprévisible.

Les auteurs disent : "Stop ! Ne parlons pas à l'IA comme à un humain, parlons-lui comme à un usine de transformation."

2. La Solution : L'Algorithme de "Transduction Logique"

Imaginez une chaîne de montage dans une usine de jouets.

• L'entrée (Input) : Une boîte de pièces détachées (vos données).
• La transformation (Transduction) : Un robot qui assemble les pièces.
• La sortie (Output) : Un jouet fini et emballé.

Dans Agentics 2.0, chaque robot (chaque appel à l'IA) doit respecter des règles strictes :

1. Le Plan de Montage (Types) : Avant même de commencer, on définit exactement à quoi doit ressembler la boîte d'entrée et le jouet de sortie. Si le robot essaie de sortir un camion alors qu'on attend une voiture, la machine s'arrête immédiatement. Pas de "ça va aller", pas d'erreur silencieuse.
2. La Preuve (Évidence) : Le robot ne peut pas juste sortir le jouet. Il doit coller une étiquette sur le jouet disant : "J'ai utilisé cette roue rouge de la boîte A et ce moteur de la boîte B". Si le robot ne peut pas montrer d'où vient chaque pièce, le résultat est rejeté. Cela empêche l'IA d'inventer des faits.
3. La Traçabilité : On sait exactement quel robot a fait quelle partie du travail.

3. Les Outils Magiques : Les "Opérateurs"

Les auteurs ont créé un langage spécial (en Python) qui permet de connecter ces robots facilement, comme des pièces de Lego :

• Le symbole << (Transduction) : C'est comme dire "Prends cette boîte de données et transforme-la en ce résultat précis".
• Le symbole @ (Composition) : C'est comme coller deux boîtes ensemble pour en faire une plus grosse.
• Le symbole & (Fusion) : C'est comme mélanger deux ingrédients pour en faire un seul plat.

4. La Puissance : Le "Map-Reduce" (Le Chef d'Orchestre)

Imaginez que vous devez trier 10 000 lettres.

• Méthode ancienne : Un seul agent lit les 10 000 lettres une par une. Ça prend des heures et il risque de se tromper à la fin.
• Méthode Agentics 2.0 : Vous avez 100 robots. Chacun prend 100 lettres, les trie instantanément (c'est le Map), puis un chef d'orchestre rassemble les résultats de tous les robots pour faire un rapport final (c'est le Reduce).
  C'est ultra-rapide, et comme chaque robot travaille seul, si l'un plante, les autres continuent.

5. Les Résultats : Ça marche vraiment ?

Les auteurs ont testé leur système sur deux défis très difficiles :

1. La Découverte Scientifique (DiscoveryBench) : Donner à l'IA des tableaux de données (comme des relevés de température ou des ventes) et lui demander de trouver une loi scientifique cachée.
   • Résultat : Les agents d'Agentics 2.0 ont trouvé de meilleures lois que les meilleurs systèmes actuels, car ils ne se sont pas perdus dans les détails et ont bien utilisé les preuves des tableaux.
2. La Traduction en Langage de Base de Données (Archer NL-to-SQL) : Demander à l'IA de transformer une question en français ("Quels sont les clients qui ont acheté plus de 100€ ?") en code informatique complexe pour interroger une base de données.
   • Résultat : Là encore, leur méthode a battu presque tous les autres systèmes, car elle vérifie chaque étape du code généré.

En Résumé

Agentics 2.0, c'est comme passer d'une équipe d'artistes qui improvisent (souvent avec des erreurs) à une usine automatisée et surveillée.

• Fiabilité : On vérifie les plans avant de construire.
• Explicabilité : On sait exactement d'où vient chaque décision (grâce aux étiquettes de preuve).
• Vitesse : On fait travailler des centaines de robots en même temps.

C'est une façon de rendre l'IA plus sérieuse, plus sûre et plus utile pour les entreprises qui ont besoin de résultats précis, pas juste de belles phrases.

Résumé technique

1. Problématique

Le passage des prototypes de recherche aux déploiements d'IA agentique en entreprise se heurte à des défis majeurs concernant la fiabilité, l'observabilité et l'évolutivité. Les approches actuelles reposent souvent sur des chaînes de prompts (prompt chaining), des graphes d'états ou des appels de fonctions contraints par un schéma, mais elles souffrent de :

• Manque de contrôle vérifiable : Les workflows basés sur des conversations (agents conversationnels) ou des sous-tâches en langage naturel manquent de flux de contrôle formels.
• Corruption silencieuse : Les erreurs de génération de l'LLM ne sont pas toujours détectées, entraînant une accumulation d'erreurs sémantiques.
• Absence de traçabilité : Il est difficile de comprendre comment une sortie a été déduite d'une entrée (problème de "boîte noire").
• Limites d'évolutivité : L'orchestration repose souvent sur des appels d'API LLM séquentiels ou complexes, limitant le traitement parallèle massif.

L'article soutient que ces limitations découlent d'une perspective anthropocentrique (vue l'LLM comme une conversation) plutôt que d'une approche de transduction de données structurée.

2. Méthodologie : L'Algèbre de Transduction Logique

Les auteurs proposent Agentics 2.0, un framework Python natif fondé sur une Algèbre de Transduction Logique. L'idée centrale est de modéliser l'appel d'inférence d'un LLM non pas comme une conversation, mais comme une fonction transductible (transducible function) typée et composable.

Concepts Clés :

• Fonction Transductible ($f: X \ll Y$) : Une transformation sémantique typée qui prend un état d'entrée $X$ et produit un état de sortie $Y$. Elle doit satisfaire quatre propriétés :
  1. Typée : La sortie respecte strictement le schéma de type $Y$ (validation via Pydantic).
  2. Explicable : Elle génère une explication $e$ justifiant la transformation.
  3. Preuve Locale (Local Evidence) : Chaque valeur de sortie est calculée à partir d'un sous-ensemble spécifique des slots d'entrée.
  4. Provenance : Une carte de provenance lie chaque slot de sortie aux slots d'entrée spécifiques utilisés, empêchant les hallucinations.
• Opérateurs Algébriques :
  • Composition ($\circ$) : Permet de chaîner des fonctions transductibles ($f_2 \circ f_1$).
  • Fusion ($\&$) et Projection ($\downarrow$) : Manipulation des types (fusion de champs, sélection de sous-ensembles).
  • Identité : Fonction qui renvoie l'entrée sans modification.
• Sémantique Map-Reduce :
  • Map : Application parallèle d'une fonction transductible sur une liste d'entrées (asynchrone).
  • Reduce : Agrégation d'une collection de résultats en une seule sortie, tout en préservant la trace de provenance et d'évidence.

Implémentation Technique (Agentics 2.0) :

Le framework est une bibliothèque Python qui étend les modèles Pydantic et les fonctions asynchrones :

• Opérateur << : Crée une fonction transductible entre deux types Pydantic (ex: Answer << Question).
• Opérateur @ et & : Pour la composition et la fusion de types.
• Décorateur @transducible : Permet d'envelopper du code Python asynchrone standard dans une fonction transductible, permettant de mélanger code déterministe et inférence LLM.
• Exécution : Les workflows s'exécutent comme des appels asynchrones sans état (stateless), facilitant le parallélisme massif.

3. Contributions Principales

1. Algèbre de fonctions typées : Formalisation mathématique de l'inférence LLM comme une algèbre de fonctions composables, garantissant la validité des schémas à chaque étape.
2. Modèle de programmation agentique : Un modèle qui intercale code déterministe et transductions LLM via des coroutines asynchrones typées.
3. Observabilité sémantique : Introduction de la traçabilité de la preuve (evidence tracing) et de la provenance au niveau sémantique (slots), et non plus seulement au niveau de l'appel API.
4. Validation empirique : Évaluation sur des benchmarks exigeants (DiscoveryBench et Archer) démontrant des performances de pointe (SOTA).

4. Résultats Expérimentaux

A. Benchmark DiscoveryBench (Découverte de données)

• Tâche : Dériver des hypothèses scientifiques à partir de données tabulaires (CSV) et de métadonnées.
• Configuration : Comparaison entre des agents basés sur ReAct (baseline) et des agents Agentics 2.0 (avec agrégation de données, ReAct, ou les deux).
• Résultats :
  • L'agent Agentics-Both (agrégeant données structurées et générations ReAct) atteint un score moyen de 37,27, surpassant le meilleur score du leaderboard (33,7 par ReAct).
  • Les agents Agentics 2.0 excellent dans l'extraction de contexte et de variables, bien que l'extraction des relations entre variables reste un défi.
  • L'approche fonctionne particulièrement bien sur des tableaux de taille gérable sans nécessiter de modèles d'apprentissage automatique complexes.

B. Benchmark Archer (NL vers SQL)

• Tâche : Traduction du langage naturel vers SQL, nécessitant un raisonnement arithmétique, du bon sens et des hypothèses.
• Résultats :
  • Les agents implémentés dans Agentics 2.0 surpassent la plupart des soumissions du leaderboard, se classant juste derrière la méthode OraPlan-SQL (qui utilise des stratégies spécifiques au benchmark).
  • L'agent de "validation par raisonnement" (Reasoning-Validation) montre une forte performance, notamment avec le modèle GPT-o3 sur les tâches combinant arithmétique et bon sens.
  • Le framework permet une itération efficace : génération, vérification syntaxique, et validation sémantique.

5. Signification et Conclusion

Agentics 2.0 marque un changement de paradigme dans le développement d'agents IA :

• Fiabilité par conception : En traitant l'inférence LLM comme une fonction typée, les erreurs sont rejetées explicitement plutôt que de corrompre silencieusement le texte.
• Évolutivité : La nature sans état (stateless) et asynchrone des transductions permet un parallélisme massif, essentiel pour les charges de travail d'entreprise.
• Explicabilité : La traçabilité de la provenance (mapping entrée-sortie) offre une transparence cruciale pour les applications critiques.

Le papier démontre qu'il est possible de construire des workflows de données agentiques complexes, réutilisables et de haute qualité en combinant la rigueur des types de programmation (Python/Pydantic) avec la flexibilité des LLM, tout en maintenant une traçabilité complète des décisions prises par l'IA.