Start free

Updated

The best memory for Grok in 2026

The best memory for Grok is Glen for engineering teams running Grok Build, xAI's coding CLI, and Grok's own memory for someone on their own, whether in the grok.com app or in Grok Build. People searching for this mean one of two products, and the answer differs between them. Glen installs into Grok Build as a plugin that records every completed turn into memory your org shares, next to sessions from Claude Code, Codex and Cursor. Glen does not connect to grok.com, the consumer chat app, which has no confirmed MCP support; there, the options are Grok's built-in memory and Supermemory's Chrome extension, which imports Grok memories into Supermemory.

Grok Build's own memory is local to one user: rules from AGENTS.md, CLAUDE.md and .grok/rules/, plus a cross-session memory that is experimental and off by default. One limit applies to every tool on this page. Grok Build discards what its UserPromptSubmit hook returns, so nothing can put memory in front of each prompt; recall happens when the agent searches. The ranking below is for Grok Build on an engineering team.

Short answer

An engineering team running Grok Build
Glen
Solo on Grok Build, nothing extra to install
Grok Build rules + experimental memory
The grok.com chat app
Grok memory
Taking grok.com memories to other assistants
Supermemory Chrome extension
Free, local, verbatim session history
MemPalace

Grok memory tools at a glance

#ToolConnects viaCapturesTeam sharingPrice
01GlenOur pickPlugin (hooks) plus the glen CLIEvery completed turn, automaticallyWhole orgOrg-wide, filtered per user at recallFree for 15,000 memories, no card
02Grok memory and Grok Build memorygrok.comBuilt ingrok.com memory; opt-in memory in Grok BuildRepo filesPer user; repo rules files travel with the repoIncluded with Grok
03Supermemorysupermemory.aiChrome extension (grok.com); remote MCP (Grok Build)Imports from grok.com; add_memory tool calls over MCPShared spacesPer container; orgs with scoped API keysFree with $5 credit; Pro $19/mo
04Mem0mem0.aiRemote MCPTool callsShared spacesPer user, agent or app entityFree tier; paid is usage-based or custom
05Basic Memorybasicmemory.comMCP (stdio locally, HTTPS cloud)Notes the agent writesShared spacesCloud workspaces with membersFree locally; Cloud $19/mo per workspace
06MemPalacemempalaceofficial.comLocal MCP serverTool calls in Grok Build; hooks in other agentsShared spacesPrivate, or a shared hub several clients connect toFree, runs locally

How we ranked them

  • Records Grok Build sessions. Grok Build has UserPromptSubmit and Stop hooks, so a plugin can record each completed turn without the model choosing to. Tools that connect only over MCP save when the agent calls them.
  • Gets recall in front of the agent. Grok Build ignores the output of SessionStart and UserPromptSubmit hooks, and only Pre/PostToolUse hooks can add context. Every option here recalls on demand, so what matters is how the agent is told to search.
  • Reaches the rest of the team. Grok Build's rules and memory live on one machine. Can a teammate's Grok Build, or their Claude Code or Codex sessions, read what yours worked out?
  • Documented for Grok. Grok Build speaks MCP over stdio and HTTP/SSE with OAuth, configured under [mcp_servers] in ~/.grok/config.toml, so most memory servers can be added by hand. Few vendors document a Grok setup, and we say which do.

