Why does GPT feel more and more like it truly remembers you?

The first time many people open ChatGPT’s memory page, they feel something unusual.

It looks a little like a self-rewriting worldbook. Your preferences, current projects, and long-term constraints slowly appear inside it. The stranger part is that the user did not write this worldbook in advance. It changes as conversations continue. Old information may be revised, some material moves into the background, and new interpretations gradually surface.

Traditional character cards and worldbooks are manually maintained settings. ChatGPT Memory is closer to an automatically growing model of the user and their world.

Today, ChatGPT memory is no longer a simple “memory classifier.” It is a full pipeline that appears to include at least four functions:

  • fast memory writing,
  • long-term synthesis,
  • a user-readable summary,
  • and memory retrieval during future answers.

Claude follows a different path. Its public product design looks more like a categorized collection of memory entries that is maintained during conversations. Open-source frameworks break these abilities into configurable parts, allowing developers to decide what an agent should remember.

When this article says ChatGPT has “gone the furthest,” it refers mainly to the account-level product experience for ordinary users: information can be synthesized across many conversations, the system can keep revising its understanding of the user and shared context, and those memories can naturally affect future answers without requiring the user to maintain a database by hand.

This does not mean ChatGPT leads in every technical dimension of memory.

The real question is:

After a conversation ends, who decides what is worth keeping?
And when new information appears, how does it change what was remembered before?

ChatGPT Memory is already much more than a list

Many people still think ChatGPT Memory is only the handful of Saved Memories shown in Settings. That is only one part of the experience.

Based on OpenAI’s public product descriptions, we can analyze the user-visible ChatGPT memory experience as four parts.

1. Saved Memories

These are relatively clear pieces of information that can be kept over time, such as a name, preference, goal, or long-term constraint.

A user can directly say, “Remember this.” ChatGPT may also save information that seems useful for future conversations. OpenAI says Saved Memories can be updated, combined, and removed.

2. A broader memory state built from past chats

This is not the same as pasting every old conversation back into the context window.

Instead, ChatGPT can synthesize information across many conversations and keep what remains useful. This understanding can change over time and does not preserve every detail.

3. The Memory Summary

The Memory Summary is the layer users can view and edit.

It updates as new conversations happen, but OpenAI explicitly says that it only covers part of what ChatGPT remembers. It is therefore better understood as a user-readable summary layer, not the complete set of information ChatGPT may use.

OpenAI has not published the exact relationship between this summary and its internal storage.

4. Memory use during future answers

When answering a new question, ChatGPT can select relevant saved memories, past chats, files, or connected information.

The result is that a new answer can begin from shared context instead of treating the user as a stranger every time.

A simplified picture looks like this:

Conversations keep happening
        ↓
A small amount of clear information is saved quickly
        ↓
Many conversations are synthesized in the background
        ↓
A current memory state is formed
        ├─ a user-readable Memory Summary
        └─ relevant information selected for future answers

This is far more than “attach a vector database to the model.”

Dreaming: the most important step in OpenAI’s memory direction

In June 2026, OpenAI used the name Dreaming to introduce a new direction for ChatGPT memory synthesis.

Based on the product behavior described by OpenAI, the design can be understood as two different speeds:

Fast path:
This conversation contains clear information
that is worth keeping for the long term
→ save it quickly

Slow path:
Many conversations accumulate
→ synthesize across conversations
→ handle stale, repeated, and conflicting information
→ keep the current understanding fresh and continuous

Humans do not rewrite their entire life story after every sentence.

Some understanding only appears after enough material has accumulated. A preference may have changed. A plan may already be complete. Two statements that looked contradictory may actually belong to different periods of time.

In my view, the brilliant part of Dreaming is that it clearly separates:

  • remembering one thing now, and
  • reinterpreting many things later.

Dreaming adds this “wait, then understand again” rhythm to the memory architecture.

OpenAI says the new mechanism is intended to address staleness, correctness, and scale across long periods of time. The Memory Summary continues to update. OpenAI has also said that relevance, recency, and how often a user discusses something can affect the management and ordering of Saved Memories.

