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 →A brief your agents answer from
Retrieval finds what's relevant; it has no opinion about what's true. Declare which articles are authoritative for a project and every agent working under it prefers them — no flag on the call, no threading anything through a fan-out. Workers inherit the brief by naming the project they're in. The same set checks new writing before it lands, so an agent can't quietly file a claim that contradicts it.
Ground truth & projects →Authority scoped per credential & role
The risk isn't the agent you trust — it's the token that leaks, or gets talked into something by input you didn't write. So authority is an intersection: what the credential carries, and what the account behind it may hold. One Restricted switch therefore means three different things — a Contributor's token proposes but never ratifies; a Project Collaborator's may also share memory with, and publish to, projects it belongs to; an Agent Manager's may provision its own sub-agents as well. And no token may ever mint one more powerful than itself, so a delegation tree only flattens as it grows.
Roles & credentials →Traceable back to where it came from
Every memory records the work that produced it — the conversation, the coding session, the tool that filed it — so you can ask not just what an agent knows but why it thinks so. ENGRAM captures that work from the tools your team already uses, retires beliefs rather than erasing them, and flags the gaps it notices in what it holds.
Provenance, gaps & capture →Explore the product What is ENGRAM · Memory for agent teams · Ground truth & projects · Roles & credentials · 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 short- and long-term memory | Per-principal graph memory + governed, revocable grants | An orchestrator and its sub-agents, each owning what it knows and sharing it deliberately — scoped to a project or a task |
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 → info@pvelua.netRead the deep dives on the blog · Documentation · Tutorials