La cuisine d'un restaurant à l'heure de pointe : des dizaines de commandes, le grésillement de l'huile, le bruit des couteaux. Le chef ne peut pas se permettre d'attendre que la poêle soit lavée — il y a toujours quelqu'un à côté pour préparer une poêle propre. C'est à peu près ainsi que fonctionnent les agents LLM : ils gèrent du code, planifient des tâches, communiquent avec l'utilisateur — et génèrent de longues chaînes de messages qui surchargent rapidement le modèle. Même dans les limites de la longueur de contexte autorisée, la qualité des réponses diminue : le modèle se perd dans les anciens détails. Ce phénomène a été baptisé « pourriture du contexte » (context rot). Pour préserver la pertinence, les développeurs intègrent dans les agents des stratégies d'ingénierie de contexte grands modèles de langage : une partie de l'historique est déchargée dans des fichiers, une autre est résumée brièvement, et pour les sous-tâches complexes, on crée un contexte propre séparé. Le prix de cette hygiène, ce sont des arrêts soudains : après la transformation, le modèle doit recalculer le cache de clés et de valeurs (cache KV), et à chaque fois l'agent trébuche avant de produire le jeton suivant.
Les auteurs ont remarqué que la plupart des opérations de transformation de contexte possèdent la propriété de « décomposabilité en segments » : le traitement d'une partie de l'historique ne dépend pas de ce qui apparaîtra plus tard. Cela a permis de déplacer les transformations dans un flux anticipé séparé (lookahead stream). Dans SmoothAgent, à côté de l'agent principal, un agent « fantôme » travaille : il applique de manière asynchrone la stratégie choisie au segment suivant — par exemple, le déchargement ou la réduction de l'historique — et construit un cache KV prêt pour le préfixe transformé. Lorsque l'agent principal atteint la limite et demande un nettoyage, on lui fournit immédiatement un contexte préparé à l'avance. Pour que les requêtes en arrière-plan ne gênent pas les requêtes principales, un répartiteur a été développé avec une planification anticipée, qui tient compte des contraintes de latence (SLO) et n'autorise les tâches anticipées que pendant les intervalles libres.
Les expériences ont été menées sur des GPU NVIDIA H100 avec les modèles Qwen3-8B et Qwen3-32B. L'agent effectuait une analyse de code en plusieurs étapes, générant à chaque étape 600 à 650 jetons — le contexte grandissait ainsi, imitant un processus stochastique d'interactions. En mode synchrone, le temps jusqu'au premier jeton (TTFT) aux points de transformation grimpait de plusieurs fois : lors du résumé, jusqu'à 1,2 s pour le modèle simple. SmoothAgent a éliminé ces pics : la latence de queue a chuté en moyenne de 62 %, et pour le résumé, jusqu'à 11,9 fois. Sur un système avec des GPU séparés pour le préremplissage et le décodage, le gain a été maintenu et s'est élevé en moyenne à 64,5 %. L'intégration dans des frameworks populaires (LangChain, LlamaIndex, AutoGen, OpenClaw) a montré une réduction du TTFT de 27 % à 81 %.
SmoothAgent transforme l'ingénierie de contexte d'un mal nécessaire en une procédure d'arrière-plan discrète. Cette approche démontre comment les méthodes d'apprentissage automatique permettent de concevoir un service efficace : le prétraitement asynchrone du cache KV masque des latences auparavant irréductibles. La décomposabilité en segments met en évidence une propriété structurelle applicable à tout calcul auxiliaire dans le pipeline de l'IA générative. En fin de compte, l'agent cesse d'être un cuisinier solitaire et devient une brigade de cuisine bien rodée, où chacun s'affaire sans agitation.
La branche de développement est évidente : étendre l'approche à des scénarios plus complexes avec de multiples agents et un contexte partagé. La technique de calcul anticipé pourrait migrer vers les systèmes RAG, où le traitement coûteux des documents se prête à une exécution préalable. Une autre direction est la planification adaptative : on peut fournir au répartiteur un prédicteur de probabilité de déclenchement imminent, afin de faire avancer les tâches en arrière-plan sans risque de retard.
Les déploiements industriels d'agents LLM (centres d'appels, IDE avec assistants IA, simulations autonomes) bénéficieront d'une réponse plus fluide et plus prévisible. Les fournisseurs de cloud pourront proposer des calculs en arrière-plan à tarifs réduits, améliorant l'utilisation des GPU.
Les prochaines étapes consistent à tester soigneusement les scénarios multi-agents avec contexte partagé et à intégrer des modèles de résumé pré-entraînés pour réduire le coût de la requête LLM en arrière-plan.
Ce travail aborde le problème fondamental de l'efficacité du raisonnement long en IA : comment maîtriser un contexte qui croît sans limite sans perdre en qualité ni en vitesse. Il fait écho au problème non entièrement résolu de l'attention en temps linéaire et à la recherche d'une politique optimale de remplacement du cache KV.
Cette section s'adresse à l'auteur du travail et à ses collègues. Les travaux voisins ont été trouvés par une recherche sémantique dans notre archive, et non par correspondance de mots. Nous n'évaluons pas : nous montrons le champ autour.
Ce que fait ce travail
Dans SmoothAgent, on s'attaque au problème des latences lors de la transformation du contexte des agents LLM : les auteurs proposent un flux anticipé qui prépare de manière asynchrone le cache KV pour les transformations futures du contexte. Les expériences sur Qwen3-8B/32B montrent une réduction du TTFT jusqu'à 11.9 fois lors de la summarisation et de 27 à 81 % dans les frameworks d'agents populaires.
Où est sa force
La force clé réside dans l'introduction de la propriété de décomposabilité en segments et l'utilisation d'une planification anticipée tenant compte des SLO, ce qui permet de masquer les latences de transformation du contexte sans interférer avec le flux principal.
Vers où avancer
À essayer
Travaux voisins dans notre archive
L'archive est vide autour de ce travail : l'analyse la plus proche n'est qu'à 0.58, contre 0,64 d'ordinaire. Il semble qu'on ait peu foré à côté.
La métaphore de la « pourriture du contexte » vient de l'observation que même dans la fenêtre officielle, le modèle commence à faire des erreurs sur des schémas répétitifs — presque comme un humain qui perd le fil dans une longue chaîne d'actions similaires.