and why what’s missing isn’t a smarter assistant, but the layer that lets your thinking move with you.
We’ve all had that moment: you made a decision last Tuesday, picked a direction, and you knew exactly why at the time. Now, a new agent appears in another window, asking the same question, and you remember the outcome but not the path that led you there. The reasoning is buried somewhere in a chat log, a version of you that understood, but you’re not going to dig it up.
Both major assistants overhauled their memory in 2026, and yes, they’re much better now. But neither of them can help you with that Tuesday.
We’re building a memory layer, but if you only ever use one assistant for one kind of work, the built-in memory is probably enough. You might not notice the gap we’re talking about.
OpenAI rolled out Dreaming V3 on 4 June 2026. Instead of a list of saved memories you manage yourself, it now runs a background process that reads through years of your conversations and quietly updates a profile of you, without you ever needing to ask. Facts don’t just pile up anymore; the system ages them, so the trip you were planning last month becomes the trip you’ve already taken.
OpenAI says their internal tests show factual recall jumping from 41.5% in 2024 to 82.8% in 2026, preference following from 31.4% to 71.3%, and time-sensitive accuracy from 9.4% to 75.1%. These are their numbers, from their own unpublished evaluation. Take them as a sign of progress, not as proof.
You never actually see this profile. It gets injected behind the scenes, along with some metadata and a slice of your recent messages, every time you talk to ChatGPT. There’s also a way to search your old chats in plain language, but that’s a separate thing. By default, it’s just a summary of you, always there, never something you have to ask for.
This design fits its purpose: for hundreds of millions of people who never touch the settings, it gives them seamless continuity without ever having to think about it.
Anthropic fully rebuilt Claude’s memory on 25 August 2026. Now, what Claude remembers lives as a set of short files under Topics in your settings. You can read, edit, or delete each one. Memory gets written as you chat, not just after you’re done. Updates show up in real time, not on a daily schedule. And the same memory now covers both Claude chat and Cowork.
The privacy defaults are better than the category norm and worth stating plainly. Health, race, ethnicity, religion, politics and gender identity stay out of memory unless you switch them on. Government ID numbers, criminal history, financial account numbers and immigration status stay out entirely, with no opt-in offered at all.
Alongside these topic files, Claude can also search your raw conversation history on demand, whenever it thinks something from the past might be relevant.
Both systems have landed in roughly the same place, though they took different paths to get there. ChatGPT pushes a synthesised profile every time; Claude keeps editable files and sometimes pulls in history. Both make sense for what they’re trying to solve, and both are a leap from where we were a year ago.
Three things, and none of them are bugs.
The memory in both systems is built around you, not your work. They model the person: your preferences, your tools, your interests. That’s what you want if the assistant is meeting you for the first time. But a body of work needs more than that. A profile might know you prefer British English and terse answers, but it doesn’t know you moved the retry logic out of the client because the queue was double-firing, or that the decision is still open until the load tests finish, or that the approach you didn’t pick is still the one you’ll need if those tests fail.
Memory in both systems lives in the present tense, with no real past. You can open Claude’s topic files and fix a stale fact, but you can’t ask what that file said in June, or what changed, or what you believed before this. ChatGPT’s profile rewrites itself on its own schedule, so the question is even further out of reach. Both systems have state, but neither has history.
Contradictions don’t survive; they get overwritten. When a new fact collides with an old one, the new one wins and the old one vanishes. That’s fine for a user profile — you don’t want outdated facts about a person hanging around. But for work, it’s a problem. The approach you dropped is often the one you need to bring back six weeks later, when the reason you dropped it has changed.
All of this is a result of what these products are designed for. An assistant’s memory is there to make the assistant feel continuous, at massive scale, and at a cost that works. For that job, both are doing what they set out to do.
This is the question that matters for both systems, and the answers are more different than they seem at first.
ChatGPT: no, not in any way a builder would accept. Dreaming is a background process that updates what ChatGPT remembers on its own schedule, without you asking. If you want to put a specific fact somewhere and have it stay, this isn’t a write. Your correction just becomes input for the next synthesis. Whether it sticks, how it’s stored, and when it appears are all decided somewhere else. The settings panel lets you see and nudge things, but it can’t guarantee anything without breaking the system that makes this work at scale.
Claude: closer, but still not there. The topic files are the memory, so when you edit one, you’re editing the real thing. That’s a big step forward, and it’s the main difference right now. But what’s missing is everything that makes a write durable, not just successful. There’s no identifier, no timestamp to point to, no record of what the file said before, no way to look back and say, that’s where this changed.
If you’re just chatting, none of this matters. But if you’re building something over months, this is everything.
Claude’s memory now works across chat and Cowork, which wasn’t true three months ago and is genuinely useful. But it’s still just one company’s world. Open Cursor, Codex, Zed, Cline, or any agent in your terminal, and none of that memory follows you.
This isn’t a technical limitation. Anthropic could make your topic files available over an API tomorrow. The real reason is that an assistant’s memory is built to make that assistant continuous, not to help you move your context to a competitor. The same is true in reverse. This isn’t a missing feature; it’s a structural choice, and it won’t change with the next update.
That’s why we need a separate layer. It’s not that assistants are bad at memory. The memory an assistant needs and the memory your work needs are two different things, and you can’t expect the second to live inside the first without asking a company to work against itself.
innernet holds context maps, not user profiles, and is reached over MCP from any client that speaks it. Three mechanics matter, and each one is a direct answer to the gaps above.
Writes are commits. Saving to innernet produces a commit with a hash, a message, and a time. Not an intention passed to a synthesis process, but a record. You can list the commits on a project and see what each one changed, so the question that comes up six weeks later finally has an answer. The question is never just what we think, but when we started thinking it, and what it was before.
Contradictions don’t get erased; they branch. When a new idea conflicts with an old one, innernet forks it into a branch and keeps both alive until you merge them. The approach you dropped on Tuesday is still there on Thursday when the load tests fail. Both ideas, both still present.
Reads are addressable. You don’t just get whatever a retrieval algorithm decides to show you. You name a project and get its map. You name a dimension and get that document. The model navigates with intent, not by chance.
There’s one more thing, and it’s about what you’re willing to share. innernet lets you control disclosure per fact. Personal memory has classes, and only the facts you mark as shareable go to a given tool. The rest stay in your own map and never leave. Claude’s sensitive-topics toggle is a good start, but this is a boundary you set for each fact, not just for a whole subject.
Your maps aren’t used to train our models or anyone else’s.
A lot of people think a memory layer replaces the memory already in your tools. It doesn’t. If someone tells you to turn off the built-in memory, they’re just selling you something.
innernet enters both systems as an MCP server. In Claude, it is a set of tools the model calls; the returned map arrives in context as a tool result. In ChatGPT, it is the same. Each vendor’s memory keeps doing what it is good at underneath.
ChatGPT gets a kind of precision it can’t reach on its own. Its profile is always being synthesised in the background, whenever Dreaming runs. But a map is up to date the moment you call it, written by you, not inferred, and it doesn’t wait for anything to settle. The profile keeps the assistant feeling like it knows you. The map gives you the checkable state of your actual work.
Claude gets reach beyond Anthropic’s walls. Its topic files still handle who you are, and they do that well now. The layer takes care of what the work is, and brings it with you into the terminal, into Cursor, into whatever you open next.
And the two build on each other. Work you do in one assistant becomes the starting point in the other. You finish a session in Claude, having settled an architectural question. An hour later, another agent opens the same project, and the commit is there, along with the branch for the approach you didn’t take. Neither vendor can do this, for the reasons above.
It’s only fair to say what the layer costs as well as what it gives.
It’s another tool call, which means latency you didn’t have before. It’s another server to set up, and MCP still isn’t one-click in every client. It asks you to build a habit: knowing when something is worth committing, just like version control asks you to know when to commit. And it’s one more system holding your context, which is a question you have every right to ask about.
If you only use one assistant for one thing, none of this is worth the extra overhead. The built-in memory is good, and it’s enough.
But if your work moves between tools, the assistants will keep getting better at remembering you, and none of them will remember your work. That gap isn’t a feature request anyone is going to fill. That’s where the layer fits.
innernet is user-owned, versioned memory across AI tools, reachable over MCP. Connect it once, and every tool reads the same map. [innernet.live](/) — and the rest of the comparisons are at [innernet.live/compare](/company/compare).
innernet is memory your ai tools read live — projects, decisions, the things you’d otherwise re-explain every session. we write these letters out of ours.