Qu'est-ce qu'Auto Compact dans Claude Code ?

Claude Code est l’assistant de programmation agentique d’Anthropic, capable de lire une base de code, d’éditer des fichiers, d’exécuter des commandes et de s’intégrer aux outils dans des flux de travail en terminal, IDE, application de bureau et navigateur. Comme il fonctionne dans une fenêtre de contexte partagée, les longues sessions finissent par se remplir de l’historique du chat, de sorties de fichiers et de « bruit » d’outils. Claude Code gère cela automatiquement en compactant l’historique de conversation à l’approche de la limite, et des consignes initiales peuvent être perdues si elles ne figurent que dans l’historique du chat.

Cela compte d’autant plus en 2026, car Anthropic continue de pousser Claude Code vers un travail plus long et plus autonome. Le 25 mars 2026, Anthropic a publié « Claude Code auto mode: a safer way to skip permissions », indiquant que les utilisateurs approuvent 93 % des demandes d’autorisation et décrivant le mode auto comme un juste milieu basé sur un classifieur entre l’approbation manuelle et le saut d’autorisations non sécurisé. Le 5 février 2026, Anthropic a également lancé Claude Opus 4.6, mettant en avant un codage plus robuste, un meilleur débogage et des sessions agentiques plus longues. Ces mises à jour ne sont pas identiques à l’auto-compactage, mais elles montrent clairement la direction du produit : moins d’interruptions, des sessions plus longues et une meilleure continuité.

CometAPI propose actuellement un accès à l’API Claude à un prix inférieur à celui de l’API officielle, par exemple Claude Sonnet 4.6, Claude Opus 4.6 et le Claude 5.

Ce que signifie réellement l’auto-compactage dans Claude Code

Auto-Compact est un mécanisme intégré d’optimisation du contexte dans Claude Code (l’outil CLI/de bureau d’Anthropic) et dans l’écosystème plus large de l’API Claude. Il intervient automatiquement lorsque votre conversation approche du plafond de la fenêtre de contexte du modèle — généralement autour de 200 000 tokens pour des modèles phares comme Claude Opus 4 ou Sonnet 4. La documentation des hooks est explicite : PreCompact se déclenche avant une opération de compactage, et le matcher auto signifie « auto-compactage lorsque la fenêtre de contexte est pleine ». Le hook PostCompact correspondant se déclenche après la fin du compactage et reçoit le compact_summary généré.

C’est important car le compactage n’est pas la même chose que la « mémoire ». La mémoire automatique est le propre système de prise de notes de Claude, tandis que le compactage est un mécanisme de gestion de session qui compresse l’état de conversation en direct. La documentation sur la mémoire indique clairement que CLAUDE.md est persistant, que la mémoire automatique est écrite par Claude et que le compactage est le moment où l’historique conversationnel de la session est réduit pour que le modèle puisse continuer à travailler.

Au lieu de forcer une nouvelle conversation (et de perdre l’historique) ou de laisser le modèle « oublier » des détails critiques, Auto-Compact :

1. Analyse l’historique complet — en identifiant les éléments essentiels à conserver.
2. Génère un résumé concis — des décisions, de l’architecture du code, des bogues résolus, des états de fichiers et des prochaines étapes.
3. Remplace les anciens messages — par ce résumé (un « bloc de compactage » en termes d’API).
4. Reprend sans accroc — avec le contexte préservé.

Points clés (2026) :

• Seuil de déclenchement : par défaut à ~95 % de capacité (ou ~25 % restants). Certains utilisateurs signalent un tampon interne réservant 20–45k tokens (~22,5 % du contexte) pour le processus de compactage lui-même.
• Amélioration des performances : depuis Claude Code v2.0.64, le compactage est « instantané » au lieu de prendre des minutes.
• Exemple d’économies de tokens (d’après les benchmarks du Claude Agent SDK) : un flux de 5 tickets est passé de 204k à 82k tokens d’entrée (réduction de 58,6 %) avec deux événements de compactage.

Auto-Compact n’est pas la même chose que /clear (qui efface tout) ni qu’une simple troncature. Il préserve intelligemment ce qui compte — diffs de code récents, choix architecturaux, conventions de nommage — tout en condensant les boucles de débogage résolues et les digressions exploratoires.

Pourquoi utiliser Auto-Compact dans Claude Code ?

Les longues sessions de codage sont la norme. Une seule implémentation de fonctionnalité peut s’étendre sur plus de 50 tours : planification, débogage, refactorisation, tests. Sans compactage, l’utilisation de tokens croît linéairement, la qualité des réponses se dégrade et les coûts explosent.

