What Should AI Remember, and What Should It Forget?

What Should AI Remember, and What Should It Forget?

Yesterday you told the AI, “For now, just save this as a draft.” Today you have explicitly asked it to publish, but it still insists that it cannot.

Another hypothetical situation is subtler: you said only that an approach “might be worth trying.” A few days later, it treats that remark as a standing rule and keeps acting on it for you.

Neither scenario is simply a matter of “poor memory.” The information may have been preserved perfectly. The problem is that the AI has failed to distinguish a temporary instruction from a long-term preference or a decision that is no longer current.

In the previous article on context, we discussed what information to give an AI for the task at hand. Long-term memory must answer another question: What information is worth carrying into the next task, and when does it stop applying?

Chat History, Project Materials, and Long-Term Preferences Need Not Live Together

LangGraph’s documentation separates short-term memory within a conversation from long-term memory across conversations. The former maintains the current dialogue and task state; the latter can store user or application information in custom namespaces.[1]

That is one framework’s design approach, not a claim that every AI product works the same way. Still, the distinction is useful for organizing your own work.

For example, a formatting preference for articles can be retained long-term. Sources for a particular article are better kept in project documents. A draft ID returned by a particular upload belongs in the execution record for that task.

Information Better place to keep it What to check before using it
A preference for explaining the problem before the method in the main text Writing preferences Whether this task has special requirements
A project’s deployment entry point and directory structure Project documentation Whether they have been migrated or updated
Save this article only as a draft Current task constraints Do not automatically apply it to other articles
An object ID and receipt from a platform Execution record Verify the object and content version
A product’s current price and features Dated reference record Verify them again before use

Putting all of this into one “memory about the user” makes it increasingly hard to maintain. A task ends, but its temporary state remains. A project changes, but its old paths remain. A guess may also start to look more and more like a fact simply because it keeps appearing.

A Good Memory Should Answer “Where Did This Come From?”

“The user likes concise writing” sounds reasonable, but it may be no more than the AI’s guess based on a single edit.

If the user asks to shorten one passage, that does not establish that all future articles must be short. Likewise, permission to carry out a step automatically in one project cannot simply be extended to other projects.

I would be more inclined to save a record like this:

Writing project: The user wants articles to open by stating a concrete problem directly. This comes from an explicit editing request and applies to subsequent articles in this project; if the requirements for a particular article differ, follow those requirements.

Unlike a vague label, this includes scope and source. It also makes later corrections easier: if the memory proves wrong, you can return to the original decision instead of having the AI keep explaining why it thought that way.

Uncertain information should remain uncertain. For example, “the user may prefer charts” can only be an observation awaiting confirmation, not a rule requiring a chart in every article.

This record format is a design suggestion, not a set of standard fields already provided by a particular product.

Updating Memory Is Often More Important Than Adding to It

LangGraph’s documentation discusses two ways to store information: continually updating one profile, or maintaining a collection of separate memories. As the profile grows, updates become more error-prone; with a collection, the difficulty shifts to finding, deleting, updating, and linking older entries.[1]

In other words, adding one more entry is easy. Working out how it relates to earlier entries takes more effort.

Suppose an old record says, “Put all article images at the end,” and a new requirement says, “Put the cover image after the introduction.” Simply appending the new requirement leaves a conflict if the next retrieval brings back both.

A clearer approach is to update the current rule, mark the old one as superseded, and, where needed, keep the reason for the change in the history. The history remains traceable without continuing to compete with the current rule.

Another possibility is an exception for this article only. Omitting the cover image from one article does not necessarily mean the default layout has changed permanently. In that case, record the exception for this article and retain the long-term rule.

Before writing a memory, then, it is worth asking: Is this a new preference, a change to an old rule, or a one-time exception?

Storing a Memory Does Not Mean It Will Be Used Correctly Next Time

Many applications must retrieve a memory first, then pass the relevant information to the model. Storing, retrieving, and interpreting it correctly are separate steps.

Anthropic’s article on context engineering describes an on-demand approach: keep lightweight pointers such as file paths, queries, or links, and read the details when a task calls for them.[2] It is a reminder that not all material needs to be kept permanently in the same prompt.

But “retrievable” does not mean “still valid.” Instructions for using an admin interface from a month ago may be outdated, even if they are highly relevant to the current question. Beyond similarity of content, you need to consider the project, the object involved, the date, and whether the information is still in effect.

Stable preferences do not need to expire every day. Information likely to change is better marked with a verification date or an explicit instruction to check it again before use. There is no need to impose the same retention period on every memory.

For information such as account keys, ordinary memory should hold a pointer to the controlled configuration, not a copy of the secret itself. It is generally better for the model to know where to access an authorized capability than to remember a credential.

How Can You Tell It Learned the Rule, Rather Than Just Saying “I’ll Remember”?

A few small tests can reveal its behavior: start a new conversation and see whether a preference still applies within the same project; switch projects and see whether it applies that preference incorrectly; change a rule and see whether the old one still affects the result.

There is another test that is easy to miss: after a temporary exception ends, can it return to the default behavior?

When recording test results, do not look only at whether the response mentions the memory. Check whether the action follows the requirement. An AI may be able to repeat “save as a draft only” without actually constraining a later publishing operation.

This article has not run a controlled experiment on memory systems, so it cannot report an improvement in accuracy. Storing and retrieving information externally also does not mean the model’s parameters have undergone new training.

For everyday collaboration, useful long-term memory should be something the user can see, correct, and delete. It truly helps only if it can be updated accurately when requirements change.

References

Verification date: November 11, 2026. The scenarios and organizational methods in this article are design examples.

  1. LangChain: Memory overview, on short-term and long-term memory and the maintenance tradeoffs between profiles and collections of memories.
  2. Anthropic: Effective context engineering for AI agents, 2025-09-29, on-demand reading, lightweight references, and context maintenance.

AI-generated concept illustration, not a test photograph or network topology diagram.

Discussion

Share a question or your experience. Comments appear after moderation. Your email is never displayed publicly. Comment privacy

Loading comments…