La fenêtre de contexte : comment bien gérer la mémoire de travail de Claude

Quand tu discutes avec Claude, tu as parfois l’impression qu’il a une mémoire infinie. Ce n’est pas le cas. Tout ce qu’il « voit » à un instant donné tient dans un espace limité qu’on appelle la fenêtre de contexte. Comprendre comment cet espace se remplit, pourquoi il se dégrade quand on le sature, et comment ça gonfle la facture, c’est sûrement la compétence qui change le plus ta façon de travailler avec une IA. Surtout si tu utilises Claude Code : coder et automatiser avec un agent.

Cet article te donne d’abord une vue générale, valable pour n’importe quel LLM, puis un focus pratique sur Claude Code, là où la gestion du contexte fait vraiment la différence.

C’est quoi, la fenêtre de contexte

La fenêtre de contexte, c’est la mémoire de travail de Claude pour une conversation. Elle contient tout ce que le modèle peut voir et sur quoi il peut raisonner en même temps : tes messages, ses propres réponses, les documents que tu as partagés, et le prompt système.¹ C’est une sorte de bureau : tout ce qui est posé dessus est immédiatement accessible, mais la surface est finie. Quand le bureau est plein, les choses les plus anciennes finissent par tomber par terre.

On mesure cet espace en tokens, l’unité de découpage du texte pour un LLM. Un token vaut grosso modo trois quarts de mot en anglais, un peu moins en français. Pour fixer les idées, les modèles actuels comme Opus 4.8 et Sonnet 4.6 disposent d’une fenêtre de 1 million de tokens, soit environ 750 000 mots, l’équivalent d’une dizaine de romans ou d’un projet de code de taille moyenne.¹ Haiku 4.5, lui, reste à 200 000 tokens.¹

Un million de tokens, ça paraît énorme. Et pourtant cet espace se remplit plus vite que tu ne le crois, parce que beaucoup de choses y entrent avant même que tu aies tapé ton premier mot.

Tout ce qui remplit la fenêtre

Voici les grands postes qui occupent de la place, du plus invisible au plus visible.

Le prompt système. Ce sont les instructions de base qui définissent le comportement de Claude. Tu ne les vois pas, mais elles sont là à chaque échange et consomment des tokens.

Les définitions d’outils. Dès que Claude peut L’appel d’outils : comment un LLM passe à l’action (recherche web, exécution de code, lecture de fichiers), la description de chaque outil, son nom, ce qu’il fait, ses paramètres, est injectée dans le contexte. Plus tu actives d’outils, plus ce socle est lourd, et ce, avant la moindre utilisation.

Les connecteurs et serveurs MCP. Quand tu branches Claude sur Gmail, Drive, Notion ou n’importe quel serveur MCP : le standard ouvert qui connecte Claude à tout, chaque outil exposé par ces connecteurs ajoute sa description au contexte. Un serveur MCP un peu riche peut exposer des dizaines d’outils. Multiplie par plusieurs connecteurs actifs et tu comprends pourquoi une partie de ta fenêtre est déjà occupée au démarrage.

La mémoire et le contexte projet. Si tu utilises les Projects et mémoire : donner du contexte durable à Claude, les instructions personnalisées et les éléments mémorisés rentrent eux aussi dans la fenêtre.

La conversation elle-même. Chacun de tes messages, chacune des réponses de Claude, et surtout le contenu des outils qu’il appelle. C’est souvent le poste le plus gourmand : un fichier lu, une page web récupérée, le résultat brut d’une requête, tout cela s’accumule au fil de l’échange.

