Engram — a memory that compounds

Engram is a private, cross-project knowledge base for AI coding agents. It stores what you and your agent learn as small, linked Markdown pages — systems, frames, gotchas, decisions — and quietly searches the relevant ones back into context every time you start work. Knowledge compounds instead of being re-derived from scratch each session.

The engine is open source. Your store never leaves your machine.

The one honesty rule

A sealed record proves provenance, not veracity — that a thing was recorded at a time, unaltered. Never that it is true.

This is the idea everything else in Engram is built around, so it is worth saying plainly. When Engram seals a page, it is making a narrow, checkable promise: this exact text existed at this moment, and it has not been changed since. That is genuinely useful — it lets your agent ask itself "is this a real memory of our work, or am I imagining that it happened?" and get a cryptographic answer.

What sealing does not do is vouch that the content is correct. A mistaken note sealed on Monday is faithfully proven to be a mistake that was written on Monday. Engram never dresses up a guess as a fact: every page carries an evidence state — traced (someone checked it against reality), inferred (reasoned, but unverified), or stale (it was checked once, but the ground has since moved) — and Engram always shows that state when it surfaces a page.

Honesty about what a system cannot prove is the whole point. A false certainty is worse than an open question.

Why memory that compounds matters

AI coding agents are brilliant in the moment and amnesiac between sessions. Every new conversation starts cold: the gotcha you hit last week, the reason you chose one library over another, the shape of the retry logic you already debugged — all of it has to be rediscovered, re-grepped, or re-explained.

Engram closes that loop. The durable things you learn get written down once, linked to each other like a wiki, and pulled back into context automatically when they are relevant. The value is cumulative: the store you build this month makes next month's sessions sharper, and the same memory follows you across every project you work on.

It does not replace your existing notes or per-session history — it sits alongside them as the distilled, reusable layer: the things worth carrying from one project into the next.

How it feels to use it — 30 seconds

You ask a question in plain language. No keywords, no query syntax.

$ engram ask "how did we handle the rate-limit retries"
[[retry-backoff-policy]]   · traced · used 4
[[idempotency-keys-gotcha]] · traced
(2 pages · 1,812 bytes read)

Engram reads its index, opens only the two pages that actually answer the question, cites where each came from, and stops. The thing your agent figured out last week is simply there — you did not have to remember that it exists.

And most of the time, you will not even type that command. Once Engram is wired into your editor, it surfaces the relevant pages on its own at the start of a session, and writes a fresh page from the conversation when the session ends. It runs itself; the value accrues in the background.

Where to go next

Getting started — install it and run your first recall (per platform).
Core concepts — the four ideas that make Engram honest, in plain language.
Commands — a friendly tour of the CLI.
Choosing a model — none, local, or cloud — and why recall needs none of them.
Using it in your editor — wiring Engram into Claude Code and other AI coding tools.
FAQ — the honest answers: does my data leave my machine, do I need an API key, and more.

Engram comes from the team behind Titan AI and Mnemosyne — production systems whose symbolic, evidence-ruled trust model Engram inherits. It also builds directly on Andrej Karpathy's "LLM Wiki" retrieval model and converges with Google's Open Knowledge Format. Apache-2.0.