Engram
Long-term memory for your AI. It remembers across sessions — encrypted on your machine, never in a cloud.
The problem
Every AI agent forgets. Between sessions, between turns, between models. The industry answer is either “stuff everything in the prompt” (expensive, hits context limits) or “ship your data to our cloud” (privacy nightmare, vendor lock-in).
Engram is neither. It’s a local-first, encrypted memory vault that lives on your machine — capturing what your agent experiences, remembering it with real cognitive biology, and assembling the optimal context window for every inference call.
Built for AI agents today — but the problem it solves, what to keep, what to strengthen, and what to forget, is far older than AI.
How it works
User interaction → Capture as episodic memory
│
▼
┌─────────────────┐
│ Engram Vault │
│ │
│ Episodic layer │ ← what happened
│ Semantic layer │ ← what was learned
│ Imagined layer │ ← what was dreamed (quarantined)
│ │
│ Ebbinghaus decay│ ← unused memories fade
│ Hebbian strength│ ← used memories strengthen
└────────┬─────────┘
│
▼
Context Assembler → optimal LLM context window
What makes it different
Encrypted at rest, local-first
SQLCipher encryption with keys bound to your hardware. Memory never leaves your machine. Unlike cloud memory tools, the vault is encrypted, local by default, and its keys are bound to your hardware.
Imagined memories stay quarantined
When your agent speculates or dreams, those memories are segregated, weakened, and pruned unless grounded by real experience. Your agent never acts on ungrounded memories. No other product even distinguishes real from imagined.
Forgets like you do
Memories fade with disuse following the Ebbinghaus forgetting curve — R = e^(-t/S). Frequently accessed memories strengthen (Hebbian learning). This isn’t dumb LRU eviction — it’s a cognitive model that preserves what matters.
Memories that connect
Memories connect via Associative (reminds you of), Causal (led to), Analogical (is like), and Temporal (happened before) links — a traversable knowledge graph.
The right context, not everything
Not just “cram everything in the prompt.” Slots are Required → High → Normal → Low, token budgets are enforced, and overflow is compacted. The assembler answers the question every RAG pipeline gets wrong: what should the LLM know right now?
Every answer traceable
Every memory has a content-addressed identity. Every retrieval has a traceable path. “Why did the agent say that?” is answerable — with proof.
The three layers
| Layer | What it stores | Lifecycle |
|---|---|---|
| Episodic | What happened — interactions, context, events | Captured in real time, decays with disuse |
| Semantic | What was learned — abstractions, patterns, rules | Promoted from episodic after ≥5 retrievals |
| Imagined | What was dreamed — speculation, scenarios | Quarantined at 0.5 strength, pruned at 0.05 unless grounded |
Compared
| Engram | mem0 | Zep | Letta | |
|---|---|---|---|---|
| Encrypted at rest | ✅ SQLCipher | ❌ | Cloud only | ❌ |
| Local-first | ✅ | ✅ | ❌ | ❌ |
| Biology decay | ✅ Ebbinghaus | ❌ | ❌ | ❌ |
| Imagined quarantine | ✅ | ❌ | ❌ | ❌ |
| Typed links | ✅ 4 types | ❌ | Temporal only | ❌ |
| Context assembly | ✅ Priority tiers | Token-aware | Token-efficient | Agent-managed |
Privacy
Your memory is yours. The vault is encrypted at rest with SQLCipher and keys bound to your hardware, and it lives on your machine. There is no cloud vault holding your memory: if you turn on multi-device sync, encrypted blobs pass through a public relay that never sees plaintext. The vault is the product.
Built on ELLM
Engram runs on the ELLM kernel — a deterministic symbolic reasoning engine. Memory retrieval feeds into symbolic inference. Every retrieval has a proof trace. The kernel knows what it knows, knows what it doesn’t, and articulates the difference.
Install Engram
Engram is in beta and there is nothing to request. It’s source-available, it runs on your machine, and one line installs it:
curl -fsSL https://engram.ellmstack.dev/install.sh | bash
Linux and macOS, x86_64 and arm64, with a published SHA-256 beside every
artifact. Prefer to check the binary yourself, or on Windows? Take it from
the releases page
instead. Changed your mind? curl -fsSL https://engram.ellmstack.dev/uninstall.sh | bash.
Beta means the interfaces can still move, not that it’s unfinished — the vault is encrypted at rest, the daemon runs, and it’s what we use ourselves every day. If something breaks, tell us; that’s the whole point of the beta.
Self-hosting is free under the Functional Source License, and stays that way. Cloud sync is $10/month flat, live now — optional, and you never need it to use Engram.
Tell us what’s broken
Engram is in beta and we need the reports. A memory vault fails quietly — a recall that returns nothing useful looks identical to having nothing to recall — so if it feels wrong, it probably is, and we want to hear about it.
GitHub Issues
The public tracker. Crashes, install problems, sync failures, "this should work and doesn't", and anything you wish it did. Search first — if someone beat you to it, add your details to theirs.
Open an issue →Report privately
Anything touching encryption, key handling, the sync relay, or vault contents leaking. Please don't file it publicly — email it and we'll confirm receipt within a couple of days.
Email security →Just write to us
No GitHub account, or it doesn't fit an issue template? "I don't understand what this does" and "I stopped using it because…" are the most useful messages we get.
Send feedback →Useful in a bug report: your OS and architecture, the Engram version (engram --version), what you ran, and what happened instead. If the daemon is involved, its log tail usually contains the answer. Never paste your passphrase or vault contents into an issue — we will never ask for either, and we can’t read your vault even if you sent it.
Recall quality is worth reporting even when nothing crashed: if a search misses something you know you captured, that’s a real bug and one we can only find from the outside. Tell us what you searched for and what you expected back.
What happens next. Issues get a reply and a label. Security reports get priority and a private thread until there’s a fix. What you send may be used to improve Engram under §10 of our Terms.