Mémoire de Grok Build entre les sessions : paramètres et limites

Grok Build, l’agent de terminal de xAI, dispose d’une mémoire intersessions : il peut retenir les conventions du projet, les décisions et les étapes de débogage qui ont fonctionné, puis les ajouter au contexte d’une nouvelle session sans qu’il soit nécessaire de les lui rappeler. Cette fonctionnalité est désactivée par défaut et expérimentale : un seul paramètre suffit pour l’activer.

Cette présentation s’appuie sur le guide officiel du dépôt xai-org/grok-build, tel qu’il était le 20 septembre 2026. L’auteur de l’article original n’a pas utilisé le produit : son fonctionnement est décrit à partir de la documentation, et non de tests personnels.

La documentation contient des informations pratiques sur l’utilisation d’Ailoot.

À quoi sert la mémoire dans Grok Build ?#

Par exemple, lors d’une session, vous avez expliqué à l’agent que le projet utilise une indentation de deux espaces, que les migrations de base de données sont exécutées avec une commande distincte et qu’un module particulier gère les paiements. Lors d’une nouvelle session, vous devez fournir ces informations à nouveau.

Lorsque la mémoire est activée, Grok Build peut :

• se rappeler les conventions du projet que vous avez expliquées auparavant ;
• réutiliser les étapes de débogage qui ont déjà fonctionné ;
• conserver les décisions d’architecture pour les sessions suivantes ;
• éviter de vous redemander des informations déjà fournies.

La fonctionnalité est expérimentale et désactivée par défaut. Tant que vous ne l’activez pas, le comportement de l’agent ne change pas.

Comment activer la mémoire ?#

Une fois, pour une seule exécution :

GROK_MEMORY=1 grok

La variable ne s’applique qu’à cette exécution. La commande export GROK_MEMORY=1 la conserve dans le shell actuel et active la mémoire pour toutes les exécutions ultérieures de grok depuis ce shell, jusqu’à la fin de la session du terminal ou jusqu’à ce que vous exécutiez export GROK_MEMORY=0.

De manière permanente, via la configuration. Ajoutez ceci à ~/.grok/config.toml :

[memory]
enabled = true

Dans une session, sans redémarrer : ouvrez /memory et appuyez sur t.

Ce bouton ne s’applique qu’à la session en cours et n’est pas écrit dans la configuration. Il permet d’activer ou de désactiver la mémoire. La désactiver supprime l’accès aux outils de mémoire, mais n’efface pas les fichiers du disque ; la réactiver rouvre l’accès au stockage. Le bouton ne peut pas outrepasser une désactivation forcée de la mémoire à l’échelle du processus via GROK_MEMORY=0 : /memory reste indisponible pendant toute la session.

Lorsque des paramètres sont définis à plusieurs endroits, ils suivent l’ordre de priorité suivant :

• GROK_MEMORY=0 désactive de force la mémoire pour tout le processus et a la priorité la plus élevée.
• Un paramètre explicite enabled = false dans la configuration désactive la mémoire, même si un paramètre distant géré l’active.
• La mémoire peut être activée avec GROK_MEMORY=1, avec enabled = true dans la configuration ou par un paramètre distant géré.
• Si rien n’est spécifié, la mémoire est désactivée.

Les notes sont ajoutées au premier tour d’une session. Si vous avez activé la mémoire en cours de travail et souhaitez que l’agent commence à utiliser les informations enregistrées sur le projet, exécutez /new. Vous pouvez vérifier si la mémoire est activée dans la sortie de grok inspect.

Qu’enregistre Grok Build, et où ?#

Structure du répertoire ~/.grok/memory/ :

Un hash court de l’identifiant du dépôt est ajouté au nom du répertoire du projet. L’identification utilise le dépôt distant origin au format « organisation/dépôt », ou le chemin du répertoire s’il ne s’agit pas d’un dépôt Git. Ainsi, les clones et les worktrees (copies de travail distinctes de branches Git) partagent la même mémoire de projet : ce dont l’agent se souvient dans une copie est également disponible dans l’autre.

Les entrées sont créées de quatre façons :

