How Does ChatGPT Remember Your Conversation if LLMs Are Stateless?

Here is a puzzle that trips up almost everyone new to AI. The language model behind ChatGPT is stateless, meaning it remembers nothing between one request and the next. Yet the chat clearly recalls your name, your last question, and the code you pasted three messages ago. Both of those things are true at once, and the way they fit together reveals how these systems really work.

The model itself has no memory

Each time an LLM is called, it starts completely fresh. It has no built-in record of previous requests, no notebook, and no sense that it has ever spoken to you before. A call goes in, a response comes out, and the moment it finishes the model retains nothing at all. This is what stateless means, and it is true even in the middle of what feels like a flowing conversation. The model you talk to at message ten is, from its own point of view, meeting you for the first time.

The trick is resending everything

So how does the conversation hold together? The application, not the model, keeps the history, and it resends the entire conversation with every single message. When you type your tenth message, the app quietly bundles up all nine previous exchanges plus your new one and sends the whole thing as the input. The model then predicts a reply as if it is reading the whole discussion for the first time, which, in a sense, it is. What looks like memory is really a very fast rerun of the full transcript on every turn.

Memory lives in the context, not the model

This means the conversation lives in the context window, the block of text the model reads on each call. Everything the assistant appears to remember is simply text that got included in that input again. The model is not recalling your name, it is reading your name, freshly, in the transcript it was just handed. This is the same principle by which an LLM uses its context as working memory for any task. Remove a line from that resent history and the model instantly forgets it, because for the model there was never anything else.

Why this design makes sense

Statelessness sounds like a limitation, but it is a deliberate and useful design. A stateless model is simple to scale, since any server can handle any request without needing to know its history. It also keeps each interaction clean and reproducible, with the full input visible rather than hidden in some internal state. The cost of carrying context is pushed to the application, which is exactly where it can be managed and inspected. Simplicity in the model buys enormous flexibility in the system around it.

Context windows set the limit

Because the whole conversation is resent each time, it cannot grow forever. Every message you exchange adds to the transcript, and that transcript is capped by the model’s context window, measured in tokens. Once a long conversation approaches that ceiling, something has to give, or the model would simply run out of room to read. This is why very long chats can start to feel like the assistant is losing track of the earliest details. The limit is not the model forgetting, it is the transcript no longer fitting.

What happens when a chat gets long

When a conversation outgrows the window, the application steps in to manage it. It may drop the oldest messages, summarize earlier parts into a compact note, or selectively keep only what seems relevant. That is why an assistant sometimes forgets a detail from far earlier while remembering recent ones perfectly. None of this is the model choosing what to keep, it is the surrounding app deciding what to resend. The felt memory of the assistant is really the memory management of the software wrapped around it.

Persistent memory is another layer

Newer assistants also offer memory that survives across separate conversations, and it works the same way underneath. When an app remembers a fact about you from last week, it has stored that fact somewhere and quietly inserts it into the context of new chats. The model still has no memory of its own, it is just being handed relevant notes at the start. Long-term memory features are a storage-and-retrieval system bolted onto a stateless core. The illusion is seamless, but the mechanism is always the same: put the information back in the context.

Why this matters for coding agents

This design has direct consequences once you move from chat to agents. A coding agent working through a long task is constantly managing what to keep in context and what to drop, because it faces the same finite window. That is why context management becomes a core skill in agentic coding, where an agent may read dozens of files across a session. Understanding that the model only knows what is currently in front of it tells you exactly why feeding it well is so important. The agent is only ever as informed as its current transcript.

The mental model to keep

The clean way to hold all this is to separate the model from the application around it. The model is a stateless function: text in, text out, no memory. The application is the part that remembers, deciding what to put back into the input on every call. Almost every confusing question about AI memory dissolves once you keep those two roles distinct. Ask not what the model remembers, but what the app is choosing to resend.

Statelessness is a feature

Far from being a flaw, this stateless-model-plus-smart-app pattern is what makes modern AI systems flexible. It lets memory be inspected, edited, summarized, and reset, all outside the model where you can actually control it. When you understand that the conversation is text being replayed, you gain real power over it, because you can shape what the model sees. That control, more than any raw model upgrade, is where a lot of practical skill in this field lives.

Common questions