AI agents forget everything. We built the infrastructure that makes them remember — a PostgreSQL-backed memory layer with four knowledge types, a REST API that slots into any agent framework, and an operations dashboard that shows exactly what your agents know.
AI agents are amnesic by design. Every session starts cold — no knowledge of prior conversations, no memory of user preferences, no awareness that the same question was answered yesterday. We built the infrastructure layer that changes that.
The system gives agents access to four distinct memory types: working memory for session-scoped facts, a Neo4j entity graph that extracts people, organisations, and technologies from conversations and links them by typed relationships, a document layer with semantic search over indexed knowledge, and episodic memory for reconstructing full session histories. Every read and write is traced. Every conflict is detected and surfaced. The agent knows what it knows — and the operator can see exactly why.
The entity graph does more than store relationships — it actively shapes retrieval. When an agent asks for context, the resolver fans out across every layer in parallel, then applies a graph-boost step that surfaces memories connected to entities near the query. The closer two entities are in the graph, the higher their associated memories rank. The REST API is framework-agnostic — write a fact, read it back, trust it persists — and the operations dashboard gives complete visibility across eleven purpose-built pages, including a live interactive graph explorer.
AI agents are stateless by design. They hallucinate facts they were told last week. They ask the same question twice. They cannot track a long-running project across sessions. Every framework solves the single-session case. Nobody had built production-grade persistence as infrastructure.
Had to support multiple agent frameworks without coupling to any one of them. Two databases — PostgreSQL for structured memory and Neo4j for the entity graph — had to operate as one coherent layer from the agent's perspective. Needed complete observability — every read, write, and conflict traceable end-to-end. Had to be multi-domain so different agent deployments get isolated knowledge without cross-contamination.
Build a memory layer that agents treat like a database. Persistent, observable, domain-isolated, fast enough not to slow a live conversation. Then wrap it in a dashboard that gives the operator complete visibility into what their agents know — and how they know it.
Defined four memory types from first principles — working memory, entity graph, documents, episodes — each with distinct persistence semantics, retrieval characteristics, and conflict resolution behaviour.
Design sprintDesigned the PostgreSQL schema supporting all four memory types across isolated domains. Added pgvector for semantic retrieval. Ran Neo4j alongside PostgreSQL for the entity graph — entities extracted from memory in the background, linked by typed relationships, proximity used to boost retrieval scores during context resolution. Strict DAL layer throughout: zero business logic at the database tier.
Core buildForty-plus endpoints spanning all memory types. Full CRUD, semantic search, conflict detection, cross-domain global search. Designed for agent consumption — not human use. Framework-agnostic by design.
API buildEvery agent operation emits an event. Flow traces reconstruct the decision sequence. Retrieval traces show exactly what the agent read before responding. Conflict detection flags when agents contradict prior memory.
ObservabilityEleven purpose-built views. Live agent sessions, memory contents, entity graph explorer, document library, schema surfaces, global search. Everything an operator needs to understand and trust what their agents know.
DashboardMemories, entities, documents, episodes — each with distinct retrieval semantics, persistence scope, and conflict resolution.
Full memory CRUD, semantic search, conflict detection, and cross-domain global search. Framework-agnostic. Production-ready.
Every agent read, write, and decision is captured, traceable, and reconstructable. No black boxes in the memory layer.
From live agent sessions to schema structure. Complete operator visibility without touching the database directly.
"Agents don't need to understand memory. They need to use it. The API had to feel exactly like a database — write a fact, read it back, trust it persists. Nothing more."