institutional knowledge for AI-native teams

Engram: Institutional Knowledge and Persistent Memory for AI Agents, Claude Code, and Cursor

Engram remembers.

Engram gives every agent on your team the institutional knowledge that makes senior engineers senior. No more code that's technically correct and contextually wrong.

Get Started GitHub
$npm install -g engram-sdk && engram init

The problem

Fast agents.
Zero context.

Your team gave every engineer an AI agent. Those agents write code fast. They also have no idea you migrated off Redis last month, or that the CTO decided all new endpoints need rate limiting. They ship code that’s technically correct and contextually wrong.

Then your senior engineers spend their time reviewing and correcting agent output instead of building. You didn’t save engineering time. You moved it.

without engram
Day 1I prefer TypeScript for all my projects.
Day 3What programming language do you prefer?
Day 5TypeScript. I already told you this.
Day 14Do you have a preferred programming language?
Day 30…
with engram
Day 1I prefer TypeScript for all my projects.
Day 3Since you prefer TypeScript, I’ll set up the project with strict mode.
Day 30Based on your TypeScript preference, here’s a type-safe API client.

What’s different

Memory that thinks,
not just stores.

Knowledge Graph

Memories connect via typed edges — supports, contradicts, elaborates, supersedes. A web of understanding, not a pile of text.

Sleep Cycles

LLM-powered consolidation distills hundreds of raw episodes into structured knowledge. Like how your brain processes memories during sleep.

Spreading Activation

Query “Thomas” and recall cascades: marathon → training schedule → prefers morning runs. Context you didn’t know to ask for.

Three memory types
Entity tracking
Contradiction detection
Memory decay
Source-available

Shared knowledge

One agent learns.
Every agent knows.

When one agent discovers a pattern, preference, or decision, the entire team has that context by the next session. No syncing. No copy-pasting. Just shared understanding.

Without shared memory
Monday - Engineer A
Agent: "How should I structure this API endpoint?"
A: "We use the repository pattern with service layers. Always."
Tuesday - Engineer B
Agent: "How should I structure this API endpoint?"
Same question. No memory of yesterday.
Wednesday - Engineer C
Agent: "How should I structure this API endpoint?"
Again. Every agent starts from zero.
With Engram
Monday - Engineer A
A: "We use the repository pattern with service layers."
✓ Stored to shared knowledge graph
Tuesday - Engineer B← never told about the pattern
Agent: "I'll set up the repository pattern with service layers, consistent with how your team structures API endpoints."
✓ Recalled from team knowledge
Wednesday - Engineer C
Agent: "Using the repository pattern. I also see the team prefers explicit error types over thrown exceptions."
✓ Knowledge compounds over time

Developer experience

Two commands.
Infinite memory.

MCP IntegrationClaude Code · Cursor
# Your agent gets 10 memory tools automatically
engram_remember — Store a memory
engram_recall — Retrieve relevant context
engram_briefing — Session start summary
engram_consolidate — Distill knowledge
engram_surface — Proactive surfacing
engram_connect — Link memories
engram_forget — Remove memories
engram_entities — List tracked entities
engram_stats — Vault statistics
engram_ingest — Auto-extract from text
TypeScript SDKagent.ts
import { Vault } from 'engram';

const vault = new Vault({ owner: 'my-agent' });

// Store — entities extracted automatically
await vault.remember(
  'User prefers TypeScript over Python',
  { type: 'episodic' }
);

// Recall via semantic search + spreading activation
const memories = await vault.recall(
  'What languages does the user like?'
);

// Consolidate — distill episodes into knowledge
await vault.consolidate();

Works with any MCP client. REST API also available for non-Node environments.

vs manual memory files

Better recall.
Lower cost.
Zero maintenance.

Most developers maintain a MEMORY.md or context file by hand — writing summaries, curating facts, hoping the agent reads the right parts.

Engram replaces that entirely. Better accuracy, fewer tokens per query, and it’s fully automatic. No curation. No maintenance. Just memory that works.

30×
fewer tokens than full context
776
tokens per recall query
96.6%
token reduction
LOCOMO benchmark · 1,540 questions
Engram80.0% accuracy
776 tokens/queryautomatic
Manual memory files74.5% accuracy
1,373 tokens/queryhand-curated
Mem066.9% accuracy
cloud API
Vector search only64.5% accuracy
embeddings only
+15.1pts
vs vector search
+12.7pts
vs Mem0
+5.1pts
vs manual files
0 hours
of maintenance
80.0%
recall accuracy
LOCOMO benchmark (1,540 questions)
44%
fewer tokens
vs hand-maintained docs
1.2×
better than Mem0
on their preferred model

Get started

Running in
sixty seconds.

npm
$ npm install -g engram-sdk
$ engram init
✓ Vault created
✓ 10 memory tools available
homebrew
$ brew tap tstockham96/engram
$ brew install engram-sdk
$ engram init
✓ Vault created
✓ 10 memory tools available
or just ask Claude

Paste this into Claude Code:

“Install engram-sdk globally and run engram init to give yourself persistent memory across sessions.”

Or use the REST API for non-Node environments
REST API
# Add your Gemini key (free at ai.google.dev)
$ export GEMINI_API_KEY=your-key-here
# Start the HTTP server
$ npx engram-serve
✓ Engram API listening on http://127.0.0.1:3800
# Store a memory over HTTP
$ curl -X POST localhost:3800/v1/memories \
-d '{"content": "User prefers dark mode"}'
→ {"id":"mem_7f3a","type":"episodic","stored":true}

Engram Cloud

Hosted memory infrastructure. Zero setup. We handle the servers, backups, and scaling.

View Plans