Pour les développeurs, le bénéfice est moins de fatigue liée aux redémarrages. Plutôt que de copier manuellement un résumé dans une nouvelle session, vous laissez Claude compacter la session et continuer. C’est particulièrement utile lors de la correction de bogues, de refactorisations multi-fichiers, de changements pilotés par les tests et de workflows riches en relectures, où la conversation peut devenir très longue. Les sessions Claude Code commencent avec une fenêtre de contexte vierge, de sorte que le compactage est l’un des mécanismes clés qui rendent viable le travail de longue durée.

Principaux avantages

• Longueur de session illimitée : poursuivre indéfiniment sans repartir de zéro.
• Efficacité en coût et performances : réduit drastiquement les tokens d’entrée. Des retours du terrain montrent 50–60 % d’économies dans des workflows multiphases.
• Meilleure focalisation et stabilité : évite la « surcharge de contexte » où le modèle hallucine ou oublie des contraintes antérieures.
• Préserve la connaissance institutionnelle : les décisions clés restent dans le contexte même après des centaines de messages.
• Fluide pour les workflows agentiques : essentiel avec des outils, des serveurs MCP ou des configurations multi-agents dans Claude Code.

Quand faut-il compter sur l’auto-compactage ?

Utilisez l’auto-compactage lorsque la tâche est naturellement de longue durée : refactorisations multi-fichiers, sessions de débogage alternant entre journaux et sources, implémentation de fonctionnalités avec vérifications répétées, ou recherche nécessitant de nombreux appels d’outils. La documentation d’Anthropic indique explicitement les longues sessions où la fenêtre de contexte se remplit de conversation non pertinente, de contenus de fichiers et de commandes, et précise que l’auto-compactage préserve le code et les décisions clés tout en libérant de l’espace.

Il est moins adapté lorsque la tâche est courte, isolée, ou exige des instructions précises et durablement conservées. Des consignes présentes en début de conversation peuvent être perdues après compactage ; c’est pourquoi les règles de projet doivent figurer dans CLAUDE.md, et non dans une invite éphémère susceptible d’être compressée plus tard.

Quand l’utiliser (ou l’activer) :

• Activé par défaut pour la plupart des utilisateurs — idéal au quotidien, pour de grandes refactorisations ou des projets exploratoires.
• Tâches de longue haleine — traitement de files, pipelines de données, ou bases de code multi-fichiers.
• Environnements d’équipe/entreprise — où la continuité du contexte entre les sessions est importante.
• Projets à fort enjeu — où la perte d’une décision architecturale pourrait coûter des heures.

Quand envisager de le désactiver (via /config) :

• Vous voulez chaque token de contexte pour un contrôle ultra-précis.
• Vous préférez une gestion entièrement manuelle (utilisateurs avancés qui sauvegardent/restaurent les plans via des fichiers).

Dernières nouvelles (2025–2026) : en mars 2025, Anthropic a amélioré la logique de préservation d’Auto-Compact, rendant les résumés plus intelligents pour conserver « l’information importante tout en réduisant l’utilisation de tokens ». Fin 2025, le déclenchement a été affiné (parfois plus tôt à 64–75 % d’utilisation pour éviter les compactages échoués). Début 2026, des bogues temporaires sont apparus dans les interfaces web/de bureau (corrigés mi-janvier, malgré des signalements résiduels), tandis que le CLI est resté stable. La version 2.0.64 (février 2026) a rendu le compactage instantané, un grand progrès pour l’expérience développeur.

Comment utiliser Auto-Compact dans Claude Code : guide pas à pas

Claude Code est conçu pour que chaque session commence avec une fenêtre de contexte vierge. C’est utile car chaque nouvelle tâche démarre proprement, et cela facilite aussi la détection d’une session qui devient bruyante. Nous recommandons /clear entre des tâches sans lien afin que du contexte obsolète n’occupe pas l’espace.

Étape 1 : Vérifier l’état actuel du contexte

Utilisez /context pour visualiser la charge actuelle du contexte. La liste des commandes intégrées de Claude Code indique que /context affiche une grille colorée et met en évidence le gonflement de la mémoire, des suggestions d’optimisation et des alertes de capacité. C’est le moyen le plus rapide de savoir si vous approchez du moment où l’auto-compactage risque de se déclencher.

Dans votre session Claude Code, tapez :

/context

Cela affiche « Context left until auto-compact: XX% » — votre barre de progression en temps réel.

Étape 2 : Configurer l’Auto-Compact (facultatif)

