💬 NLP

Learning What Not to Forget: Long-Horizon Agent Memory from a Few Kilobytes of Learning

L'article présente LRE (Learned Relevance Eviction), un scoreur léger, exclusivement CPU et sans modèle de langage, qui apprend à identifier et à conserver l'historique d'interaction critique pour les agents de longue durée, atteignant une précision et une efficacité supérieures par rapport aux bases de référence existantes tout en opérant avec un coût computationnel minimal et un entraînement sans annotation.

Auteurs originaux : Nusrat Jahan Lia, Aritra Mazumder

Publié 2026-06-23

📖 6 min de lecture🧠 Analyse approfondie

CC BY 4.0

Auteurs originaux : Nusrat Jahan Lia, Aritra Mazumder

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 assistant super intelligent (comme une IA hautement avancée) essayant de résoudre un puzzle complexe ou d'avoir une longue conversation avec un ami. Le problème est que votre cerveau a une limite de taille stricte. Vous ne pouvez contenir qu'une certaine quantité d'informations dans votre « mémoire active » à la fois.

Pendant que vous travaillez, vous accumulez un historique massif de notes, d'actions et de conversations. Finalement, cet historique devient trop volumineux pour tenir dans votre cerveau. Vous devez alors jeter certaines choses pour faire de la place à de nouvelles pensées. C'est ce qu'on appelle l'éviction.

Le document présente une nouvelle méthode appelée LRE (Learned Relevance Eviction - Éviction par Pertinence Apprise) pour résoudre ce problème. Voici comment cela fonctionne, en utilisant des analogies simples :

Le Problème : Un cerveau « trop gros pour tenir »

Imaginez que vous préparez vos bagages pour un voyage, mais que votre valise possède une petite fermeture éclair qui ne s'ouvre qu'à moitié. Vous avez des centaines d'articles (votre historique de conversation ou les étapes d'une tâche).

L'ancienne méthode (FIFO/Récence) : Vous jetez simplement les articles les plus anciens au bas de la pile pour faire de la place aux nouveaux.
- Le risque : Vous pourriez jeter l'article « porteur », comme votre passeport ou un jeton de code spécifique nécessaire pour se connecter. Si vous perdez cela, votre voyage (ou votre tâche) échoue, même s'il vous reste de l'espace.
La méthode coûteuse (Compression par LLM) : Vous engagez un éditeur professionnel (une autre IA) pour lire vos notes et les résumer en un court paragraphe.
- Le risque : L'éditeur pourrait accidentellement oublier un détail crucial en essayant d'être bref. De plus, engager un éditeur à chaque fois que vous ajoutez une note est lent et coûte cher (puissance de calcul).

La Solution : LRE (Le petit bibliothécaire intelligent)

LRE est un « bibliothécaire » minuscule et super rapide qui vit sur une puce informatique standard (CPU). Il n'a pas besoin d'un super-ordinateur ou d'une seconde IA pour faire son travail.

1. C'est minuscule et rapide
Considérez LRE comme une liste de contrôle de poche (ne faisant que quelques kilo-octets). Il ne réécrit pas vos notes ; il décide simplement quelles notes conserver. Il fonctionne si vite qu'il peut vérifier plus de 1 000 notes par seconde, alors que les « éditeurs professionnels » (encodeurs denses) pourraient seulement en gérer 36.

2. Il apprend ce qui est important (Le concept de « porteur »)
LRE examine votre historique et se demande : « Aurai-je besoin de cette pièce d'information spécifique plus tard ? »

L'analogie : Imaginez que vous construisez une maison. Vous avez un tas de briques, de bois et de détritus divers.
- Une approche par « récence » conserve les derniers éléments que vous avez touchés.
- LRE regarde le tas et dit : « Cette brique spécifique de l'étape 3 est la fondation du toit que nous construisons à l'étape 17. Gardez-la exactement telle quelle. »
- Il conserve le texte exact (verbatim), de sorte que si un mot de passe ou un numéro d'identification spécifique est nécessaire plus tard, il sera toujours là, inchangé.

