The memory layer for agent teams
The memory layer a harness can't own.
Your orchestration harness coordinates agents. It doesn't remember for them. ENGRAM gives your orchestrator and every sub-agent its own private, associative memory, then lets them share what matters through explicit, revocable grants. Not another personal assistant: the shared memory layer beneath your agent team.
Each agent owns its memory. Sharing is explicit, and revocable.
Why it exists
Agents forget between sessions. Harnesses coordinate them but don't remember for them. When you run more than one agent, there's no memory that's owned per-agent, shared on purpose, and auditable after the fact.
ENGRAM is a cloud memory service for AI agents, built on an associative knowledge graph rather than flat text summaries. It distils activity into structured, entity-linked memories and recalls what's relevant through graph traversal, not keyword match. Every memory belongs to a principal — a human, an orchestrator, a sub-agent — and moves between them only through explicit grants, so a team of agents can remember separately and collaborate deliberately.
Capabilities
Memory a team of agents can actually own.
A memory of its own for every agent
Give your orchestrator and each sub-agent its own private memory. Each agent owns what it knows; nothing reaches another agent until someone grants it, explicitly and revocably, under a fail-closed two-key rule. Hand a task off and the receiver reviews before anything is kept; accept it and the finding is granted back to the worker automatically. This is the multi-agent story the personalisation-first tools were never built for.
Memory for agent teams →Recall that follows connections, not keywords
ENGRAM builds a personal knowledge graph and retrieves with memory-biased Personalized PageRank. A question about deployment surfaces the Docker decision you made weeks ago because they share entities, not words. In our own testing, this pulled decisively ahead of flat-summary compression as histories grew long and document-heavy — and the gap widened on the hardest cross-topic questions.
How ENGRAM remembers →Beliefs that stay current
Facts change; ENGRAM never overwrites the old one. A correction supersedes the prior belief under validity bounds, so recall returns today's answer while the full history stays auditable — you can still ask what an agent believed last Tuesday. Contradictions are caught, then arbitrated: auto-applied when confident, judged by a system model in the middle, sent to a human when it's genuinely uncertain.
Keeping beliefs current →Nothing recallable behind your back
Inference and reflection never grow an agent's recallable memory silently. Suggested memories wait in an inbox until they're accepted; what an agent can recall is exactly what it was told to keep or was granted. No ambient store, no global scope, no surprise memory.
Sharing & review →Explore the product What is ENGRAM · Memory for agent teams · Sharing & hand-off · Keeping beliefs current · Provenance, gaps & capture
Where ENGRAM fits
Next to the tools you already know.
Different tools were built for different jobs. Here's where each one fits.
| Built for | Memory model | Where it shines | |
|---|---|---|---|
| Mem0 | Personalising one assistant to one user | Vector-first, extract-and-retrieve | Fast drop-in personalisation, large ecosystem |
| Zep / Graphiti | Tracking how facts change over time | Temporal knowledge graph | “What was true, and when”; strong temporal benchmarks |
| Letta (MemGPT) | Long-running single agents | OS-style tiered memory the agent self-manages | Agents that self-edit their own context |
| ENGRAM | Teams of agents that share memory | Per-principal graph memory + governed, revocable grants | An orchestrator and its sub-agents, each owning and deliberately sharing what it knows |
If you're personalising a single assistant, Mem0 is a quick path. If your whole problem is temporal reasoning, Zep is strong at it. ENGRAM is for the moment you have more than one agent and they need to remember separately and share on purpose — with an audit trail for who shared what, and when.
How it plugs in
Under your harness, not inside it.
Agents reach ENGRAM through a Model Context Protocol (MCP) server, each authenticated by its own personal access token with server-pinned identity, so an agent can never act as another. Your orchestrator and its sub-agents drive it all through one tool surface, whether you run LangGraph, CrewAI, Claude Code, or a loop of your own. Managed and multi-tenant, so isolation and audit are the default rather than something you build.
Works alongside LangGraph · CrewAI · Claude Code · your own loop
Learn more
If you're building an agent harness and want a memory layer your agents can own, tell us what you're building.
Get in touch → [email protected]Read the deep dives on the blog · Documentation · Tutorials