Engram

Engram

The second brain your AI agents read and write.

▶ Watch the full-length video (real-time, full quality)

↗ Try the live demo — no signup. Search retainer price and watch the retired note get withheld.

---

Engram is a self-hosted MCP server + dashboard that gives Claude Code, Cursor, Hermes, and any Model Context Protocol agent shared, long-term memory they read _and write_ — over a plain, git-backed folder of markdown you own. Built for the case a single agent's memory never hits: a team running several agents against one brain.

Autonomous agents forget everything between sessions — and worse, they can't tell what they remember is _still true_. An agent pulls an old README, a retired price, an API doc you changed months ago, and quotes it with full confidence, because keyword and vector search both rank by resemblance, not truth. Engram makes "is this still true" a first-class, written property: mark a fact superseded or expired and search withholds it — and tells the agent what it skipped and why. Per-agent read/write tokens and a git audit trail of who-wrote-what keep it sane when the writers are a fleet, not just you.

Unlike a headless memory store, you can watch it happen. A fast dashboard lets you search your brain, see exactly what every agent and teammate changed (with per-file diffs), jump back into recent notes, and curate it all — while agents read and write the same vault over one MCP endpoint. No database: your .md files are the source of truth, git is the durable store, and an in-memory index powers full-text search + a wikilink knowledge graph.

Opinionated about _how_ it stores memory — git-backed markdown, no database, agents write (not

just read), self-hosted. Unopinionated about _what_ you keep in it — any markdown vault, any folder

structure, any MCP client. Point it at a fresh repo or your existing Obsidian vault: no import

step, no lock-in.

---

