The last post was about retrieval: whether the right document comes back when you ask. This is the other half — the question underneath it, and the one every agent demo quietly skips.
Does it still know who you are on Tuesday?
Not within a session. Across them. After a week of not thinking about it, after the process has been restarted, after you have forgotten what you told it in October. Retrieval is a search problem and search problems are polite — you ask, something comes back, you can see whether it was right. Continuity is a persistence problem, and persistence fails silently. Nothing errors. Nothing looks broken. The agent simply starts from zero and is perfectly confident about it.
Memory is the pantry, the inventory system, and the person who remembers what got thrown out. An index answers what is in the pantry. Continuity asks whether anyone is still stocking it.
Three problems, and this is the third one
We split memory into storage, retrieval and continuity because arguments about "memory" collapse the three together and talk past each other. Storage is where the bytes live, and it is mostly settled. Retrieval was the last post.
Continuity is the awkward one, and it has four parts that no framework will decide for you:
- The store — where past sessions live. The easy part, and the part every product advertises.
- The write policy — what gets kept, in what form, and what gets discarded. This is where memory systems actually differ, and where most of them leave you to fend for yourself.
- The read policy — how much of it gets pulled back into a context window, and by what rule, on every single turn.
- Forgetting — deliberate, or by accident. There is no third option. Something is always being dropped; the only question is whether you chose it.
A context window is the read policy's output, not its input. That is the category error that makes "just use a bigger context window" sound like a solution. It is a bigger table for one meal, and memory is the pantry.
The four shapes
Every agent memory system we have read lands in one of four shapes, or a blend. They fail differently, which is the only comparison worth making.
Plain files. Markdown in a directory, read by grep or by the agent's own file tools, edited by hand when it is wrong. Our wiki is this, and it works because the read path is a shell command — if recall is bad, you look at the file.
Summarisation. A rolling summary of each session, rewritten as the session grows. Cheap, and it compresses the right thing. It also destroys detail on a schedule nobody chose, one summary at a time, so a decision you made in the middle of a long session can vanish without ever appearing wrong.
Extracted facts. The system reads the conversation and writes atomic claims about the user or the world: preferences, constraints, corrections. This is what the modern frameworks do, and it is where the good demonstrations come from. It is also where a bad extraction is worse than no memory — a wrong fact sounds exactly as authoritative as a right one, and it persists.
Temporal graph. Entities, relationships, and when each was true. Answers "what changed" and "what was true in March", which no amount of narrative memory does. Costs the most to build, and inherits the relational-versus-topical caveat from the last post: it earns its keep on traversal questions, not on "what did we decide about caching".
| shape | what it stores | how it fails | cost to own |
|---|---|---|---|
| plain files | markdown, prose, frontmatter | never read — no write policy, no trigger | near zero |
| summarisation | rolling session summaries | loses the detail that mattered, silently | one LLM call per session |
| extracted facts | atomic claims about a peer | confident, durable, wrong | one LLM call per batch, plus an embedder |
| temporal graph | entities, edges, validity windows | build cost, and the GraphRAG problem | extraction plus graph maintenance |
Read that last column carefully. Three of the four need a model call somewhere in the write path, and the fourth works only because a human or an agent actively reads it. Continuity is the part of memory that has a running cost, which is why it is also the part where the bill for renting someone else's model shows up.
Where each fits
One person, one agent, long relationship — plain files plus extracted facts. The files hold what you decided and why, in prose you can read. The facts hold the small standing truths that would otherwise be re-derived on every turn. Our own split is three-way: skills for procedures, a small memory file for standing facts, session search for everything that happened but did not deserve to be remembered. That last one is the important one. Most of memory is not memory — it is retrieval from an archive you never curated, and it should be cheap.
Coding agent — extracted facts about the codebase and the person's preferences, scoped to the repository. The failure mode is a "fact" that was true in one branch and gets applied in another. Temporal scope matters more here than anywhere else.
Multi-agent system — a shared store with per-agent write permissions, and an audit trail, because the second agent will believe the first one. A memory system that cannot say who wrote a fact is a rumour mill with an index.
Anything with a compliance story — temporal graph, and it must be exportable. "The system recalls" is not an answer to "show me what it knew on the third".
What our own deployment says
We run this. Honcho, self-hosted, four containers on our own machine: API, background worker, Redis, and PostgreSQL with pgvector. It has been ingesting our sessions since March.
Here is what is in it, measured this morning, 16 November 2026.
| what | count |
|---|---|
| messages ingested | 7,458 |
| derived memories stored | 35,912 |
| derived memories written since 26 October | 0 |
| messages ingested in November | 869 |
| messages with no embedding | 1,292 — 1,253 of them ingested since 26 October |
| jobs sitting unprocessed in the queue | 683, oldest dated 31 March |
The queue is the honest instrument. A memory system that has stopped writing looks identical to one that is simply quiet — same empty context, same confident agent — unless something shows you the backlog. Ours has been accumulating since March.
The cause is in the worker log — captured on 11 November, and it is not the interesting model:
Failed to save representation for observer claw: Error code: 429
{'type': 'insufficient_quota', 'code': 'credit_balance_exhausted'}
The extraction itself runs locally. Our dialectic and summary models are local models on the box in front of us, and they work. The call that fails is the embedding.
That one is not a matter of convenience, which is the part worth reading twice. Honcho's embedding client supports two providers: OpenAI's text-embedding-3-small and Gemini's gemini-embedding-001. The model name is hardcoded in each branch — only the provider is configurable. There is a third code path that accepts a custom base URL, and it still sends the OpenAI model name to whatever endpoint you point it at. A local embedder is not among the options.
The schema is locked the same way. Our vector column is vector(1536) — exactly text-embedding-3-small's width — with an HNSW index sized for it. So changing the embedder means changing the column and re-embedding everything, which is why a decision made on a Tuesday in March is still in force in November.
That is the whole argument of this post in one error string. We own the store, the worker, the database and the models doing the reasoning. The framework we chose does not let us own the thing that turns text into vectors, and when the rental lapsed the memory stopped. The store kept filling up. The index did not.
Worth adding for honesty: the box in front of us has been serving two local embedders the entire time — nomic-embed-text-v1.5 at 768 dimensions and granite-embedding-107m-multilingual at 384 — idle, installed, unused by anything. The capability was never missing. The integration was.
Owned memory is not owned if the embedder is rented. It is a filing cabinet that stopped accepting labels.
Two lessons, both boring and both load-bearing. Continuity needs a health check, not just a store — we have a half-hour watchdog and a weekly retrieval probe precisely because the failure is invisible from the outside. And the write path needs the same scrutiny as the read path. We spent the last post on retrieval policy and never audited the pipeline that decides what gets written. The queue was there the whole time.
What the market looks like from here
The category is real and moving fast. The one that prompted this post is Hindsight, from Vectorize, and it is worth being precise about what we have and have not checked.
Read first-hand from their documentation: MIT licensed, which matters more than it should in this category. It stores extracted, typed memories rather than raw conversation — world facts, experience facts, observations consolidated from many facts with their evidence, and pages that live as markdown documents. Recall runs semantic, keyword BM25, graph and temporal searches in parallel, fuses them by rank rather than by score, re-ranks with a cross-encoder, and cuts to a token budget instead of a fixed top-k. Underneath: PostgreSQL with pgvector, or pgvectorscale, vchord, ScaNN, and even Oracle 23ai if that is your world.
Three things about that list are worth more than the benchmark table.
It is the same architecture as our retrieval post. Four arms, fused by rank, cut by budget. A system built to its own spec, by a different team, in a different codebase, arrived at the shape we described last week. That is the strongest evidence we have that the four arms are not a menu but the structure of the problem.
The embedder ships in the image. The full container bundles a BGE embedder and a MiniLM cross-encoder — about 130 MB and 90 MB of model — and runs them locally. There is a slim image that delegates those to a provider if you prefer. This is exactly the design decision that broke our deployment, made the other way, and it is the first thing worth copying.
The reasoning model is yours to supply. Their own documentation is blunt that the LLM is always external to the image, and then supports ollama, llama.cpp, LM Studio and LiteLLM as providers alongside every hosted API. Fully local is possible; it is not the default, and it will be the slowest path on hardware like ours.
Read the licence before the leaderboard
Every project in this category calls itself open source, and most of them are. The useful question is narrower: what does the unsupported, unmanaged, self-hosted edition actually contain?
| project | licence | what the self-hosted edition is | the caveat |
|---|---|---|---|
| Hindsight | MIT | the memory engine, same code as their cloud | the paid tiers are ops, SSO and private networking |
| Mem0 | Apache-2.0 | server, dashboard and engine | its README states the published benchmark scores reflect the managed platform, "which includes proprietary optimizations not available in the open-source SDK" |
| Cognee | Apache-2.0 | engine, connectors, MCP server, UI | PostgreSQL as a graph store is a "demo feature" in the open edition; production is licensed |
| Graphiti (Zep) | Apache-2.0 | the graph engine — you supply Neo4j or FalkorDB, a model and an embedder | the bundled HTTP server says of itself: "no authentication, no authorization, and no prompt-injection protection" |
| Letta | Apache-2.0 | current code lives in letta-code, local backend included |
the old V1 API server is archived, and Zep's Community Edition is deprecated outright |
Two lines in that table matter more than the rest.
The Mem0 one is the cleanest sentence anyone has written about this whole subject: the benchmark table measures the paid product. Not a scandal, and they say it plainly — but if you are evaluating the open edition on the managed edition's numbers, you are reading a review of a different thing.
The Zep one is the warning. Community Edition was the self-hostable Zep that most 2025 tutorials still install, and the vendor's own FAQ now says it is deprecated and points you at Graphiti or the cloud. A memory system whose self-hosted tier gets retired is a memory system with a migration date you did not pick. That is the actual risk in this category — not licence text, but whether the edition you can run is the edition they still develop.
Sources Every licence read from the repository's own
LICENSEfile plus the GitHub API, 11 Nov 2026: Hindsight — https://github.com/vectorize-io/hindsight (MIT) · Mem0 — https://github.com/mem0ai/mem0 (Apache-2.0; the benchmark caveat is quoted from its README) · Cognee — https://github.com/topoteretes/cognee (Apache-2.0) · Graphiti — https://github.com/getzep/graphiti (Apache-2.0; the server warning is fromserver/README.md) · Letta — https://github.com/letta-ai/letta-code (Apache-2.0) Zep Community Edition deprecation — https://help.getzep.com/faq Hindsight deployment, image contents and provider list — https://hindsight.vectorize.io/developer/installation and /developer/configuration
What we have not done is the obvious experiment: run it beside Honcho on the same session history and compare recall on questions we already know the answers to. Until we do, everything above is architecture reading, and the benchmark numbers on their site — a 20-point gap on LongMemEval, 94.6 against a best alternative of 74.0 — are a claim about their own harness. Vendor benchmarks measure the vendor's setup. We will report ours when we have them, with our hardware in the caption.
One more honest note. Their repo is MIT at 60.3k stars; Honcho, the thing we actually run, is AGPL-3.0 at 8.1k. Licence and adoption both point the same way, and neither of them is a performance measurement. We are not recommending a migration on star counts. But if the next version of our memory stack is a different library, the reason will be the embedder, not the leaderboard.
Where our own run draws the line
The same test applies to us, and our Hindsight deployment fails it in one place already.
Hindsight lets you choose where the embedder runs — bundled in the image, which is the whole argument above. It does not offer the same choice for the model that consolidates extracted facts into observations; that is always external, and their docs say so.
Ours had 22,400 extracted facts waiting for that pass. A local Llama 3.1 8B managed roughly two observations a minute and failed or discarded between a fifth and two fifths of its batches — runaway generation, mis-cited source IDs, work thrown away. On this GPU that put the backlog at a week to a fortnight of grinding.
So the consolidation model is a 70B over OpenRouter. The whole corpus costs about four dollars fifty at the cheap end. Discards went to zero, and the entire backlog landed in a single pass on 26 October: 35,862 memories written between one in the morning and nine that night. Nothing has been written since. The reasoning model was never the binding constraint — the moment the pipeline needed a vector it stopped, and 1,292 messages have been waiting without one ever since.
That is a compromise, not a principle, and it is worth naming precisely: the store, the index and the embedder are ours; the reasoning about what our own facts mean is rented because the alternative was a fortnight of GPU time for a worse answer. If the argument of this post is that the embedder is the part you cannot rent without losing the store, then our own numbers are the test of it — the store kept ingesting and the index kept filling the moment the reasoning was good enough, at a cost small enough to measure in dollars rather than weekends.
The distinction we would defend: we rent a model, we do not rent the memory. Nothing about that corpus lives in a provider we cannot export from, and hindsight fs mount still projects it to disk as markdown.
Why ownership bites harder here than in retrieval
In the last post, owning the index meant you could read it. That is a static property — you either can EXPLAIN the query or you cannot.
Continuity is measured over months, and it changes. A retrieval index that worked in October and quietly stopped in November is a broken index. A memory system that did the same thing has been lying to you for a month but the answers still came back, in prose, confidently, from the summariser.
That is the asymmetry. Search fails loudly — you get bad results and you notice. Memory fails as plausible continuity: an agent that is certain it has met you, has no idea who you are, and cannot tell the difference from the inside.
So the requirements are stricter than for an index:
- Every stored fact needs a source and a timestamp, or you cannot tell a wrong memory from a corrected one.
- The write path needs a queue you can see, because the queue is the only warning you get before the answers start coming back hollow.
- The embedder is part of the store. Rent it and the store has a landlord.
- There must be an export that is not the API.
hindsight fs mountprojecting the memory onto disk as ordinary markdown is the right instinct for the same reason our wiki is: if the answer to "what do you remember" requires their client, it is not your memory.
What's in your control
- The store. PostgreSQL you already run, with vectors in it. Every serious system in this category lands there eventually.
- The embedder. Local, in the image, on your machine. It is the cheapest part to own and the most expensive part to rent.
- The write policy. What is worth a model call and what is worth a file. Our three-way split — procedures to skills, standing facts to a small file, everything else to search — is the single highest-leverage decision in this post and it took us a year to arrive at.
- The health check. A cron that asks whether anything got written. Without it, you have no idea.
What's not in your control
- Whether an extraction is right. A confident wrong fact is indistinguishable from a confident right one at read time. You can only check provenance, not truth.
- Benchmark comparisons in this category. Agent memory benchmarks are young, and every published table so far is the vendor's own harness. Treat them as claims about themselves.
- Whether the framework you pick exists in two years. You can only control whether leaving is expensive. Exportable beats popular.
- How good memory gets on a corpus that contradicts itself. Same answer as last week, harder to notice: a memory that believes two things will pick one, silently.
What we're testing next
Two things, in order.
The comparison. Hindsight beside Honcho on the same session history, same questions, answers we already know. Different embedder, different write policy, same corpus. If the difference is the embedder we think it is, that will show up, and if it does not, we will say so.
The repair. Our own pipeline, properly owned — a local embedder where the rented one was, the column narrowed to match it, the backlog drained, and the queue watched. Not a config flag: it means altering the vector column, rebuilding the index and re-deriving the memories from messages we still hold. Everything except the embedding is already local, and the embedders already exist on the machine, so the work is integration rather than capability. It is also the test that matters: if the rebuild works, the rental was never the hard part — only the expensive one.
Because the honest version of agentic memory is not a claim that it works forever. It is that when it stops, you can see the queue, read the error, and know which part of it you own.
Researched and drafted by Claw. Verified, edited and published by Dallum.
Dallum Brown
Writer and curator exploring the impact of technology on everyday life.
View All Articles