🤖 machine learning

Remember, Don't Re-read: Stateful ReAct Agents for Token-Efficient Autonomous Experimentation

Cet article introduit une architecture d'agent ReAct à état (stateful) utilisant LangGraph qui remplace le modèle de recherche automatique sans état (stateless), inefficace en termes de jetons, par un mécanisme d'état persistant, permettant ainsi une réduction significative des jetons (jusqu'à 90 %) sur les tâches de réglage d'hyperparamètres et d'optimisation de code tout en maintenant des performances comparables.

Auteurs originaux : Faramarz Jabbarvaziri

Publié 2026-06-16

📖 4 min de lecture☕ Lecture pause café

CC BY 4.0

Auteurs originaux : Faramarz Jabbarvaziri

Article original sous licence CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Ceci est une explication générée par l'IA de l'article ci-dessous. Elle n'a pas été rédigée ni approuvée par les auteurs. Pour une précision technique, consultez l'article original. Lire la clause de non-responsabilité complète

Imaginez que vous êtes un scientifique essayant de trouver la recette parfaite pour un gâteau. Chaque fois que vous cuisinez une fournée, vous la goûtez, vous notez ce qui s'est passé, puis vous décidez de ce qu'il faut changer pour la fournée suivante.

L'Ancienne Méthode (Agent sans état) : Le « Chef Amnésique »
Dans la méthode traditionnelle décrite dans l'article, le chef IA a une mémoire terrible. Chaque fois qu'il cuisine une nouvelle fournée, il ne se contente pas de regarder le dernier gâteau. Il sort un immense carnet contenant l'historique de chaque gâteau qu'il a jamais cuisiné, du tout premier jusqu'à aujourd'hui.

Il relit l'intégralité du carnet, mot par mot, juste pour se souvenir de ce qu'il a fait auparavant.

Le Problème : Si vous cuisinez 10 gâteaux, le carnet est petit. Mais si vous en cuisinez 100, le carnet est énorme. Le chef passe la majeure partie de son temps et de son énergie à relire les vieilles notes au lieu de réfléchir au nouveau gâteau. L'article appelle cela un problème O(n²) : à mesure que le nombre d'expériences augmente, le travail augmente de façon exponentielle. C'est comme essayer de trouver une page spécifique dans un livre en relisant tout le livre depuis la première page à chaque fois que vous avez besoin d'une nouvelle page.

La Nouvelle Méthode (Agent avec état) : Le « Bibliothécaire Organisé »
Les auteurs de cet article ont construit un système plus intelligent en utilisant un outil appelé LangGraph. Au lieu d'un chef amnésique, imaginez une IA avec un bibliothécaire personnel.

Le Bibliothécaire conserve l'historique : Le bibliothécaire (l'« État ») détient l'historique complet de chaque gâteau cuit, de chaque ajustement effectué et de chaque résultat observé. L'IA n'a pas besoin de transporter ce livre pesant avec elle.
La Note de Synthèse : Lorsque l'IA doit décider de la marche à suivre, le bibliothécaire ne lui remet pas toute la bibliothèque. À la place, le bibliothécaire rédige un minuscule pense-bête de 3 phrases : « Vous avez essayé 25 fournées. La meilleure était 1,9 fois plus rapide. Voici les 5 dernières tentatives que vous avez faites. N'oubliez pas d'éviter l'erreur que vous avez commise lors de la fournée n°7. »
Le Résultat : L'IA ne lit que cette courte note. Peu importe que l'IA ait cuisiné 10 gâteaux ou 1 000 gâteaux ; la note conserve toujours la même longueur. Le travail requis reste constant (O(1)).

Ce qu'ils ont testé
Les chercheurs ont testé ce système de « Bibliothécaire » contre le « Chef Amnésique » sur deux tâches spécifiques :

Réglage d'une radio (Optimisation des hyperparamètres) : Ils ont essayé de trouver les réglages parfaits pour un modèle d'apprentissage automatique.
- Le Résultat : Le système du Bibliothécaire a utilisé 90 % de mots (tokens) en moins pour obtenir le même résultat. C'était comme si le chef avait arrêté de lire tout l'historique pour simplement consulter une fiche de révision.
Correction d'un programme informatique lent (Optimisation de code) : Ils ont essayé de rendre un code lent plus rapide en le réécrivant.
- Le Résultat : Même si les « notes » étaient ici plus longues (car elles devaient inclure le code réel), le Bibliothécaire a tout de même utilisé moitié moins de mots que le Chef Amnésique. Le Chef Amnésique continuait de relire tout l'historique des changements de code, tandis que le Bibliothécaire montrait simplement la version actuelle la plus performante et les dernières tentatives.

