La compaction du contexte devient un objectif d'entraînement

Toute session d’agent un peu longue se termine de la même façon. Le contexte se remplit, un résumé se déclenche, et l’exécution se poursuit sur une mémoire compressée de ce qui a précédé. Dans Claude Code, le déclencheur est /compact, ou la passe automatique qui s’exécute à mesure que vous approchez de la limite de la fenêtre. Les opérateurs considèrent ce moment comme une friction à gérer : protéger l’état qui compte, espérer que le résumé le conserve, puis passer à autre chose. Un ensemble de travaux de recherche récents laisse entendre que cet instinct est sur le point de vieillir. La compaction passe d’un correctif appliqué à l’inférence, que vous contournez par ingénierie, à un objectif d’entraînement que le modèle optimise directement. Lorsqu’un modèle est récompensé pour produire des trajectoires qui survivent à leur propre compression, la gestion du contexte cesse d’être une tâche de surveillance qui vous incombe et devient une propriété que vous sélectionnez. {.answer-block}

TL;DR

• Aujourd’hui, la compaction du contexte vit au moment de l’inférence. Anthropic la présente elle-même comme une technique d’ingénierie du contexte : résumer une conversation qui approche de la limite de la fenêtre et repartir de ce résumé.² L’outillage d’exécution qui l’entoure — /compact, l’auto-compaction, l’édition du contexte, l’outil de mémoire — enveloppe un modèle qui ignore qu’on le compacte.³⁴
• CompactionRL entraîne le modèle à anticiper la compaction. La méthode optimise conjointement l’exécution des tâches et la génération des résumés par apprentissage par renforcement, de sorte que l’agent apprend à partir de trajectoires compactées au lieu d’en être interrompu.¹
• Les chiffres sont réels. Sur GLM-4.5-Air, la méthode atteint 66,8 % de Pass@1 sur SWE-bench Verified, soit un gain de 7,0 points, et 24,5 % sur Terminal-Bench 2.0.¹ Ces benchmarks sont discutés et d’actualité, ce ne sont pas des jouets.⁸⁹
• Il ne s’agit pas d’un seul article. Memory-R1 entraîne des opérations de mémoire ADD/UPDATE/DELETE par RL ; MemAct traite la curation du contexte comme des actions prises par la politique et les optimise de bout en bout.⁶⁷ Trois équipes indépendantes ont opté pour la même démarche.
• L’enseignement pour l’opérateur tient dans tous les cas. Traitez la jointure de compaction comme une surface de conception, non comme un accident : décidez ce qui relève de la mémoire durable par opposition au contexte transitoire, protégez la frontière avec un hook PreCompact, et commencez à lire la compétence de compaction acquise d’un modèle comme une ligne de spécification, non comme une note de bas de page.⁵

Le correctif que tout le monde gère déjà

Le contexte est une ressource finie, et tout opérateur qui mène de longues sessions a appris à le rationner. Les publications d’ingénierie de Anthropic nomment précisément le mode de défaillance : à mesure que le nombre de tokens augmente, la mémoire se dégrade, une détérioration qu’ils appellent « context rot ».² Le même article définit la parade en termes simples. La compaction est la pratique consistant à prendre une conversation qui approche de la limite de la fenêtre de contexte, à en résumer le contenu et à réinitialiser une nouvelle fenêtre de contexte à partir de ce résumé.²

Relisez cette définition et remarquez où se déroule le travail. Il se déroule autour du modèle, au moment de l’inférence, au moyen d’une machinerie à laquelle le modèle ne prend pas part. Claude Code rend cette machinerie concrète. La commande /compact libère du contexte en résumant la conversation jusqu’à présent, et vous pouvez passer des instructions de ciblage pour orienter ce que le résumé conserve.⁴ L’auto-compaction exécute la même passe automatiquement à mesure que le contexte approche de la limite ; elle est activée par défaut via le paramètre autoCompactEnabled, et vous définissez la fenêtre effective qui la déclenche avec CLAUDE_CODE_AUTO_COMPACT_WINDOW, ou vous la désactivez avec DISABLE_AUTO_COMPACT.⁴ Du côté de la plateforme, l’édition du contexte efface automatiquement les appels d’outils et les résultats obsolètes à mesure que vous approchez des limites de tokens, et un outil de mémoire fondé sur des fichiers permet au modèle de stocker des informations entièrement hors de la fenêtre.³

