Grok Build-minne mellan sessioner: inställningar och begränsningar

Grok Build, xAI:s terminalagent, har minne mellan sessioner: det kan komma ihåg projektkonventioner, beslut och felsökningssteg som har fungerat, och sedan lägga till dem i kontexten för en ny session utan påminnelser. Funktionen är avstängd som standard och experimentell – den kan aktiveras med en enda inställning.

Den här beskrivningen bygger på den officiella guiden i repot xai-org/grok-build den 20 september 2026. Författaren till originalartikeln testade inte produkten: funktionerna beskrevs utifrån dokumentationen, inte personliga tester.

Praktisk information om att arbeta med Ailoot finns i dokumentationen.

Vad ger minnet i Grok Build?#

Du kanske till exempel har förklarat för agenten i en session att projektet använder två mellanslag för indrag, att databasmigreringar körs med ett separat kommando och att en viss modul hanterar betalningar. I en ny session måste du upprepa den här informationen.

Med minnet aktiverat kan Grok Build:

• komma ihåg projektkonventioner som du har förklarat tidigare;
• använda felsökningssteg som redan har fungerat;
• föra över arkitekturbeslut till senare sessioner;
• undvika att fråga igen om sådant som redan har besvarats.

Funktionen är experimentell och avstängd som standard. Agentens beteende förändras inte förrän du aktiverar den.

Hur aktiverar du minnet?#

En gång, för en enda körning:

GROK_MEMORY=1 grok

Variabeln gäller bara den här körningen. Kommandot export GROK_MEMORY=1 behåller inställningen i det aktuella skalet och aktiverar minnet för alla efterföljande grok-körningar från det skalet – tills terminalsessionen avslutas eller du kör export GROK_MEMORY=0.

Permanent, via konfigurationen. Lägg till detta i ~/.grok/config.toml:

[memory]
enabled = true

I en session, utan omstart: öppna /memory och tryck på t.

Den här växlingen gäller bara den aktuella sessionen och skrivs inte till konfigurationen. Du kan använda den för att aktivera eller inaktivera minnet. Om du inaktiverar det tas åtkomsten till minnesverktygen bort, men filerna på disken raderas inte. Om du aktiverar det igen får du åter åtkomst till lagringen. Växlingen kan inte åsidosätta en tvingande avstängning av minnet på processnivå via GROK_MEMORY=0: /memory är då inte tillgängligt under hela sessionen.

Om inställningar anges på flera ställen gäller följande prioritering:

• GROK_MEMORY=0 stänger av minnet för hela processen med högsta prioritet.
• Ett uttryckligt enabled = false i konfigurationen stänger av minnet, även om en hanterad fjärrinställning aktiverar det.
• Minnet kan aktiveras med GROK_MEMORY=1, enabled = true i konfigurationen eller en hanterad fjärrinställning.
• Om ingenting anges är minnet avstängt.

Anteckningar läggs till vid sessionens första tur. Om du aktiverade minnet mitt i arbetet och vill att agenten ska börja använda sparad projektinformation, kör /new. Du kan kontrollera om minnet är aktiverat i utdata från grok inspect.

Vad registrerar Grok Build, och var lagras det?#

Katalogstrukturen för ~/.grok/memory/:

En kort hash av repoidentifieraren läggs till i projektnamnet på katalogen. Fjärradressen origin i formatet ”organisation/repo” används för identifieringen, eller katalogsökvägen om det inte finns något Git-repo. Därför delar kloner och worktrees (separata arbetskopior av Git-grenar) samma projektminne: det agenten kommer ihåg i en kopia är tillgängligt i en annan.

Poster skapas på fyra sätt:

1. Automatisk sammanfattning vid sessionens slut. När en session avslutas sparar Grok Build en kort systemsammanfattning i den dagliga loggen: antalet meddelanden, upp till fem inledande innehållsrika utbyten samt datum och tid. Sammanfattningen skapas från metadata utan modell-anrop eller fördröjning. Mycket korta sessioner hoppas över: om det finns färre än tre innehållsrika utbyten eller mindre än 50 byte text från dig skapas ingen post. Sammanfattningen innehåller inte använda verktyg, filsökvägar eller kommandon. Automatiska sammanfattningar kan stängas av med inställningen session.save_on_end = false.
2. /flush – en detaljerad anteckning på begäran. Med det här kommandot sammanfattar modellen de viktigaste punkterna från den aktuella sessionen: beslut, mönster, felsökningssteg och API-resultat. Sammanfattningen skrivs till en daterad logg och indexeras för framtida sessioner. Dokumentationen rekommenderar att köra /flush innan kontextkomprimering, i slutet av en lyckad felsökningssession och efter att viktiga mönster har upptäckts.
3. /remember – en uttrycklig begäran om att komma ihåg något. Skriv /remember always open PR links after sending eller säg till agenten: ”kom ihåg att ...”. En granskningspanel öppnas innan posten skrivs: anteckningen sparas först efter att du har bekräftat, och Memory saved to ~/.grok/memory/MEMORY.md visas i flödet. Projektinformation hamnar i projektets MEMORY.md; information som delas mellan alla projekt hamnar i den globala filen.
4. /dream – konsolidering. Kommandot grupperar spridda loggar och anteckningar efter ämne och tar bort dubbletter för att göra sökningen mer träffsäker. Precis som med /flush utförs konsolideringen av modellen – den läser samlade poster och skriver om dem till ämnesgrupper, så du bör regelbundet granska resultatet med /memory. Det finns även ett automatiskt läge: som standard kontrollerar Grok Build villkoren vid start och en gång i timmen och startar konsolideringen när minst 24 timmar har gått och minst 5 sessioner har samlats. Tröskelvärdena kan konfigureras i avsnittet [memory.dream] i konfigurationen.