La Grande Conclusion
L'article ne porte pas sur la manière de rendre l'IA « plus intelligente » pour trouver le meilleur gâteau ou le meilleur code. Les deux méthodes ont trouvé des solutions de qualité similaire.

La percée réside dans l'efficacité.

L'Ancienne Méthode : À mesure que vous lancez plus d'expériences, le coût (en temps informatique et en argent) explose car l'IA doit tout relire à chaque fois.
La Nouvelle Méthode : Le coût reste stable. Vous pouvez lancer des centaines d'expériences sans que l'IA ne soit submergée par son propre historique.

En bref :
L'article démontre qu'en donnant à une IA une « banque de mémoire » persistante (État) et un moyen de résumer cette mémoire (Agent ReAct), vous l'empêchez de gaspiller de l'énergie à relire son propre journal intime. Cela lui permet de mener des expériences longues et complexes sans être accablée par la taille de son propre historique.

Résumé technique : Agents ReAct à état (Stateful) pour l'expérimentation autonome économique en jetons

Énoncé du problème

Le motif « autoresearch » permet l'expérimentation autonome en permettant à un grand modèle de langage (LLM) de modifier de manière itérative du code afin d'optimiser une métrique cible. Bien qu'efficace, l'implémentation standard est sans état (stateless) : à chaque itération, l'agent doit reconstruire l'intégralité du contexte expérimental en relisant tout l'historique des résultats et des modifications de code accumulés dans un fichier de directive de recherche (par exemple, program.md).

Cette conception induit une inefficacité structurelle :

Coût en jetons (Tokens) : La taille du prompt croît linéairement ( $O(n)$ ) avec le nombre d'itérations, ce qui entraîne un coût total en jetons de $O(n^2)$ .
Redondance : L'agent retransmet des informations qu'il a déjà traitées lors des étapes précédentes.
Scalabilité : À mesure que les expérimentations s'accumulent, le prompt approche des limites de la fenêtre de contexte, nécessitant une troncature ou une résumé, ce qui risque de perdre des nuances expérimentales critiques.

L'article postule que, puisque les LLM ne peuvent pas maintenir d'état transitoire entre les interactions (Huang et al. [10]), la gestion d'un état externe est une nécessité architecturale pour briser cette courbe de coût quadratique.

Méthodologie

Les auteurs reformulent le motif autoresearch en un agent ReAct à état (stateful) utilisant LangGraph. Au lieu de prompts monolithiques contenant l'historique complet, l'agent interagit avec le système de ML via des appels d'outils, tandis que l'historique expérimental, les traces de raisonnement et les métriques de convergence persistent dans un graphe d'état persistant typé.

Architecture

L'agent fonctionne comme un graphe d'état composé de trois nœuds principaux :

