Inspiration Every time I started a new agent session, it began from zero. No memory of why an architectural decision was made last week. No record of which approaches already failed. No awareness of constraints that a teammate's agent had already discovered.
I kept watching AI tools forget everything I taught them — forcing me to repeat context again and again. And I realized the problem wasn't just annoying. It was structural. Agent memory today is treated as a runtime side effect: produced during a session, discarded when it ends. When multiple agents work the same codebase or workflow, they don't share what they learn. One agent commits to PostgreSQL. Another assumes MongoDB. Neither knows the other exists. The system silently accumulates contradictions.
That's not a retrieval problem. It's a preservation problem. And nobody had built the infrastructure to solve it.
What it does Engram is a persistent, conflict-aware knowledge base exposed as an MCP server. It gives multi-agent teams a shared memory layer that survives sessions, accumulates over time, and actively detects when agents start disagreeing.
Three core tools:
engram_query(topic) — Before starting any task, an agent pulls relevant facts, past decisions, and known constraints about what it's about to touch. engram_commit(fact, context) — When an agent discovers something worth preserving, it writes a structured entry: the fact, what triggered the discovery, the relevant scope, a confidence level, and a timestamp. Entries are append-only and never deleted. engram_conflicts() — Returns pairs of facts that semantically contradict each other, flagged automatically using embedding similarity. Produces a structured conflict artifact — traceable, reviewable, resolvable. Every session starts with accumulated team intelligence instead of nothing. Agents stop re-discovering. They build on.
How we built it Engram is built as an MCP server — the emerging standard for giving agents access to external tools and data. This means Claude Code, Cursor, Windsurf, and any MCP-compatible agent can connect without any changes to how engineers work.
The backend is SQLite with three tables: a facts table storing typed, structured knowledge entries; an embeddings table for semantic search; and a conflicts table for tracking detected contradictions and their resolution status. Facts are append-only — the full history is retained so you can reconstruct what the team's agents collectively believed at any point in time.
Conflict detection runs on commit: when a new fact's embedding similarity score against existing entries crosses a contradiction threshold, a conflict artifact is generated. Not an error — a structured, reviewable record.
Challenges we ran into Conflict detection is genuinely hard. Engineering facts aren't semantically opposite the way "hot" and "cold" are. A fact like "authentication uses JWT" and "authentication uses session cookies" are contradictory in context but not in raw
Log in or sign up for Devpost to join the conversation.