# Mémoire partagée pour agents de code IA : le Brain

URL: https://agentvera.dev/fr/blog/shared-memory-for-ai-coding-agents/ · Publié: 2026-10-24

Mémoire partagée pour agents de code IA : un cerveau de projet garde décisions, notes de passation et corrections pour que chaque session démarre informée.

**En bref:**

- Chaque nouvelle session d’agent démarre à blanc. Une mémoire de projet partagée garde décisions, corrections et notes de passation, pour que l’agent suivant ne répète pas les erreurs ni ne rouvre les questions closes.
- Le Brain d’AgentVera construit cette mémoire à partir de vos docs, commits, PR, issues et anciennes conversations d’agents, et marque chaque décision comme current, stale ou superseded.
- Les agents la lisent et l’écrivent via MCP : brain_recall cherche dans la mémoire, brain_remember retient une correction ou une décision, et de courtes notes de passation sont laissées après les tours et à la compaction.

**La mémoire partagée pour agents de code IA est un stock de décisions, de corrections et de notes de passation, au niveau du projet, que chaque agent lit au démarrage et enrichit pendant qu’il travaille, pour qu’une nouvelle session ne reparte pas de zéro.** Sans elle, chaque session Claude Code ou Codex ne connaît que le contenu du dépôt et de ses fichiers d’instructions. Avec elle, l’agent suivant sait pourquoi vous avez choisi JWT, que l’utilisateur a déjà dit « pas de nouvelle dépendance » et que le dernier agent a laissé le flux de remboursement à moitié fait.

Cet article explique pourquoi les agents oublient, ce qui a sa place dans une mémoire partagée, et comment le Brain d’AgentVera en construit une à partir de l’historique de votre projet et permet aux agents de la lire et de l’écrire via MCP.

## Pourquoi les agents de code oublient

La mémoire d’un agent de code, c’est sa fenêtre de contexte. Quand la session se termine, ou que la conversation est compactée, l’essentiel de ce qui s’est passé disparaît. La session suivante reçoit :

- Le prompt système et les définitions d’outils
- Vos fichiers d’instructions, comme `CLAUDE.md` ou `AGENTS.md`
- Ce qu’elle lit dans le dépôt pendant la tâche

Cela suffit pour le code, puisque le code est dans le dépôt. Cela échoue pour les raisons. Le commit dit *ce qui* a changé ; la raison se trouve souvent dans un commentaire de PR, une issue ou une conversation avec un agent qui n’existe plus. Les agents reposent donc les mêmes questions, proposent l’approche que vous avez rejetée la semaine dernière et refont un travail qu’un autre agent a déjà fini. Quand vous [lancez plusieurs agents en parallèle](/fr/blog/run-multiple-claude-code-agents/ "Lancer plusieurs agents Claude Code"), c’est pire : chacun apprend quelque chose que les autres ne voient jamais.

## Ce qui a sa place dans une mémoire partagée

Les fichiers d’instructions et une mémoire partagée ont des rôles différents.

| | Fichier d’instructions (CLAUDE.md, AGENTS.md) | Mémoire partagée |
| --- | --- | --- |
| Écrite par | Vous, à la main | Construite depuis l’historique, plus les agents au fil du travail |
| Contenu | Règles, commandes, conventions | Décisions avec leurs raisons, corrections, notes de passation |
| Évolution | Rarement | Chaque jour |
| Chargement | Fichier entier, à chaque session | Recherche à la demande, court résumé au démarrage |
| Sait quand elle est périmée | Non | Peut marquer des décisions comme stale ou superseded |

Gardez votre fichier d’instructions court et stable ([comment en écrire un](/fr/blog/claude-md-agents-md/ "CLAUDE.md et AGENTS.md")). Mettez les éléments mouvants dans la mémoire. Une mémoire partagée utile contient quatre sortes de choses :

1. **Décisions.** « Nous utilisons JWT pour l’API parce que les sessions cassaient l’app mobile », avec la date et la source.
2. **Corrections.** Ce que l’utilisateur a dit à un agent qu’il avait mal fait. Ce sont les plus coûteuses à perdre.
3. **Notes de passation.** Ce qu’un agent a fait et ce qu’il a laissé ouvert.
4. **Faits.** De petites vérités sur le projet qui ne sont pas évidentes à la lecture du code.

## Comment le Brain d’AgentVera construit la mémoire

Dans AgentVera, chaque projet a un onglet **Brain** sur sa page Details. Cliquez sur **Build memory** (puis **Refresh memory**) et il lit l’historique du projet :

