Résumé technique : La mémoire dans la boucle

Énoncé du problème

Les agents linguistiques opèrent sur une boucle standard : observer, raisonner, agir, répéter. Cependant, la mémoire sur laquelle ils raisonnent est généralement traitée comme une ressource externe interrogée au plus une fois par tour (récupération par tour). Cette conception est dictée par l'hypothèse que la latence de récupération est prohibitive. Les bases de données vectorielles en réseau répondent typiquement en 50 à 200 ms ; si un agent consulte une telle base à chaque étape de raisonnement, la latence de bout en bout peut être multipliée par 83. Par conséquent, les recommandations actuelles de l'industrie (« la mémoire d'abord ») et les conceptions de systèmes rationnent la récupération à une fois par tour ou masquent les coûts via la couche de service par le biais de l'ordonnancement.

L'article soutient que cette contrainte de latence n'est pas une loi fondamentale de la conception d'agents, mais un artefact de l'endroit où réside le magasin. La latence réseau (dizaines à centaines de millisecondes) rend la récupération dans la boucle coûteuse, tandis qu'un magasin en processus peut répondre en environ 100 µs. Le problème central est de savoir si déplacer la mémoire à l'intérieur de la boucle de raisonnement — en la lisant et en l'écrivant à chaque étape — est réalisable et bénéfique lorsque la barrière de la latence est levée.

Méthodologie

Architecture centrale

Les auteurs instaurent la « Mémoire dans la boucle » en utilisant un magasin sémantique éphémère et en processus (vxdb) enveloppé sous la forme d'un primitif WorkingMemory (mémoire de travail). Ce magasin supporte les opérations add (ajouter), recall (rappeler) et match (faire correspondre). Crucialement, le magasin est alloué par agent/tâche et n'est pas connecté à un service réseau, visant des temps de réponse de l'ordre de la microseconde.

Protocole expérimental

L'étude emploie deux régimes expérimentaux principaux :

1. Tâche de rappel fenêtrée (Performance de bout en bout) :

   • Scénario : Une conversation de planification de voyage en six tours où l'utilisateur énonce cinq contraintes durables tôt dans la conversation. L'agent doit lister les cinq contraintes à la fin.
   • Contrainte : La fenêtre de contexte est plafonnée à $w=4$ messages, ce qui fait que les contraintes initiales sortent de la vue du contexte.
   • Conditions :
     • Baseline/Aware (Référence/Conscient) : Pas d'outils de mémoire (Aware est informé que son historique est court).
     • Notes : Instructé de reformuler toutes les contraintes dans chaque réponse (une borne supérieure « sans outils »).
     • Memory (Mémoire) : Équipé d'outils remember/recall s'appuyant sur le magasin en processus.
   • Modèles : Testés à travers une « échelle GPT-5 » (gpt-5-nano, gpt-5-mini, gpt-5, gpt-5.5).

2. Tâche de garde de boucle causale (Latence vs Résultat) :

   • Scénario : Un agent traite un flux d'alertes de sécurité, décidant d' INVESTIGATE (enquêter) ou de SKIP (ignorer) les doublons.
   • Mécanisme : Une garde de code vérifie le magasin avant chaque action pour éviter les investigations redondantes.
   • Variable : La latence du magasin est manipulée en injectant des délais d'aller-retour (0 µs à 200 ms) tout en maintenant le budget de mémoire par tour fixe (100 ms).
   • Bras :
     • In-process (En processus) : Vitesse en temps réel (~17,5–85 µs).
     • Delayed Ladder (Échelle de délai) : Logique identique avec des délais injectés (+5, +15, +30, +50, +110 ms).
     • Per-turn RAG (RAG par tour) : Standard de l'industrie (récupération une fois par tour).
   • Métrique : Actions redondantes exécutées (sur 12 doublons).

Modélisation des coûts

Les auteurs définissent une frontière de faisabilité où la mémoire dans la boucle est viable si le coût de la récupération ($f \cdot c$) est négligeable par rapport au temps de l'étape de raisonnement ($r$). Ils mesurent le coût complet de l'opération (embedding + magasin) pour déterminer si l'accès par étape est « gratuit » par rapport à une étape de LLM.

Résultats clés

1. Faisabilité et taxe de latence

• Vitesse en processus : Le magasin en processus fonctionne à une latence médiane de 80–165 µs.
• Taxe de latence : Avec 20 récupérations dans la boucle par tour, le temps de blocage total est de ~1,7 ms pour le magasin en processus. En revanche, un magasin vectoriel dans le cloud (RTT de 110 ms) inflige une taxe de 2,2 secondes par tour.
• Faisabilité : Aux vitesses en processus, un agent peut se permettre ~953 récupérations par étape (en supposant un budget de latence de 10 %), alors que les magasins réseau permettent moins d'une recherche par étape, imposant un rationnement.

2. Performance des tâches (Rappel fenêtré)

• Échec de la référence : Toutes les exécutions de référence et « aware » ont obtenu un score de 0/5 pour le rappel des contraintes. La limitation de la fenêtre de contexte a provoqué un échec total, quelle que soit la taille du modèle.
• Référence de reformulation : Une référence instruite qui reformulait les contraintes dans chaque réponse a obtenu 5/5, démontrant que la tâche est soluble si l'agent gère activement le contexte, bien que cela implique un « loyer » en tokens qui croît avec l'ensemble de travail.
• Mémoire dans la boucle : La condition de mémoire dans la boucle a atteint un rappel de 3,6–4,8/5 à travers les modèles.
  • Analyse d'échec : Le magasin n'a jamais perdu de fait (244/244 écritures préservées). Les ratés étaient exclusivement des échecs de politique de lecture : les agents ont trop réécrit les contraintes (créant des doublons) puis n'ont lu qu'une seule fois par exécution via une fenêtre fixe de $k=8$, qui était encombrée par des entrées redondantes. L'échec résidait dans l'utilisation des outils par l'agent, et non dans le substrat de la mémoire.

3. Impact causal de la latence (Garde de boucle)

• Réponse dose-effet monotone : Les actions redondantes augmentent de manière monotone avec la latence du magasin sous un budget fixe.
  • En processus (0 ms) : 0,0 action redondante.
  • +15 ms : 1,4–1,6 action redondante.
  • +110 ms (Cloud) : 7,2 de 12 actions redondantes.
• Signification statistique : La différence entre la latence en processus et celle de 110 ms était statistiquement significative ($p=0,0079$) pour les deux modèles testés.
• Mécanisme : À 110 ms, le budget (100 ms) ne pouvait pas supporter une seule recherche, la garde était donc effectivement désactivée. Les « erreurs » n'étaient pas des erreurs de récupération, mais l'absence de vérifications.
• RAG par tour : Le standard de l'industrie (récupération par tour) a bien performé (0,4–0,6 action redondante) mais a échoué structurellement à détecter les doublons survenant au sein d'un même tour, là où la garde en processus a capturé tous les doublons.

4. Le goulot d'étranglement de l'embedding

• Le coût dominant dans la pile « in-loop » n'est pas le magasin, mais l'embedding. Les API d'embedding réseau prennent 200–400 ms.
• En associant le magasin en processus à un petit encodeur local (32M de paramètres, 32 µs), l'opération complète (embed + magasin) tombe à **40 µs**. Cela lève le dernier obstacle à la mémoire dans la boucle.

Signification et affirmations

Contribution théorique : Mémoire de travail étendue

L'article fonde ses conclusions d'ingénierie sur la Thèse de l'esprit étendu (Clark & Chalmers, 1998). Il soutient qu'une ressource externe devient « constitutive » de la cognition (c'est-à-dire une partie de la mémoire de travail de l'agent) uniquement si elle est :

1. Constamment disponible.
2. Directement accessible sans difficulté.
3. Automatiquement approuvée.

Les auteurs interprètent ces deux premiers critères comme un budget de latence. Un appel réseau de 100 ms est un outil que l'agent consulte ; un magasin en processus de 100 µs est une ressource que l'agent possède. Lorsque la latence est suffisamment faible pour être transparente à l'étape de raisonnement, le magasin passe de base de données externe à mémoire de travail étendue.

Contribution d'ingénierie

• La latence comme variable de conception : L'article déplace la fréquence de récupération d'une contrainte de la couche de service vers un axe de conception au niveau de l'agent. Il démontre que la latence du magasin, et non le motif « in-loop » lui-même, est le facteur de verrouillage.
• Lien causal : Il fournit une preuve causale que la latence du magasin détermine à elle seule les résultats des tâches (actions redondantes) sous un budget fixe, indépendamment de la capacité du modèle.
• Changement architectural : Il propose que la mémoire soit traitée comme un primitif de boucle (comme un bloc-notes/scratchpad) alloué par tâche, plutôt que comme un service connecté.

Modestie et limites

Les auteurs sont explicites quant à la portée de leur travail :

• Ils ne prétendent pas que le magasin rend le modèle plus « intelligent » ; les modèles ont toujours échoué à reconnaître les doublons sans la garde. Le système a réussi parce que l'échafaudage (scaffold) pouvait se permettre de vérifier la mémoire.
• La référence « Notes » (reformulation) a surpassé les outils de mémoire sur la petite tâche de 5 faits, soulignant que la reformulation paie un coût par tour qui croît avec l'ensemble de travail, ce que le magasin évite à grande échelle.
• L'étude se concentre sur l'aspect temporel de la mémoire (quand elle participe au raisonnement). Les questions concernant ce qu'il faut conserver, comment l'organiser et la gestion du cycle de vie (oubli/priorisation) sont identifiées comme des travaux futurs.

En conclusion, l'article affirme que le régime « in-loop » est non seulement réalisable mais causalement supérieur pour les tâches nécessitant une cohérence d'état au sein d'un tour, à condition que le substrat de mémoire soit en processus et couplé à un encodeur local pour éliminer la latence réseau.