Plus la fenêtre est grande, plus la pourriture est silencieuse

La falaise des 30 %

Il y a deux ans, les modèles plafonnaient autour de 200 000 tokens. Le raisonnement et l’attention étaient plus faibles, et ce plafond, on ne pouvait pas y échapper.

Je me souviens qu’à environ 30 % de remplissage, l’agent commençait à déraper. Il hallucinait bien avant la limite dure. Il oubliait des consignes que je lui avais données quatre étapes plus tôt. Il ne suivait plus l’indirection, ces enchaînements « fais X, puis sers-toi du résultat pour décider Y » qui demandent au modèle de tenir un fil. À l’époque, il n’y avait ni skills, ni sous-agents, ni modèle capable de les piloter vraiment : le seul levier dont je disposais, c’était la fenêtre elle-même.

La boucle de débogage était le pire de tout. Quand je lui demandais un correctif, l’agent lançait les tests, et le mur de sortie à lui seul avalait une part de ce qui restait. Les logs inondent la fenêtre plus vite que le modèle ne peut raisonner dessus : à la troisième itération, ce qui était censé lire l’erreur s’y noyait.

Puis les fenêtres ont grandi. Un million de tokens. Le raisonnement a suivi. La pression qui imposait la discipline s’est simplement levée. Rester sobre a cessé d’être une question de survie pour devenir, sans bruit, une préférence. Et les préférences glissent.

Une fenêtre plus grande ne vous incite pas seulement à relâcher. Elle vous pousse vers des tâches plus grosses. Et dans une grosse tâche, la pourriture se cache : quand l’agent mastique quarante fichiers et mille lignes de son propre raisonnement, vous ne pouvez pas lire l’exécution d’assez près pour repérer le seul endroit où il a dévié. L’abondance n’a pas fait disparaître la défaillance. Elle l’a rendue silencieuse.

ℹ️ La fenêtre de contexte ? La fenêtre de contexte, c’est l’ensemble de travail des tokens que le modèle lit en une passe : vos consignes, les fichiers ouverts, la conversation en cours, la sortie des outils, le tout borné par une capacité (disons un million de tokens). Pour la mécanique de sa construction et son lien direct avec les coûts, voir ce qu’est vraiment une fenêtre de contexte.

Mieux n’est pas une immunité

Les fenêtres sont plus grandes aujourd’hui. Mais si cela a relevé le plafond de complexité des tâches, cela n’a acheté aucune immunité contre la pourriture. Entassez du bruit dans une fenêtre d’un million de tokens et vous obtiendrez quand même de la pourriture du contexte. La place a augmenté. La pourriture, elle, n’a pas disparu.

🔬 Mesuré, pas deviné. En 2025, Chroma Research l’a montré directement : les LLM deviennent mesurablement moins fiables à mesure que la longueur d’entrée augmente, même sur des tâches de récupération triviales, un effet qu’ils ont mesuré sur 18 modèles de pointe dont GPT-4.1, Claude 4, Gemini 2.5 et Qwen3 (Chroma Research, Context Rot: How Increasing Input Tokens Impacts LLM Performance, 2025). Leur rapport a fait de « context rot » le nom standard de l’effet.

C’est donc le même combat qu’avant, avec juste plus de corde. Pas le moins de tokens pour le principe. Pas le plus, parce que vous le pouvez. Le moins de tokens, et les meilleurs. Voilà la fenêtre sobre, et la tenir sobre est le travail de la prochaine génération d’ingénieurs et de développeurs.

Le tableau blanc est plat

Voyez la fenêtre comme un tableau blanc, pas comme un entrepôt. Un entrepôt vous laisse garder un million de choses parce qu’elles sont en cartons, sur des étagères, hors de vue, sans rien coûter à ce sur quoi vous travaillez maintenant. Un tableau blanc montre tout d’un seul coup. Tout ce que vous avez écrit il y a une heure est encore là, en concurrence pour le même mur. Il prélève un loyer sur chaque trait, indéfiniment, que vous vous en serviez encore ou non.

Le modèle pondère bien les traits différemment : c’est exactement ce qu’est l’attention. Mais cette pondération se fait à l’intérieur du modèle, pas devant vous. À vingt mille traits sur le tableau, vous, vous ne distinguez pas le token porteur du token mort. Ce ne sont que des traits. On ne peut pas trier ce qu’on ne sait pas distinguer, et c’est précisément pour ça que le nettoyage ne peut pas reposer sur votre œil, sur le moment.

Il y a un second coût, vrai quelle que soit la pondération du modèle. Chaque trait sur le tableau coûte du calcul à lire, à chaque étape. Un tableau plus rempli n’est donc pas seulement plus sujet à l’erreur : il est plus lourd et plus cher à faire tourner, et de plus en plus à mesure qu’il se remplit (le b.a.-ba de la fenêtre de contexte). Un tableau que vous effacez régulièrement reste bon marché et net.

Imposez la sobriété, ne comptez pas dessus

Le geste directeur est celui-ci : inscrivez la sobriété dans l’environnement. Ne comptez pas sur l’agent pour se surveiller lui-même, et ne comptez pas non plus sur vos yeux. Vous ne voyez pas venir la pourriture à grande échelle : faites-la voir par le harnais. Je range ça sur deux axes :

Maîtriser le flot. C’est l’afflux à l’intérieur de la boucle, la sortie des outils qui s’empile pendant que l’agent travaille. Deux gestes en règlent l’essentiel.

• Faire taire le chemin heureux : ne rien émettre en cas de succès, pour qu’une exécution de tests au vert coûte zéro token au lieu de deux cents lignes.
• Tronquer le reste par la tête et par la queue. Gardez les N premières et les N dernières lignes d’un log, jetez le milieu. Ce n’est pas arbitraire : les modèles négligent le milieu d’une entrée longue (Liu et al., 2024), donc la tête et la queue sont justement les parties qui survivent à l’attention. La coupe épouse la façon dont le modèle lit vraiment.