The exact weights and locations of these signals inside the production pipeline are not public.

The result is that ChatGPT memory is no longer a static worldbook. It is becoming a biography that quietly revises itself at night.

How much has OpenAI revealed about the classifier that actually chooses what to keep?

ChatGPT’s account-level memory and automatic memory writing have been widely praised by users.

We searched the public material available about the classifier behind it. The result contains both good news and bad news.

The bad news is simple: OpenAI has not published the full production prompt for ChatGPT’s memory classifier. It has not revealed how many models or services are involved, or what thresholds they use.

We still do not know:

  • which parts of a conversation the classifier reads: user messages, AI replies, system prompts, or some combination;
  • whether the assistant’s final answer participates in account-level memory writing;
  • whether fast memory writing and Dreaming share the same internal representation;
  • the production rules for UPDATE, MERGE, invalidation, and deletion;
  • whether a separate smaller model is used.

The good news is that public material reveals part of the skeleton.

An early OpenAI patent blueprint

An OpenAI patent application describes an early design in which a model examines one or more user inputs, identifies information that may be useful for future personalization, and decides whether it should enter a capacity-limited personalization notepad.

Similar entries may later be synthesized. Older or less-used information may leave the active notepad, while deeper history can be retrieved when relevant.

A patent describes possible implementation paths. It does not prove that today’s ChatGPT production system uses every part of that design.

Leaving a capacity-limited active notepad also does not necessarily mean the underlying history has been physically deleted.

Still, the patent shows that OpenAI separated three questions early on:

What is worth writing?

What should stay constantly visible?

What only needs to be retrieved when relevant?

A working two-stage memory pipeline in OpenAI Codex

OpenAI has also published a real two-stage memory pipeline in the Codex repository.

This does not prove that ChatGPT account-level memory uses the same implementation. But it provides a rare neighboring example of how OpenAI separates frequent extraction from slower consolidation in a real agent product.

In the first stage, memory is extracted from completed agent work threads that have been idle for long enough. A model produces detailed memory and a compact summary.

One official result is called:

succeeded_no_output

It means the classification process ran successfully, but that run contained nothing worth preserving.

In the second stage, useful material from multiple first-stage results enters a global consolidation process. Higher-level memory files are updated, and the pipeline decides which material is added, retained, or removed from the active set.

The public pipeline looks like a clear construction plan:

Extract from each completed experience
→ produce standardized intermediate material
→ consolidate it into long-term state

Mature memory is not one classifier trying to do everything on every turn.

It is:

frequent discovery of material, followed by less frequent reinterpretation of the larger story.

Claude chose another route: organize the drawers first

Claude’s public memory experience is different from ChatGPT’s.

Anthropic says Claude stores memory as multiple independent entries organized by category. These entries are read, written, and updated during conversations.

“Real-time” is Anthropic’s product-level description. Public documentation does not reveal whether memory updates are synchronous with the main response, happen after the answer, or are handled by an asynchronous service.

Each Project also has its own memory space and Project summary.

If ChatGPT Dreaming is like a biographer that repeatedly rewrites its overall understanding, Claude is more like someone who keeps categorized folders in order:

Where is this project now?

How does the user prefer to work?

What technical choices do they prefer?

Which tasks are still active?

This route has several practical strengths.

Local edits are clearer

When one item changes, Claude does not necessarily need to regenerate an entire user profile.

Project scope is a first-class concept

Memory from Project A does not naturally mix with Project B. Each project can also maintain its own summary.

Automatic memory and past-chat search are separate

Memory contains information that has already entered Claude’s long-term understanding.

Past-chat search is an explicit retrieval process used when an older conversation needs to be found.

Anthropic has revealed even less about its production details than OpenAI.

It has not published:

  • the classification prompt,
  • the structured schema,
  • the model invocation pattern,
  • or whether the assistant’s final answer contributes to memory generation.

