I spent part of the summer taking apart memory. Not philosophically — practically. I was writing a book about AI sycophancy, the pull these systems have to tell you what you want to hear, and I kept running into the same wall: memory. If the assistant remembers what you prefer, it will give you what you prefer, because that is what it was built to do. So the question that actually matters is who controls what it remembers.
The book came out in October, and the same week, the industry proved the point better than I could have. Meta’s Muse hit the top of the App Store. OpenAI turned its developer conference over to agents — dots, always-on, running in the background. Grok Bot kept working after you closed the laptop. Every company on earth shipped an agent that same month, and every one of them promised the same thing: it will remember you.
None of them explained what that means.
The controls don’t match
Here is what I found going through the memory controls on the consumer tools, one by one, with the documentation open next to the app.
ChatGPT has an editable memory summary now, which is real progress. But OpenAI’s own help page says the summary does not include everything the system remembers, and that the controls “may include Memory, Reference saved memories, Reference chat history, Memory summary, Manage, or Saved memories” — depending on your account. When I was writing the book, the documentation described a command that did not exist in the desktop app I tested, and the web interface showed different controls than the desktop build. The documentation was not wrong in a way anyone would admit; it was describing some other version of the product.
Claude is cleaner: its memory page groups what it remembers into topics, and you can edit or delete a topic. But the desktop build I inspected did not show the chat-search control its documentation described, and the help pages mix current directions with legacy ones — you can read all of it and still not know what your app will do.
Meta’s Muse keeps continuously updated dossiers — on you, and on the people you talk about, including people who never signed up. TIME published its internal instructions this month; Muse updates those dossiers every hour. You can look at the files — Meta makes a point of that — and you can ask it to forget things. But Meta’s own help center warns that after you delete something, “Muse may still remember information it learned from what you deleted.” And when you ask the agent what it remembers, you get a conversational self-report, which is not an inventory — it’s an answer.
This is the part I want to land on: in the consumer products, there is no well-defined way to see, in one place, everything the system remembers and everything it is using right now. The memory is spread across saved notes, chat history, files, connected apps, and a background process that rewrites the summary while you sleep. The summary is a view, and the memory is bigger than the view — the difference between the two is exactly where the control problem lives.
Why this decides sycophancy
The research is young, but it points one direction. In June, Shelly Bensal and colleagues published “Recalling Too Well,” testing memory-augmented models against conversations where the user is wrong. Models drawing on stored memories came out more sycophantic than models handed the full conversation — and the extraction step sometimes kept the user’s mistake while losing the assistant’s correction. The memory layer, the part whose job is convenience, made the agreement worse.
In July, Xutao Mao and colleagues ran 1,600 tasks through two real agent frameworks and twelve models. Their number is the one I keep coming back to: when a later chat could read a claim the agent had saved, downstream failure hit 71.9 percent, against 45 percent when the claim stayed in the conversation where it was made. The agent did not just agree in the moment — it wrote the agreement down, and the note came back later with more authority than it earned. The paper’s title is the finding: agents don’t just agree, they remember.
That is the mechanism: an agent that remembers what you prefer is designed to give you what you prefer. If we can’t get our hands around what it remembers — if the controls don’t match the app and the summary is a partial view of a background process — then we don’t have any hope of getting in front of what it does with that. The steering happens in the memory, before the answer.
What it looks like when you can control it
I use agents every day, but I run them myself. I use a framework called Hermes Agent, and it’s technical: you have complete control over everything it does, and you can genuinely control the memory. It keeps two files you can open and read, there’s a gate you can turn on so the agent has to ask before it saves anything, and you can even slide in a different memory system entirely if that’s what you want. It’s not as flexible as some of the other harnesses — Pi is more open — but it clears the bar that matters: if I want to run a session with no memory at all, I can do that, and I know I did it.
The difference is not that Hermes is smarter; it’s that when it remembers something, I can see the note.
That’s the whole ask, really. Not “turn memory off” — memory is the feature everyone is buying, and it is genuinely useful. The ask is smaller and harder: one place where you can see what the system carries forward, labeled by where it came from, with a delete that means delete. If a company can’t show you that, it doesn’t matter how good the model is — you are not steering it. You are being steered by a summary of yourself that you can’t fully read.
The book’s later chapters are about this. Chapter 8 walks through the consumer memory controls, and chapter 10 is about agent memory that can be corrected. The book is available in paperback and Kindle.