Maîtriser la charge permanente. C’est la base persistante, ce qui occupe le tableau avant même que le vrai travail commence.

• Divulgation progressive : charger la seule skill ou la seule doc dont une étape a réellement besoin, au moment où elle en a besoin, plutôt que tout le manuel d’entrée de jeu.
• Sous-agents : déléguer une sous-tâche à un exécutant pour que le fil principal ne voie jamais la pile qu’elle a produite, seulement le résultat. C’est comme ça qu’on tient une longue session sur une tâche difficile sans que le fil principal dérive.
• Le pattern de passation : quand je veux travailler sur une tâche sur plusieurs sessions ou la confier à l’agent d’un collègue, je compresse l’état dans un fichier markdown qui contient les décisions, l’objectif courant, les chemins de fichiers et les numéros de ligne pertinents, pas des extraits collés. N’importe quelle nouvelle session lit ce fichier et repart exactement là où la précédente s’est arrêtée. Un pointeur coûte une ligne. Le fichier collé coûte le fichier.

Concrètement, cette note de passation peut être aussi courte que ça :

## STATE: parser refactor
Decisions:
- Split the tokenizer out of parser.rs (it was doing two jobs). Kept the old
  error type; changing it breaks three callers.
Standing: steps 1 and 2 done. Step 3 (wire up the new tokenizer) is next.
Files: src/parser.rs:120 (entry point), src/tokenizer.rs (new), tests/parser_test.rs:40.
Open: does step 3 need a migration for the saved-session format?
Resume: run `just test parser`, then start at src/parser.rs:120.

Jugez-la à un seul test : une session neuve, à qui l’on ne donne rien d’autre que ce fichier, pourrait-elle continuer correctement ? Sinon, il lui manque quelque chose. En général, il vous en faudra davantage que dans l’exemple ci-dessus.

Une mise en garde sur le mot « imposer ». Ce n’est pas une règle intangible. C’est toujours l’agent qui fait le travail, et le harnais est une aide pour tirer le meilleur des modèles d’aujourd’hui, pas une cage. C’est une discipline dans laquelle vous voulez rester agile. Pour l’instant, aucun outil tout-en-un ne couvre bien l’ensemble : vous choisissez vos briques et vous câblez les vôtres, idéalement en équipe. Au-dessus se trouve une couche plus lourde, des specs qu’un script peut exécuter, de l’orchestration, des agents qui remédient et escaladent. C’est une autre histoire, pas celle-ci.

N’attendez pas que ça parte de travers

Surveillez la jauge. N’attendez pas le dérapage. L’instrument le plus utile dont je dispose, c’est une ligne de statut qui change de couleur à mesure que la fenêtre se remplit, pour que je ne puisse pas la manquer, même quand j’ai cessé de lire le chiffre brut.

Ma ligne rouge est à environ 10 % d’une fenêtre d’un million de tokens, soit à peu près 100 000 tokens. C’est la ligne que je ne franchis pas, pas le niveau auquel je navigue. La couleur commence à virer bien avant : jaune vers 50 000, la moitié de la ligne rouge, pour que l’alerte arrive avec de la marge pour agir. Ce sont mes chiffres à moi, une marge prudente que je tiens sur les modèles de pointe à un million de tokens, pas une loi. Organisez votre harnais autrement ou routez vers d’autres modèles, et les seuils bougent. Prenez-les comme un ordre de grandeur.

La posture compte plus que le chiffre exact. Je n’attends pas que les choses tournent mal. Et la jauge finit par enseigner une seconde leçon : parfois, la bonne lecture n’est pas « il faut élaguer la fenêtre », c’est « cette session est mal partie ». Quand les consignes étaient imprécises dès le premier message, ajouter du contexte ne répare rien, ça enterre l’erreur plus profond. Repartez de zéro. Ne récupérez rien.

Le moins, et les meilleurs

L’ère des 200 000 imposait cette discipline à tout le monde. L’ère du million de tokens la rend facultative. C’est bien pourquoi « avec combien de tokens puis-je m’en tirer ? » est la mauvaise question pour finir. Ça n’a jamais vraiment été la question.

La vraie, c’est la tension dans laquelle vit tout harnais sérieux. Donnez à l’agent le maximum d’informations dont il a besoin, pour qu’il ne brûle jamais de tokens à re-dériver la forme d’un dépôt qu’il a déjà vu. Mais ne bourrez pas la fenêtre pour autant, sinon chaque session démarre déjà remplie à 10 % et le tableau n’est jamais propre. Deux modes de défaillance : sous-informez et il ré-explore sans fin, sur-remplissez et il pourrit dès le premier message. Un seul art se faufile entre les deux : pas le moins de tokens, pas le plus, mais le plus de signal par token. Le moins, et les meilleurs.

Restent deux questions ouvertes que ce billet ne tranche volontairement pas. D’abord, parmi tout ce que vous pourriez charger en permanence, quels tokens méritent vraiment leur place ? Ensuite, une fois choisis, comment tenir ce préchargement à jour quand le code bouge sous vos pieds ? Deux histoires pour un autre jour. La fenêtre n’a jamais été quelque chose à remplir. C’est quelque chose que vous dépensez.

Sources

• Chroma Research, Context Rot: How Increasing Input Tokens Impacts LLM Performance, 2025. https://www.trychroma.com/research/context-rot
• Liu, N. F., et al., Lost in the Middle: How Language Models Use Long Contexts, TACL 2024. https://aclanthology.org/2024.tacl-1.9/