# Ingénierie du contexte pour agents IA : guide pratique

URL: https://agentvera.dev/fr/blog/context-engineering-for-ai-coding/ · Publié: 2026-10-28

L’ingénierie du contexte pour les agents de code IA : ce qui remplit le contexte, pourquoi il se dégrade et les techniques qui battent les retouches de prompt.

**En bref:**

- L’ingénierie du contexte consiste à choisir les tokens qu’un agent voit à chaque tour : prompt système, fichiers de règles, outils et leurs résultats, MCP, fichiers lus et historique.
- Les modèles deviennent moins fiables à mesure que l’entrée s’allonge (context rot) : un contexte plus petit et plus net bat en général un prompt plus astucieux dans une session surchargée.
- Les techniques clés : fichiers de règles courts et ciblés, lecture à la demande, sous-agents à fenêtre propre, compaction, carte du code, fichiers de notes et sorties d’outils courtes.

**L’ingénierie du contexte consiste à décider de ce qu’un agent de code IA voit à chaque tour : quelles instructions, quels fichiers de règles, définitions d’outils, fichiers lus, résultats d’outils et quel historique se trouvent dans sa fenêtre de contexte, et lesquels restent dehors.** Pour les agents de code, elle compte en général davantage que les retouches de prompt, car le prompt que vous tapez n’est qu’une petite partie de ce que lit le modèle. L’essentiel de la fenêtre est occupé par les fichiers de règles, les sorties d’outils et la conversation jusque-là. Gardez ce contexte petit et pertinent, et vous obtiendrez de meilleurs résultats qu’avec n’importe quelle reformulation de votre prompt.

Ce guide explique ce qui entre dans le contexte d’un agent, pourquoi les contextes longs se dégradent, quelles techniques aident et comment savoir si elles marchent. Les informations sur Claude Code et Codex sont à jour en octobre 2026.

## Ce que recouvre l’ingénierie du contexte

L’article d’ingénierie d’Anthropic [Effective context engineering for AI agents](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents) (29 septembre 2025) définit le contexte comme l’ensemble des tokens inclus lors de l’échantillonnage d’un modèle, et l’ingénierie du contexte comme le fait de sélectionner et d’entretenir le meilleur ensemble de ces tokens pendant l’inférence.

La différence avec le prompt engineering tient au périmètre et au moment :

| | Prompt engineering | Ingénierie du contexte |
| --- | --- | --- |
| Ce que vous façonnez | La formulation des instructions | Tout ce qui est dans la fenêtre |
| Quand | Une fois, en écrivant le prompt | À chaque tour de la boucle de l’agent |
| Leviers typiques | Formulation, exemples, format | Fichiers de règles, récupération, outils, compaction, sous-agents, mémoire |
| Mode d’échec | Un prompt vague ou fragile | Une fenêtre pleine de tokens périmés, bruités ou contradictoires |

Un agent de code tourne en boucle : lire, appeler un outil, lire le résultat, décider, rappeler. Chaque étape ajoute des tokens, et chaque étape relit ce qui est déjà là. C’est pourquoi l’article qualifie l’ingénierie du contexte d’itérative : la sélection se refait chaque fois que l’agent décide de ce qu’il transmet au modèle.

## Ce qui entre dans le contexte d’un agent de code

Avant votre premier message, puis au fil de la session :

- **Prompt système et outils intégrés.** Fixés par la CLI. Vous ne les contrôlez pas, mais vous les payez à chaque tour.
- **Fichiers de règles.** `CLAUDE.md` pour Claude Code, `AGENTS.md` pour Codex et beaucoup d’autres agents. Ils se chargent au début de la session.
- **Définitions d’outils et MCP.** Chaque outil que l’agent peut appeler a un nom et une description. Les serveurs MCP en ajoutent. Claude Code diffère les définitions complètes des outils MCP jusqu’à leur utilisation : seuls les noms et les instructions des serveurs se chargent d’emblée.
- **Contenu récupéré.** Les fichiers que l’agent lit, les résultats de recherche, la documentation qu’il va chercher.
- **Résultats d’outils.** Exécutions de tests, logs de build, `git diff`, requêtes en base, captures de pages.
- **Historique de conversation.** Vos messages, les réponses de l’agent et chaque tentative ratée.

