Memory Is an Institution, Not a Database

The AI industry is building memory as a storage problem: embed, index, retrieve, measure recall. But every question that decides whether memory can be trusted is a question human institutions answered centuries ago: whose version wins, who may see it, whether it still stands, how a mistake gets corrected without being erased. This essay is about why we build Yohanun by translating those institutions, and what that produces that a better retriever never will.

Four men, one name

In Glenties, the small town in County Donegal where our founder grew up, as in every rural parish in Ireland, there were several men who shared the same common name. The town never confused them. Each was known by a moniker drawn from something orthogonal to the name itself. One might be John Pat Eoin: John, son of Pat, son of Eoin, a patronymic chain in which the father's name is itself a reference to his father: a key made of keys. Another, John Hotel, because his family kept the hotel in town. A third, John Dorian, after the townland he was from. Say any of these and there was no ambiguity left to resolve. (These monikers are invented; real ones uniquely identify real neighbours, which is rather the point. The system itself is exactly as it ran, and runs still.)

Notice what the town did not do. It did not ask listeners to disambiguate the bare name from context every time, and it did not merge four men into one because their names matched. It fixed the problem at the key: it minted richer identifiers, everyone learned them, and the collision disappeared before it could reach anyone's reasoning. And when an unqualified bare name did come up in conversation, the listener ran a quiet protocol: rank the candidates from context, hold the guess as a guess, and above a certain doubt, ask. Not "which John?" but "is that John Dorian?", proposing the best candidate by its proper key, so the speaker pays one yes or no.

That is not folklore. That is a distributed identity system with write-time key enrichment, consensus-learned canonical identifiers, and a read-time resolution protocol with explicit uncertainty and cheap confirmation. It ran for generations without a database. Last week we shipped it into our entity graph, more or less verbatim: qualified entity identities minted at write time, colliding bare names parked as flagged ambiguities rather than silently merged, and a query surface whose whole job is to hand an agent the material for the question "is that John Dorian?"

The questions a benchmark never asks

The field measures memory with recall benchmarks: store a conversation, ask questions, count correct answers. We publish on those benchmarks ourselves and we care about them. But watch what happens when memory leaves the demo and enters an organization: a law firm, a clinic, a company with three hundred agents writing into a shared store. The questions that decide everything are not "can you find it?" They are:

These are not retrieval questions. They are questions of governance, authority, standing, provenance, and correction, and no amount of embedding quality answers any of them. A memory system that cannot answer them is not wrong, exactly. It is just a library with no catalogue rules, no editions, no withdrawal stamps, and no librarian: a pile of true-ish pages.

The institutions already solved this

Here is the observation Yohanun is built on: every one of those questions was solved, at scale and under adversarial pressure, by human institutions, long before computers. Not metaphorically solved. Mechanically solved, with mechanisms specific enough to translate into software.

Law solved "does it still stand." For two centuries, no serious lawyer has cited a case without checking its treatment: whether later courts followed, distinguished, or overruled it. The citator is a graph of judgments about judgments, and its output is a standing verdict: still good law, or not. In our authority engine this is literally implemented: sources carry treatment edges (reaffirmed, developed, superseded, condemned) and every answer shows a deterministic standing flag computed from them. A superseded source can still be read; it can no longer masquerade as current.

The Church solved "who vouches, and how strongly." Catholic theology has maintained, for centuries, an explicit gradation of authority: a solemn definition, ordinary teaching, a Father's opinion, and a condemned proposition are different kinds of claim, and honest teaching carries the grade with the content. Our first vertical, Catena, is built on exactly this: every source carries a canonical authority tag, the model is required to carry each claim at its grade, never presenting opinion as dogma, and we hold that behavior to a standing test suite before any prompt change ships. Grade honesty is not a style; it is the certified property.

Libraries solved "which one do you mean." Librarians call it authority control: the canonical, qualified heading that keeps two authors with one name apart forever. Glenties solved the same problem socially with monikers. Our entity layer now does both halves: qualified identities at write time, a confirm-form protocol at read time. The alternative, merging on name similarity, is how a fleet of agents quietly fuses every "Sarah" and every "the API" in the organization into one wrong node.

Registries solved "correct without erasing." A land registry or a ship's log never scrubs an entry; it appends the correction and both remain facts: the mistake, and its repair. Our memory lifecycle is retire-only: a memory can be closed or superseded, it drops out of retrieval instantly, and it stays readable forever, with the supersession chain intact. Deletion of history is not an operation our store offers, which is a feature a compliance officer understands immediately.

