{"slug": "engram-a-single-go-binary-that-gives-any-ai-coding-agent-persistent-memory", "title": "Engram: A Single Go Binary That Gives Any AI Coding Agent Persistent Memory", "summary": "Alan Buscaglia (Gentleman Programming) released Engram, a single Go binary backed by SQLite with FTS5 full-text search that gives MCP-compatible AI coding agents persistent memory stored in one database at ~/.engram/engram.db, with no Node.js, Python, or Docker dependency. Engram installs via Homebrew and connects to agents including Claude Code, Codex, Gemini CLI, Cursor, and VS Code Copilot through one-command setup, exposing the same memory store through 26 MCP tools, an HTTP API, a CLI, and a terminal UI. The tool is designed around curated project knowledge rather than transcript dumps, keeping memory local by default with optional Git Sync and Engram Cloud for sharing across machines.", "body_md": "# Engram: A Single Go Binary That Gives Any AI Coding Agent Persistent Memory\n\nAI coding agents have a goldfish problem. Every new session starts from zero. The architectural decision you made last Tuesday, the subtle bug you already fixed, the naming convention the team agreed on — all gone the moment the context window resets or compaction kicks in. You end up re-explaining the same things, or worse, the agent re-introduces a bug you already killed.\n\n[Engram](https://github.com/Gentleman-Programming/engram), from Alan Buscaglia (Gentleman Programming), is a clean answer to that problem — and it does it without the usual infrastructure tax.\n\n## One Binary, No Runtime Baggage\n\nMost memory layers come wrapped in a stack: a Node service here, a Python embedding server there, maybe a Docker container to tie it together. Engram throws all of that out.\n\nIt’s a single Go binary backed by SQLite with FTS5 full-text search. One file, one database at `~/.engram/engram.db`. No Node.js, no Python, no Docker.\n\n```\nbrew install gentleman-programming/tap/engram\n```\n\nThat self-contained design is the whole point. Memory you have to babysit is memory you stop using.\n\n## Agent-Agnostic by Design\n\nThe other smart bet Engram makes: it doesn’t pick sides in the agent wars. It speaks [MCP](https://modelcontextprotocol.io/) (Model Context Protocol), so it plugs into essentially any MCP-compatible client. Setup is one command per agent:\n\n```\nengram setup claude-code\nengram setup codex\nengram setup gemini-cli\nengram setup cursor\nengram setup vscode-copilot\n```\n\nThe supported list also includes OpenCode, Antigravity, Windsurf, Qwen Code, Kiro, Kilo Code, and more. Switch tools, keep your memory. That portability is rare — most memory solutions are welded to a single client.\n\n## Four Ways In\n\nThe same memory store is reachable through four interfaces:\n\n- **MCP tools** — 26 tools for saving, searching, timelines, sessions, review, and diagnosis, called directly by your agent.\n- **HTTP API** — the same memory over local endpoints, for compound/multi-agent workflows.\n- **CLI** — scriptable access from the shell.\n- **TUI** — an interactive terminal dashboard (Catppuccin Mocha theme) to browse, search, and copy memories by hand.\n\n## Curated Memory, Not a Transcript Dump\n\nThe part I appreciate most is the philosophy. Engram’s operating contract is explicit: **treat memory as curated project knowledge, not a transcript sink.** Don’t save every conversational turn or raw tool output. Save the things that stay true — completed bug fixes, decisions, discoveries, config changes, patterns, and durable user constraints.\n\nThe recommended loop looks like:\n\n1. **Orient before writing** — confirm the current project, recover recent history.\n2. **Search before repeating** — check whether a decision or bug is already known.\n3. **Retrieve progressively** — previews first, full observations only when you lean on them.\n4. **Save deliberately** — with stable topic keys like`architecture/auth-model` so a topic evolves instead of spawning competing duplicates.\n5. **Leave a handoff** — a session summary with goal, discoveries, next steps, and relevant files, so the next session (or the next agent) picks up cleanly.\n\nIt even handles the ugly edge cases: a conflict-surfacing mechanism flags related or contradicting memories so the agent can judge them, and there’s a compaction-recovery path for persisting a handoff before context is lost and reloading it afterward.\n\nA saved memory is meant to be small and searchable:\n\n```\nWhat:    Added retry-safe upload handling.\nWhy:     Retries could create duplicate records.\nWhere:   internal/upload/handler.go\nLearned: Reuse the request id as the idempotency key.\n```\n\n## Local First, Shareable When You Want\n\nEngram keeps memory **local by default** — the SQLite database is the source of truth. When you need to share across machines, **Git Sync** exports portable, compressed chunks you can commit. And **Engram Cloud** is an optional, project-scoped replication layer with browser visibility and shared access for teams. Nothing leaves your machine unless you decide it should.\n\n## How Engram Compares to the Rest of the Memory Field\n\nWe’ve covered a lot of agent-memory systems on this blog, and Engram lands in a crowded but well-mapped space. Here’s where it sits:\n\n**vs. [soul.py](https://themenonlab.blog/soul-py-persistent-memory-llm-agents/) (file-based memory).** soul.py is the opposite design philosophy: memory lives in plain Markdown files you can read, diff, and commit — no database at all, zero dependencies, and a [LoCoMo score of ~70%](https://themenonlab.blog/soul-py-locomo-benchmark-results/) to back it. Engram instead keeps a single SQLite+FTS5 store and leans on structured tools (26 MCP calls, topic keys, session summaries). soul.py wins on radical transparency and “just files” portability; Engram wins on structured full-text retrieval and a richer tool surface. If you believe [memory should be files, not a system](https://themenonlab.blog/memory-as-system-vs-memory-as-file-google-adk-vs-soul-py/), soul.py is your pick — Engram is the “disciplined local database” counterpoint.\n\n**vs. [Stash](https://themenonlab.blog/stash-shared-memory-coding-agents/).** Both target coding agents, but Stash is built around a *shared* hub so multiple agents converge on one brain. Engram is local-first-per-developer with optional Git Sync and Cloud replication bolted on top. Engram’s edge is the single-binary, no-runtime install.\n\n**vs. [codebase-memory](https://themenonlab.blog/codebase-memory-mcp-stop-grep-start-graph/) and [Obsidian Mind](https://themenonlab.blog/obsidian-mind-persistent-memory-ai-coding-agents/).** codebase-memory is graph-first (stop grepping, start traversing); Obsidian Mind rides on your Obsidian vault. Engram is deliberately simpler — flat, searchable observations with conflict surfacing, not a knowledge graph. Notably, Engram *does* offer an Obsidian export in beta, so it can feed that graph workflow rather than compete with it head-on.\n\n**vs. [Beacon](https://themenonlab.blog/beacon-cross-harness-agent-memory-vs-native-skills/).** Beacon’s whole thesis is cross-harness lessons that survive the session. Engram shares the “don’t let the lesson die” goal but solves it with explicit session summaries and compaction-recovery steps rather than a native-skills approach.\n\n**vs. [TencentDB Agent Memory](https://themenonlab.blog/tencentdb-agent-memory-local-long-term-memory-ai-agents/) and [memory-lancedb-pro](https://themenonlab.blog/memory-lancedb-pro-openclaw-long-term-memory/).** These are the other “local long-term memory without a heavyweight vector DB” entrants. Engram’s differentiator remains portability — one Go binary, FTS5 instead of embeddings, agent-agnostic via MCP.\n\n**vs. the cloud/framework crowd ([mem0, Zep, Letta](https://themenonlab.blog/soul-py-vs-mem0-zep-letta-agent-memory/)).** Those are services or Python frameworks with hosted components and embedding pipelines. Engram is the anti-service: no Python, no embeddings, no account required to start. It only reaches for the network if you opt into Engram Cloud.\n\nThe short version: **soul.py and Engram are the two “keep it local, keep it simple” poles** — soul.py via files, Engram via one SQLite binary. Almost everything else either adds a graph, a hosted service, or an embedding stack. Which you want comes down to whether you’d rather `cat` your memory or query it.\n\n## Why This One’s Worth Watching\n\nThe agent-memory space is getting crowded, but most entrants either lock you into one client or drag along a heavy runtime. Engram’s combination — single Go binary, SQLite+FTS5, MCP-native, agent-agnostic, local-first, with a disciplined “curate, don’t hoard” protocol — is a genuinely practical take on a problem every heavy agent user feels daily.\n\nIt’s MIT-licensed (with a trademark notice on the Engram name and logos), inspired by [claude-mem](https://github.com/thedotmack/claude-mem) but deliberately simpler and tool-independent, and it doubles as the memory layer for Buscaglia’s [Gentle-AI](https://github.com/Gentleman-Programming/gentle-ai) while staying usable standalone.\n\nIf your agents keep forgetting what they learned yesterday, Engram is worth an afternoon.", "url": "https://wpnews.pro/news/engram-a-single-go-binary-that-gives-any-ai-coding-agent-persistent-memory", "canonical_source": "https://themenonlab.blog/blog/engram-persistent-memory-ai-coding-agents/", "published_at": "2026-10-18 00:00:00+00:00", "updated_at": "2026-10-26 02:11:40.764156+00:00", "lang": "en", "topics": ["ai-agents", "ai-tools", "agent-protocols", "developer-tools", "ai-products"], "entities": ["Engram", "Alan Buscaglia", "Gentleman Programming", "SQLite", "Model Context Protocol", "Claude Code", "Codex", "Cursor"], "also_reported_by": [], "alternates": {"html": "https://wpnews.pro/news/engram-a-single-go-binary-that-gives-any-ai-coding-agent-persistent-memory", "markdown": "https://wpnews.pro/news/engram-a-single-go-binary-that-gives-any-ai-coding-agent-persistent-memory.md", "text": "https://wpnews.pro/news/engram-a-single-go-binary-that-gives-any-ai-coding-agent-persistent-memory.txt", "jsonld": "https://wpnews.pro/news/engram-a-single-go-binary-that-gives-any-ai-coding-agent-persistent-memory.jsonld"}}