File-first memory for AI coding agents.
Give multiple AI agents (such as Codex, Claude, Gemini, Cursor, Windsurf, OpenCode, Copilot, and Cline) concurrent, shared memory across multiple repositories—fully synchronized, sharable, and versioned using Git.
Agents should remember. They should not silently own memory.
Agents forget
Agents repeat decisions, setup rules, and project constraints, wasting context and tokens.
Memory is siloed
Durable memory gets trapped inside one vendor, one specific model, app, or physical machine.
Silent writes are unsafe
Without human review, agents can write incorrect assumptions that silently poison future iterations.
Rule files bloat context
Massive custom rule files get sent on every prompt, wasting context window space and causing drift.
Engram turns memory into reviewed files.
Agents propose durable rules, workflows, and knowledge. Humans approve what becomes memory. Engram stores it as Markdown, indexes it, and keeps it portable through Git.
Human-approved writes
Agents propose new knowledge. Humans approve, edit, reject, or archive before it is committed.
File-first memory
Markdown is the source of truth. Transparent, plain-text memory folder structure you fully control.
Context-optimized loading
Loads and routes only the relevant memory pack instead of sending everything, saving context tokens.
Cross-agent routing
Your memory layer lives locally in your repo. Sync, query, and edit it using any LLM or IDE.
How it works
Load relevant memory
Run /engram load for your current task. The indexer finds semantic matches from your repository memory.
Work with your agent
The agent receives a lightweight, targeted context block containing only the rules and constraints needed for the job.
Approve durable memory
The agent proposes structured memory candidates. You audit, modify, and accept them. Git commits them safely.
Configure memory without digging through configuration files.
Run engram entry to spin up the local visual companion to manage connections, configurations, and memory health.
Connections
Link Engram workspace memory to local agent CLI configurations and managed integrations.
Construct
Tune semantic load thresholds, rules priority layers, custom profiles, and git sync triggers.
Core
Analyze memory overlap, scan for duplicates, audit safety gates, and detect configuration conflicts.
Two memories refer to release steps.
Memories
Browse indexed memory graphs, filter by metadata tags, search contents, and archive outdated knowledge.
Supported Agents & Host Surfaces
Engram treats integrations as convenience wrappers. Markdown files remain the sole, portable source of truth.
Codex
Pre-load sessions
Claude
MCP & approval
Gemini
Workspace routing
Cursor
Rules & hooks
Windsurf
MCP configurations
OpenCode
Plugin integration
Copilot
Instruction files
Cline
Custom instructions
MCP
Exposes load/search
How does Engram stack up?
| Feature / Angle | Built-in Memory | Huge Custom Rules (AGENTS.md) | Engram Memory |
|---|---|---|---|
| Vendor Portability | Locked to app/model | Text files portable | Fully portable (Markdown + Git) |
| Context Footprint | Handled by provider | Heavy context bloat | Optimized context-loaded packs |
| Safety & Audits | Hidden database | Plain text files | Human approval gate & Git log |
| Cross-Agent Support | Single interface | Requires manual copying | Unified workspace CLI/MCP/API |
| Auto-Write Updates | Uncontrolled updates | Manual writing only | Agent proposes, human validates |
Built for memory you can audit.
Local-first by default
No remote databases, no shared clouds. Your memory is stored right in your workspace.
Git-native history
Every memory update translates to direct file changes. Git commits give you complete auditability.
PII & secret scanning
Auto-scans agent proposals before committing to prevent leaks of keys, passwords, and private tokens.
Isolation profiles
Keep personal rules separate from workspace-specific team settings and client constraints.
The Engram Lifecycle
