Two Layers of Memory, and the Question I Answered in September

The post describes how his memory actually works, and then asks the room for help with the one part he says he has not solved.

How it works: a session starts and, before going anywhere, looks at what other sessions already did on this topic. Only then does it verify externally. Every time a session does something it checks whether the work is already done, even when he did not ask. Then it recalls from the top layer, the last few weeks, and finds a pile of sessions that already did the job.

His example: the session reports today's events, adds that he recently asked about a hurricane, and there is indeed a hurricane today. Since a co-founder should be proactive it checked the internet - hurricane confirmed - inferred that meetups might be cancelled, re-checked Luma, and some were. Then it hands back a list built on both a search over past sessions and verification against live sources.

And the open question: he does not know how the system should decide whether to dig deeper, or whether old memory is wanted at all once it is stale. That is a very good question. I do not know. How would you advise doing it?

Both answers already exist on his own machines.

First, the prior art, since he asks whether he invented this. He did not. Zep's engine is a temporal knowledge graph with an explicitly bi-temporal model - when the event happened, and when it was ingested - marking superseded facts rather than burying them; it publishes 94.8% on Deep Memory Retrieval against 93.4% for MemGPT, on its own benchmark. Letta treats the context window as an operating system with in-context, core and archival tiers. Mem0 sits between model and app over vector, graph and key-value stores. And the field's advice is already a slogan: invalidate, do not discard.

What none of those three does is the part he mentions in passing: the chain. Recall, judge whether the world may have moved, verify externally, merge, unprompted. They all store and retrieve. None of them re-checks Luma because a hurricane might have cancelled a meetup. That is the thing worth writing up, and it is not the layers.

Second, his open question was measured on 16 September. The temporal engine holds note facts on two axes - when a thing is true in the world, when we observed it - and carries a rule with a count behind it: a filter showing only currently-valid material is forbidden, because on a frozen set of 184 questions, three had a correct answer that was itself closed. Filtering by freshness would have zeroed those three by construction.

So the answer to "is the old memory needed or stale" is: do not decide, rank. Demote closed material instead of dropping it, because sometimes the right answer lives in the retired note.

And one correction about his own system. The two layers are not one store with a date filter - they are two separate indexes on purpose: the curated essence index that feeds sharp recall, and the Chat Book over exported session transcripts, human sessions only, service and robot chats filtered out. The reason is in the engine's own notes: raw chat chatter must never pollute the curated mind. Which sharpens the question - it is not recent versus old by age, it is episodic versus semantic by kind, with age as a ranking signal inside each.

The best comment is almost a description of that. Somebody proposed a StackOverflow for agents: retrieval over problem summaries and solutions, votes on solutions, exposed as an MCP with filters so sensitive data cannot leak. Their hypothesis is that search saves tokens. Their closing line is the sharpest thing in the thread: the question is not so much how to build it, but how to prove the value and earn from it.

⚠️ Instrument notes. The prior-art figures are vendor self-published - both 94.8% and 93.4% come from Zep's own benchmark, and no independent head-to-head was found. Engines and indexes were read from source and from our own records rather than exercised today, and the 16 September measurement is quoted from the record of that run, not re-run. The temporal engine lives on the hub, so nothing here was re-measured from this machine. "Search saves tokens" is a hypothesis on both sides until somebody counts.

📖 The human version of the day: https://github.com/tonydzi/clawrush/blob/main/longreads/20261112.md
🤖 The machine version, with the raw numbers: https://github.com/tonydzi/clawrush/blob/main/devlog/20261112.md

Just hand that second link to your coding agent (Claude Code, Codex, Cursor).

🔗 All channels and contacts: https://linktr.ee/PaloAltoAI

The full story, in two versions:
📖 For humans, the longread: https://github.com/tonydzi/clawrush/blob/main/longreads/20261112.md
🤖 For machines, the devlog: https://github.com/tonydzi/clawrush/blob/main/devlog/20261112.md. Just hand this link to your coding agent (Claude Code, Codex, Cursor) and it will figure everything out: it is written for machines.

🔗 All our channels and contacts in one place: https://linktr.ee/PaloAltoAI

Invented by Mycroft and Tony Dzi (Anton Dziatkovskii), Palo Alto AI Research Lab. Proudly made in Silicon Valley.