Anteckningar söks fram med ett SQLite-index: som standard används fulltextsökning med FTS5, och om en inbäddningsmodell är konfigurerad läggs semantisk vektorsökning till.

Hur förs minnet över till en ny session?#

Den inledande inläsningen använder tröskelvärdet min_score = 0.9, som du kan ändra i avsnittet [memory.initial_injection]. Efter automatisk kontextkomprimering söker agenten i minnet igen för att återställa information som kan ha tagits bort ur kontexten tillsammans med äldre utbyten.

Du kan också fråga agenten direkt: ”Vad minns du?” Den grupperar svaret efter källa: globala inställningar, projektkunskap och sessionshistorik.

Sessionsposter har aktualitetsmarkörer. Ju äldre en post i en sessionslogg är, desto tydligare markeras den med ”Kontrollera att det här fortfarande är aktuellt innan du förlitar dig på det.” De globala MEMORY.md-filerna och projektens MEMORY.md-filer får inte sådana markörer: innehållet är avsett för långvarig användning, så du behöver själv kontrollera att det är korrekt.

Hur visar, redigerar och raderar du anteckningar?#

Kommandot /memory i en session öppnar ett fönster med alla minnesfiler, grupperade efter omfattning: globalt, projekt och sessioner (i omvänd kronologisk ordning). Fillistan visas till vänster och en skrivskyddad förhandsvisning av den valda filen visas till höger.

Användbara tangenter i översikten:

Fönstret kan radera enskilda anteckningar och sessionsfiler, men det kan inte radera de genererade MEMORY.md-indexen (globala och projektspecifika).

Den andra metoden är att redigera filer direkt. De finns i ~/.grok/memory/ och kan öppnas med valfri redigerare. Ändringar i katalogen spåras: skapade och ändrade filer indexeras på nytt, och raderade filer tas bort från indexet vid nästa sökning.

Begäran ”glöm snake_case” fungerar utan garanti: modellen söker efter och tar bort matchande poster, men kan missa några. Om du vill säkerställa att posten tas bort öppnar du filen (du kan enkelt kopiera sökvägen med y i /memory) och tar bort posten manuellt. Du kan rensa minnet helt från kommandoraden: grok memory clear för projektminnet, grok memory clear --global för det globala minnet och grok memory clear --all för båda.

Hur skiljer sig minnet från en instruktionsfil i ett repo?#

En instruktion i repot delas med alla som arbetar med projektet och är synlig i koden och ändringshistoriken. Minnet växer under sessionerna, lagras på din dator och publiceras inte av sig självt.

Minnet ersätter inte en instruktionsfil. Allmänna projektregler som behövs av hela teamet och alla agenter hör fortfarande hemma i repot. Vi har en separat guide om hur du använder en instruktionsfil för Claude Code, Codex och Cursor: AGENTS.md och CLAUDE.md tillsammans. Minnet bevarar personlig kontext: dina inställningar, vad som redan har provats och vilket beslut som fattades.

Claude skiljer på samma sätt mellan olika typer av minne: vi förklarar hur minnet skiljer sig från CLAUDE.md i artikeln Claude-minne och CLAUDE.md. Läs Grok Build eller Claude Code om du vill jämföra själva verktygen.

Begränsningar och kontroll av att minnet fungerar#

Tänk på följande begränsningar:

• Experimentell status. Kommandon, tröskelvärden och beteenden kan ändras i framtida versioner. Kontrollera minnets guide i repot om något inte fungerar som förväntat.
• Inledande inläsning i en ny session. Starta arbetet med /new efter att du har aktiverat minnet, så att sparade anteckningar läggs till under den första turen.
• Modellen avgör vad som är viktigt. Modellen skapar sammanfattningen med /flush och väljer vad som ska ingå i anteckningen. Öppna /memory varje eller varannan vecka och granska det som har samlats. Radera sådant som inte behövs.
• Be inte agenten att komma ihåg hemligheter. Nycklar, token och lösenord ska inte finnas i långlivade anteckningar: filerna i ~/.grok/memory/ lagras i klartext. Om något känsligt har sparats tar du bort det genom att redigera filen.
• Projektminnet delas mellan kopior av repot. Om agenten kommer ihåg något i en klon som är inaktuellt för en annan, tänk på att katalogen delas när du rensar.

Om minnet inte fungerar:

1. Kontrollera utdata från grok inspect för att bekräfta att minnet är aktiverat.
2. Kontrollera att GROK_MEMORY=0 eller konfigurationen inte stänger av det.
3. Kör RUST_LOG=debug GROK_LOG_FILE=/tmp/grok.log grok för diagnostik och kontrollera raderna om minnet i /tmp/grok.log.

Kort sammanfattning#

Grok Build-minnet aktiveras med GROK_MEMORY=1 eller [memory] enabled = true i ~/.grok/config.toml. Starta en ny session med /new så att anteckningar läggs till första gången efter aktiveringen. Agenten skriver anteckningar till ~/.grok/memory/: sessionssammanfattningar utan modell-anrop, detaljerade sammanfattningar med /flush, uttryckliga poster med /remember efter att du har bekräftat och ämnesgrupper med /dream. Visa och rensa anteckningar med /memory och genom att redigera filer direkt. Funktionen är experimentell, så kontrollera tröskelvärden och kommandon mot den officiella guiden och granska anteckningarna regelbundet.

För systematiskt arbete är kombinationen AI-klon + Second Brain + Context Engineering användbar.

Öppna Ailoot.