1. Résumé automatique de fin de session. Lorsqu’une session se termine, Grok Build enregistre dans le journal quotidien un bref résumé de service : le nombre de messages, jusqu’à cinq premiers échanges substantiels, ainsi que la date et l’heure. Le résumé est généré à partir des métadonnées, sans appel au modèle ni délai. Les sessions très courtes sont ignorées : si elles comptent moins de trois échanges substantiels ou moins de 50 octets de texte de votre part, aucune entrée n’est créée. Le résumé n’inclut ni les outils utilisés, ni les chemins de fichiers, ni les commandes. Les résumés automatiques peuvent être désactivés avec le paramètre session.save_on_end = false.
2. /flush — une note détaillée à la demande. Avec cette commande, le modèle résume les points les plus importants de la session en cours : décisions, schémas, étapes de débogage et découvertes liées aux API. Le résumé est inscrit dans un journal daté et indexé pour les sessions ultérieures. La documentation recommande d’exécuter /flush avant la compaction du contexte, à la fin d’une session de débogage réussie et après la découverte de schémas importants.
3. /remember — une demande explicite de mémorisation. Saisissez /remember always open PR links after sending ou dites à l’agent : « souviens-toi que… » Un panneau de vérification s’ouvre avant l’écriture de l’entrée : la note n’est enregistrée qu’après votre confirmation, et Memory saved to ~/.grok/memory/MEMORY.md apparaît dans le fil. Les informations sur le projet sont enregistrées dans le fichier MEMORY.md du projet ; celles qui concernent tous les projets sont enregistrées dans le fichier global.
4. /dream — consolidation. La commande regroupe par sujet les journaux et les notes dispersés, et supprime les doublons afin d’améliorer la précision des recherches. Comme pour /flush, la consolidation est effectuée par le modèle : il lit les entrées accumulées et les réorganise par sujet. Vous devriez donc vérifier régulièrement le résultat avec /memory. Il existe également un mode automatique : par défaut, Grok Build vérifie les conditions au démarrage et toutes les heures, et lance la consolidation si au moins 24 heures se sont écoulées et si au moins 5 sessions se sont accumulées. Les seuils peuvent être configurés dans la section [memory.dream] du fichier de configuration.

Les notes sont recherchées au moyen d’un index SQLite : par défaut, la recherche plein texte FTS5 est utilisée ; si un modèle d’embeddings est configuré, une recherche vectorielle sémantique est ajoutée.

Comment la mémoire est-elle ajoutée à une nouvelle session ?#

L’injection initiale utilise un seuil de sélection min_score = 0.9, que vous pouvez modifier dans la section [memory.initial_injection]. Après la compaction automatique du contexte, l’agent lance une nouvelle recherche dans la mémoire pour restaurer les informations qui ont pu être supprimées du contexte en même temps que des échanges plus anciens.

Vous pouvez aussi demander directement à l’agent : « De quoi te souviens-tu ? » Il regroupera sa réponse par source : préférences globales, connaissances du projet et historique des sessions.

Les entrées de session comportent des marqueurs d’actualité. Plus une entrée du journal de session est ancienne, plus elle est fortement accompagnée de la mention : « Vérifiez que cette information est toujours d’actualité avant de vous y fier. » Les fichiers globaux et ceux des projets MEMORY.md ne reçoivent pas de tels marqueurs : leur contenu est destiné à un usage à long terme, vous devez donc en vérifier vous-même l’exactitude.

Comment consulter, modifier et supprimer des notes ?#

Dans une session, la commande /memory ouvre une fenêtre affichant tous les fichiers mémoire, regroupés par portée : globale, projet et sessions (dans l’ordre chronologique inverse). La liste des fichiers se trouve à gauche et l’aperçu en lecture seule du fichier sélectionné, à droite.

Touches utiles dans l’aperçu :

La fenêtre permet de supprimer des notes individuelles et des fichiers de session ; elle ne permet pas de supprimer les index MEMORY.md générés (global et projet).

La deuxième méthode consiste à modifier directement les fichiers. Ils se trouvent dans ~/.grok/memory/ et peuvent être ouverts avec n’importe quel éditeur. Les changements dans le répertoire sont suivis : les fichiers créés ou modifiés sont réindexés et les fichiers supprimés sont retirés de l’index lors de la recherche suivante.