Lorsque la fenêtre de contexte se remplit, Claude Code compacte automatiquement la conversation. La référence des hooks étiquette cet événement comme auto, et il se déclenche lorsque la fenêtre de contexte est pleine. En pratique, vous n’« activez » pas vraiment l’auto-compactage ; vous laissez plutôt Claude Code le faire au besoin.

/config

Accédez à « Auto-compact enabled » et basculez sur true/false. Par défaut, il est activé. Vous pouvez également ajuster des paramètres connexes comme l’utilisation des serveurs MCP pour libérer des tokens de manière proactive.

Étape 3 : Laissez Auto-Compact s’exécuter automatiquement

Lorsque vous atteignez ~95 % :

• Claude affiche « Compacting our conversation so we can keep chatting… » (ou équivalent).
• Il s’exécute en arrière-plan et reprend.
• Vous verrez le nouveau résumé en haut du contexte.

Astuce : ne pas attendre 0 %. Compactez manuellement plus tôt pour de meilleurs résultats (voir bonnes pratiques ci-dessous).

Étape 4 : Utilisez des hooks si vous voulez automatiser ce qui se passe autour du compactage

Claude Code expose les hooks PreCompact et PostCompact. La référence des hooks montre que PreCompact peut détecter si le compactage est manuel ou automatique, et que PostCompact reçoit le compact_summary généré. Les hooks conviennent donc très bien à la journalisation, aux pistes d’audit, aux notes post-compactage ou à l’automatisation externe.

Un pattern simple de hook ressemble à ceci :

{  "hooks": {    "PostCompact": [      {        "matcher": "auto",        "hooks": [          {            "type": "command",            "command": "./scripts/save-compact-summary.sh"          }        ]      }    ]  }}

Et le script shell correspondant peut lire l’entrée JSON via stdin, car les hooks de type commande dans Claude Code reçoivent le JSON de cette manière :

#!/usr/bin/env bashset -euo pipefailjq -r '.compact_summary // empty' \  | sed 's/^/[compact] /' \  >> .claude/compact-log.txt

La documentation confirme que les hooks de type commande reçoivent le JSON via stdin, et que PostCompact inclut compact_summary, de sorte que ce pattern est aligné avec le modèle de hook actuel.

Étape 5 : Compactage manuel avec précision (recommandé)

Utilisez /compact lorsque vous souhaitez que l’assistant compresse le fil maintenant. Vous pouvez inclure des instructions qui façonnent le résumé que vous souhaitez préserver. La page des commandes intégrées d’Anthropic liste /compact [instructions] comme « Compact conversation with optional focus instructions ».

/compact keep the auth flow decisions, the current test plan, and the open TODOs

Ce pattern est utile juste avant une passation, avant un changement de branche, ou avant de demander à Claude de démarrer une nouvelle phase de travail.

Exemples d’usage réel :

• Après un débogage : /compact keep the solution we found, remove debugging steps
• Jalons de projet : /compact focus on the new feature requirements

Compactage au niveau API (avancé – SDK Python et Messages API)

Pour des agents ou scripts personnalisés, utilisez les outils de compactage officiels.

Exemple avec le SDK Python Claude Agent (automatique pour les workflows utilisant des outils) :

from anthropic import Anthropic

client = Anthropic()

runner = client.beta.messages.tool_runner(
    model="claude-opus-4-6",
    max_tokens=4096,
    tools=your_tools,
    messages=messages,
    compaction_control={
        "enabled": True,
        "context_token_threshold": 100000,  # or lower for aggressive compaction
        "model": "claude-haiku-4-5",        # cheaper summarizer
        "summary_prompt": """Create a focused summary preserving:
1. COMPLETED TASKS and key outcomes
2. CURRENT STATE and open items
3. NEXT STEPS
Wrap in <summary></summary> tags."""
    }
)

Détecter les événements de compactage :

if curr_msg_count < prev_msg_count:
    print(f"Compaction occurred! Messages reduced from {prev_msg_count} to {curr_msg_count}")
```<grok-card data-id="f4afb5" data-type="citation_card" data-plain-type="render_inline_citation" ></grok-card>

**Full Messages API (beta, 2026)** – nécessite l’en-tête :
```bash
curl https://api.anthropic.com/v1/messages \
  --header "anthropic-beta: compact-2026-01-12" \
  --data '{
    "model": "claude-opus-4-6",
    "messages": [...],
    "context_management": {
      "edits": [{
        "type": "compact_20260112",
        "trigger": {"type": "input_tokens", "value": 150000},
        "pause_after_compaction": true
      }]
    }
  }'