- Les docs et décisions suivies par Git : README, ARCHITECTURE, CONTRIBUTING, CLAUDE, AGENTS, CHANGELOG, `docs/`, `adr/` et `decisions/` (jusqu’à 250 fichiers)
- Les 1 500 commits les plus récents hors merges
- Jusqu’à 200 pull requests et 200 issues, si le projet est sur GitHub et que vous êtes connecté
- Jusqu’à 120 anciennes conversations d’agents

Claude Haiku en extrait les décisions. Chacune reçoit un titre, la raison, une date, ses sources et les termes de code concernés. Les doublons sont fusionnés.

Les décisions ne sont pas vraies pour toujours : chacune a donc un statut, **current**, **stale** ou **superseded**. **Compare with code** compare les termes de code d’une décision avec le dépôt via `git grep`. **Verify with Claude** lance une vérification Sonnet en lecture seule pour un examen plus poussé. La mémoire peut ainsi dire à un agent « nous avons décidé cela, mais le code a évolué ».

L’onglet Brain a quatre vues : **Decisions**, **Knowledge graph**, **Context pack** et **Memory**. Il y a aussi une zone **Ask**. Demandez « Pourquoi utilisons-nous JWT ? » et Sonnet répond à partir de la mémoire, en lecture seule, avec des citations des sources.

## Comment les agents lisent et écrivent la mémoire

Construire la mémoire n’est que la moitié du travail. L’autre moitié est de faire en sorte que les agents s’en servent. AgentVera ajoute un serveur MCP nommé `agentvera-brain` à chaque agent dont la CLI accepte des serveurs MCP. Si MCP est nouveau pour vous, commencez par [ce qu’est un serveur MCP](/fr/blog/what-is-mcp-server/ "Qu’est-ce qu’un serveur MCP ?").

Le serveur a deux outils :

| Outil | Ce qu’il fait |
| --- | --- |
| `brain_recall` | Cherche dans les décisions (avec leur statut), docs, commits, PR, issues, anciennes conversations, notes de passation et faits mémorisés. Renvoie jusqu’à 8 résultats, chacun avec un `[id]` à citer. Appelé sans requête, il renvoie les souvenirs gardés et les fils ouverts. |
| `brain_remember` | Retient une phrase autonome comme `fact`, `correction` ou `decision`. Pas prévu pour les points d’avancement. Un texte identique n’est pas stocké deux fois. |

Le serveur indique aussi à l’agent quand les utiliser : appeler `brain_recall` avant une tâche qui touche un travail antérieur, appeler `brain_remember` quand l’utilisateur le corrige, énonce une règle ou une préférence, ou qu’une décision est prise, et citer les éléments par `[id]`.

Un échange typique dans une session Claude Code ressemble à ceci :

```text
You: Add refresh tokens to the API.
Agent: (calls brain_recall "auth tokens JWT")
       Found [d12] "Use JWT for the API, sessions broke the mobile app" (current)
       and a correction [m4] "Never store tokens in localStorage".
       I will keep JWT and put the refresh token in an httpOnly cookie.
You: Good. And refresh tokens expire after 30 days.
Agent: (calls brain_remember, kind: decision)
```

L’agent suivant qui touche à l’auth trouve les deux, sans que vous ayez à vous répéter.

## Notes de passation : la mémoire entre sessions

Le commutateur **Agents write the memory** de l’onglet Brain est activé sauf si vous le coupez. Activé :

- Après les tours (au plus toutes les 15 minutes par agent), et toujours quand un agent compacte sa conversation, l’agent laisse une courte note de passation. Haiku la rédige : un résumé d’une à quatre phrases et jusqu’à six fils ouverts, affichés sous **Left open**.
- Les corrections et décisions que l’agent retient avec `brain_remember` vont dans la même mémoire.
- Les nouveaux agents du projet reçoivent les plus récentes.
- Entre 03:00 et 06:00, le brain est recompilé, mais seulement s’il a déjà été construit, qu’il y a de nouvelles notes depuis, et au plus une fois toutes les 12 heures.

Notes et souvenirs sont listés dans la vue **Memory**, étiquetés Fact, Correction, Decision ou Session note. **Forget** en supprime un.

Quand un nouvel agent démarre, ses instructions reçoivent une courte introduction de 2 500 caractères au plus : les souvenirs gardés (corrections d’abord, jusqu’à 15), plus la note la plus récente de jusqu’à six autres agents des sept derniers jours qui ont encore des fils ouverts. C’est ce qui rend la compaction moins pénible : le résumé écrit par Claude Code disparaît après la session, mais la note de passation reste. Pour en savoir plus sur ce que la compaction garde et supprime, voir [la fenêtre de contexte de Claude Code](/fr/blog/claude-code-context-window/ "Fenêtre de contexte de Claude Code").