The professions solved "how much autonomy." No hospital lets a first-year resident operate unsupervised; privileges are earned against a track record, and withdrawn against one too. When our system detects that a new memory contradicts an old one, it does not silently rewrite anything. It files a proposal; the change happens on ratification; and only a verdict class with a sustained record of correct proposals can ever graduate to acting on its own. We apply the same rule to our own automation that a profession applies to its juniors: autonomy is bought with evidence.

Why centuries-old designs fit brand-new minds

It is fair to ask why any of this should transfer. Courts and catalogues were built for people; why expect their mechanisms to suit a language model? The answer comes in two steps, and it is the deepest reason we work this way.

First: institutions are not merely like memory systems; that is what they are. A register, a citator, a catalogue, a moniker, a sworn record: every one of them is something humans invented to shore up, extend, or share the memory we actually have. And they were shaped under the harshest selection pressure there is: daily use by human minds, across generations, with real consequences for failure. An institution that fought how human memory and judgment actually work got abandoned or reformed; the ones that survived centuries in a stable form survived because they fit us. Their longevity is not tradition. It is evidence: accumulated usability testing on the human mind, at a scale no lab could run.

Second, and this is the part that makes it matter for AI: a large language model is trained on the corpus of human writing, and the human frame for how information is kept, vouched for, superseded, and recalled is referenced in every piece of writing that touches remembering anything. Not just in neuroscience papers: in every court judgment that cites a precedent, every library slip, every parish record, every letter that says "as agreed last spring." A model raised on that corpus does not need to be taught what a register is, what it means that a ruling was overruled, what a grade of authority implies, or why "is that John Dorian?" is the right question to ask. The institutional frame is already in the weights, referenced a billion times over. These designs are native to the model in a way no bespoke schema invented last quarter can be.

We keep measuring exactly this. When we replaced free-text authority labels with a small closed vocabulary of canonical tags (the most institution-shaped form possible), the model's grade-honesty, which we test against a standing suite, produced its cleanest result ever. When we gave our agents names, a thing we did for the humans working with them, the models themselves handled identity and memory boundaries better, because a named colleague with a past is a shape human writing knows everywhere, and a nameless process with a database is not. Working with the human frame is not sentiment. It is the low-energy path through the model's own training distribution.

Governance you bolt on will leak

The research field is arriving at these questions: recent work proposes verifiable-governance primitives for agent memory, temporal knowledge graphs now mark superseded facts instead of deleting them, and there are papers on training agents to prefer current values over stale ones. We think this convergence is correct, and we would rather have company here than novelty.

But there is a design lesson inside that literature already. Recent measurement studies of governed memory systems have documented a recurring failure: access scopes enforced around the retrieval pipeline, as filters on ranked results, get overridden by the ranking itself, and entitled-looking results leak across boundaries. The lesson generalizes: filtering results is not governing retrieval. In Yohanun, access is decided inside the query: the reader's entitlements are compiled into the vector search itself, so an unauthorized memory is never in the candidate set to begin with, and the model never sees what the reader may not. The same is true of authority: the grade is attached before generation, not requested from the model afterward. The model is never the gatekeeper. Institutions know this in their bones: you do not govern the archive by asking the reading room to be careful.

The model brings knowledge. Memory brings identity.

There is a deeper reason the institutional frame matters. Frontier models have read everything; a general reference text adds almost nothing to what they know. When an ingested corpus does help, it mostly works as a seed: a retrieved claim doesn't just recall itself, it wakes the competence already in the model around it. That is why a handful of sharp, graded claims outperform a bulk ingestion, and why the grades matter twice over: activation elaborates plausible-wrong neighbours as readily as right ones, and the institutional apparatus is the fence around the growth. What a memory layer genuinely adds beyond that is what institutions accumulate and models cannot: your commitments, your corrections, which of four namesakes you mean, which version of the policy is in force, what this organization decided and why, and the standing record that lets any of it be trusted, shared, audited, or revoked. Knowledge lives in the model and is replaceable with every upgrade. Identity lives in the memory, below the model, and compounds.

That is why we describe Yohanun as the institution under the intelligence. The agents change models the way an institution changes staff. The registers, the grades, the standing, the walls, and the earned trust remain, and they are the part that appreciates.

Yohanun Guilds gives coding agents persistent, governed memory: pip install yohanun. Catena, our graded-authority reference engine, has a public demo. The benchmark work referenced above is written up, with everything we measured, here.