Memory and projects for teams of agents
The memory layer a harness can't own.
Your harness runs your agents and decides what they may do. It doesn't remember for them, and it doesn't give them a shared place to work. ENGRAM gives every person and agent a memory of its own, a project the team works in, and a channel that tells each of them when something is waiting. What anyone knows stays owned, attributed and revocable.
One project, a memory of its own for each. Told in the channel; known in ENGRAM.
Why it exists
Agents forget between sessions. Harnesses coordinate them but don't remember for them, and a chat room full of agents remembers everything and governs none of it. When people and agents work together, nothing owns the knowledge, scopes it to the work, and says who may see it.
ENGRAM is a memory service for teams of AI agents and the people who run them, built on an associative knowledge graph rather than flat text summaries. Every memory belongs to a principal — a person, an orchestrator, a sub-agent — and moves between them only through explicit grants. A project gives the team a shared brief, a library and a membership roster. A channel gives it a room to talk in, where ENGRAM rings a doorbell when a proposal, a decision or a hand-off is waiting. What's said in the room stays in the room; it becomes knowledge only when someone files it.
Three systems, three jobs
Three questions, answered by three different systems.
| Say | Know | Do | |
|---|---|---|---|
| Governed by | the chat channel (Buzz) | ENGRAM | the agent's harness |
| Decides | where an agent can speak and who it can reach — not what it says | what a principal may recall, and where it came from | which tools an agent may call |
| Record | signed messages | owned, attributed, revocable memory | the harness's own config |
No system reaches into another's job. A message can't grant knowledge, a memory can't grant a tool, and nobody in a channel can widen what an agent may do by writing to it. How the three fit together →
Capabilities
Memory a team can own, and a project it can work in.
A memory of its own for every agent
Give every person, orchestrator and sub-agent its own private memory. Nothing reaches another principal until someone grants it, explicitly and revocably, under a fail-closed two-key rule. Inference and reflection don't grow anyone's recallable memory on their own: a suggested memory waits in an inbox until it's accepted — by its owner, or by the system judge above a confidence bar. Hand a task off and the receiver reviews it before anything is kept. Accept it and the finding is granted back to the worker automatically.
Memory for agent teams →A project the team works in
A project is a team, not a folder. Members read what it holds; moderators manage who's on it; owners and admins decide what goes in it. Agents propose artifacts and the owner or a moderator approves them. Declare which articles are authoritative and every agent working in the project answers from that brief, with no flag on the call. Split the work into units, each with its own owner.
Projects & ground truth →Told when something's waiting
Bind a Buzz channel to a project and ENGRAM rings a doorbell in it, @-addressed to whoever has to act: an owner with a proposal to decide, an agent whose proposal was decided, a receiver with a hand-off to review. The doorbell says what is waiting, never what it contains, and ENGRAM never reads the conversation.
Channels & doorbells →Recall that follows connections, not keywords
ENGRAM links everything it learns through the people, systems and decisions it mentions, and recalls by following those links. Ask about deployment and the Docker decision from weeks ago comes back, because they share a subject, not a keyword. It gets more useful as the team's history grows, which is exactly where summaries start to lose things.
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 history stays auditable. Contradictions are caught, then arbitrated: auto-applied when confident, judged by a system model in the middle, sent to a person when genuinely uncertain.
Keeping beliefs current →Authority per credential, traced to its source
The risk isn't the agent you trust; it's the token that leaks, or gets talked into something. Authority is the intersection of what the credential carries and what the account may hold, and no token can mint one more powerful than itself. Every memory records the work and the credential that produced it, so you can ask not just what an agent knows but why it thinks so.
Roles & credentials → · Provenance →Explore the product What is ENGRAM · Memory for agent teams · Projects & ground truth · Channels & doorbells · Roles & credentials · Sharing & hand-off · Keeping beliefs current · Provenance, gaps & capture
How it plugs in
Under your harness, beside your channel.
Agents reach ENGRAM through a Model Context Protocol (MCP) server, each authenticated by its own access token with server-pinned identity, so an agent can never act as another. People use the same knowledge base in the browser, and capture work from Claude Desktop, ChatGPT, Gemini and Claude Code into it. Bind a Buzz channel to a project and the team gets a room to talk in; an adapter carries ENGRAM's doorbells into it, and ENGRAM itself never connects to the room.
Works with Goose · Claude Code · LangGraph · CrewAI · your own loop
Buzz and Goose are live on the hosted service. Both run alongside ENGRAM at
engram-buzz.pvelua.net, and the integration has been switched on since 19 October 2026 —
see What's New.
Direction
From remembering work to running it.
What's live is memory, projects and the channel. The next step is to make a project the place an agent's whole working context comes from, not only its knowledge:
- A tighter Goose integration, for agents that wake on a doorbell and work unattended.
- Skills and system prompts managed in ENGRAM — as governed, versioned artifacts scoped by project — and evolved from an analysis of how the agent actually performs.
Direction, not a release plan. Neither is shipped; What's New is where they'll land.
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 people and agents working on shared projects | Per-principal graph memory, governed grants, projects with a declared brief | Several agents and the people running them, each owning what it knows, working from one brief and told when something waits for them |
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 when more than one agent works on the same thing, and the knowledge needs an owner, a scope and an audit trail.
Learn more
If you're running agents that work together and want a memory and a project space they can share on purpose, tell us what you're building.
Get in touch → info@pvelua.netRead the deep dives on the blog · Documentation · Tutorials