The 6 best memory tools for Grok

  1. Glen

    Our pick

    Best for: Engineering teams where some people run Grok Build and others run Claude Code, Codex or Cursor.

    Glen homepage at tryglen.com
    tryglen.com
    Connects to Grok
    Plugin (hooks) plus the glen CLI
    Captures
    Every completed turn, automatically
    Shared with your team
    Org-wide, filtered per user at recall

    Running glen install --agent grok adds Glen's Grok Build plugin: a SessionStart hook, UserPromptSubmit and Stop hooks that record each completed turn, and a PostToolUse hook that links git commits to the session that made them, so glen code-search can later trace a line back to its conversation. Because Grok discards what UserPromptSubmit returns, Glen can't inject memories before each prompt the way it does in Claude Code and Codex. It installs a rules file at ~/.grok/rules/glen.md instead, which tells the agent to run glen search when it needs past context.

    The store belongs to your org and is shared with every teammate's Claude Code, Codex and Cursor sessions, plus public Slack channels, GitHub, tickets and call transcripts. Access control runs per observation at recall, and a decision the team has reversed stops surfacing. Glen's benchmark replayed 100 merged PRs with Codex 5.5 and the Glen arm used 29% fewer tokens and reached a merged change 21% faster, with quality at parity or better. That run used per-prompt injection, which Grok Build doesn't allow, so read it as a reference point rather than a Grok number.

    Strengths

    • Records every Grok Build turn with no save step
    • One memory with teammates on Claude Code, Codex and Cursor
    • Commits linked to sessions, for glen code-search
    • glen incognito keeps recall and records nothing; glen off stops both

    Limits

    • No per-prompt recall in Grok Build; the agent has to run glen search
    • Doesn't connect to the grok.com app
    • Hosted only, with no self-hosted build

    Managed service · Free for 15,000 memories, no card

    Set up Glen in Grok →

  2. Grok memory and Grok Build memory

    Best for: One person, in the grok.com app or in Grok Build, who wants memory without another account.

    Grok homepage at grok.com
    grok.com
    Connects to Grok
    Built in
    Captures
    grok.com memory; opt-in memory in Grok Build
    Shared with your team
    Per user; repo rules files travel with the repo

    Grok has two separate memories. In grok.com and the Grok apps, memory launched in April 2025: you turn it on or off in Settings > Data Controls, you can view and delete individual memories, and it is tied to your account. Grok Build reads instructions from AGENTS.md, CLAUDE.md and .grok/rules/*.md in the repo, from ~/.grok/ globally, and also from .claude/rules and .cursor/rules, which helps in a repo already set up for another agent.

    Grok Build's cross-session memory is experimental and off by default. Turn it on with [memory] enabled = true in ~/.grok/config.toml or with GROK_MEMORY=1, and it keeps Markdown in ~/.grok/memory/, with /remember, /flush and /dream as its commands. It stays local to one user on one machine, so a teammate's Grok Build works the same things out again on their own.

    Strengths

    • Nothing to install; grok.com memories can be viewed and deleted in settings
    • Grok Build reads rules written for Claude Code and Cursor
    • Grok Build memory is plain Markdown you can inspect

    Limits

    • Grok Build memory is experimental and off by default
    • Both memories are per user
    • Nothing from Slack, GitHub or other agents

    Built into Grok · Included with Grok

    Visit grok.com ↗

  3. Supermemory

    Best for: grok.com users who want their Grok memories available in other assistants.

    Supermemory homepage at supermemory.ai
    supermemory.ai
    Connects to Grok
    Chrome extension (grok.com); remote MCP (Grok Build)
    Captures
    Imports from grok.com; add_memory tool calls over MCP
    Shared with your team
    Per container; orgs with scoped API keys

    Apart from Grok's own memory, Supermemory is the only option here that touches grok.com. Its Chrome extension imports the memories Grok has saved, along with those from ChatGPT, Claude and Gemini, into Supermemory. The extension's suggest-while-typing feature covers Claude and Gemini, not Grok, so it moves memories out of Grok rather than into it.

    For Grok Build, Supermemory's remote MCP server at mcp.supermemory.ai signs in with OAuth, which Grok Build's MCP client supports. Supermemory doesn't document a Grok-specific setup, and over MCP a memory is saved only when the agent calls add_memory; its automatic-capture plugins are for Claude Code, Cursor, Codex and OpenCode. The core is MIT-licensed and can run in Docker. Pro costs $19 a month for three seats, and new accounts get $5 of credit.

    Strengths

    • Imports your grok.com memories
    • Same memory across ChatGPT, Claude, Gemini and Grok
    • MIT-licensed core with a Docker option

    Limits

    • No Grok-specific setup documented for Grok Build
    • No automatic capture in Grok Build; saving waits for add_memory

    Open source (MIT) · Free with $5 credit; Pro $19/mo

    Visit supermemory.ai ↗

  4. Mem0

    Best for: Teams already building on Mem0 who want Grok Build to read the same store.

    Mem0 homepage at mem0.ai
    mem0.ai
    Connects to Grok
    Remote MCP
    Captures
    Tool calls
    Shared with your team
    Per user, agent or app entity

    Mem0 doesn't document Grok, but its remote MCP server at mcp.mem0.ai takes a browser sign-in or a bearer key, and Grok Build can add remote MCP servers under [mcp_servers] in ~/.grok/config.toml. In that setup, memory is added and searched only when the agent calls Mem0's tools. The hook-based capture in Mem0's plugins exists for Claude Code, Codex, Cursor and OpenCode, not Grok Build.

    Mem0 is mainly an SDK and hosted platform for putting memory into your own product, with about 68,000 GitHub stars and an Apache 2.0 license. Memory is scoped to user, agent, app and run entities, and team sharing isn't described. The Starter, Growth and Pro plans are closed to new accounts; new users get 10,000 adds and 1,000 retrievals a month free, then usage billing or a custom contract.

    Strengths

    • Same store as an app built on Mem0
    • Works over Grok Build's standard MCP support
    • Large open-source project

    Limits

    • No Grok-specific setup documented
    • No automatic capture in Grok Build
    • No published paid plan for new accounts

    Open source (Apache 2.0) · Free tier; paid is usage-based or custom

    Visit mem0.ai ↗

  5. Basic Memory

    Best for: Solo developers who want Grok Build's notes as Markdown they can open in Obsidian.

    Basic Memory homepage at basicmemory.com
    basicmemory.com
    Connects to Grok
    MCP (stdio locally, HTTPS cloud)
    Captures
    Notes the agent writes
    Shared with your team
    Cloud workspaces with members

    Grok Build's own experimental memory is already Markdown on disk, and Basic Memory is a fuller version of the same idea: an MCP server over a folder of Obsidian-compatible notes that you and the agent both edit. It runs over stdio locally, which Grok Build supports, or over HTTPS through Basic Memory Cloud. Its docs cover Claude Desktop, Claude Code, Codex, Cursor and VS Code, with no Grok-specific setup, so you add it under [mcp_servers] yourself.

    The agent writes most notes, when it decides something is worth keeping or when you ask. Cloud workspaces have members, which lets two people share one notebook. Locally it is free under AGPL-3.0; Cloud costs $19 a month per workspace with two members.

    Strengths

    • Plain Markdown you own, readable in Obsidian
    • Runs locally over stdio
    • Free locally

    Limits

    • No Grok-specific setup documented
    • Capture depends on the agent choosing to write
    • AGPL license can rule it out inside some companies

    Open source (AGPL-3.0) · Free locally; Cloud $19/mo per workspace

    Visit basicmemory.com ↗

  6. MemPalace

    Best for: Solo developers who want every conversation kept word for word, locally, for free.

    MemPalace homepage at mempalaceofficial.com
    mempalaceofficial.com
    Connects to Grok
    Local MCP server
    Captures
    Tool calls in Grok Build; hooks in other agents
    Shared with your team
    Private, or a shared hub several clients connect to

    Instead of summarizing sessions, MemPalace keeps conversation history verbatim and searches it semantically, with ChromaDB as the default store. It runs as a local MCP server, which Grok Build can launch over stdio, though MemPalace's docs don't cover Grok. Its auto-save hooks exist for Claude Code, Codex CLI and Cursor; in Grok Build it saves when the agent calls it.

    You can keep it private on one machine, or run it as a shared hub that several clients connect to, in which case the hub is yours to host and keep running. It has about 60,000 GitHub stars and is free under the MIT license.

    Strengths

    • Free and MIT-licensed
    • Keeps full conversations, not summaries
    • Optional shared hub for several clients

    Limits

    • No Grok-specific setup or hooks; capture waits for tool calls
    • You run and maintain it yourself

    Open source (MIT) · Free, runs locally

    Visit mempalaceofficial.com ↗

Set up Glen in Grok

Glen installs into Grok Build through its CLI. You need Node.js, Grok Build's grok CLI, and a Glen account; the free plan covers 15,000 memories with no card. There is no Glen setup for the grok.com app.

  1. 1. Install the CLI and sign in

    This installs the glen CLI globally and signs you in to your Glen org.

    bash
    npm install -g @tryglen/cli && glen login

  2. 2. Add the Grok Build plugin

    This adds Glen's hooks to Grok Build and writes the rules file at ~/.grok/rules/glen.md that tells the agent when to search.

    bash
    glen install --agent grok

  3. 3. Work, then search

    Start grok in a repo. Each completed turn is recorded. When the agent needs history it runs glen search, and you can run it yourself.

    bash
    glen search "why the deploy script skips migrations on staging"

Which one should you pick?

Start with which Grok you use. In grok.com, Grok's own memory is the one that works inside the app. Glen doesn't connect there, and Supermemory's extension is for carrying those memories elsewhere, not for giving Grok more.

In Grok Build on your own, turn on the experimental memory and keep instructions in AGENTS.md or .grok/rules/; add MemPalace or Basic Memory if you want more on your own machine. In Grok Build on a team, and especially a team where people use different agents, pick Glen. It records every Grok Build turn into the same org memory as everyone's Claude Code, Codex and Cursor sessions, Slack and GitHub, and its rules file has the agent search that memory when it needs it. Grok Build gives no tool a way to inject before each prompt, so recall depends on the agent running glen search.

FAQ

Does Grok have memory?
Yes. grok.com and the Grok apps have had memory since April 2025, controlled in Settings > Data Controls, where you can also view and delete memories. Grok Build, the CLI, has rules files and an experimental cross-session memory that is off by default.
How do I turn off Grok memory?
In grok.com or the apps, use the memory toggle in Settings > Data Controls. In Grok Build, memory is off unless [memory] enabled = true is set in ~/.grok/config.toml or GROK_MEMORY=1 is in your environment, so remove whichever you set.
Where does Grok Build store memory?
Once turned on, in ~/.grok/memory/ as Markdown, with /remember, /flush and /dream as its commands. Rules come from AGENTS.md, CLAUDE.md and .grok/rules/*.md in the repo, and from ~/.grok/ for global ones.
Does Glen work with grok.com?
No. Glen connects to Grok Build, xAI's coding CLI, through a plugin. The grok.com app has no confirmed MCP support, and Glen doesn't connect to it.
Why doesn't Glen inject memories before each prompt in Grok Build?
Grok Build discards the output of its SessionStart and UserPromptSubmit hooks, so no tool can add context there. Glen still records every turn through those hooks, and its rules file at ~/.grok/rules/glen.md tells the agent to run glen search when it needs past context.
Can Grok Build share memory with Claude Code or Codex?
Not with its own memory, which is local and per user, though it does read CLAUDE.md and .claude/rules. With Glen, Grok Build, Claude Code, Codex and Cursor sessions all record into one org memory that each of them can search.