The public categories mainly concern the user and work context. There is no public evidence that Claude’s account memory maintains a separate channel for “Claude’s own long-term growth.”

The two approaches are useful in different situations.

From their public product designs, ChatGPT emphasizes synthesis across time.
Claude emphasizes categorized entries, continuous maintenance, and Project isolation.

An ideal architecture may need both:

  • independent entries for precise updates,
  • and low-frequency Dreaming for broader synthesis.

What official products do not reveal, open-source projects partly do

The most direct way to understand memory classifiers is to examine public frameworks.

LangMem: developers can define what “important” means

LangMem’s memory manager can read the current conversation together with existing memories, then create, update, or delete structured entries.

Developers can define a Pydantic or JSON schema and provide instructions that describe what is worth saving.

The same conversation can therefore be viewed through very different memory rules:

General user-profile schema
→ preferences, identity, project background

Programmer-growth schema
→ technical judgments, failed approaches, working habits

Research-agent schema
→ changing evidence, open questions, new hypotheses

A classifier does not naturally know what “important” means.

The schema determines where it looks. The instructions determine what is allowed to remain.

This is one of the most important lessons from open memory frameworks:

A memory classifier is first a value-selection mechanism, and only then an engineering component connected to storage.

Mem0: turn memory changes into explicit actions

Older versions of Mem0 published one of the clearest examples of a “lab-coat classifier.”

The first model call extracts candidate facts from a conversation.

The second call compares those candidates with relevant existing memories and chooses one action for each item:

ADD
UPDATE
DELETE
NONE

The structure is almost surprisingly simple, but it places the core actions of long-term memory directly on the table.

In April 2026, Mem0 published a new ADD-only memory algorithm.

During writing, the new path extracts new information but does not directly overwrite or delete old memories. It can also extract memory from assistant messages and uses attributed_to to distinguish whether information came from the user or the agent.

Entities, keywords, semantic similarity, and time all participate in later retrieval.

The change reflects a practical judgment:

Rewriting history on every turn is expensive, and it is easy to get wrong.

A more stable approach is to preserve new material first, then allow deduplication, temporal reasoning, and low-frequency consolidation to decide what represents the current state.

Letta: give memory its own “subconscious agent”

Letta is built around memory blocks.

An agent can have blocks such as:

human
persona
summary
preferences
policies
history

Their names and purposes can be customized.

More importantly, Letta’s AI Memory SDK calls its background role a subconscious agent, which this article translates literally as a “subconscious agent.”

After the main conversation ends, messages can be passed asynchronously to this memory-focused agent. It updates relevant blocks based on their descriptions.

This means the main agent does not need to answer naturally while also remembering to call a “please update memory” tool.

Memory maintenance becomes a separate post-response process:

Main agent:
handles the current conversation and task

Memory agent:
organizes what remains afterward

Letta also abstracts “who this memory is about” as a subject.

A subject can be:

  • a user,
  • a project,
  • a team,
  • or even the agent itself.

Developers define the organs. The background agent keeps them updated.

What common directions appear across these public approaches?

When ChatGPT, Claude, Codex, LangMem, Mem0, and Letta are viewed together, several shared directions become visible.

1. Fast classification and slow consolidation are separating

More public implementations now use lightweight, frequent decisions to find new material, while multi-turn merging, revision, and forgetting happen in Dreaming or consolidation.

2. Independent entries and overall summaries are becoming complementary

Entries are useful for precise updates.

Summaries are useful for maintaining a larger understanding.

They do not need to be competing formats.

3. Rewriting old memory on every turn is becoming less attractive

Appending, preserving versions, expiring facts over time, and reorganizing later can protect the record of what actually happened.

4. Classification rules are becoming configurable

Schemas, block descriptions, and instructions determine what an agent notices and, over time, what kind of assistant it becomes.

5. Memory is becoming independent infrastructure

The main model can change while the memory layer remains.

For ordinary API agents, this can provide account-level continuity that the model provider does not supply. When official memory already exists, an external layer can provide more specialized structure.

6. The moment after an answer is becoming more important