Ce sont de bons outils. Anthropic rapporte que l’édition du contexte a à elle seule amélioré de 29 % l’évaluation d’un agent à long horizon, et que son association avec l’outil de mémoire a réduit de 84 % la consommation de tokens sur une exécution de cent tours.³ Le propos n’est pas que l’approche à l’exécution soit faible. Le propos, c’est ce qu’elle présuppose. Chacune de ces techniques gère le contexte comme une propriété externe d’une session, appliquée à un modèle entraîné sur des trajectoires non compactées et qui ne rencontre la compaction qu’au déploiement. Le modèle produit une longue trajectoire comme il l’a toujours fait. C’est autre chose qui décide quand résumer, quoi conserver et comment reprendre. Le modèle se réveille alors dans un contexte compressé qu’il n’a pas rédigé et qu’il n’a jamais été entraîné à anticiper.

Cet écart, entre la façon dont le modèle a été entraîné et la façon dont il est exécuté, est la jointure que les nouveaux travaux referment.

Ce que CompactionRL change réellement

CompactionRL, issu de l’équipe GLM chez Zhipu, part du même énoncé de problème et inverse la solution. Au lieu de greffer la compaction sur l’inférence, la méthode fait de la compaction une partie de ce que le modèle est entraîné à faire. Elle optimise conjointement l’exécution des tâches et la génération des résumés, à l’aide d’une normalisation de la perte au niveau du token et d’une estimation d’avantage généralisée entre trajectoires, afin que l’agent puisse apprendre à partir de trajectoires à long horizon compactées plutôt que de s’en trouver dérouté.¹

Une fois la machinerie mise de côté, le changement est facile à énoncer. Dans l’approche à l’exécution, un résumeur se tient à l’extérieur de la politique et le modèle tolère ce qu’il produit, quel qu’il soit. Dans CompactionRL, le résumé est généré par la même politique qui accomplit la tâche, et les deux sont récompensés ensemble. Le modèle est entraîné à rédiger des résumés sur lesquels il peut agir, et à bien agir sur les résumés qu’il a rédigés. La compaction cesse d’être une interruption et devient un geste que l’agent a déjà répété.

Les résultats s’inscrivent sur des benchmarks d’actualité. Bâti sur le modèle ouvert GLM-4.5-Air, CompactionRL atteint 66,8 % de Pass@1 sur SWE-bench Verified, soit un gain absolu de 7,0 points, et 24,5 % sur Terminal-Bench 2.0.¹ Sur le plus petit GLM-4.7-Flash, elle ajoute 5,5 et 6,8 points sur les deux benchmarks.¹ Les deux benchmarks sont réels et difficiles : SWE-bench Verified est un sous-ensemble de 500 tickets validé par des humains pour la résolution de véritables tickets GitHub, et Terminal-Bench 2.0 réunit 89 tâches en ligne de commande vérifiées par des humains, où les agents de pointe obtiennent encore un score inférieur aux deux tiers.⁸⁹ SWE-bench Verified mérite une réserve, puisque OpenAI a publiquement pris ses distances avec ce benchmark début 2026 en raison de défauts de tests et de contamination ; considérez-le donc comme le benchmark de codage agentique le plus cité plutôt que comme une référence irréprochable.⁸ Les gains survivent à cette réserve parce qu’il s’agit d’écarts au sein d’un même modèle : le même modèle de base, entraîné à compacter, se surpasse lui-même.

La ligne la plus révélatrice de l’article n’est pas un benchmark. CompactionRL est déployé dans le pipeline d’apprentissage par renforcement servant à entraîner le prochain modèle GLM ouvert.¹ La compaction est passée d’une chose que l’on fait subir à un modèle à une chose avec laquelle un modèle est construit.

Pas un cas isolé

Un article, c’est un résultat. Trois équipes indépendantes qui optent pour la même démarche, c’est une direction. Aux côtés de CompactionRL, deux autres articles de 2025 traitent la gestion du contexte comme quelque chose à entraîner plutôt qu’à envelopper.

Memory-R1 dote un agent d’un gestionnaire de mémoire qui apprend des opérations structurées — ADD, UPDATE, DELETE et NOOP — par apprentissage par renforcement, de sorte que la décision de ce qu’il faut retenir et de ce qu’il faut écarter devienne une politique apprise au lieu d’une heuristique figée.⁶ Elle obtient ses résultats avec seulement 152 exemples d’entraînement, ce qui donne à penser que la capacité est plus proche du latent que du coûteux.⁶ MemAct pousse plus loin le cadrage dont traite cet essai. Il formule la gestion du contexte comme des opérations d’édition sur place — suppression et insertion — et optimise conjointement la rétention d’information et la performance sur la tâche par apprentissage par renforcement de bout en bout.⁷ La mémoire comme action, selon leurs termes : la curation du contexte de travail n’est pas une étape de prétraitement, elle fait partie de la politique.