3. Il n'a pas besoin de professeur (Auto-supervision)
Habituellement, pour apprendre à un ordinateur ce qu'il doit garder, il faut un humain pour étiqueter des milliers d'exemples (« Garde ceci », « Jette cela »).

L'astuce de LRE : Il apprend en s'observant lui-même. Il regarde son propre comportement passé.
- Dans une conversation : Si l'IA mentionne un fait (comme « Je suis transgenre ») et qu'ensuite, 400 échanges plus tard, elle utilise ce fait pour répondre à une question, LRE apprend : « Ah, ce fait était important ! J'aurais dû le garder. »
- Dans une tâche : Si l'IA génère un jeton de connexion et l'utilise trois fois plus tard, LRE apprend : « Ce jeton est porteur. Gardez-le. »
- Cela signifie qu'il peut apprendre sans qu'aucな humain n'ait à payer pour étiqueter des données.

Les Résultats : Pourquoi il gagne

Le document a testé LRE dans deux scénarios principaux :

1. L'Agent (Le robot travailleur)

Scénario : Une IA essayant de réserver un vol ou de gérer un compte de messagerie via une série d'étapes.
Résultat : Lorsque la limite de mémoire était serrée, les autres méthodes ont échoué car elles ont jeté le jeton de connexion ou le numéro d'identification spécifique nécessaire pour terminer le travail. LRE a conservé ces détails exacts.
Analogie : Tandis que les autres méthodes tournaient en rond en essayant de se reconnecter encore et encore (perdant du temps), LRE avait la clé dans sa poche tout le temps et a terminé le travail en 37 % moins d'étapes. Il était aussi précis que si l'on gardait tout, mais utilisait 52 % d'espace en moins.

2. Le Conversationaliste (Le partenaire de discussion)

Scénario : Se souvenir de détails d'une longue discussion survenue il y a des semaines.
Résultat : LRE était meilleur pour trouver la pièce d'information exacte pour répondre à une question que les modèles d'IA complexes et coûteux qui tentent de résumer la discussion.
Analogie : Si vous demandez : « Qu'est-ce que Caroline a dit sur sa famille il y a 400 messages ? », LRE trouve ce message exact instantanément. Les autres méthodes ont soit oublié l'information, soit l'ont si mal résumée que la réponse a été perdue.

L'essentiel

LRE est un moyen peu coûteux, rapide et précis de gérer la mémoire.

Il ne résume pas et ne réécrit pas (ce qui cause des erreurs).
Il n'a pas besoin de super-ordinateurs coûteux pour décider quoi garder.
Il apprend de ses propres erreurs et de ses succès.

Le document soutient que pour les agents d'IA et les chatbots, nous n'avons pas besoin de jeter des informations ou d'engager des éditeurs coûteux pour les résumer. Nous avons juste besoin d'un filtre minuscule et intelligent qui sait conserver les briques « porteuses » de notre historique afin que la structure ne s'effondre pas.

Résumé technique : Apprendre ce qu'il ne faut pas oublier (LRE)

Énoncé du problème

Les agents de grands modèles de langage (LLM) et les assistants conversationnels à longue durée de vie accumulent des historiques d'interaction qui finissent par dépasser la fenêtre de contexte du modèle. Pour fonctionner avec des budgets de jetons (tokens) fixes, les systèmes doivent évincer (supprimer) l'historique ancien. Le défi central est que l'éviction est une décision proactive et aveugle à la requête : le système doit décider de ce qu'il garde avant que la requête ou l'action future nécessitant cette information n'existe.

Les approches standard échouent dans ce contexte :