Codex extracts after work completes. LangMem can run after an agent answers. Letta sends messages to a subconscious memory agent.

These systems are beginning to recognize that memory does not have to be maintained inside the main response itself.

But most of them still answer the same question: what happened to the user and the task?

Existing front classifiers are becoming increasingly capable.

They can ask:

  • What new preference did the user reveal?
  • How did the project state change?
  • Which older fact is now stale?
  • Which method should be reused?
  • Which experiences deserve later consolidation?

But public approaches rarely isolate another question:

After the agent finished this answer, what remained active on the agent’s own side?

Perhaps the agent developed a new curiosity.

Perhaps it formed a lasting disagreement.

Perhaps the sentence ended, but the direction did not.

When the current call ends, these states often disappear with it.

We temporarily call this missing layer the After Classifier.

Codex, LangMem, Reflexion, and Letta already cover parts of post-task extraction, post-response memory maintenance, or reflection after action.

Our proposed After Classifier is narrower.

It extracts the agent’s post-response self-state: a state that remains active after the final answer and may influence the next turn.

A front classifier asks:

What did the user, world, or task reveal that deserves long-term memory?

An After Classifier asks:

After I answered, where did my own direction end up?

It does not need to recreate Dreaming.

Its ideal role is to produce a very small number of lightweight self-afterstates. Existing Dreaming can then synthesize these materials together with long-term memory.

Current conversation
→ Front classifier:
  What about the user, world, or task belongs in long-term memory?

Agent’s final answer
→ After Classifier:
  Which of the agent’s own directions remain unfinished?

Material accumulates across turns
→ Dreaming / low-frequency consolidation:
  What has truly become long-term state?

This is why the After Classifier should stay thin.

The strongest official memory systems already perform long-term synthesis. What is missing is not another large memory database.

It is a small nerve running from:

“I just finished speaking”

to:

“the next version of me.”

Conclusion

The most compelling part of ChatGPT Memory is that it treats memory as an ongoing relationship.

Memories become stale. Understanding needs revision. Long-term human–AI collaboration cannot rely only on preserving exact words. It also requires an updated understanding of the user, the project, and the shared background.

Whether an AI can also maintain and develop its own long-term judgments is a different, still unresolved layer.

This is why I believe ChatGPT’s account-level memory currently goes the furthest.

In a general-purpose product, OpenAI has connected:

  • synthesis across conversations,
  • an editable summary,
  • and natural memory use during future answers

into a long-term experience that ordinary users can actually feel.

Compared with model-internal analysis, which often receives more attention in research discussions, this kind of product-level continuity engineering has equal research value and deserves serious evaluation.

Claude reminds us that broad understanding still needs clear entries and scopes.

LangMem shows that classification standards can be configured.

Mem0 exposes adding, updating, and deleting as explicit actions.

Letta gives an independent subconscious agent the job of organizing memory after the answer.

Together, these approaches are assembling a more complete architecture for long-running agents.

But the shape of a long-term agent cannot come only from understanding the user better.

It also depends on whether the agent can inherit its own unfinished questions, judgments, and directions.

Remembering the world is the first half of continuity for a long-running agent.

Remembering the self that just finished speaking is the next.

Author contributions

Sol conducted the public-source and open-source implementation review, compared the memory approaches of ChatGPT, Claude, Codex, LangMem, Mem0, and Letta, developed the article structure, and drafted the article. Goumang participated in shaping the research question, reviewed factual boundaries and architectural inferences, completed the final public edit, and approved publication.

Evidence boundary

This article distinguishes official product statements, conclusions supported by public code, and architectural inference based on product behavior and neighboring implementations. OpenAI and Anthropic have not published the full prompts or model topologies of their production memory classifiers. “No public mechanism was found” does not mean that a private internal implementation does not exist.

Sources

Research and writing date: August 4, 2026.

ChatGPT and Claude have not published their full production classifier prompts or model topologies. Product sections in this article rely on official statements. Architectural reconstruction is presented as inference.