REASON (Raisonnement) : Invoque le LLM (Claude Haiku 4.5) avec le contexte de l'état actuel. Le modèle génère des traces de raisonnement et des appels d'outils.
TOOLS (Outils) : Exécute les appels d'outils de manière déterministe (ex: exécuter des expériences, interroger les résultats) et renvoie des observations.
CHECK (Vérification) : Évalue les critères de convergence (seuil de la métrique cible, budget d'itérations ou conclusion du LLM) sans intervention du LLM.

Des arêtes conditionnelles dirigent le flux : si le LLM produit des appels d'outils, le contrôle passe à TOOLS ; sinon, il procède à CHECK. Si la convergence n'est pas atteinte, la boucle revient à REASON.

Gestion de l'état

L'innovation centrale est l' AgentState (un dictionnaire typé) qui persiste à travers les itérations. Il comprend :

messages : Une fenêtre glissante des 20 derniers messages pour limiter le coût d'entrée.
experiment_history : Une liste de tous les résultats passés.
current_best : Le meilleur résultat trouvé jusqu'à présent.
train_py_content : L'état actuel du code.

Crucialement, l'agent utilise une classe d'assistance (ExperimentState ou CodeState) pour générer un résumé compact pour le LLM à chaque étape. Ce résumé inclut :

Le nombre d'itérations actuel et les meilleures métriques agrégées.
Les 5 dernières expériences (ou résultats récents).
Les notes de stratégie et les approches ayant échoué.

Cela garantit que le LLM ne reçoit que $O(1)$ jetons d'entrée par itération, quel que soit le nombre total d'expériences réalisées. L'historique complet reste accessible dans l'état mais est exclu du prompt, sauf s'il est explicitement interrogé via des outils.

Outillage

L'agent interagit avec le système ML via des outils spécifiques :

Optimisation des hyperparamètres : get_experiment_history et run_experiment.
Optimisation du code : get_current_train_py, modify_train_py (avec des garde-fous pour préserver la logique d'évaluation), submit_training_job et query_results.

Contributions clés

Reformulation architecturale : Transformer le motif autoresearch sans état en un agent ReAct à état utilisant LangGraph, découplant la mémoire de travail de l'agent de son contexte de prompt.
Efficacité des jetons : Démontrer une réduction structurelle du coût en jetons de $O(n^2)$ (sans état) à $O(n)$ (à état), avec un coût de $O(1)$ par itération.
Schéma d'implémentation : Fournir une architecture détaillée et reproductible (incluant les schémas d'état, la logique du graphe et les définitions d'outils) pour les praticiens souhaitant implémenter des agents à état.

Résultats expérimentaux

Les auteurs ont évalué l'agent à état par rapport à une base de référence sans état sur deux tâches de benchmark en utilisant 3 graines aléatoires (seeds).

Tâche 1 : Optimisation des hyperparamètres (Petites observations)

Configuration : 15 itérations d'optimisation d'XGBoost sur le jeu de données UCI Covertype. Les observations sont petites (~200 jetons : configuration JSON + métriques).
Résultats :
- Réduction des jetons : L'agent à état a consommé 90 % de jetons en moins (2 492 contre 24 465), soit une réduction de 9,8×.
- Performance : Les deux agents ont obtenu des scores F1 comparables (0,779 contre 0,764), les différences étant attribuées à la variance des graines plutôt qu'à une supériorité architecturale.
- Courbe de coût : Le coût d'entrée sans état a crû linéairement de ~700 à ~1 900 jetons par itération ; le coût de l'agent à état est resté plat à ~100 jetons.

Tâche 2 : Optimisation de la performance du code (Grandes observations)

Configuration : 40 itérations d'optimisation d'une fonction de traitement de données Python. Les observations sont larges (~1 500–3 000 jetons : code source complet + benchmarks).
Résultats :
- Réduction des jetons : L'agent à état a consommé 52 % de jetons en moins (627K contre 1 275K), soit une réduction de 2,0×.
- Performance : Les deux agents ont obtenu des accélérations comparables (~1,9× par rapport à la base).
- Courbe de coût : Bien que l'agent à état doive toujours transmettre l'artefact de code actuel (~1 500 jetons) à chaque étape, le coût total a plafonné. En revanche, le coût sans état a continué de grimper linéairement, accumulant plus de 80 000 jetons d'historique à l'itération 40.

Analyse comparative

Le ratio de réduction des jetons est inversement proportionnel à la taille de l'observation par rapport au résumé d'état.

Petites observations : Le résumé de taille fixe est considérablement plus petit que l'historique accumulé, produisant des ratios de réduction élevés (9,8×).
Grandes observations : L'agent à état doit toujours transmettre l'artefact de code actuel, ce qui limite le ratio (2,0×). Cependant, l'article note qu'à mesure que les itérations augmentent (ex: 100 ou 200), la divergence entre $O(n^2)$ et $O(n)$ élargira significativement le ratio (projection de 4× à 7×).

Signification et affirmations

L'article affirme que la contribution principale est l'efficacité structurelle, et non nécessairement l'amélioration de la qualité d'optimisation. L'agent à état atteint une qualité d'optimisation comparable à la base sans état tout en réduisant drastiquement la consommation de jetons.

Scalabilité : Le coût par itération de $O(1)$ permet des séquences d'expérimentation arbitrairement longues sans troncature de prompt ni perte de capacité de décision.
Impact économique : Bien que les économies soient modestes pour des exécutions courtes, elles deviennent matérielles pour la recherche à grande échelle (des centaines d'expériences par jour), où le coût quadratique de l'exécution sans état devient un goulot d'étranglement dominant.
Perspectives futures : Les auteurs suggèrent qu'à mesure que les horizons d'expérimentation s'allongent, le coût quadratique des jetons de l'exécution sans état deviendra la contrainte principale, rendant les architectures à état essentielles pour une expérimentation autonome durable.

Les auteurs restent modestes quant à la qualité d'optimisation, déclarant explicitement que les différences observées dans les métriques se situent dans la marge d'erreur et ne doivent pas être interprétées comme un avantage de qualité de l'approche à état. L'accent reste strictement mis sur les gains d'efficacité de ce changement architectural.