La demande « oublie snake_case » ne garantit pas le résultat : le modèle recherche les entrées correspondantes et les supprime, mais il peut en manquer. Pour garantir la suppression, ouvrez le fichier (vous pouvez facilement copier son chemin avec y dans /memory) et supprimez manuellement l’entrée. Vous pouvez effacer entièrement la mémoire depuis la ligne de commande : grok memory clear pour la mémoire du projet, grok memory clear --global pour la mémoire globale et grok memory clear --all pour les deux.

En quoi la mémoire diffère-t-elle d’un fichier d’instructions du dépôt ?#

Les instructions du dépôt sont partagées avec toutes les personnes qui travaillent sur le projet et visibles dans le code et l’historique des modifications. La mémoire s’enrichit au fil des sessions, est stockée sur votre machine et n’est pas publiée d’elle-même.

La mémoire ne remplace pas un fichier d’instructions. Les règles générales du projet utiles à toute l’équipe et à chaque agent ont toujours leur place dans le dépôt. Nous proposons un guide distinct sur l’utilisation d’un seul fichier d’instructions pour Claude Code, Codex et Cursor : Utiliser AGENTS.md et CLAUDE.md ensemble. La mémoire conserve le contexte personnel : vos préférences, ce qui a déjà été essayé et la décision qui a été prise.

Claude établit une distinction similaire : nous expliquons la différence entre sa mémoire et CLAUDE.md dans l’article Mémoire de Claude et CLAUDE.md. Pour comparer les outils eux-mêmes, consultez Grok Build ou Claude Code.

Limites et vérification du fonctionnement de la mémoire#

Gardez à l’esprit les limites suivantes :

• Statut expérimental. Les commandes, les seuils et le comportement peuvent changer dans les versions futures ; consultez le guide de la mémoire du dépôt si quelque chose ne fonctionne pas comme prévu.
• Injection initiale dans une nouvelle session. Après avoir activé la mémoire, commencez le travail avec /new pour que les notes enregistrées soient ajoutées dès le premier tour.
• Le modèle décide de ce qui est important. Le modèle rédige le résumé de /flush et choisit les informations à inclure dans la note. Toutes les semaines ou toutes les deux semaines, ouvrez /memory et vérifiez ce qui s’est accumulé ; supprimez tout ce qui est inutile.
• Ne lui demandez pas de mémoriser des secrets. Les clés, les jetons et les mots de passe n’ont pas leur place dans des notes conservées à long terme : les fichiers de ~/.grok/memory/ sont stockés en texte brut. Si une information sensible est enregistrée, supprimez-la en modifiant le fichier.
• La mémoire du projet est partagée entre les copies du dépôt. Si l’agent mémorise dans un clone une information obsolète pour un autre, tenez compte du répertoire partagé lors du nettoyage.

Si la mémoire ne fonctionne pas :

1. Vérifiez la sortie de grok inspect pour confirmer que la mémoire est activée.
2. Vérifiez que GROK_MEMORY=0 ou la configuration ne la désactive pas.
3. Pour diagnostiquer le problème, exécutez RUST_LOG=debug GROK_LOG_FILE=/tmp/grok.log grok et vérifiez les lignes concernant la mémoire dans /tmp/grok.log.

Bref résumé#

La mémoire de Grok Build s’active avec GROK_MEMORY=1 ou avec [memory] enabled = true dans ~/.grok/config.toml. Pour que les notes soient ajoutées la première fois après l’activation, démarrez une nouvelle session avec /new. L’agent écrit les notes dans ~/.grok/memory/ : résumés de session sans appel au modèle, résumés détaillés avec /flush, entrées explicites avec /remember après votre confirmation et sujets organisés avec /dream. Consultez et nettoyez les notes avec /memory ou en modifiant directement les fichiers. La fonctionnalité est expérimentale : vérifiez les seuils et les commandes dans le guide officiel et examinez régulièrement les notes.

Pour un travail systématique, la combinaison clone IA + Second Brain + Context Engineering est utile.

Ouvrir Ailoot.