flowchart TD
    A[Fenêtre de contexte] --> B[Prompt système]
    A --> C[Définitions d'outils]
    A --> D[Connecteurs et serveurs MCP]
    A --> E[Mémoire et contexte projet]
    A --> F[Conversation: tes messages + réponses]
    A --> G[Résultats d'outils: fichiers, pages web, requêtes]
    style A fill:#2d3748,color:#fff
    style G fill:#742a2a,color:#fff
    style F fill:#742a2a,color:#fff

Le point important : une grosse partie de ce remplissage est structurelle. Avant même ta première question, le prompt système, les outils et les connecteurs peuvent déjà occuper plusieurs dizaines de milliers de tokens.

Pourquoi trop remplir dégrade la qualité

On pourrait croire que tant qu’on ne touche pas le plafond, tout va bien. C’est faux, et c’est le piège principal.

Le phénomène porte un nom : le context rot, ou « pourrissement du contexte ». L’idée est que la performance du modèle se dégrade à mesure que le contexte grandit, parce que son attention se répartit sur de plus en plus de tokens, et que les contenus anciens ou hors sujet finissent par parasiter la tâche en cours.² Autrement dit, plus tu charges la fenêtre, plus Claude a du mal à se concentrer sur ce qui compte vraiment maintenant.

Concrètement, dans une session longue et chargée, on observe ce genre de symptômes : Claude oublie une décision prise plus tôt, recommence à expliquer des choses déjà établies, ou produit du code qui contredit ce qui avait été acté vingt minutes avant. Un développeur résume bien le compromis : pousser une session jusqu’à 90 % de remplissage produit plus de code brut, mais avec plus de bugs et des choix d’architecture incohérents ; s’arrêter autour de 75 % produit moins de volume mais un travail de meilleure qualité, qui passe vraiment en production.³

Il y a aussi le problème classique du « perdu au milieu » (lost in the middle) : un modèle retrouve moins bien une information placée au beau milieu d’un très grand contexte qu’au début ou à la fin.⁴ Une fenêtre d’un million de tokens ne garantit donc pas que Claude exploite bien le million. La règle d’or, formulée par l’équipe d’Anthropic, est de viser le plus petit ensemble d’informations à fort signal qui maximise tes chances d’obtenir le bon résultat.⁵

Pourquoi ça fait grimper la facture

Si tu passes par l’API ou par un outil facturé au token, le contexte a un effet direct et souvent sous-estimé sur le coût.

La raison tient à un détail mécanique : à chaque tour de conversation, l’intégralité du contexte est renvoyée au modèle. Claude n’a pas de mémoire entre deux appels ; pour répondre à ton nouveau message, il faut lui réexpédier tout l’historique. Donc si ta fenêtre est gonflée à 600 000 tokens de vieux historique, de fichiers lus et de sorties d’outils, ces 600 000 tokens sont re-facturés à chaque nouveau message.⁶

Fais le calcul. Avec Opus à 5 dollars le million de tokens en entrée, un contexte de 600 000 tokens coûte de l’ordre de 3 dollars par tour rien qu’en entrée, là où un contexte de 140 000 tokens reviendrait à environ 0,70 dollar.⁶ Sur une session avec des dizaines d’échanges, l’écart explose. Et le context rot aggrave le tout : la qualité baisse, donc les essais ratés s’accumulent, donc le contexte grossit encore, donc le tour suivant coûte plus cher.⁷

Bonne nouvelle côté tarif : sur les modèles actuels, la fenêtre étendue n’ajoute pas de surcoût par token. Une requête de 900 000 tokens est facturée au même tarif unitaire qu’une requête de 9 000 tokens, sans pénalité « long contexte ».⁸ Le danger n’est donc pas un tarif spécial, c’est le volume que tu laisses s’accumuler. Deux leviers aident à amortir : le prompt caching, qui peut réduire jusqu’à 90 % le coût des portions de contexte réutilisées, et le batch, qui offre 50 % de remise sur les traitements non urgents.⁸

Une nuance utile à garder en tête : depuis Opus 4.7, Anthropic a changé de tokenizer. Le tarif par token n’a pas bougé, mais le même texte peut consommer jusqu’à 35 % de tokens en plus. À texte égal, ta facture réelle monte donc un peu sur ces modèles.⁸

Bien gérer le contexte : les principes généraux

Avant d’entrer dans Claude Code, voici les réflexes qui valent partout.

Le premier, c’est de séparer les sujets. Quand tu changes complètement de tâche, ouvre une nouvelle conversation plutôt que de poursuivre dans un fil qui traîne déjà dix sujets sans rapport. L’ancien contenu n’aide pas, il encombre et il coûte.

Le deuxième, c’est de n’apporter que le contexte utile. Coller un document de cent pages quand seules trois pages comptent, c’est saturer la fenêtre pour rien et diluer l’attention de Claude. Cible ce qui sert vraiment la tâche.

Le troisième, c’est de maîtriser les outils et connecteurs actifs. Chaque connecteur MCP branché ajoute son lot de descriptions d’outils dans le contexte. Si tu n’as pas besoin de Gmail, Drive et Notion en même temps pour une tâche donnée, n’active que ce qui sert. À ce sujet, garder un œil sur ce que tu connectes a aussi un intérêt de sécurité, comme je l’explique dans Donner à Claude l’accès à ton PC, tes mails et ton cloud : quels risques ?.

Le quatrième, c’est de choisir le bon modèle. Une tâche simple de classification ou d’extraction n’a pas besoin d’Opus et de son énorme contexte : un modèle plus léger comme Haiku fait le travail pour bien moins cher. Le choix du modèle fait partie de la gestion du contexte, et c’est le sujet de Opus, Sonnet, Haiku, Fable : quel modèle Claude choisir.

Bien gérer le contexte dans Claude Code

C’est dans Claude Code que tout ça devient concret, parce qu’un agent qui lit des fichiers, exécute des commandes et enchaîne les tours remplit sa fenêtre à toute vitesse. Anthropic a d’ailleurs intégré plusieurs outils dédiés.

Surveille le remplissage. La commande /context te donne une répartition vivante de ta consommation par catégorie : prompt système, outils, fichiers mémoire, skills, historique.⁹ Si tes fichiers mémoire mangent 15 % de la fenêtre avant même que tu commences, tu le vois et tu corriges. Le statut en bas du terminal affiche aussi le pourcentage utilisé : prends l’habitude d’y jeter un œil avant de lancer une nouvelle tâche.

Nettoie entre les tâches. /clear repart d’une page blanche. À utiliser dès que tu passes à un sujet sans rapport : l’ancienne conversation occupe la place dont tu as besoin pour la suite et coûte des tokens à chaque message.⁹ La règle simple d’Anthropic : nouvelle tâche, nouvelle session.²

Compacte au bon moment. /compact remplace l’historique par un résumé structuré et continue par-dessus. C’est utile, mais c’est une opération à perte : le modèle décide ce qu’il garde et ce qu’il jette, et son jugement n’est pas toujours le tien.⁶ Deux conseils. D’abord, compacte de façon proactive, sans attendre d’être au taquet : à 95 % de remplissage, le modèle est déjà au plus bas de sa forme à cause du context rot, donc il résume mal.² Beaucoup recommandent de déclencher autour de 60 % plutôt que d’attendre le seuil automatique.¹⁰ Ensuite, guide-le : /compact concentre-toi sur le bug d'authentification garde ce que tu juges important plutôt que ce que la passe automatique devine.⁹

Délègue à des sous-agents. C’est le pattern le plus efficace contre le context rot. Quand Claude lance un sous-agent, celui-ci travaille dans sa propre fenêtre de contexte, séparée de la tienne.⁵ Il peut lire des dizaines de milliers de tokens pour une recherche ou une revue de code, puis ne renvoyer qu’un résumé condensé de 1 000 à 2 000 tokens.⁵ Tout le bruit reste chez lui. Le test mental utilisé chez Anthropic : « est-ce que j’aurai encore besoin de cette sortie d’outil plus tard, ou juste de la conclusion ? » Si c’est juste la conclusion, c’est un cas pour un sous-agent.² Tu peux le demander explicitement, par exemple « lance un sous-agent pour vérifier ce résultat à partir du fichier de spec ».²

Mets le stable dans un fichier dédié. Les exigences qui ne doivent jamais être oubliées (stack technique, conventions du projet, règles de base) ont leur place dans un fichier CLAUDE.md, chargé au démarrage de chaque session, plutôt que répétées dans la conversation.³ Ça sort l’information stable de l’historique fragile.

flowchart LR
    A[Quelle situation ?] --> B{Nouveau sujet<br/>sans rapport ?}
    B -->|Oui| C["/clear"]
    A --> D{Session longue,<br/>contexte qui monte ?}
    D -->|Oui| E["/compact ciblé<br/>vers 60%"]
    A --> F{Gros travail<br/>jetable ensuite ?}
    F -->|Oui| G[Sous-agent]
    A --> H{Règle à ne<br/>jamais oublier ?}
    H -->|Oui| I[CLAUDE.md]
    style C fill:#2c5282,color:#fff
    style E fill:#2c5282,color:#fff
    style G fill:#2c5282,color:#fff
    style I fill:#2c5282,color:#fff

Ce qu’il faut retenir

La fenêtre de contexte est une ressource finie, et la traiter comme telle change tout. Trop la remplir ne fait pas planter Claude, ça le rend juste plus distrait et plus cher. La discipline tient en une phrase, empruntée à Andrej Karpathy : remplir la fenêtre avec juste la bonne information pour l’étape suivante, ni plus, ni moins.

Dans la vie de tous les jours, ça veut dire séparer tes sujets, n’apporter que le contexte utile et ne brancher que les connecteurs nécessaires. Dans Claude Code, ça veut dire surveiller avec /context, nettoyer avec /clear, compacter tôt et ciblé avec /compact, et déléguer le travail volumineux à des sous-agents. Un million de tokens te donne de la marge, pas une dispense de gérer ton espace.