[What it's for](#what-its-for) · [How it compares](#how-it-compares) · [Features](#features) · [Works with](#works-with) · [Quick start](#quick-start) · [MCP tools](#mcp-tools) · [Deploy](#deploy) · [FAQ](#faq) · [Contributing](#contributing)

---

What it's for

• Shared memory for a team running multiple agents — one vault, many agents reading and writing concurrently, with per-agent read/write tokens and a git audit trail of who changed what.
• Memory that knows what's still true — retire a price, a term, or a changed API doc and your agents stop quoting it; they're told what they skipped and why. The failure a single agent's memory never fixes.
• Long-term memory for Claude Code and other coding agents — stop re-explaining your project every session.
• A self-hosted, Obsidian-compatible second brain exposed over MCP — your notes, your server, your git repo.
• Memory you can see, not a black box — a dashboard to search, watch (with diffs), and curate what your agents remember.
• Markdown RAG without the vector database — full-text search + a link graph over human-readable files.

How it compares

Most agent memory is built to answer *"what did I store about this?"* Engram is built to answer *"what is still true about this?"* — a different question, and the one that bites when an agent quotes a price you retired months ago.

| | Engram | Vector-store memory (mem0, Zep, …) | Markdown memory (Basic Memory, …) | Plain RAG over docs | |---|---|---|---|---| | Storage | markdown files, git is the database | embeddings in a vector DB | markdown files | embeddings in a vector DB | | Ranking | relevance × authority | similarity | relevance | similarity | | Knows a fact is retired | ✅ superseded_by + valid_until, enforced at search | — | — | — | | Explains what it withheld | ✅ excluded[] with a reason per note | — | — | — | | Retire + replace atomically | ✅ brain_supersede, one commit | — | — | — | | Refuses contradicting writes | ✅ at write time, not read time | — | — | n/a (read-only) | | Audit trail | ✅ git, per-write attribution, per-file diffs | varies | git, if you commit | — | | Per-agent access control | ✅ read / write token scopes | varies | — | — | | Human UI | ✅ dashboard, search, diffs, graph | varies | — | — | | Runs on | your box, one container | mostly hosted SaaS | your box | your box |

The row that matters is the third one. Similarity search cannot tell a contradiction from a duplicate — a retired price and a live one are textually identical, so the retired one often *outranks* the live one by being longer and more detailed. That can't be fixed at read time, which is why Engram writes the retirement down when it happens.

This exact pair ships in sample-vault/ . Run bun dev , search acme price , and watch the retired note get withheld with a reason.

Categories, not feature-by-feature audits of specific products, and accurate to the best of my knowledge as of July 2026. If something here misrepresents a tool you maintain, open a PR — I'll fix it.

Features

• MCP server — 15 brain_* tools over one bearer-authenticated HTTP endpoint (POST /api/mcp, streamable HTTP JSON-RPC). Connect any MCP client to a single URL. Per-agent token scopes: a read-only token never even sees the write tools.
• Human dashboard — a search-first home, file tree, note viewer with Obsidian callouts, wikilinks, and backlinks, Preview / Edit / Split editor with autosave, ⌘K search + in-page keyboard navigation, "jump back in" recents, and a force-directed knowledge graph.
• Authority-aware search — ranking knows relevance, not truth, so a superseded note repeats your query words as often as the live one. Every hit carries an authority (authoritative → current → provisional → superseded → archived) derived from the note's folder and frontmatter — so your agents quote the locked doc, not the dead one. Markdown RAG that won't hand back yesterday's answer.
• Temporal validity + explainable rejection — mark a fact superseded_by another note or give it a valid_until date, and search withholds it by default (even if it's locked) — then hands the agent an excluded list of what it skipped, each with a reason ("expired 2026-06-01"). One atomic `brain_supersede` retires the old fact and links the new one in a single commit, so add-and-retire can't drift apart. This is the difference between an agent that *remembers* and one that knows what's still true.
• Write-time contradiction guards — authority ranking fixes *reading*; these stop the vault accepting the contradiction in the first place. Engram refuses to create a second live note on a subject a live note already covers (the acme-pricing-2026.md-beside-acme-pricing.md bug) and points the agent at brain_supersede instead; refuses to overwrite a note the caller hasn't read; and warns when a status: isn't a word the ranking model knows, so a typo can't silently strip a note's authority.
• Audit trail + access control — every write is attributed in git to the token or human that made it, with expandable per-file diffs in the activity feed. Give an agent a read-only token and it never even sees the write tools; a write token can create, edit, move, and archive.
• The Curator *(optional)* — Engram's built-in agent harness over your vault. Chat with your notes (grounded answers, wikilink citations). Or hand brain_capture a rough dump — a meeting note, a voice transcript — and an agentic loop searches what already exists, then files, merges, or archives and returns a manifest of what it touched. It reads before it overwrites and never deletes. Opus / Sonnet / Haiku, your key.
• Markdown-native — plain .md + YAML frontmatter + [[wikilinks]]. Drop in an existing Obsidian vault and it just works.
• Git-backed — optional auto commit + push of every change. Full history, no lock-in, your data lives in your repo.
• No database — files are the source of truth; an in-memory MiniSearch index + a ported wikilink graph power search and backlinks. Nothing to provision.
• Multi-workspace — connect multiple vault repos (URL + token or GitHub OAuth), rename, switch the active one, or remove them — all from the UI.
• Self-hosted — one Docker container. Railway / Render / Fly / any host with a volume. Not serverless (it needs a persistent volume, a file watcher, and a long-running index).
• Team auth — Google SSO + email allowlist for the dashboard; per-agent bearer tokens — or OAuth for Claude.ai custom connectors — for MCP, created/revoked in the UI. Secrets encrypted at rest.
• Runtime config — toggle git-sync and the Curator right from the home; manage commit author, keys, and OAuth in Settings — no redeploy.

Works with

Any client that speaks the Model Context Protocol — one endpoint, bearer-token auth. Most-used first:

• [Claude Code](https://claude.com/claude-code) — Anthropic's agentic coding CLI
• Codex — OpenAI's coding agent (CLI + IDE)
• Hermes — always-on autonomous agent runtime
• openclaw — open-source coding agent
• Cursor — AI code editor
• Cline — VS Code agent
• Windsurf — agentic IDE
• Claude Desktop — Anthropic's desktop app
• …and any other MCP client — Continue, Goose, Zed, Amp, and the rest

If it speaks MCP, it can read and write Engram as shared memory.

Quick start

Want to poke at it first? [There's a live demo](https://engram-demo.up.railway.app) — open, no signup, resets a few times a day. Break it all you like.

bun install

bun dev # http://localhost:3000 — runs against ./sample-vault

Point it at your ow