Heuristiques réactives (Récence/FIFO) : Suppriment les informations les plus anciennes en se basant uniquement sur le temps, éliminant souvent des détails « porteurs » (ex: jetons d'accès, identifiants) nécessaires aux étapes futures, ce qui provoque des boucles ou des échecs chez les agents.
Compression basée sur le LLM : Résumer l'historique via des appels au LLM introduit un comportement non déterministe, des erreurs de paraphrase (perte d'identifiants exacts) et une latence/un coût significatifs.
Récupération/Scoring neural : Les méthodes utilisant des plongements (embeddings) denses ou un scoring basé sur l'attention nécessitent souvent une passe avant neurale pour chaque unité ou sont liées à des couches spécifiques du modèle, entraînant des coûts d'inférence qui augmentent mal avec l'échelle.

L'article soutient que l'éviction de la mémoire est fondamentalement un problème de fidélité : le système doit conserver un état exact, verbatim (mot pour mot), et non pas seulement des concepts résumés, pour garantir le succès des actions futures, mais il doit le faire avec une politique peu coûteuse, proactive et indépendante du LLM hôte.

Méthodologie : LRE (Learned Relevance Eviction)

Les auteurs proposent LRE, un scoreur léger, tournant uniquement sur CPU et sans modèle de langage, conçu pour apprendre quelles unités de l'historique sont « porteuses ».

Mécanisme central

Définition de l'unité : L'historique est segmenté en unités discrètes (ex: tours de dialogue ou paires action-observation de l'agent).
Extraction de caractéristiques causales : Pour chaque unité $u_i$ $u_{i}$ , LRE calcule un vecteur de caractéristiques $\phi(u_i, u_{\le i})$ $ϕ (u_{i}, u_{\leq i})$ basé uniquement sur le préfixe de l'historique. Les caractéristiques incluent :
- Structurelles : Position dans la trajectoire, récence, longueur.
- Lexicales : TF-IDF, comptage de chiffres, mots en majuscules, présence d'URL/ID.
- Spécifiques au domaine : Indicateurs d'erreur, présence de jetons de code (pour les agents), marqueurs de questions (pour la conversation).
Scoring : Un petit modèle de régression logistique avec régularisation L2 ( $f_\theta$ $f_{θ}$ ) attribue une probabilité de pertinence $p_i$ $p_{i}$ à chaque unité.
- Coût : Le modèle est minuscule (ex: 1,7 Ko pour les agents) et s'exécute sur CPU sans passe avant neurale lors de l'inférence.
Sélection (Problème du sac à dos) : Étant donné un budget de jetons $B$ $B$ , LRE sélectionne le sous-ensemble d'unités anciennes $S^*$ $S^{*}$ qui maximise la somme des scores $\sum p_i$ $\sum p_{i}$ sous la contrainte de coût de jetons $\sum c_i \le B$ $\sum c_{i} \leq B$ .
- La sélection est extractive : les unités sont conservées verbatim. Aucune résumé ou réécriture n'a lieu, préservant les identifiants et valeurs exacts.
- Une fenêtre récente $R_k$ (ex: les 5 dernières étapes) est toujours conservée sans limite.

Apprentissage auto-supervisé

Pour éviter une annotation humaine coûteuse, LRE tire ses étiquettes du propre comportement du système (rétrospective) :

Domaine des agents (AppWorld) : Une étape est étiquetée positivement ( $y=1$ ) si un identifiant qu'elle introduit (ex: un ID, un jeton) est réutilisé par $\ge 3$ étapes suivantes. Cela identifie un « état porteur ».
Domaine de la conversation (LoCoMo/LongMemEvalS) : Un tour est étiqueté positif si son contenu présente un chevauchement $\ge 40\%$ avec la réponse finale à une question posée plus tard dans la session.
Résultat : Cette approche récupère 95 % de la performance d'un modèle entièrement supervisé (entraîné sur des étiquettes d'or humaines) sur LongMemEvalS et 82 % sur LoCoMo.

Principales contributions

