GRM — local memory for AI coding agents

Your coding agent forgets everything between sessions, and everything you told a different agent. GRM gives Claude Code, Cursor and Antigravity one shared memory of your codebase's decisions — and the reasons behind them.

npm i -g getgrm
grm init

That's the install. It prints every file it touches, and grm uninstall reverses all of it.

Why not just use a cloud memory service

| | Cloud memory (mem0, Zep) | GRM | |---|---|---| | Per query | an LLM call + an embedding | arithmetic | | Latency | 200–800 ms | 14–60 ms | | Marginal cost | fractions of a cent, every call | zero | | Your data | leaves your machine | never leaves your machine | | Works offline | no | yes | | Download | — | 575 kB |

The cost row is the one that matters. Memory priced per operation can only be called a few times per task — which is why agents still forget everything in between. At zero marginal cost, memory can run on every step of the loop.

What it actually looks like

Real output, not an illustration:

$ grm recall --limit 1 "icr.cjs acorn"

🧠 Ground-Truth Verified Facts:
• [INFRASTRUCTURE] Config: 2. The hard part: the extension is CommonJS and packaged
  separately, while ICR is ESM. Rather than hand-port 600 lines (drift-prone), I wrote
  build-icr-cjs.cjs — a small generator that turns lang-js.js + icr.js into
  extension/icr.cjs (each file wrapped in its own scope so internal names don't collide,
  ESM stripped, acorn required once). Re-run it anytime the sources change; no manual sync.

📖 Architecture Context:
Done. ICR is now genuinely **used in Hivecode** — on both surfaces.
**1. ICR was only in the relay engine (`sync.js`).** The thing users actually install —
the VS Code extension — still used plain line-merge. So I wired ICR into the extension too.
...

That is a design decision and its reason, recovered from a months-old conversation by two keywords. No embeddings, no vector database, no API key, no GPU — a co-occurrence graph over your own history with bounded 2-hop spreading activation.

Cue it with identifiers, not sentences. Function names, file names, config keys, error codes. That is what the engine is strongest at, and what code is made of. Prose queries work noticeably worse.

Cues match whole tokens, not substrings. If the graph holds parse_config_v2, searching parse_config finds nothing. Type the identifier as it appears in your code.

Commands

grm init                     wire it into every agent on this machine; prints what it touched
grm start                    turn the engine on
grm stop                     turn it off, and it stays off until you start it
grm status                   what is running, which snapshot is live, how fresh the journal is
grm doctor                   verify all of it, loudly

To update:

npm i -g getgrm@latest

Use a global install rather than `npx`. npx resolves a global copy before it consults the
registry, so `npx getgrm@latest` can keep running an old binary and say nothing about it.

There is a control room at <http://127.0.0.1:8792/> while the engine is running: uptime,
memories held, recalls served, and bytes sent to the internet, which is always zero.
grm recall <cue...>          query from the terminal  [--limit N]
npx getgrm serve             MCP server over stdio (this is what your IDE spawns)
npx getgrm compact           fold the journal into the snapshot
npx getgrm forget <text>     delete matching memory
npx getgrm log               show the last context that was injected
npx getgrm stop              stop the background daemon
npx getgrm uninstall         remove everything init wrote  [--dry-run]
npx getgrm version

Exit codes: 0 success, 1 failure, 2 unknown command — so a typo in a script fails instead of quietly passing.

recall asks the running daemon first and falls back to the on-disk snapshot. That order matters: the snapshot only holds what the last compact folded in, so reading it directly makes recent memory invisible.

Where your data lives

~/.grm/graph.grm4              the live snapshot (binary; what compact writes)
~/.grm/graph.json              the JSON snapshot it was built from
~/.grm/graph.journal.jsonl     append-only log of new turns
~/.grm/code_roots.txt          folders it indexes — you control this

compact writes the binary snapshot and leaves the JSON one alone, so after your first compaction the .grm4 is the newer of the two and is the one actually read. status always names the one being used, so you never have to work it out yourself.

One graph per machine, shared by every agent. Nothing is transmitted anywhere; there is no server to transmit to. Updating, removing or uninstalling this package never touches ~/.grm.

Turning it off

Point GRM_HOME at an empty directory and you get a genuinely empty memory — it beats the running daemon and refuses to harvest anything into itself, so it is a real off switch rather than a colder version of on. Useful for measuring whether the agent is actually better with memory:

$ GRM_HOME=/tmp/no-memory npx getgrm recall anything
❌ Error: No graph at /tmp/no-memory/graph.json and GRM_HOME is set, so nothing was
   harvested. This is an empty memory on purpose -- unset GRM_HOME to use the real one.

It says so rather than silently returning an empty result, because an empty memory and a failed lookup should never look the same.

Removing it

npx getgrm uninstall --dry-run    # lists every item, changes nothing
npx getgrm uninstall

It removes the memory entry from each IDE's MCP config (including entries left by older versions), the fenced block from each agent's rules file, the hook registrations in Claude Code, Cursor and Antigravity, and the autostart entry — naming each one as it goes. Text outside our markers in your own rules files is left exactly as it was, and a config file it cannot parse is reported and skipped rather than rewritten.

Your memory is never touched. ~/.grm survives uninstall; delete that directory yourself if you want the history gone too.

Platform support

Windows x64 only right now. macOS and Linux builds are in progress. On any other platform the package fails with a clear message rather than installing and doing nothing.

Licence

Commercial, per machine, yearly. A 7-day trial starts on your first run.

https://getgrm.tech