FAQ

Honest answers to the questions people actually ask.

Does my data leave my machine?

No. The engine is open source, but your store — your pages, their key, your local config — is kept local only. It is gitignored, never pushed to any remote, and locked to owner-only permissions on disk. Recall, indexing, and sealing all happen on your machine.

The one time bytes can leave is if you choose to make a backup or an export — and a backup that leaves your machine is encrypted, so an off-machine copy is opaque without the key.

Is Engram "private" in a cryptographic sense — can even the host not read it?

We are careful not to overclaim here, because a false privacy promise is worse than an honest one.

• What Engram does defend against: a leak or an accidental push. The store is local-only, gitignored, and never leaves your machine; backups that do leave are encrypted.
• What it does not defend against: the host machine itself. The key that reads the store has to be available to your agent when a session opens, so it lives on the machine. Anything the operating system can see, it can see. Engram cannot cryptographically hide from the environment it runs in, and it does not pretend to.

In short: Engram closes the leak-and-push vector honestly. It does not claim to hide from your own computer.

Do I need an LLM API key?

No. Engram runs fully without one. Recall, indexing, linting, sealing, and integrity checks are all local and key-free.

A key is only used for the optional distillation features — automatically summarizing a session transcript into a page, or splitting a large page into focused ones. Even those have a no-key mode that produces a deterministic outline instead. Nothing core depends on an external model.

What does "sealed" actually prove?

Provenance, not veracity. A seal proves that a specific piece of text was recorded at a specific time and has not been altered since. It does not prove the content is true.

A mistaken note sealed on Monday is faithfully proven to be a mistake written on Monday. What sealing buys you is the ability to answer "is this a real memory of our work, or am I imagining it happened?" — a genuine, checkable question — without any pretense of certifying that the world still matches what the page says. (More in Core concepts.)

So is this a hallucination detector?

Not in the way that phrase is usually sold, and we will not market it that way. Engram cannot tell you whether an external fact is correct. What it can do is attack one specific, real kind of hallucination — memory confabulation, where an agent is unsure whether an event it "remembers" actually happened. Sealed, provable records make "show me where this was recorded" a check the agent can run on itself. That is a narrower and more honest claim than "detects hallucinations."

Why not just use grep?

Grep returns every file that mentions your words — a large pile you still have to read and sift. Engram reads one index, opens only the few pages that answer your question, and cites them. On a real store that is on the order of 86% fewer bytes than the lines grep -rin prints — and it is a measured number, computed from the actual command, not a figure you are asked to trust.

More fundamentally, grep re-searches raw sources every time; Engram compiles what you have learned into a linked wiki once, so knowledge compounds instead of being rediscovered on every question.

Do I have to remember to use it?

Mostly, no. Once it is wired into your editor, Engram surfaces relevant pages at the start of a session on its own and distills the conversation into a new page at the end. The value accrues in the background. You can always reach for it directly — with a recall command or a slash command — when you want to.

My store seems empty and nothing is surfacing. Is it broken?

Almost certainly not. A fresh store is empty, so the first session or two look quiet — there is simply nothing relevant to surface yet. It fills as you work. You do not need to seed it by hand.

If you want to confirm the install itself is healthy, engram init re-runs its self-test any time.

Do I need Bitcoin for this to work?

No. Your memory works fully without it. Bitcoin anchoring is an optional layer that timestamps your memory's state against a public, environment-independent clock — useful when you want portable proof of when something entered your memory that holds up even on a brand-new machine. It proves provenance, never veracity, like every other seal.

Does it replace my existing notes or per-session history?

No — it composes with them. Engram is the distilled, linked, reusable layer: the systems, frames, and gotchas worth carrying from one project into the next. It deliberately does not try to be your dense per-session log or your hand-curated human notes; those are different jobs, and Engram sits alongside them rather than duplicating them.

What license is it, and where does it come from?

The engine is Apache-2.0. It builds on Andrej Karpathy's "LLM Wiki" retrieval model, converges with Google's Open Knowledge Format for interoperability, and inherits its symbolic, evidence-ruled trust model from the production systems Titan AI and Mnemosyne. The engine is public; your store is always private.