Your AI Doesn't Remember Your Conversations. It Remembers a Summary.

Ask ChatGPT to “remember” something and it will tell you it has. Claude, Codex, and every other assistant now ships a memory feature too. So most people have quietly concluded that their AI remembers their conversations.

It doesn't. What it remembers is a summary— a short, model-written abstraction of what you talked about, with the actual words thrown away. That's not a bug or a limitation someone forgot to fix. It's the deliberate design of every built-in memory system, and once you see why, you'll understand what you're actually losing.

The misconception

“Memory” sounds like recall. You said it; the machine kept it; later it gives it back. That's what the word implies, and it's what the marketing suggests.

What these systems actually do is closer to note-taking by an intern who then shreds the transcript.After a conversation, a model reads it, writes down a few things it judges important, and discards the rest. Next time, you get the notes — not the conversation. If the intern's summary missed the detail you needed, that detail is simply gone.

This is easy to assert and hard to believe, so let's look at the actual evidence — from the tools themselves.

What Codex actually stores

OpenAI's Codex CLI keeps its memory in a local SQLite database. You can open it and read the schema. Here is the table that holds what Codex “remembers,” field for field:

CREATE TABLE stage1_outputs (
    thread_id            TEXT PRIMARY KEY,
    raw_memory           TEXT NOT NULL,   -- model-generated memory
    rollout_summary      TEXT NOT NULL,   -- a summary of the session
    generated_at         INTEGER NOT NULL,
    selected_for_phase2  INTEGER NOT NULL DEFAULT 0,
    usage_count          INTEGER,
    ...
);

Every column tells you the same thing. The stored memory is generated, not recorded. There is an explicit rollout_summary — a summary of the session. The table is named stage1_outputsbecause it's the first step of a multi-stage extraction pipeline (there's a selected_for_phase2 flag), and the whole point of that pipeline is to boil a long conversation down to a few reusable facts.

Meanwhile, the actual verbatim conversation exists too — briefly. Codex writes each session to a rollout transcript on disk. In one real session, that transcript was 174 KB of complete, word-for-word conversation.The memory system reads it, produces a summary a fraction of that size, and the full transcript is left to be rotated away. What survives in “memory” is the compression, not the source.

What Claude Code actually keeps

Claude Code is more honest about it: by default, it doesn't claim persistent memory at all. Every session starts from zero. You re-explain your conventions, your architecture, the bug you fixed yesterday — because the agent genuinely doesn't carry anything between sessions.

It does write a complete transcript of each session to ~/.claude/projects/as JSONL — verbatim, every message. But nothing reads it back. It's a log, not a memory: the words are preserved on your disk, siloed to one tool, and never surfaced in a future conversation. The information you'd want is right there, and the assistant ignores it.

So across the two, you get both failure modes: Codex keeps a memory but compresses it; Claude Code keeps the words but never recalls them. Neither gives you what you assumed you had — your actual conversations, available later.

Why they all compress — and why it's rational

This isn't incompetence. Compression is the correct choice for them, given what they're optimizing for.

A built-in memory feature exists to make the model's next response better, and the model has a fixed, expensive context window. You can't paste a year of raw transcripts into every prompt — it wouldn't fit, and it would cost a fortune. So the rational move is to distill: extract the few facts most likely to help, store those, and inject them going forward. Summarization isn't a shortcut they took; it's the entire mechanism.

The same logic explains ChatGPT's memory (a bulleted list of facts it decided to keep about you) and dedicated memory libraries like Mem0 or Zep (which extract “facts” and “entities” from conversations). They all compress, because they're all built to feed a context window efficiently — not to be a faithful archive of what was said.

The three hidden costs of summary memory

Optimizing for the context window is reasonable. But it quietly costs you three things you probably assumed you had:

• The detail you didn't know you'd need. A summary keeps what the model judged important at the time. The specific error message, the exact number, the offhand constraint that turns out to matter three months later — if it didn't make the summary, it's unrecoverable. You can't search a conversation that no longer exists.
• Portability.Codex's memory lives in Codex. ChatGPT's lives in ChatGPT. Each tool's summary is trapped in that tool. Research something in one AI and it's invisible to the next.
• Trust in the record.A summary is an interpretation. When you go back to check what was actually said — what you decided, what the reasoning was — you're reading the model's paraphrase, not the transcript. For anything that matters, that's not a record you can rely on.

What verbatim memory looks like

The alternative is boring in the best way: keep every word, and make the words searchable. No summarizing, no fact-extraction, no throwing away the transcript.

That's what Engramdoes. Every conversation is stored exactly as it happened — verbatim — and then chunked and embedded so you can search it by meaning. Ask “what did I decide about the database in March?” and it finds the real conversation, with the real reasoning, not a paraphrase of it. And because it speaks the Model Context Protocol, the same memory is available from ChatGPT, Claude, Cursor, Codex, and anywhere else you connect it — one archive, every tool.

Verbatim storage is only possible because Engram isn't trying to cram your history into a context window. It's an archive first and a retrieval layer second, so it has no reason to compress. The built-in memories can't make that trade — their whole job is to be small enough to inject. That's the difference, and it's structural, not a feature gap someone will close next quarter.

None of this means the built-in memories are useless. Codex's summary makes Codex a bit smarter about you; that's fine. Just don't mistake it for a record of your conversations. If you want the actual words — searchable, portable, permanent — you need something that was built to keep them.