Grok Build-minne på tvers av økter: innstillinger og begrensninger

Grok Build, xAIs terminalagent, har minne på tvers av økter: Den kan huske prosjektkonvensjoner, beslutninger og vellykkede feilsøkingstrinn, og deretter legge dem til i konteksten for en ny økt uten påminnelser. Funksjonen er slått av som standard og er eksperimentell – den kan aktiveres med én enkelt innstilling.

Denne beskrivelsen er basert på den offisielle veiledningen i repositoriet xai-org/grok-build, slik den forelå 20. september 2026. Forfatteren av den opprinnelige artikkelen prøvde ikke produktet: Funksjonen ble beskrevet ut fra dokumentasjonen, ikke personlig testing.

Praktisk informasjon om bruk av Ailoot finnes i dokumentasjonen.

Hva gir minne i Grok Build?#

For eksempel forklarte du i én økt agenten at prosjektet bruker innrykk med to mellomrom, at databasemigreringer kjøres med en egen kommando, og at en bestemt modul håndterer betalinger. I en ny økt må du gi denne informasjonen på nytt.

Når minnet er aktivert, kan Grok Build:

• hente fram prosjektkonvensjoner du har forklart tidligere;
• bruke feilsøkingstrinn som allerede har fungert;
• videreføre arkitekturvalg til senere økter;
• unngå å spørre på nytt om ting som allerede er besvart.

Funksjonen er eksperimentell og slått av som standard. Agentens atferd endres ikke før du aktiverer den.

Hvordan aktiverer du minnet?#

Én gang, for én enkelt kjøring:

GROK_MEMORY=1 grok

Variabelen gjelder bare for denne kjøringen. Kommandoen export GROK_MEMORY=1 beholder den i gjeldende shell og aktiverer minnet for alle påfølgende grok-kjøringer fra denne shellen – fram til terminaløkten avsluttes eller du kjører export GROK_MEMORY=0.

Permanent, via konfigurasjonen. Legg dette til i ~/.grok/config.toml:

[memory]
enabled = true

I en økt, uten å starte på nytt: Åpne /memory og trykk på t.

Denne bryteren gjelder bare for den gjeldende økten og skrives ikke til konfigurasjonen. Den kan brukes til å aktivere eller deaktivere minnet. Når du deaktiverer det, fjernes tilgangen til minneverktøyene, men filene på disken slettes ikke; hvis du aktiverer det igjen, åpnes tilgangen til lagringsområdet på nytt. Bryteren kan ikke overstyre en tvungen deaktivering av minnet for hele prosessen via GROK_MEMORY=0: /memory er utilgjengelig gjennom hele økten.

Hvis innstillinger er angitt flere steder, gjelder følgende prioritet:

• GROK_MEMORY=0 deaktiverer minnet med tvang for hele prosessen og har høyest prioritet.
• En eksplisitt enabled = false i konfigurasjonen deaktiverer minnet, selv om en administrert ekstern innstilling aktiverer det.
• Minne kan aktiveres med GROK_MEMORY=1, enabled = true i konfigurasjonen eller en administrert ekstern innstilling.
• Hvis ingenting er angitt, er minnet av.

Notater legges til i den første turen i en økt. Hvis du aktiverte minnet mens du allerede arbeidet, og vil at agenten skal begynne å bruke lagret prosjektinformasjon, kjører du /new. Du kan kontrollere om minnet er aktivert, i utdataene fra grok inspect.

Hva registrerer Grok Build, og hvor lagres det?#

Katalogstrukturen for ~/.grok/memory/:

En kort hash av repositoriets identifikator legges til i prosjektnavnet. origin-remoten i formatet «organisasjon/repositorium» brukes til identifikasjon, eller katalogbanen hvis det ikke finnes et Git-repositorium. Kloner og worktrees (separate arbeidskopier av Git-grener) av det samme repositoriet deler derfor ett prosjektminne: Det agenten husker i én kopi, er tilgjengelig i en annen.

Oppføringer opprettes på fire måter:

1. Automatisk oppsummering ved slutten av en økt. Når en økt avsluttes, lagrer Grok Build en kort tjenesteoppsummering i den daglige loggen: antall meldinger, opptil fem av de første innholdsrike samtaleutvekslingene samt dato og klokkeslett. Oppsummeringen bygges fra metadata uten modellkall eller forsinkelse. Svært korte økter hoppes over: Hvis det er færre enn tre innholdsrike samtaleutvekslinger eller teksten din er kortere enn 50 byte, opprettes ingen oppføring. Oppsummeringen inneholder ikke brukte verktøy, filbaner eller kommandoer. Automatiske oppsummeringer kan deaktiveres med innstillingen session.save_on_end = false.
2. /flush – et detaljert notat på forespørsel. Med denne kommandoen oppsummerer modellen de viktigste punktene fra den gjeldende økten: beslutninger, mønstre, feilsøkingstrinn og API-funn. Oppsummeringen skrives til en datert logg og indekseres for framtidige økter. Dokumentasjonen anbefaler å kjøre /flush før konteksten komprimeres, ved slutten av en vellykket feilsøkingsøkt og etter at viktige mønstre er oppdaget.
3. /remember – en uttrykkelig forespørsel om å huske noe. Skriv /remember always open PR links after sending, eller si til agenten: «husk at …». Før oppføringen skrives, åpnes et gjennomgangspanel: Notatet lagres først etter at du bekrefter, og Memory saved to ~/.grok/memory/MEMORY.md vises i feeden. Prosjektinformasjon lagres i prosjektets MEMORY.md; informasjon som deles på tvers av alle prosjekter, lagres i den globale filen.
4. /dream – konsolidering. Kommandoen grupperer spredte logger og notater etter emne og fjerner duplikater for å gjøre søket mer presist. Som med /flush utføres konsolideringen av modellen – den leser oppføringene som er samlet inn og skriver dem om i emnegrupper, så du bør gjennomgå resultatet med jevne mellomrom ved hjelp av /memory. Det finnes også en automatisk modus: Som standard kontrollerer Grok Build vilkårene ved oppstart og én gang i timen, og starter konsolidering når det har gått minst 24 timer og minst 5 økter er samlet inn. Tersklene kan konfigureres i [memory.dream]-seksjonen i konfigurasjonen.

Notater søkes fram via en SQLite-indeks: Som standard brukes fulltekstsøk med FTS5, og hvis en embeddingmodell er konfigurert, legges semantisk vektorsøk til.

Hvordan kommer minnet inn i en ny økt?#

Den første innsettingen bruker en utvalgsterskel på min_score = 0.9, som du kan endre i seksjonen [memory.initial_injection]. Etter automatisk kontekstkomprimering søker agenten i minnet igjen for å hente tilbake informasjon som kan ha blitt fjernet fra konteksten sammen med eldre samtaleutvekslinger.

Du kan også spørre agenten direkte: «Hva husker du?» Den grupperer svaret etter kilde: globale preferanser, prosjektkunnskap og økthistorikk.

Øktoppføringer har aktualitetsmarkører. Jo eldre en oppføring i en øktlogg er, desto tydeligere markeres den med «Kontroller at dette fortsatt er aktuelt før du stoler på det». De globale MEMORY.md-filene og prosjektfilene får ikke slike markører: Innholdet er ment for langsiktig bruk, så du må selv følge med på om det fortsatt stemmer.

Hvordan viser, redigerer og sletter du notater?#

Kommandoen /memory åpner et vindu i en økt med alle minnefilene gruppert etter omfang: globalt, prosjekt og økter (i omvendt kronologisk rekkefølge). Fillisten står til venstre, og en skrivebeskyttet forhåndsvisning av den valgte filen vises til høyre.

Nyttige taster i oversikten:

Vinduet kan slette individuelle notater og øktfiler; det kan ikke slette de genererte MEMORY.md-indeksene (globalt og prosjekt).