L’API renvoie un bloc de compactage que vous devez réinjecter dans les appels suivants. Des instructions personnalisées et une pause offrent un contrôle total sur la budgétisation (par ex., imposer un plafond total de 3 M de tokens sur plusieurs sessions).

Si vous utilisez l’API Claude de CometAPI, changez l’en-tête des messages en "https://api.cometapi.com/v1/messages\\".

Auto-Compact vs compactage manuel vs Clear : tableau comparatif

Bonnes pratiques pour l’Auto-Compact de Claude Code (conseils de pros)

Compactez de manière proactive

La troisième règle consiste à utiliser le compactage comme un reset, pas comme une béquille. Si le fil est plein d’impasses, demandez à Claude de compacter avec une instruction claire sur ce qui compte : objectif actuel, approche choisie, tests en échec et questions non résolues. En pratique, cela rend le résumé bien plus utile que de laisser le système compacter à l’aveugle en espérant le meilleur.

Gardez vos consignes durables courtes.

Anthropic indique que les fichiers de plus de 200 lignes peuvent réduire l’adhérence ; de gros blocs de règles sont souvent pires que des consignes concises et bien délimitées. Utilisez .claude/rules/ pour les comportements spécifiques à un type de fichier ou un chemin, et utilisez des imports @path quand vous avez besoin de détails de support plus riches sans alourdir le fichier principal d’instructions.
Free tokens first — désactivez les serveurs MCP inutilisés avec /mcp ou @server-name disable avant de compacter.

Combinez avec CLAUDE.md

Considérez CLAUDE.md comme la source de vérité pour tout ce que vous souhaitez voir survivre à une longue session. CLAUDE.md est relu après /compact, ce qui en fait le bon endroit pour les commandes de build, conventions de codage et règles persistantes à ne jamais perdre. La mémoire automatique est utile aussi, mais c’est un système différent pour un objectif distinct.

Autres conseils

Surveillez via /context — Maintenez si possible l’utilisation sous 70–80 %.

Pour les utilisateurs de l’API — Fixez des seuils plus bas (p. ex. 50k–100k) et utilisez des modèles de synthèse moins coûteux comme Haiku.

Désactivez seulement si nécessaire — La plupart des développeurs recommandent désormais de garder Auto-Compact activé après les améliorations de 2025.

Testez le compactage — D’abord dans des sessions non critiques pour voir comment votre workflow spécifique est résumé.

Impact réel : des développeurs rapportent des sessions productives 2–3x plus longues et moins de moments où « Claude a oublié ce que nous faisions ».

Problèmes courants et dépannage (édition 2026)

• L’auto-compactage ne se déclenche pas : vérifiez web/bureau vs CLI ; certains bogues de janvier 2026 ont été corrigés, mais vérifiez la version.
• Contexte perdu après compactage : utilisez /compact avec des instructions explicites la prochaine fois.
• Boucles infinies ou 102 % d’utilisation : rares ; redémarrez la session ou utilisez /clear en dernier recours.
• Compactage lent : problème pré-v2.0.64 — mettez à jour Claude Code.
• Erreurs de bloc de compactage API : joignez toujours le bloc de contenu de compactage complet dans les appels suivants.

Conclusion

L’auto-compactage est l’un des mécanismes clés, souvent invisibles, de Claude Code, car il permet de garder les longues sessions de codage utilisables sans vous obliger à redémarrer à chaque fois que la fenêtre de contexte se remplit. La règle pratique est simple : laissez l’auto-compactage gérer le trop-plein, utilisez /compact quand vous voulez garder la main, stockez les consignes durables dans CLAUDE.md, et utilisez /clear ou /rewind lorsque la structure de la session change. Cette combinaison offre le meilleur équilibre entre continuité, contrôle et rapidité dans les workflows de codage longs avec Claude Code.

Auto-Compact dans Claude Code représente un bond en avant pour le développement assisté par IA, au quotidien. En gérant intelligemment la fenêtre de contexte de 200k tokens, il élimine le plus grand point de friction du codage long format : « tomber à court de mémoire ». Avec des performances instantanées (2026), des options de configuration riches et de puissantes extensions API, c’est désormais une fonctionnalité mûre, éprouvée, utilisée quotidiennement par des milliers de développeurs.

Actions à entreprendre dès aujourd’hui :

1. Ouvrez Claude Code et lancez /config — confirmez que l’Auto-Compact est activé.
2. Essayez un /compact manuel avec des instructions sur votre projet en cours.
3. Explorez le SDK Python ou la Messages API pour des agents automatisés via CometAPI.