Une politique proactive et aveugle à la requête : LRE est la première politique d'éviction apprise qui fonctionne sans accès à la requête future, ce la rendant adaptée aux boucles d'agents en temps réel où l'étape suivante est inconnue.
Fidélité Verbatim : Contrairement aux méthodes de compression qui paraphrasent, LRE extrait les unités exactement telles qu'elles sont apparues. Ceci est crucial pour préserver les identifiants opaques (jetons, IDs) que la summarisation détruit.
Efficacité extrême :
- Coût neural nul : Le scoreur s'exécute sur CPU sans appels au LLM ni passes avant GPU.
- Vitesse : Il score environ 1 181 unités/seconde, ce qui est nettement plus rapide que les encodeurs denses (~~103 unités/s) ou les LLM de pruning de jetons (~~36 unités/s).
- Taille du modèle : Le scoreur ne fait que quelques kilo-octets.
Supervision sans annotation : Démontre que la « pertinence » peut être apprise à partir des propres journaux opérationnels du système (schémas de réutilisation) sans supervision humaine.

Résultats expérimentaux

Performance des agents (AppWorld)

Succès de la tâche : Avec un budget de 2048 jetons, LRE atteint un succès de tâche de 41,1 %, égalant le taux de succès de 44,0 % du maintien de l'intégralité de l'historique (non borné).
Comparaison :
- FIFO (Récence) : Chute à 34,5 % de succès ; les agents tournent en boucle à cause de la perte de credentials.
- ACON (Compression LLM) : Chute à 26,2 % de succès ; la summarisation perd les jetons exacts, provoquant des boucles de ré-authentification.
- LRE : Résout 14 tâches qu'aucune autre politique (y compris l'historique complet dans certains cas limites de boucles) ne pouvait compléter.
Efficacité : LRE termine les tâches en 19 étapes en moyenne, contre 30,6 pour FIFO et 33,5 pour ACON. Il nécessite zéro appel au compresseur, alors qu'ACON nécessite environ 5,45 appels par tâche.
Réduction du contexte : Réduit la taille de pointe du contexte jusqu'à 52 % par rapport à la ligne de base non bornée la plus défavorable tout en maintenant une haute précision.

Mémoire conversationnelle (LoCoMo & LongMemEvalS)

Classement de la pertinence : LRE atteint un Macro-AUC de 0,829 sur LoCoMo et de 0,708 sur LongMemEvalS.
Comparaison avec les lignes de base : Il surpasse les encodeurs d'embeddings denses (0,643) et les méthodes de pruning de jetons (0,402) bien que ces dernières utilisent des passes avant neurales. Les modèles de récence et de décroissance (decay) performent près du hasard (0,478).
QA en aval : Lorsqu'il est utilisé comme politique de rétention pour un modèle de QA, LRE fournit la meilleure qualité de réponse sous un budget fixe, surpassant les bases de récence et de saillance de contenu.

Signification et affirmations

L'article soutient qu'un apprentissage de la pertinence peu coûteux est suffisant pour la rétention proactive de la mémoire dans les agents LLM.

Fidélité plutôt que Compression : Le principal mode de défaillance des systèmes existants n'est pas seulement l'« oubli », mais la « distorsion » (via la summarisation) ou la « perte » (via la récence) de l'état exact. LRE résout cela en privilégiant l'extraction verbatim.
Déployabilité : Parce que LRE est aveugle à la requête, tourne uniquement sur CPU et ne nécessite aucune annotation, c'est une politique pratique pour les systèmes de production où la latence et le coût sont des contraintes.
Autonomie : Les systèmes peuvent apprendre ce qu'il faut garder à partir de leurs propres journaux opérationnels, éliminant ainsi le besoin de supervision externe.

Les auteurs concluent que bien que l'éviction proactive ne puisse pas prédire parfaitement tous les besoins futurs (une limitation fondamentale), une politique extractive apprise comme LRE offre un équilibre Pareto-optimal entre précision, coût et fidélité que les bases actuelles ne peuvent égaler.