Pour se faire une idée de la partie fixe : nous avons mesuré la première requête de Claude Code à environ 34,4k tokens avec une configuration standard, et environ 13,3k avec une configuration allégée (voir [notre article sur la consommation de tokens](/fr/blog/claude-code-token-usage/ "Réduire de 61 % la consommation de tokens de Claude Code")). Cette base est renvoyée à chaque tour. Pour les détails propres à Claude Code sur `/context`, `/compact` et `/clear`, voir [le guide de la fenêtre de contexte de Claude Code](/fr/blog/claude-code-context-window/ "Fenêtre de contexte de Claude Code").

## Pourquoi plus de contexte n’est pas mieux : le context rot

Une fenêtre de contexte a une limite dure, mais la limite douce arrive plus tôt. L’article d’Anthropic parle d’un « budget d’attention » : les transformers mettent chaque token en relation avec tous les autres, donc n tokens créent n² relations par paires, et chaque token de plus dilue l’attention. À mesure que la fenêtre grandit, la capacité du modèle à se souvenir de ce qu’elle contient diminue.

La recherche indépendante montre la même chose. Le [rapport Context Rot](https://www.trychroma.com/research/context-rot) de Chroma (14 juillet 2025) a testé 18 modèles et constaté que les performances se dégradent avec la longueur de l’entrée dans toutes ses expériences, même sur des tâches simples. Quelques résultats qui comptent pour le code :

- Un seul distracteur, un texte qui semble pertinent sans l’être, suffisait à faire baisser la précision, et l’effet augmentait avec la longueur de l’entrée.
- Sur un benchmark de mémoire longue, tous les modèles faisaient nettement mieux avec un prompt ciblé d’environ 300 tokens qu’avec le prompt complet d’environ 113k tokens.

Pour un agent de code, les distracteurs sont partout : l’ancienne version d’un fichier lue avant une modification, la stack trace d’un bug déjà corrigé, une approche rejetée. Une fenêtre de 1M de tokens donne de la marge, pas une immunité.

## Les techniques qui marchent

Voici les techniques décrites par l’article d’Anthropic, transposées à ce que vous faites avec un agent de code.

### 1. Des fichiers de règles courts et ciblés

Les fichiers de règles se paient à chaque session : chaque ligne doit mériter sa place. La [documentation mémoire](https://code.claude.com/docs/en/memory) de Claude Code recommande de garder chaque `CLAUDE.md` sous 200 lignes et note que les fichiers plus longs sont moins bien respectés. Plutôt qu’un long fichier unique :

- Mettez les règles qui ne concernent qu’une partie du code dans `.claude/rules/` avec un champ `paths`. Elles ne se chargent que quand Claude lit ou modifie un fichier correspondant.
- Utilisez des `CLAUDE.md` imbriqués dans les sous-dossiers. Claude Code les charge à la demande quand il travaille dans ce dossier.
- Sachez que les imports `@path` organisent un fichier sans en réduire le coût : les fichiers importés se chargent avec le fichier qui les importe.

```markdown
---
paths:
  - "src/api/**/*.ts"
---

# Règles de l’API

- Valider chaque corps de requête avec le schéma partagé.
- Renvoyer les erreurs au format d’erreur standard.
```

Codex fonctionne de la même façon avec `AGENTS.md` : il lit un fichier global dans `~/.codex`, puis un fichier par dossier, de la racine du projet jusqu’au dossier de travail ; les fichiers les plus proches viennent en dernier et priment. Il cesse d’ajouter des fichiers à `project_doc_max_bytes`, 32 Kio par défaut. Notre [guide CLAUDE.md et AGENTS.md](/fr/blog/claude-md-agents-md/ "Bonnes pratiques pour CLAUDE.md") détaille quoi y mettre.

Sur le fond, Anthropic conseille d’écrire à la « bonne altitude » : assez précis pour guider le comportement, assez général pour ne pas figer une logique if-else fragile. Quelques exemples canoniques valent mieux qu’une longue liste de cas limites.

### 2. Récupérer juste à temps

Au lieu de tout charger d’avance, gardez des références légères (chemins de fichiers, noms de fonctions, liens) et laissez l’agent charger le contenu quand il en a besoin. Anthropic prend Claude Code en exemple : il utilise glob et grep pour trouver les fichiers, et `head` et `tail` pour examiner de gros volumes sans tout charger. En pratique :

- Indiquez à l’agent un fichier ou un symbole au lieu de lui demander de « jeter un œil ».
- Demandez un plan du fichier ou une plage de lignes avant de lire un gros fichier en entier.
- Gardez dans le fichier de règles une courte carte du dépôt (où vit l’API, où sont les tests) et laissez l’agent aller chercher le reste.

### 3. Isoler le travail dans des sous-agents

Un sous-agent tourne dans sa propre fenêtre de contexte, vierge. Il peut dépenser des dizaines de milliers de tokens à explorer et ne renvoyer qu’un résumé condensé ; Anthropic évoque des résumés souvent de 1 000 à 2 000 tokens. Bons candidats : l’exploration du code, la lecture de longs logs et la relecture du diff dans un contexte neuf.

Les sous-agents ne sont pas gratuits. L’[article d’Anthropic sur son système de recherche multi-agents](https://www.anthropic.com/engineering/multi-agent-research-system) (13 juin 2025) indique que les agents consomment environ 4 fois plus de tokens qu’un chat, et les systèmes multi-agents environ 15 fois plus. Ce que vous achetez, c’est un fil principal propre, pas une facture plus légère.

### 4. Compacter et effacer les anciens résultats d’outils

La compaction résume une conversation proche de sa limite et repart du résumé. Anthropic considère l’effacement des anciens résultats d’outils comme l’une des formes de compaction les plus sûres : l’agent a rarement besoin de la sortie brute d’un test lancé quarante tours plus tôt. Côté API, l’[annonce d’Anthropic sur la gestion du contexte](https://claude.com/blog/context-management) (29 septembre 2025) indiquait que l’édition du contexte, qui efface les appels et résultats d’outils périmés, réduisait la consommation de tokens de 84 % sur une évaluation de recherche web en 100 tours.

Dans une CLI de code, orientez le résumé au lieu de le laisser se déclencher à la limite :

```text
/compact Garde la liste des fichiers modifiés, le test qui échoue et la décision sur l’API
```

Et quand vous passez à un travail sans rapport, ouvrez une nouvelle session plutôt que de compacter l’ancienne.

### 5. Donner à l’agent des notes hors de la fenêtre

La prise de notes structurée, c’est l’agent qui écrit son avancement dans un fichier et le relit plus tard. Parmi les exemples d’Anthropic : un fichier `NOTES.md` et des listes de tâches. La mémoire automatique de Claude Code fonctionne ainsi : un index `MEMORY.md` par dépôt, dont les 200 premières lignes ou 25 Ko se chargent au début de chaque session. Pour plusieurs agents et plusieurs sessions, une mémoire de projet partagée va plus loin ; nous la présentons dans [la mémoire partagée pour agents de code IA](/fr/blog/shared-memory-for-ai-coding-agents/ "Mémoire partagée pour agents de code IA").

### 6. Une carte du code plutôt qu’une recherche à l’aveugle

Explorer à coups de grep et de lectures remplit la fenêtre de fichiers entiers, dont la plupart se révèlent inutiles. Une [carte de la base de code](/fr/blog/codebase-map-for-ai-agents/ "Carte de la base de code pour les agents IA") est un index des fichiers, symboles, imports et tests que l’agent peut interroger : il lit d’abord une liste classée et un plan, puis seulement les lignes dont il a besoin.

### 7. Garder les sorties d’outils courtes

Les résultats d’outils sont souvent la partie la plus volumineuse et la plus bruitée de la fenêtre. L’article d’Anthropic [Writing effective tools for agents](https://www.anthropic.com/engineering/writing-tools-for-agents) (11 septembre 2025) recommande pagination, sélection de plages, filtrage et troncature avec des valeurs par défaut raisonnables, et précise que Claude Code limite par défaut les réponses d’outils à 25 000 tokens. Vous pouvez appliquer la même idée de l’extérieur :

- Lancez un seul fichier de tests, pas toute la suite.
- Filtrez les logs avec `grep` ou `tail` avant que l’agent ne les lise.
- Préférez une commande CLI ciblée à un outil qui renvoie une page ou un tableau entier.
- Désactivez les serveurs MCP dont le projet ne se sert pas.

## Mesurer l’ingénierie du contexte

Sans mesure, on retombe dans les suppositions. Signaux utiles :

- **La répartition.** `/context` dans Claude Code montre ce qui occupe la fenêtre par catégorie et quels fichiers de règles et de mémoire ont été chargés. Vérifiez-la après chaque changement de vos fichiers de règles ou de votre configuration MCP.
- **Tokens par tâche.** Comparez des tâches similaires avant et après un changement, pas des sessions isolées.
- **Corrections répétées.** Si vous répétez sans cesse une règle, soit elle manque dans le fichier de règles, soit elle y est noyée.
- **Réussite du premier coup.** Moins de relances sur des tâches comparables, c’est le résultat que vous cherchez vraiment.
- **Signes de dégradation.** Relire des fichiers, oublier des instructions antérieures, revenir à une approche rejetée. Quand ils apparaissent, compactez ou repartez de zéro.

Changez une variable à la fois. L’article multi-agents d’Anthropic a constaté que la consommation de tokens expliquait à elle seule environ 80 % de la variance des performances sur son évaluation BrowseComp : plus de tokens peut ressembler à de meilleurs résultats. Comparez coût et qualité ensemble.

## Check-list

| Problème | Technique |
| --- | --- |
| Règles ignorées, fichier qui ne cesse de grossir | Fichier de règles plus court, règles par chemin, fichiers imbriqués |
| L’agent lit d’abord la moitié du dépôt | Récupération juste à temps, carte du code |
| La recherche noie la session principale | Sous-agent qui renvoie un résumé |
| Longue session, qualité en baisse | Compaction orientée, ou nouvelle session |
| Chaque nouvelle session part de zéro | Notes ou fichier de mémoire partagée |
| Sorties de tests et de build énormes | Commandes ciblées, sortie filtrée ou compressée |

## Où se place AgentVera

AgentVera fait tourner Claude Code, Codex et d’autres agents CLI côte à côte dans une seule application de bureau. Elle ne remplace pas les habitudes ci-dessus, mais plusieurs fonctionnalités les appliquent à chaque agent que vous lancez. Tout cela est décrit sur les pages de fonctionnalités :

- **[Économie de tokens](/fr/features/token-savings/ "Économie de tokens")** : profils de contexte qui réduisent la base de démarrage, taille du contexte en direct dans chaque panneau, auto-compaction activée par défaut à un seuil de 150k tokens avec la commande propre à chaque CLI, et RTK, qui raccourcit les sorties de tests, de build et de git avant qu’elles n’atteignent le modèle.
- **[Carte du projet](/fr/features/project-map/ "Carte du projet")** : un index local des symboles, imports, tests et fichiers qui changent ensemble, que les agents interrogent via les outils MCP `agentvera-map` comme `map_related` et `map_outline`. L’onglet AI ROI compare les conversations qui ont utilisé la carte à celles qui ne l’ont pas fait, y compris en tokens par tâche.
- **[Brain](/fr/features/brain/ "Brain")** : une mémoire de projet construite à partir de la documentation, des commits, des PR et des conversations d’agents. Les agents la consultent avec `brain_recall` et y gardent les corrections avec `brain_remember` ; un pack de contexte optionnel de 2 500 caractères au plus est donné aux nouveaux agents.
- **Outils intelligents** pour Claude Code : ils refusent la relecture d’un fichier inchangé, fournissent d’abord le plan d’un gros fichier et réduisent les lancements de toute la suite de tests aux tests concernés.

Si vous faites tourner un seul agent dans un seul terminal, les techniques de cet article fonctionnent très bien seules, et `/context`, `/compact` plus un fichier de règles bien tenu vous mènent déjà loin. AgentVera est le plus utile quand vous lancez plusieurs agents et voulez appliquer la même discipline de contexte à tous. Vous pouvez la télécharger et l’essayer sur un projet.

## En résumé

L’ingénierie du contexte consiste à sélectionner ce qu’un agent voit à chaque tour, et pour les agents de code elle bat les retouches de prompt, car le prompt n’est qu’une mince tranche de la fenêtre. Les contextes longs sont moins fiables : gardez des fichiers de règles courts et ciblés, récupérez juste à temps, confiez l’exploration à des sous-agents, compactez en orientant le résumé, gardez des notes hors de la fenêtre, utilisez une carte du code et des sorties d’outils courtes. Puis mesurez : la répartition du contexte, les tokens par tâche et la réussite du premier coup vous disent si un changement a aidé.

## Questions fréquentes

**Qu’est-ce que l’ingénierie du contexte ?** Anthropic la définit comme le fait de sélectionner et d’entretenir le meilleur ensemble de tokens pendant l’inférence. Pour un agent de code, cela veut dire décider de ce qui entre dans la fenêtre de contexte à chaque tour : instructions, fichiers de règles, outils, code lu, résultats d’outils et historique de conversation.

**Quelle différence avec le prompt engineering ?** Le prompt engineering porte sur la rédaction et l’organisation d’un jeu d’instructions. L’ingénierie du contexte couvre tout ce qui entre dans la fenêtre et se répète à chaque tour de la boucle de l’agent : c’est un travail continu, pas un brouillon unique.

**Qu’est-ce que le context rot ?** La baisse de fiabilité à mesure que l’entrée s’allonge. Le rapport de Chroma de juillet 2025 a testé 18 modèles et constaté que les performances se dégradent avec la longueur de l’entrée, même sur des tâches simples. Une grande fenêtre ne supprime pas cet effet.

**Une fenêtre de contexte de 1M de tokens rend-elle l’ingénierie du contexte inutile ?** Non. Une fenêtre plus grande donne de la marge, mais chaque token reste en concurrence pour l’attention du modèle et est renvoyé aux tours suivants. L’exploration ancienne et les tentatives ratées rendent une session plus lente, plus chère et plus bruitée, quelle que soit sa taille.

**Comment mesurer si mon ingénierie du contexte fonctionne ?** Regardez la répartition du contexte (/context dans Claude Code), les tokens par tâche, la fréquence à laquelle vous devez répéter une règle et la part de tâches réussies du premier coup. Changez une seule chose à la fois et comparez des tâches similaires.

---

**À propos d’AgentVera.** AgentVera est une app de bureau pour macOS, Windows et Linux, développée par Solviera Teknoloji. Elle exécute 18 agents de code IA (Claude Code, Codex, Gemini CLI, Copilot, Cursor, Antigravity, opencode, Hermes, Qwen Code, Kimi Code, Kiro, Amp, Droid, Goose, Vibe, Crush, Aider, Cline) côte à côte, par projet, dans de vrais terminaux avec les installations et connexions CLI de l’utilisateur. L’offre gratuite inclut des agents illimités. Télécharger: https://agentvera.dev/fr/download/ · Tarifs: https://agentvera.dev/fr/pricing/