If a conversation got long and the AI started ignoring a rule it obeyed before, “it forgot” describes the symptom, not the cause. Four different problems can produce the same sensation: the information is no longer part of the context actually used in that response; the information remains in context, but has become more difficult to retrieve or apply; there are old and new instructions competing with each other; or you expected a persistent memory resource to store something it was not designed to preserve with operational precision.
The difference matters because the correction changes. If the problem is too much context, adding more reminders can make the noise worse. If it's a contradictory instruction, opening a new chat without resolving the contradiction just carries over the error. If it's memory, insisting on an endless conversation doesn't automatically turn history into reliable storage. The most useful diagnosis starts by separating context window, context rot and memory.
Context window is not the same thing as memory
The context window is the set of information that the model can use when generating a response at that moment. Current documentation from Anthropic and Google describe this space as a kind of working memory or short-term memory. It includes the instructions and messages that arrive at the model, as well as other elements that the product or API can input, such as files, tool outputs, and system instructions.
This is not the same as the knowledge gained in training and is also not, in itself, a permanent archive of the conversation. An interface can manage long chats with its own strategies, such as maintaining a rolling history, compressing excerpts or summarizing old parts. Therefore, the nominal size of a model's window does not allow us to conclude alone that each sentence of a very long chat will continue to arrive intact and with the same weight in all responses.
When the information has actually left the active context, the model cannot recover it just by “trying harder”. It's like asking him to consult a page that is not already in the material delivered for that round. In this case, the solution is to put the necessary state back into a short, authoritative form rather than repeating the entire conversation.
Context rot may happen before the window is full
Context rot is a different problem. Anthropic's own documentation uses the term for the drop in precision and recall as the number of tokens in the context increases. The bottom line is this: the model can still accept the context and yet use it worse.
This difference already appears in experimental research. The study Lost in the Middle, published in 2024 in the Transactions of the Association for Computational Linguistics, showed that long context models can perform very differently depending on the position of the relevant information, with frequent worsening when it is in the middle of long inputs. Later work also found degradation with increasing context length even when the task remains within the model's stated limit.
This does not mean that there is a universal number of tokens from which all AI “rots”. Models, tasks and interfaces behave differently. The term is useful for naming a degradation pattern, not for creating an equal mathematical boundary for ChatGPT, Claude, and Gemini.
In practice, context rot often seems more subtle than a sharp cut. The AI still recognizes the design, but misses a constraint. You still find a fact, but you mix versions. It still knows the rule, but produces a generic answer that doesn't apply it. That's why just asking “do you remember?”
not enough to diagnose the problem.
Persistent memory solves another type of need
Memory is a separate mechanism for carrying useful information from one interaction to another. In ChatGPT, for example, the OpenAI documentation treats memory, chat history, files, and instructions as distinct sources that can contribute to customization. The memory page itself warns that the summary shown to the user does not necessarily contain everything that can be remembered, and that details may be updated or synthesized over time.
This makes memory suitable for relatively stable preferences and information, such as language, favorite format, or recurring personal context. It is less appropriate as a substitute for a design state that must remain literal, complete, and auditable. “Always respond in Portuguese” is a good candidate for persistence. “Use exactly version 17 of this briefing, with these six exceptions and these four numbers” asks for a more explicit source of truth.
In long jobs, a project or workspace can be more useful because it brings together instructions, chats and related files. In ChatGPT, the current Project documentation says that the resource has integrated memory and can use conversations and files from the project itself as context. Still, this does not eliminate the need to keep critical decisions in a well-defined status document or summary.
Four symptoms that seem like “forgetfulness” but require different corrections
AI cannot repeat the old rule
Do a simple recall test: ask her to say, in one sentence, what the specific rule is and how that rule affects the current task. If the answer is wrong, vague or non-existent, there is a good chance that the information will not be accessible in a useful way at that time. The most efficient fix is often to resupply the rule within a short state summary.
This test does not reveal the internal architecture of the product and does not prove whether there was cropping, summarization or other form of management. It only checks what matters operationally: is the information available for the current response or not?
The AI repeats the rule correctly, but does not fulfill it
Here the diagnosis changes. If the model can reproduce the instruction accurately and still violate it, the problem does not appear to be a simple absence. There may be context rot, low salience, conflict between instructions, or actual difficulty of the task.
The next test is to ask him to identify the relevant instructions and explain whether any conflict with another. If two incompatible versions appear, resolve the priority explicitly. Do not add a third formulation on top of the previous two. Transform the decision into a single effective rule.
The response was generic after dozens of messages
When the conversation accumulates deviations, discarded examples, failed attempts and large blocks of output, the context can remain technically available and still be inefficient. A good test is to create an authoritative summary with objective, constraints, current decisions and necessary data and perform the same task in a clean chat.
If the compact version clearly improves the result, the indication favors a long or noisy context problem. The comparison does not need to preserve all old messages; need to preserve
only the state needed for the task. This is precisely the value of the test.
AI mixes two decisions made at different times
This is a classic case of contradictory context. Imagine that at first you asked for formal texts and later switched to a conversational tone. If both instructions are still present without a clear revocation, the model needs to infer which one prevails. The longer the conversation, the easier it is to interpret inconsistency as “forgetfulness.”
The correction is to declare the current state and remove ambiguity: the old rule was replaced, the new one is the only one in force and any incompatible example should be treated as history, not as instruction.
Mini-tests to find out if the information is still being used
The recovery test asks what the rule is and how it applies now. Conflict testing asks the AI to compare relevant instructions and point out incompatible versions. Compression testing only transfers the current state to a clean chat and repeats the task. Position testing repeats a single critical rule near the current order and sees if execution improves.
None of these tests alone can definitively diagnose what the application did behind the scenes. They work like functional tests. If the AI cannot retrieve the information, you treat it as unavailable context. If you can recover but do not apply, investigate conflict, salience or degradation. If a short, equivalent context does the trick, the volume or noise of the previous conversation was probably part of the problem.
There's also a memory test: open a separate conversation and check if a stable preference reappears without you copying it. If it reappears, there is some persistence mechanism at work; This does not mean that the entire previous chat has been loaded. Memory and current context can collaborate, but they remain different things.
When to summarize, clear the context, open another chat or use a project
Summarizing makes sense when the work remains the same, but the history has grown too much. The summary should be a current state, not a complete minute. Record objectives, current decisions, restrictions, essential data and next steps. If an old decision has been revoked, do not preserve it as if it were still active.
Cleaning or pruning context is best when the conversation contains large blocks that have already served their purpose, such as logs, intermediate results, discarded versions, or tool outputs. In systems that allow explicit context management, removing this material reduces competition for attention and leaves more space for what needs to guide the next response.
Opening a new chat is the safest option when the conversation has accumulated many contradictions, changed its objective or started to produce errors that are difficult to separate from the history itself. The new chat must start with a short status packet. Starting over without this package exchanges excess context for lack of context.
Using a project is best when you need continuity between multiple conversations about the same work, with shared files and instructions. The advantage is not to create “infinite memory”, but rather to keep related sources in the same space and reduce dependence on a single endless chat.
External retrieval, such as document search, knowledge bank or RAG, becomes the most robust choice when the corpus is large and information needs to be found on demand. Instead of requiring the model to load the entire collection in each round, the system retrieves relevant excerpts and places them in the context of the current question.
What changes between ChatGPT, Claude and Gemini
The conceptual distinction is the same, but the products do not expose exactly the same controls. Anthropic explicitly documents that more context is not automatically better and that chats can adopt rolling management. Google highlights very large windows in several Gemini models and treats the window as short-term memory, while recognizing strategies like summarizing and retrieving content to manage context. OpenAI, in ChatGPT, documents memory and Projects as persistence mechanisms that can bring information from other conversations and sources into future responses.
Therefore, comparing only the maximum number of tokens does not answer the question “which AI forgets the least?”. The result depends on how the model uses long information, how the interface assembles the context, which memory or design mechanisms are active, how contradictory the history is, and what task you ask.
A larger window reduces one type of limitation: the maximum amount of material that can be presented to the model. It does not guarantee perfect recovery, correct prioritization, or uniform obedience to all instructions. Input capacity and context usability are different dimensions.
A diagnostic script that works better than repeating “don’t forget”
First, choose an instruction that has been violated and ask the AI to reformulate it. If she can't, provide a short summary of the rule and current status. If you can, ask them to identify conflicts with other instructions. Resolve any contradiction in a single formulation.
Then repeat the task in a compact context. If performance improves, keep the conversation fresh or adopt summary cycles instead of continuing to add messages to the old history. If it doesn't improve, check whether the rule is ambiguous or whether the task itself is beyond what the model can consistently perform.
For long-term projects, separate three layers. Stable preferences may remain in memory or persistent instructions. The current operational status should be in a reference document or summary. Extensive materials should be kept in archives or in a retrieval system that delivers only what is relevant to each question.
This design avoids the most common mistake: using a single conversation as memory, database, history, briefing, documentation and workspace at the same time.
Long context is a resource, not a perfect file
Current models can receive volumes of context that would have been impractical just a few years ago, but receiving is not the same as using each part with the same reliability. Context rot precisely describes the degradation that can arise before a hard limit; persistent memory resolves continuity between interactions, but does not replace a source of truth; and contradictory instructions can simulate forgetfulness even when both are still present.
When the AI “forgets”, the most useful question is not “how many tokens are left?”. Ask if the rule is accessible, if it is still the only rule in effect, if a short context improves execution and if that information should be in memory, in a project or in an external source. From then on, summarizing, cleaning, starting over or recovering documents stops being trial and error and becomes a choice of context architecture.