Lus ensemble, les trois articles décrivent une seule et même migration. L’outillage d’exécution — édition du contexte, mémoire externe, résumés programmés — est la réponse actuelle à une fenêtre finie. L’approche à l’entraînement rend ces mêmes comportements intrinsèques au modèle, appris en fonction de la récompense qui compte réellement : terminer la tâche. Lorsque la même idée apparaît dans les opérations de mémoire, dans l’édition du contexte et dans la compaction des trajectoires en l’espace d’une seule année, les articles pris isolément importent moins que le vecteur qu’ils partagent.

Ce que cela signifie pour votre façon de construire aujourd’hui

Rien de tout cela n’arrivera dans votre cadre d’agent dès demain, et la question honnête que se pose l’opérateur est : que faire en attendant ? La réponse n’est pas d’attendre. Cette migration revalorise le travail que vous effectuez déjà autour du contexte, et quelques manœuvres vous positionnent pour la version à venir.

Traitez la frontière de compaction comme une surface de conception. À l’heure actuelle, la plupart des opérateurs découvrent le comportement de compaction par accident, en constatant après coup qu’un résumé a laissé tomber une décision prise au troisième tour. Rendez-le délibéré. Décidez d’emblée ce qui relève de la mémoire durable qui survit à toute réinitialisation — vos règles, les conventions de votre projet, le contrat de la tâche — et ce qui constitue le contexte transitoire qu’un résumé est autorisé à compresser. Dans Claude Code, la couche durable, ce sont vos fichiers CLAUDE.md et vos fichiers de règles, qui se rechargent après compaction grâce à l’événement InstructionsLoaded, ainsi qu’un magasin de mémoire fondé sur des fichiers pour l’état qui doit survivre à la fenêtre.³⁵ Tout le reste est à la merci du résumeur.

Protégez la jointure avec un hook, non avec de l’espoir. Claude Code expose un hook PreCompact qui se déclenche avant la compaction et peut l’orienter ou la bloquer, ainsi qu’un hook PostCompact pour le nettoyage qui suit.⁵ Si une catégorie d’état ne doit jamais être escamotée par un résumé, c’est dans un hook PreCompact que vous l’imposez de manière déterministe, plutôt que de compter sur le respect d’une instruction de ciblage. La discipline est la même que celle qui fait des hooks le bon outil pour tout ce qui doit toujours s’exécuter : vous déplacez une garantie hors du prompt, dans le code.

Commencez à lire la compétence de compaction acquise comme une ligne de spécification. À mesure que la direction tracée par CompactionRL mûrit, les modèles se distingueront non seulement par la taille de leur fenêtre de contexte, mais aussi par la qualité de leur entraînement à travailler compressés. La taille de la fenêtre est le chiffre vedette depuis deux ans, la comparaison 200K contre 1M qui ancre chaque fiche de modèle. Ce chiffre est sur le point de partager la scène avec un autre, plus discret : la grâce avec laquelle un modèle se dégrade lorsqu’il doit se résumer lui-même. Lorsque vous évaluez un modèle pour du travail à long horizon, soumettez-lui une tâche véritablement longue, qui force au moins une compaction, et observez ce qui survit. Ce comportement devient une propriété qu’il vaut la peine de sélectionner.

Structurez le travail de longue haleine pour que les jointures tombent à des endroits propres. Un modèle entraîné à compacter compacte tout de même mieux à cheval sur une sous-tâche terminée qu’à cheval sur une sous-tâche à moitié écrite. Tant que l’entraînement n’a pas rattrapé son retard partout, vous obtenez l’essentiel du bénéfice gratuitement en façonnant le travail pour que des points de contrôle naturels — un test qui passe, une modification validée, une sous-tâche close — s’alignent sur l’endroit où la compaction risque de se déclencher. C’est de toute façon une bonne conception de cadre d’agent, et c’est exactement la structure que les modèles entraînés apprennent à anticiper.

La position

La taille de la fenêtre de contexte cesse d’être la contrainte qui définit l’architecture du cadre d’agent. Depuis deux ans, la conversation sur la conception part d’un budget de tokens : combien tient, quoi évincer, quand résumer. Ce cadrage traite le modèle comme un récipient fixe et le contexte comme une ressource que l’on verse avec précaution. La direction tracée par CompactionRL dissout le récipient. Lorsque le modèle est entraîné à gérer sa propre compression, la fenêtre cesse d’être un mur dur que l’on affronte par ingénierie et devient un gradient doux que le modèle a appris à descendre.

