The tutorial is not the product
Every tutorial in 2026 teaches the same architecture for agent memory — chunk the conversations, embed them, stuff them in a vector database, retrieve top-k. It is tidy, it is pluggable, and it is not what the products that actually remember you shipped. The most useful corrective to that mental model this year did not come from a paper. It came from someone reading the products themselves — Shlok Khemani, Independent, in a 19m31s talk at AI Engineer, via the Sparsenotes weekly-notes summary from 15 Aug 2026. Khemani via Sparsenotes independently reverse-engineered ChatGPT, Claude, Gemini, and Poke by probing their behavior, extracting raw profiles where possible, and reading tool calls. Watch the talk at YouTube; read the notes at Sparsenotes — attribution here follows the summary because the YouTube transcript is blocked, so every product claim below is “as summarized by Sparsenotes.”
The headline, pasted verbatim because paraphrase would blunt it, is the one line to carry out of this post:
“none of these systems is a RAG pipeline. The industry’s default mental model — chunk the conversations, embed them, stuff them in a vector database, retrieve top-k — is not what any of the frontier consumer products actually shipped.”
That sentence reframes a year of architecture advice. Tutorials sell similarity. Products shipped maintenance, visibility choices, and a hard tradeoff between how much work you pay at write time and how many tokens every future conversation pays forever. The products also converged — from opposite directions — on a maintained profile plus tools to search conversation history. They converged on shape, not on implementation. The differences — roughly 4× in size, opposite visibility, different update cadences — are the design space the tutorials collapse to one line.
This post walks what ChatGPT and Claude actually shipped, why that shape beats tutorial RAG on the exact test RAG fails, what memory looks like as a routing problem rather than a single index, and how to position your own system on the curve the products revealed. No benchmark scores are claimed for any product here — the evidence is product behavior, as summarized by Sparsenotes, with paper support hedged exactly where it belongs. The lesson is deliberately narrow: when the products that touch the most users all skip the tutorial, the tutorial is the thing to question — not a detail around its edges, but the pipeline itself.
What ChatGPT actually shipped
ChatGPT V1 was a visible list. As summarized by Sparsenotes, GPT-4 extracted a salient fact from the conversation and appended it to a memory list you could see, edit, and delete. The mechanism was transparent — open the list, read what the model kept, remove the line that was wrong. The failure was maintenance: memory management fell to the user, and facts do not stay true on their own. A preference you stated in January, a trip you mentioned in March, a correct address from last quarter — once extracted, each sat in the list until you cleaned it. Salience at extraction time is not freshness six months later, and a list that never rewrites itself quietly becomes a museum of once-true things.
ChatGPT V2 is a hidden running profile — and the numbers matter only with their tildes. Khemani via Sparsenotes extracts the current shape: roughly 4,000 tokens, packed with keyword-dense clues rather than prose, and only one of 16 different context blocks the system assembles for a conversation. The raw profile is not visible to you — it took several attempts across thinking modes to extract — and the density is the point. This is not a sentence about you. It is a compressed sketch the system carries, every time, paying its token cost on every turn so later turns do not have to rediscover what it already knows.
The cost of a profile that rewrites rather than appends shows up as staleness of a different kind. Sparsenotes’ example is specific: 2025 trip planning for Thailand and Turkey, still confidently present in the profile when it should have been retired. The mechanism improved — running profile instead of growing list — and the old truth still outlived its usefulness. Any maintained profile faces that edit problem. The product answer was to centralize revision in the profile rewrite itself; the price is that every rewrite decides what survives, and every conversation pays for that decision whether it needs the memory or not.
The V1-to-V2 move is not “RAG plus a better prompt.” It is a different contract: facts become knowledge only when the rewrite says they do, and the user loses the direct edit handle they had before. The earlier system erred by asking the user to curate — a maintenance burden no feature list fixes. The later system errs by curating without showing its work — a governance cost paid in stale Thailand-and-Turkey truths that no embedding choice would have prevented. Both are profile architectures. Neither is chunk — embed — retrieve, and the token arithmetic — roughly 4,000 dense tokens carried as one of 16 blocks — is the price of the second contract made legible.
What Claude actually shipped
Claude V1 had no profile at all. As summarized by Sparsenotes, Claude shipped pure tools — a search over past conversations and a second tool to scope that search by time period. No maintained summary of you, no durable sketch. Every conversation started genuinely fresh, and memory arrived only when the model decided to go looking. The purity is legible and its limitation is obvious: nothing is remembered unless it is retrieved, and retrieval is gated by the model choosing to call a tool.
Claude V2 added a profile — and chose the opposite point on every dial. Khemani via Sparsenotes puts it at roughly 1,000 tokens, not roughly 4,000 — about a quarter the size of ChatGPT’s — written in prose, not dense keywords. The more consequential difference is visibility: the profile is user-visible and explicitly editable, with previous edits viewable and deletions supported. Where ChatGPT’s profile is compressed, hidden, and carried silently, Claude’s is legible, revisable, and shown to you.
Read the two evolutions side by side and the symmetry is the argument. ChatGPT moved from a user-managed list to a system-maintained, hidden, dense profile. Claude moved from no profile to a system-maintained, visible, prose profile. One product started with memory-as-list and learned to rewrite. The other started with memory-as-search and learned to maintain. Sparsenotes’ framing is exact: they arrived from opposite directions and converged on shape — a maintained profile plus tools to search conversation history — while diverging sharply on implementation. Profile sizes differ by roughly 4×, update cadences differ, visibility differs. Gemini, as summarized by Sparsenotes, differs again, and Claude Code, OpenClaw, and Hermes differ more still. The honest summary is Khemani via Sparsenotes’ own hedge: they converged on shape, not on implementation — and there is no one way.
The convergence and the divergence
The convergence claim is smaller and more useful than the discourse around it. As summarized by Sparsenotes, everyone ended up with a maintained profile plus tools to search conversation history. Not a vector store alone. Not a list alone. Not tools alone. A durable, rewritten sketch of the user plus a way to go back to the raw conversation when the sketch is insufficient — and the sketch and the tools arrived from opposite starting points, which is why the products agree on the shape and disagree on everything that sets its cost.
The divergences are where architecture lives. ChatGPT’s roughly 4,000-token dense profile versus Claude’s roughly 1,000-token prose profile is not a rounding error — it is a roughly 4× difference in tokens carried every conversation, forever. Dense keywords compress more facts per token at the price of legibility; prose preserves readability at the price of density. Hidden versus visible is a governance choice: a hidden profile cannot be audited by its subject, a visible one can be — and the product that shows you its memory invites edits the product that hides its memory must infer. Sparsenotes notes extraction of ChatGPT’s hidden profile required several attempts across thinking modes; Claude’s required opening the panel. The products price transparency differently, and that price is paid in supporting tooling — edit history, deletion, diff — versus inference-time stealth.
Update cadence is the third divergence, and the one tutorials ignore entirely. A profile that rewrites often stays fresher at higher write cost and broader context fed to the rewrite. A profile that rewrites rarely costs less to maintain and risks the Thailand-and-Turkey staleness above. Neither choice is visible to the user; both are paid by every future turn. The convergence says what layer to build. The divergence says there is no default setting for that layer — only a position on a curve between what you pay when you learn and what you pay every time you answer.
Why your tutorial RAG fails the same test
Similarity is not authority — and it is not freshness. A vector index ranks by nearness in embedding space, which is a proxy for “about the same topic,” not for “true now,” “permitted to use,” or “still the user’s preference.” Point a RAG pipeline at a year of conversations and the top-k for “what’s my plan?” will contain the plan you left in February and the plan you moved to in March, ranked by which chunk embedded closer to the query — not by which fact superseded the other. The store has no clock, no writer, no validity window. It cannot tell stale from current because staleness is not a nearness property. This is the same authority-collapse mechanism described in what happens when agents remember things that never happened — persistence that keeps the claim while erasing the source constraints governing its use — wearing retrieval clothes.
Staleness compounds as a junk-drawer cost. Every turn that appends another chunk without a rewrite makes the next retrieval a little noisier and the next prompt a little longer. The failure is quiet — useful recall on day one, plausible but dated recall on day ninety, confident Thailand-and-Turkey recall when the tickets are already bought. Sparsenotes’ profile staleness example is a product with an explicit rewrite step and it still slipped; a pipeline with no rewrite step has no mechanism to slip less. The 2026 pattern is familiar from the right to be forgotten meets agent memory: a fact that cannot be located with provenance cannot be retired on schedule — and a store that never retires anything eventually serves yesterday’s truth as confidently as today’s.
The cost trap is architectural, not vendor-specific — and it is not a benchmark claim. An equal-weight hybrid on a 23-document companion corpus underperformed vector-alone on NDCG in a demo reported alongside this analysis, and reranking 40 candidates added roughly 2.2s of p50 added latency — a corpus-specific measurement, not a general result, shown here because it makes the mechanism legible, not because it generalizes. Read the demo as scaffolding, with the same hedge the source requires: the trap is structural — retrieving more can hurt agentic tasks while helping QA, and reranking trades latency for rank quality — but the numbers are not portable.
The RAG tutorial fails the same test the hidden profile occasionally fails, for the same reason — it never decided what deserves to survive — and fails it more durably because it has no place to decide. The fix is not a better embedder. It is a layer that decides — and a router that knows which layer to ask.
The shape of the failure is worth naming precisely. A pipeline that treats every chunk as equal cannot retire the expired plan, cannot quarantine the untrusted claim, and cannot keep the validated workflow from being outranked by a chatty anecdote that happened to embed closer. Those are not retrieval bugs. They are category errors — authority, freshness, and standing filed under similarity because similarity is the only score the index knows. Every product that moved past RAG replaced the single score with a decision.
Memory is a routing problem
If the tutorial sells one index, the products argue for four stores and a router — not because four is fashionable, but because the questions agents get asked have different shapes and a single ranking cannot serve them without collapsing the distinctions that make answers correct. The clearest scaffolding for that claim is the HackerNoon four-bucket framing often cited in memory design — working memory for now, episodic for what happened, semantic for stable facts with provenance, procedural for validated workflows — used here as scaffolding, not gospel. Khemani’s fragmentation observation is the proof: memory is capped not by model capability but by how much context any single product can gather, and “None of this feels like 2026” — the field, as summarized by Sparsenotes, is roughly three years old, a collection of point solutions, not a solved layer.
Map the buckets to jobs and the routing need becomes concrete. Working memory is the session — what the model sees now, bounded and recomputable. Episodic is what happened — the conversation record and its tool calls, indexed by time. Semantic is what the system believes to be durably true — facts with provenance, validity windows, and a pointer to what they superseded. Procedural is how work is done — validated workflows that earned their keep and travel with permission. A single vector index can carry none of the last three faithfully: it cannot carry authority — who wrote this and who may use it — because similarity has nowhere to put it; it cannot carry supersession — what replaced what — because a chunk has no link to its successor; and it cannot carry validation — whether this workflow was checked — because an embedding does not know its own standing.
The routing argument is also the cost argument from §4 made operational. The compute trade-off Khemani via Sparsenotes names explicitly is update cost — rewrite frequency plus the context fed to each rewrite — versus serving cost — tokens carried every conversation, forever. A fact that belongs in semantic pays its serving cost on every turn its profile is packed; a fact that belongs in episodic should not — it should be searched when needed and left out otherwise. Stuffing everything into either lane misprices it: semantic bloat taxes every conversation for facts only one conversation needed; episodic-only recall pays a search on every turn for facts the agent should have at hand. Get the bucket wrong and you pay the wrong price forever — bloat compounds silently, search compounds by latency. The profiles that converged did not solve routing — they demonstrated that routing is the unsolved job underneath, and that the HackerNoon buckets are a useful map precisely because they make the mispricing visible before the bill arrives.
The synthesis — route by type, validate before promotion
The synthesis this series keeps returning to is not a new model or a new vector. It is a set of rules around a small number of stores: classify at write, search by type, promote only through validation. The product evolution above is evidence for that shape — a maintained profile is classification plus promotion; history search is routed episodic recall — but the products leave the promotion rules implicit. The engineering is in making them explicit.
Classification is the write-time decision. Every candidate fact — an extracted preference, a stated constraint, a tool result the agent produced — is sorted into the bucket whose lifecycle matches its standing: working — ephemeral, not persisted; episodic — persisted with time and writer, retrievable but not asserted as durable truth; semantic — persisted with provenance, validity window, and supersession link; procedural — persisted only after validation, with authority. Anything that cannot name its bucket cannot name its cost, and anything that cannot name its cost will be mispriced by the serving path — which is how a preference that should have been episodic ends up riding every prompt forever.
Write rules encode the trade-off. Update cost — how often you rewrite the profile, how much context the rewrite sees — is paid to keep semantic fresh; serving cost — how many tokens ride the window — is paid on every turn thereafter. The design is the position on that curve: rewrite often and semantic stays fresh at higher write spend, rewrite rarely and every conversation carries stale truth more cheaply. Khemani via Sparsenotes frames the trade directly as the design variable; there is no default that optimizes both. The rule that matters is what deserves to become knowledge — not “what was salient when the model read it,” but “what has survived validation and still holds now.”
Search routing and validation close the loop. Queries that ask “what happened?” route to episodic with time scoping. Queries that ask “what is true about this user?” route to semantic with provenance. Queries that ask “how do we do this?” route to procedural with permission. And nothing is promoted to semantic or procedural without a validation step — extraction proposes, validation disposes — because the confabulation risk of your agent remembers things that never happened is exactly what an unvalidated promotion automates.
That is the design space OpenZync occupies, stated at the level tone this series has kept for eighteen posts: a self-hostable temporal knowledge graph where facts supersede rather than overwrite, with provenance and validity windows carried alongside every claim — a routing-aware persistence layer that treats promotion as governance, not as an embedding side effect. It claims no benchmark scores — the benchmarks that would let it are discussed, with hedges, in the next two sections. What it does claim is the semantics routing needs to operate: a fact knows where it came from, when it holds, what it replaced, and who may use it — so the router has something to route on besides nearness.
The decision table
The honest guide to the layer, read as jobs rather than products — and read with every number’s tilde intact:
| Approach | Best at | Fails at | Build when |
|---|---|---|---|
| RAG-only — chunk, embed, retrieve top-k | Zero-maintenance recall over static corpora | Stale truths compete as neighbors — no supersession, no authority, no clock | Short-lived Q&A over documents that do not change |
| Maintained profile — ChatGPT shape — roughly 4,000 dense tokens, 1 of 16 blocks, hidden | Always-available personal context without a retrieval call | Staleness when rewrites lag — e.g. 2025 Thailand/Turkey still present — and unauditable by the user | Long-lived consumer assistant where every turn benefits from personal context |
| Tool-search — Claude shape — roughly 1,000 tokens prose, visible and editable | Freshness through retrieval and transparency through edit history | Nothing remembered unless retrieved — recall gated by the model calling a tool | Sessions where freshness and user control outweigh always-on recall |
| Routed multi-store — profile plus typed episodic, semantic, procedural | Right cost for the right fact — hot truths in profile, history on demand, workflows gated | More moving parts — classification, validation, and routing to operate | Any multi-session agent where facts have different lifespans and permissions |
| OpenZync | Temporal knowledge graph — supersede-not-overwrite with provenance and validity windows | Routing still operated by the team — no benchmark scores claimed | Provenance and audit matter — facts must know where they came from and what they replaced |
Read the rows as positions on the curve from §4. Row one pays nothing at write time and everything at serving time — via staleness and noise. Rows two and three pay serving time differently — one in dense, hidden tokens carried every turn, the other in visible prose plus tool-call latency. Row four makes the trade explicit per fact type. The last row is this series’ own bet — the semantics of row four, implemented and running, with the standing caveat of every table in this series: no benchmark scores claimed, because the category has no shared leaderboard on which to claim them.
What to watch
Four signals will mark where this lands. None of them are product announcements; all of them are evidence — and each is stated with the hedge the source requires.
The fragmentation ceiling moves or it does not. Khemani via Sparsenotes frames the cap as context — memory is limited not by model quality but by how much a single product can gather about the user. The signal is cross-product context — protocols or permissions that let memory travel with the user across surfaces without re-collection — or the absence of it, which would keep the “None of this feels like 2026” feeling in place for another year. The field, as summarized by Sparsenotes, is roughly three years old; the ceiling is structural until the plumbing changes.
Continual learning in context matures. The note that continual learning is already here outside weights — via profile rewrites — matters because it reframes evaluation: progress will read as better rewrite discipline, not as larger pretraining. Watch for rewrite quality becoming a measured axis — freshness, contradiction rate, time-to-retire — rather than a product anecdote. Scope is deliberately not extended here to invented Poke or Gemini numbers; the signal is the mechanism becoming observable, not a specific token count.
Profile-edit transparency becomes a buying criterion. Claude’s visible, editable, roughly 1,000-token prose profile versus ChatGPT’s hidden, dense, roughly 4,000-token profile is a governance fork, not a cosmetic one. The signal is edit history and deletion becoming standard surfaces — who changed what, when, and whether the user could see it — turning memory from a model behavior into an accountable store. The team that can answer “when did this fact last change?” can answer who to call when it is wrong; the team that cannot is still grepping a vector for a truth that has already moved.
The harness-paper future for routing gets tested. “Harness: A Unified Evaluation Framework for Memory Systems” (arXiv:2608.15008), a preprint, v1 15 Aug 2026, 11 substrates — is support only, not a headline, and this paragraph wears that hedge openly. The paper’s direction is the signal, not its scoreboard: no single substrate dominates; structural graphs lead on QA but are Pareto-dominated on agentic tasks; refinement leads on embodied planning; retrieving more helps QA but hurts agentic; the operative rule is to trade read breadth for write depth. The companion oracle-hybrid demo on a 23-document corpus is even narrower — equal-weight hybrid underperformed vector-alone and the reranker added roughly 2.2s p50 on 40 candidates for the largest NDCG gain — corpus-specific, not a benchmark. Watch whether that routing intuition — read breadth versus write depth per substrate — survives outside the paper’s harness.
The memory your RAG can’t carry
The uncomfortable correction of this post is not that RAG is wrong. It is that RAG, alone, answers the wrong question — “what is near this query?” — when the agent’s actual questions are “what is true now?”, “who may use it?”, “what replaced it?”, and “what happened last time?”. ChatGPT and Claude did not converge on chunk — embed — retrieve. They converged, from opposite directions, on a maintained profile plus history search — paying serving tokens every turn for hot truths and paying a retrieval call for the rest, with the edit problem unresolved and the visibility choice still contested. Continual learning, as Khemani via Sparsenotes frames it, is already happening outside weights through those rewrites — which means the RAG question is already the wrong abstraction to optimize. The tutorial collapses that entire curve to a single index. The products show the curve is the work, and the fragmented, roughly three-year-old field has no shortcut around it.
OpenZync is a self-hostable temporal knowledge graph where facts supersede rather than overwrite, with provenance and an audit trail carried alongside every claim — the persistence a RAG pipeline can’t provide, and a starting point for routing-aware memory. Start with the memory & context docs and the openzync-mcp repository.
This is part of a series on agent memory. Read why context windows aren’t memory, then how a temporal knowledge graph is built, then the honest map of agent memory tools, then the five patterns of graph memory, then the MCP memory-server field guide, then when agents talk to each other, who remembers, then the new attacks on AI memory, then team memory and who fixes a wrong fact, then the gap between benchmark scores and agentic memory, then what happens when agents remember things that never happened, then your agent doesn’t need a knowledge graph, it needs a search box, then context engineering won’t fix your agent’s memory, then everyone ships an llms.txt, almost no agent reads it, then your agent’s memory file is how mind viruses spread, then MCP and A2A have a foundation now, then the right to be forgotten meets agent memory, then cheap memory is the expensive option, then the post that started it all.