## Le context pack

À part, la vue **Context pack** contient un résumé du projet de 2 500 caractères au plus. Activez **Give new agents a context pack** et les nouveaux agents reçoivent le pack plus la liste des décisions stale dans leurs instructions. C’est désactivé par défaut, car cela s’ajoute au contexte de départ de chaque nouvel agent. Activez-le si vos agents passent à côté du même contexte.

## Mise en place en cinq étapes

1. Ouvrez le projet dans AgentVera et allez à **Details → Brain**.
2. Cliquez sur **Build memory**. Connectez-vous d’abord à GitHub si vous voulez inclure PR et issues.
3. Parcourez **Decisions**. Lancez **Compare with code** sur celles dont vous doutez.
4. Laissez **Agents write the memory** activé et décidez si vous voulez le context pack.
5. Démarrez un nouvel agent Claude Code ou Codex et donnez-lui une tâche qui touche un travail antérieur. Regardez-le appeler `brain_recall`.

## Mémoire partagée et coordination

La mémoire répond à « que savons-nous ? ». La coordination répond à « qui fait quoi en ce moment ? ». Pour le travail en direct, AgentVera donne aussi aux agents un tableau d’affichage via MCP (`agentvera-board`) où ils publient notes, décisions, todos et constats, et il avertit quand deux agents modifient le même fichier. Les deux se complètent : le tableau sert pour aujourd’hui, le Brain pour le mois prochain.

La mémoire s’associe aussi bien à la [carte du projet](/fr/features/project-map/ "Carte du projet"). La carte dit à un agent *où* est le code ; le Brain lui dit *pourquoi* le code est ainsi.

## Limites à connaître

- Le Brain est ajouté aux agents qui acceptent des serveurs MCP. Les terminaux simples et les agents sur un hôte SSH distant ne le reçoivent pas.
- Les notes de session et les souvenirs gardent chacun jusqu’à 200 entrées.
- Tout est stocké localement, un fichier par projet dans le dossier de données de l’app. L’extraction des décisions, les notes de passation et les réponses utilisent Claude via votre connexion Claude Code ; ces requêtes partent donc chez Anthropic.
- Une mémoire ne vaut que par ce qu’elle garde. Relisez la vue Memory de temps en temps et supprimez les notes erronées.

## En résumé

La mémoire partagée pour agents de code IA comble l’écart entre des fichiers d’instructions statiques et une fenêtre de contexte qui se réinitialise. Le Brain d’AgentVera la construit à partir de vos docs, commits, PR, issues et conversations, suit quelles décisions tiennent encore, et laisse chaque agent compatible MCP chercher et retenir via `agentvera-brain`, avec des notes de passation après les tours et à la compaction. Le Brain est inclus dans l’offre gratuite. Lisez la [page de la fonction Brain](/fr/features/brain/ "Brain") ou [téléchargez AgentVera](/fr/download/) et construisez la mémoire de votre premier projet.

## Questions fréquentes

**Qu’est-ce que la mémoire partagée pour agents de code IA ?** Un stock de connaissances du projet que chaque agent peut lire et enrichir : pourquoi les décisions ont été prises, ce que l’utilisateur a corrigé, ce qu’un agent précédent a laissé ouvert. Elle survit à une session, si bien qu’un nouvel agent démarre avec le contexte du précédent.

**CLAUDE.md ne suffit-il pas ?** CLAUDE.md et AGENTS.md contiennent des règles que vous écrivez à la main et qui changent rarement. Une mémoire partagée contient aussi ce qui se passe pendant que vous travaillez : décisions tirées des commits et des PR, corrections, notes de passation et décisions que le code ne suit plus.

**Comment les agents utilisent-ils le Brain dans AgentVera ?** Via un serveur MCP nommé agentvera-brain. brain_recall cherche dans les décisions, docs, commits, PR, issues, anciennes conversations et notes ; brain_remember retient une phrase comme fait, correction ou décision. Les agents doivent citer ce qu’ils utilisent par son [id].

**Quels agents reçoivent la mémoire partagée ?** Les agents dont la CLI accepte des serveurs MCP, comme Claude Code et Codex. Les terminaux simples et les agents sur un hôte SSH distant ne la reçoivent pas.

**Où la mémoire est-elle stockée ?** Sur votre ordinateur, un fichier par projet dans le dossier de données de l’app. L’extraction des décisions et les réponses aux questions utilisent Claude via votre connexion Claude Code ; ces requêtes partent donc chez Anthropic.

---

**À 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/