Den andre metoden er å redigere filene direkte. De ligger i ~/.grok/memory/ og kan åpnes i et hvilket som helst redigeringsprogram. Endringer i katalogen spores: Nye og endrede filer indekseres på nytt, og slettede filer fjernes fra indeksen ved neste søk.

Forespørselen «glem snake_case» fungerer uten garanti: Modellen søker etter og fjerner oppføringer som samsvarer, men kan gå glipp av noen. For å være sikker på at oppføringen blir slettet, åpner du filen (du kan enkelt kopiere banen med y i /memory) og fjerner oppføringen manuelt. Du kan tømme minnet helt fra kommandolinjen: grok memory clear for prosjektminnet, grok memory clear --global for det globale minnet og grok memory clear --all for begge.

Hvordan skiller minnet seg fra en instruksjonsfil i et repositorium?#

En instruksjon i et repositorium deles med alle som arbeider med prosjektet og er synlig i koden og endringshistorikken. Minnet vokser gjennom øktene, lagres på maskinen din og publiseres ikke i seg selv.

Minne erstatter ikke en instruksjonsfil. Generelle prosjektregler som hele teamet og enhver agent trenger, hører fortsatt hjemme i repositoriet. Vi har en egen veiledning om bruk av én instruksjonsfil for Claude Code, Codex og Cursor: AGENTS.md og CLAUDE.md sammen. Minne bevarer personlig kontekst: preferansene dine, hva som allerede er prøvd, og hvilken beslutning som ble tatt.

Claude har et lignende skille: Vi forklarer hvordan minne skiller seg fra CLAUDE.md i artikkelen Claude-minne og CLAUDE.md. Hvis du vil sammenligne selve verktøyene, kan du se Grok Build eller Claude Code.

Begrensninger og kontroll av at minnet fungerer#

Ha følgende begrensninger i mente:

• Eksperimentell status. Kommandoer, terskler og atferd kan endres i framtidige versjoner; se repositoriets minneveiledning hvis noe ikke fungerer som forventet.
• Første innsetting i en ny økt. Etter at du har aktivert minnet, starter du arbeidet med /new slik at lagrede notater legges til i den første turen.
• Modellen avgjør hva som er viktig. Modellen lager oppsummeringen for /flush og velger hva som skal inn i notatet. Åpne /memory hver uke eller annenhver uke og gjennomgå det som har samlet seg opp; slett det som ikke trengs.
• Ikke be den huske hemmeligheter. Nøkler, tokener og passord hører ikke hjemme i notater som skal lagres lenge: Filene i ~/.grok/memory/ lagres som ren tekst. Hvis noe sensitivt blir registrert, fjerner du det ved å redigere filen.
• Prosjektminnet deles mellom kopier av repositoriet. Hvis agenten husker noe i én klone som er utdatert for en annen, må du ta hensyn til den delte katalogen når du rydder opp.

Hvis minnet ikke fungerer:

1. Kontroller utdataene fra grok inspect for å bekrefte at minnet er aktivert.
2. Kontroller at verken GROK_MEMORY=0 eller konfigurasjonen deaktiverer det.
3. For diagnostikk, kjør RUST_LOG=debug GROK_LOG_FILE=/tmp/grok.log grok og se etter linjene om minne i /tmp/grok.log.

Kort oppsummering#

Grok Build-minne aktiveres med GROK_MEMORY=1 eller [memory] enabled = true i ~/.grok/config.toml. Start en ny økt med /new for å få notatene lagt til første gang etter aktivering. Agenten skriver notater til ~/.grok/memory/: øktoppsummeringer uten modellkall, detaljerte oppsummeringer med /flush, uttrykkelige oppføringer med /remember etter at du har bekreftet, og emneorganiserte notater med /dream. Du kan vise og rydde opp i notatene via /memory og ved å redigere filer direkte. Funksjonen er eksperimentell, så kontroller terskler og kommandoer mot den offisielle veiledningen, og gjennomgå notatene regelmessig.

For systematisk arbeid er kombinasjonen AI-klone + Second Brain + Context Engineering nyttig.

Åpne Ailoot.