L’outillage d’exécution ne disparaît pas. L’édition du contexte, les outils de mémoire et le /compact manuel restent les bons leviers pour les parties de la gestion du contexte qui vous reviennent véritablement : quels faits font autorité, quels fichiers constituent la source de vérité, ce qu’est réellement la tâche. La migration est plus étroite et plus intéressante qu’une automatisation totale. Elle déplace la moitié mécanique de la gestion du contexte — la tuyauterie du résumer-puis-reprendre — dans le modèle, et vous laisse la moitié éditoriale : décider ce qui compte. L’ingénierie du contexte se scinde entre ce que le modèle prend en charge et ce qui vous appartient encore, et la frontière entre les deux est le nouveau lieu où réside la bonne conception de cadre d’agent.

Le signe révélateur est déjà présent dans l’article sur CompactionRL. La compaction a gagné sa place dans le pipeline d’entraînement d’un modèle de pointe, aux côtés des signaux de récompense pour le codage et le raisonnement. Les capacités qui atteignent la boucle d’entraînement n’en repartent généralement pas. Les opérateurs qui remporteront l’année à venir sont ceux qui cessent de traiter la compaction comme un accident auquel survivre pour la traiter comme un contrat à concevoir.

Points clés à retenir

• La compaction migre de l’inférence vers l’entraînement. CompactionRL, Memory-R1 et MemAct utilisent indépendamment l’apprentissage par renforcement pour faire de la gestion du contexte un comportement appris plutôt qu’une enveloppe externe.¹⁶⁷
• Les outils d’exécution sont la réponse actuelle, non la réponse définitive. /compact, l’auto-compaction, l’édition du contexte et l’outil de mémoire gèrent le contexte autour d’un modèle qui n’a pas été entraîné à anticiper la compression.³⁴
• Séparez délibérément la mémoire durable du contexte transitoire. Placez les règles, les conventions et le contrat de la tâche dans la couche qui survit à une réinitialisation ; laissez tout le reste compressible.³⁵
• Imposez la frontière avec un hook PreCompact. Sortez toute garantie de « ne pas résumer » d’une instruction de ciblage pour la placer dans du code déterministe.⁵
• Lisez la compétence de compaction comme une ligne de spécification. Testez un modèle candidat sur une tâche assez longue pour forcer une compaction, et observez ce qui survit. La taille de la fenêtre n’est plus le seul chiffre qui compte.

FAQ

Qu’est-ce que la compaction du contexte ?

La compaction consiste à résumer une conversation qui approche de la limite de la fenêtre de contexte et à réinitialiser une nouvelle fenêtre à partir de ce résumé, afin qu’un agent de longue durée puisse poursuivre au-delà du point où l’historique brut déborderait.² Elle échange l’historique verbatim contre une représentation compressée qui tient dans la fenêtre.

Claude Code compacte-t-il le contexte automatiquement ?

Oui. L’auto-compaction est activée par défaut et s’exécute à mesure que le contexte approche de la limite. Vous pouvez orienter la fenêtre effective avec CLAUDE_CODE_AUTO_COMPACT_WINDOW, la désactiver avec DISABLE_AUTO_COMPACT, ou déclencher une passe manuellement avec /compact, en passant éventuellement des instructions de ciblage pour le résumé.⁴

Qu’est-ce que CompactionRL ?

Une méthode d’apprentissage par renforcement de l’équipe GLM qui entraîne les agents à long horizon à composer avec la compaction en optimisant conjointement l’exécution des tâches et la génération des résumés, de sorte que le modèle apprend à partir de trajectoires compactées. Elle améliore GLM-4.5-Air de 7,0 points sur SWE-bench Verified et est déployée dans le pipeline d’entraînement du prochain modèle GLM.¹

Peut-on entraîner un modèle à gérer son propre contexte ?

C’est précisément ce que démontrent les travaux récents. Memory-R1 entraîne des opérations de mémoire explicites par RL, MemAct traite l’édition du contexte comme des actions de politique, et CompactionRL entraîne directement la compaction des trajectoires. Toutes trois rendent la gestion du contexte intrinsèque au modèle plutôt qu’un ajout au moment de l’exécution.¹⁶⁷

Entraîner un modèle à compacter rend-il les fenêtres de contexte sans importance ?

Non, mais cela change le sens de ce chiffre. Une fenêtre plus grande aide toujours, mais un modèle entraîné à bien compacter peut aller plus loin dans n’importe quelle fenêtre qu’un modèle qui ne rencontre la compaction qu’au déploiement. La compétence de compaction acquise devient un second axe, aux côtés de la taille brute de la fenêtre.

Que dois-je faire dès maintenant au sujet de la compaction du contexte des agents ?

Concevez la jointure de compaction au lieu de la découvrir. Décidez ce qui relève de la mémoire durable par opposition au contexte transitoire, protégez la frontière avec un hook PreCompact, structurez les tâches longues pour que la compaction tombe à cheval sur des sous-tâches terminées, et évaluez les nouveaux modèles sur des tâches assez longues pour forcer un résumé.⁵

Sources