Our AI operator's memory is a filing cabinet. The doctrine card is clipped to the front and loads every single session. The heavy reference lives in labeled drawers that stay shut until a question actually needs them — so the working memory stays light and the knowledge stays deep.
Relic — our AI operator — is a sharp assistant with one hard limit: it can only hold so much in its head at once. Stuff everything in and it slows down and loses the thread. So it keeps its memory like a filing cabinet.
Clipped to the front is one page it always keeps in hand. That page carries the rules it works by — how to talk to people, which calls it can make on its own, how carefully to handle money and client facts — plus a simple map of what's in each drawer. It's kept short on purpose, so it never crowds out the real work.
Everything else — the business, the people, the systems, the how-to guides — sits in labeled drawers that stay shut. Relic opens a drawer only when a task needs it: a client's history comes from the people drawer, a pricing question from the business drawer. It reads just what it needs and closes it again. That's the whole idea — a light summary always in hand, deep reference filed behind it, so Relic stays fast without ever being shallow.
Starting up is the same four moves every time: the front page loads on its own, Relic reads a sticky note on top for where things stand right now, it works by the rules on that page, and it opens drawers as questions come up.
And so the cabinet never becomes a junk drawer, a few house rules hold: every fact lives in exactly one place, edited where it sits — never a second copy; check before filing so nothing's duplicated; keep the front page short; and freshen the "right now" note daily. That's how the memory stays organized, current, and trustworthy.
These are never filed away. They open the session.
The doctrine one-pager plus a thin index of what's in every drawer. This is the only file loaded into the operator's head automatically — kept deliberately small so it never crowds the working memory.
The sticky note on top of the stack: where we are right now.
Pull a drawer only when a task needs it. Tap any drawer to open it.
Everything about the company itself — what we sell, who owns it, what it costs.
The durable directory of every human and agent in the operator's world.
How the whole operation is wired — hosts, agents, plumbing.
The playbook: repeatable recipes and the failure modes to avoid.
Where every credential lives — the env-var name and the file path, never the secret itself. A leak of this drawer leaks nothing.
The complete reference layer beneath the one-pager on the front card — the long form of how the operator thinks and acts.
A drawer of index cards — each a single hard-won rule (a correction, a gotcha, a confirmed approach). Grepped by topic when a situation calls for one.
One is off-limits by rule, one is history.
The other fleet agents keep their own memory. The operator never reads or folds these into its own tree — each is scope-partitioned on purpose. Its need-to-know about them already lives in the reference drawers.
The entire pre-rebuild tree, kept intact. Nothing was deleted — superseded facts were folded into the drawers first, then the old sprawl was set aside. Searchable when history matters; never loaded into working memory.
The same four moves, every time it wakes.
MEMORY.md loads automatically — the doctrine card and the drawer map.
active.md first: what's live, blocked, and next.
Act from the one-pager — comms, decision rights, verification.
Hit a question? grep the exact drawer, read only what's needed.
The point of the whole design: a thin index that's always loaded, over fat drawers pulled only when needed. It keeps the operator's working memory small and fast without giving up any depth — a clean index up front, deep reference filed behind it.
The maintenance rules that stop it sprawling again.
Every memory is a single file with a one-line pointer in the index. New fact → one file plus one index line.
One canonical version per fact, edited where it lives. Never a -v2 or -draft copy.
Look for an existing file that already covers it and update that — don't duplicate. Delete anything that turns out wrong.
Durable facts live in drawers, not in MEMORY.md. The card stays a doctrine one-pager plus the map.
active.md is re-trued on the daily hygiene pass — done items pruned, new state pinned.
Every load-bearing fact points back to the file, artifact, or log it came from. Money & client facts come from the books, never memory.