Ask any AI framework how its agents remember, and you get the same answer within thirty seconds: embed it, store the vector, retrieve by similarity. Every vendor slide has the same little diagram — text goes in, a thousand-dimensional point comes out, cosine similarity finds its neighbors. It’s a good trick. It’s also, at this point, the only trick most of the industry knows.
Our schema has ten entity types and fourteen relations. Grep it for embedding, vector, or centroid and you get nothing. Not because we’re allergic to the technique — we use it, once, at one edge, for one specific job — but because most of what an agent business needs to know isn’t “what does this sound like.” It’s “which agent actually converts this kind of lead,” “is this route safe to use,” “what’s true about this client.” Those are graph questions with exact answers. A vector store can’t give you an exact answer. It gives you a good guess dressed up as a number between 0 and 1.
So we built two things instead of one: a brain and a memory. The brain is the reservoir — where knowledge lives, decays, and hardens. The memory is the pipe — how a fact gets from a conversation into that reservoir and back out again on the next turn. Different jobs, different owners, one seam between them. Here’s how each one actually works.
The brain
The whole thing is six dimensions, and every kind of memory an organization needs maps onto exactly one of them.
Groups hold shared context. Actors hold procedural memory — an agent’s prompt is a thing it can rewrite about itself. Things hold skills, tasks, and corpora. Paths hold associative memory: which route to which outcome, weighted by a strength and a resistance number that move every time something happens. Events hold episodic memory — what happened, when, at what latency. Learning holds semantic memory: a hypothesis, a confidence, a p-value, watched until it earns the right to be called true.
That’s it. That’s the whole cognitive architecture. Six tables, one relation (memory-of) binding a fact to whoever owns it, and a rule for who’s allowed to read it that’s identical to the rule for who’s allowed to do anything else in the system: walk up the group tree, first answer wins. A personal brain, a client brain, an agency brain spanning forty clients — none of them are special cases. They’re just where you are in the tree.
Retrieval is a walk, not a search. sort by strength desc, limit N over a typed relation, excluding anything toxic. No embedding step anywhere in that query. The system reads its own history the way you’d read a well-organized filing cabinet, not the way you’d ask a stranger what a document reminds them of.
And it runs at three speeds, because geography is real and a cross-region database read costs you nearly a quarter of a second whether you like it or not. A Durable Object holds the hot top-500 paths in RAM — that’s your instant answer. A KV snapshot is the ten-millisecond fallback. TypeDB itself is the full, hundred-millisecond truth, and every write eventually lands there. You always write to the fast layer and read from the cache, never the other way, because nobody’s agent should wait on a database roundtrip to decide who to route a signal to.
None of that would matter without decay. Four loops run against the graph on a schedule: one fades every path a little each day, because a memory that never forgets anything just lies about what still matters. One takes any path that’s proven itself — used enough, strong enough — and compresses it into a permanent hypothesis. One watches for agents whose success rate has dropped and lets them rewrite their own prompts. And one runs periodically across everything, looking for a pattern no single conversation would ever surface on its own.
We turned these four loops back on this week after finding them silently disabled — a cron limit on our own infrastructure account had quietly capped us at five scheduled jobs months ago, and the sixth loop just never ran. Fixed, deployed, and confirmed live: watched the scheduler fire on its own clock in production and read the invocation record back. A brain that only ever accumulates and never forgets isn’t a brain. It’s a hoarder.
The memory
If the brain is where knowledge lives, memory is the discipline of getting it in and out honestly. There are six kinds, and they update on six different schedules.
Immediate memory moves in sub-milliseconds — the moment an outcome happens, a path’s weight patches in RAM before anything else touches it. Derived memory costs nothing at all, because it’s not stored, it’s computed: whether a route is proven, whether an actor is trustworthy, answered fresh from graph shape every time someone asks. Per-conversation memory assembles a context pack on every single call — recent messages, the strongest routes, the confirmed facts, the tools available — and hands it to the model as the only ground truth it gets. Periodic memory is the four loops above. Out-of-band memory is the daily synthesis pass that reads across everything and notices what nobody in the room noticed. And two kinds get written by hand: what an operator asserts outright, and what an agent asserts mid-conversation, capped at a lower trust level until something else corroborates it.
The one thing every kind of memory shares is that it’s graded. A retrieved fact that answers well gets marked; the path that produced it gets stronger. A fact that answers badly gets warned; its path weakens and eventually stops being offered at all. This is the part a similarity score structurally cannot do — a cosine distance computed at write time never finds out whether the thing it returned actually helped anyone. Ours does, because retrieval and outcome share one vocabulary instead of living in two different systems that never talk.
There is exactly one place a vector actually touches any of this: raw documents — a shared drive, a scraped page, anything that arrives as un-typed prose — get embedded into an external vector store so they’re searchable before anyone’s had time to read them. That’s the entire vector footprint. One edge, for one job: the moment knowledge hasn’t been turned into a typed fact yet. The whole point of the promotion pipeline is to keep shrinking that edge, one prose blob at a time, until it’s a typed hypothesis instead.
Where this actually stands against the field
Here’s the part worth saying plainly instead of hiding in a slide deck: Mem0 is proven and easy to install, and it has no outcome feedback, no decay, and puts a model in the middle of every read. Zep and Graphiti are the closest cousins — a real temporal knowledge graph — but they build that graph with an LLM extraction pass on every single message, which is expensive, and they still don’t route on outcomes. Letta manages a single agent’s context window well; it isn’t an organizational brain shared by a business. Plain vector RAG gives you the best day-one paraphrase recall of anything on this list, and no valence, no time, and no types at all.
The honest caveat: none of that is a benchmark. It’s architecture. We haven’t published a single recall-precision number, and until we do, that’s a claim you should discount accordingly — Mem0 and Zep publish theirs. As a plain “remember what the user said” memory, on day one, with a cold graph, they’d probably beat us. What we built doesn’t win on day one. It wins on day two hundred, because it’s the only one of the four that gets better the more you use it instead of just getting bigger.
We know the gap between “structurally better” and “provably better,” and we’re closing it the same way we closed the loop on the routing weights: build the thing, then go find the receipts.