ChatGPT Project Memory Not Working: Causes and Fixes

You set up a Project, put your background in it, and started working. For a while it behaved as though it knew where it was. Then a chat inside that same Project asked you something you had already answered, or dragged in context from a completely different piece of work, and now you are searching for why project memory is not working.

Almost every report of this turns out to be one of six things, and only one of them is a fault. The other five are scope: a reasonable expectation aimed at the wrong store. ChatGPT does not have one memory. It has several stores with different lifetimes, different scopes and different triggers, and Projects sit across them rather than replacing them.

This post separates the stores, gives you a check that tells them apart, and works through the causes in the order worth testing.

What People Mean by "Project Memory"

The phrase covers at least three different expectations, and they fail differently.

"It should apply my project instructions." You wrote guidance at the Project level and want every chat in the Project to follow it. This is configuration, and it is the expectation most likely to be met.

"It should know what we established in earlier chats in this Project." You solved something in a chat last week, you are in a new chat in the same Project, and you expect continuity. This is conversation persistence, and it is the expectation that fails most often.

"It should not leak in context from my other work." You want the Project to be a sealed room, so the personal or unrelated facts sitting in your global memory list stay out. This is isolation, and whether you get it depends on switches whose naming has moved between product versions.

Work out which of the three you are actually asking for before you change anything. The fixes have almost nothing in common.

Scope Is the Whole Explanation

Four stores, four scopes. Everything in this post follows from the table in your head.

The context window. Scope: this one conversation. It holds what has been said in the chat you are in, plus whatever was supplied at the start. It is a working buffer, it is emptied by opening a new chat, and it also fills up within a long chat, at which point the earliest messages fall out of view. Why that happens at all is covered in Why AI Forgets Your Project Context Between Sessions.

Project instructions. Scope: every chat in that Project. Re-supplied each time, which is exactly why this is the layer that behaves predictably.

Files attached to the Project. Scope: available to chats in the Project, but retrieved selectively rather than held in full. More on this below, because it is the subtlest of the four.

The global saved memory list. Scope: your account. Facts extracted from conversations, stored as a list you can read in settings. This is the one that leaks across Project boundaries if the settings allow it.

Once you hold those four apart, "project memory not working" resolves into something specific almost immediately. Most of the time the store you are complaining about is not the store you configured.

Cause 1: The Chat Is Not In the Project

The first thing to check, because it is common, embarrassing and invisible.

Starting a new chat from the sidebar, from a keyboard shortcut, or from the home screen gives you a chat that is not in the Project, even if you were looking at the Project a moment earlier. It has no project instructions and no access to project files, and it looks exactly like any other chat, because it is one.

Check: open the chat and confirm it is listed under the Project rather than in your general history. Fix: start the chat from inside the Project. If it is a chat you want to keep, move it into the Project rather than recreating it.

People dismiss this one and then find it accounts for half their examples. Check it first and you save yourself the other five.

Cause 2: Expecting Extraction Where There Is Only Instruction

This is the big one, and it is structural rather than a bug.

Project instructions are re-supplied. They apply to every chat in the Project because they are handed to the model at the start of each one. Nothing has to be remembered for that to work, which is why it works.

What happened inside a previous chat is a different matter. Unless something wrote it down, the chat ended and its contents went with it. Your Project does not accumulate a running summary of what its conversations concluded. So you can spend an hour in a Project chat establishing an approach, agreeing constraints and rejecting two alternatives, open a new chat in the same Project the next morning, and get a confident proposal of one of the alternatives you rejected.

Check: name something specific you expect continuity on, and ask yourself where it is written. Project instructions? A file? Or only in a transcript?

Fix: promote it. At the end of a session that decided something, write the decision into the project instructions or into a file attached to the Project. That is the only mechanism that carries state forward reliably, and it is the same discipline you would apply to a shared document for a human colleague. Comparing how the three major assistants handle this is the subject of ChatGPT Memory vs Claude Projects vs Gemini Gems.

Cause 3: Attached Files Are Retrieved, Not Memorised

A subtle one that produces intermittent behaviour, which is the worst kind to debug.

Uploading a document to a Project does not place its contents permanently in front of the model. The document is stored, and relevant parts are pulled in when a question appears to call for them. When retrieval picks the right passage the effect is indistinguishable from memory. When it does not, you get an answer that ignores a file you can see sitting there.

This explains the specific complaint "it knows the file exists but not what is in it". Both of those can be true at once.

Check: ask a question whose answer appears in one distinctive sentence of the document, using wording close to the document's own. If that works and your broader questions do not, retrieval is your issue rather than storage.

Fix: two levers. Make the important material easy to retrieve: short, explicit, well-headed, near the top, stated in the vocabulary you will actually use in questions. And put anything that must always apply into the instructions rather than a file, because instructions are supplied unconditionally while files are supplied when something matched.

Long reference documents are the worst case here. A forty-page attachment is not forty pages of context; it is forty pages from which a few passages may be selected.

Cause 4: The Global Switch Is Off, or the Chat Is Temporary

Two account-level states that make every store below them irrelevant.

If the memory feature is switched off in settings, nothing is extracted from any conversation, in a Project or out of it. If you are in a temporary chat, nothing is saved from it either, by design.

Check: open your settings and read the memory controls rather than trusting a label quoted from an article, including this one. Their names and placement have moved between product versions and vary by account type. The full tour of what each control reaches is in ChatGPT Memory Settings: Complete Control Guide.

Fix: turn on what you need, and be aware that the isolation question lives here too. The controls governing whether chats can draw on your saved memory and on your earlier conversations are what decide whether a Project is a sealed room or a window onto everything else. If unrelated context keeps appearing inside your Project, this is the screen where the answer is, and it is the store to inspect before anything else.

Cause 5: The Saved Memory List Is Full

Capacity produces a distinctive symptom: things used to be saved and now they are not, with nothing else having changed.

The saved memory list has a cap. The exact limit is not published, so treat any specific number you see quoted with suspicion. What is observable is the behaviour: once the list is at capacity, new saves stop landing.

Check: open the memory list and look at its length and its age. A list full of entries from projects you finished months ago is a list with no room for the one you are working on now.

Fix: prune deliberately rather than clearing wholesale, removing finished-project entries and superseded preferences before anything you still rely on. The broader diagnostic sequence for saves that never land is in How to Fix ChatGPT Memory Issues, and the case where the save fails loudly rather than silently is in ChatGPT User Not Found for Bio Error.

Cause 6: You Are Testing in the Wrong Place

The false negative that wastes the most time.

You change a setting, update your instructions, delete an entry, then go back to the chat you already had open and see the old behaviour. Of course you do. That conversation's context window still contains everything that was in it before you changed anything, and the model can see all of it.

Check: is this a genuinely new conversation, started inside the Project, since the change?

Fix: test in a new chat in the Project, every time. Anything else proves nothing, and a surprising number of "it did not work" conclusions dissolve here.

The Order Worth Testing In

Putting it together as a sequence, cheapest and most likely first:

1. Confirm the chat is in the Project. Look at where it is filed, not at where you thought you started it.
2. Open a genuinely new chat in the Project before judging anything.
3. Read your memory settings and note which controls are on. This answers the isolation question and rules out the global off switch.
4. Ask which store should hold the thing you expected. Instruction, file, saved memory or context window. If the answer is "a previous transcript", that is your bug and the fix is to write it down.
5. Probe retrieval with a narrow question aimed at one distinctive line of an attached file.
6. Check the memory list for length. Full lists stop accepting new entries.
7. Only then suspect a fault, and re-test once more in a new chat before you do.

Six of those seven steps are free and take under a minute. The seventh almost never fires.

Why Project Scoping Is Awkward By Nature

Worth naming, because it explains why this keeps happening rather than being fixed once.

Scoped memory is a genuinely hard product problem. Too global and your work project contaminates your personal chats, which people find unsettling. Too local and the assistant forgets things you consider obvious, which people find useless. Vendors move the boundary, rename the controls, and change defaults between versions, and the result is that advice written six months ago describes a screen that no longer exists.

That has a practical consequence for you. Reasoning about what each store is survives the churn. Memorising which toggle sits where does not. If you keep the four scopes clear in your head, you can walk into any version of the interface and work out what you are looking at.

Keeping Project Context Where You Can Read It

There is a version of this problem that no amount of toggle-hunting fixes. If what you actually need is "every new chat starts knowing the state of this project", you are asking for something the memory feature was not built to do: it extracts scattered facts on its own initiative, with no notion of a project, no expiry and no ordering.

The alternative is to keep that state in a document you control and supply it deliberately. That is what MindLock does. You save the conversations that mattered with Ctrl or Cmd plus S, or with the one-click button from the sideloaded Chrome extension, upload them, and distillation produces compact memory documents covering decisions, constraints and current state. Generating a context block from the relevant memories gives you a paragraph or two you paste as the first message of a new chat, in any assistant rather than only the one that stored it.

Two caveats stated up front, because both are easy to assume otherwise. Nothing is automatic: saving is a keystroke you press, and memory documents update when you re-run distillation, not continuously. And this does not change anything inside your ChatGPT account: the settings are still the settings. What it changes is your dependence on them. What memory documents contain and how distillation organises them is walked through in Memory Documents.

The Short Version

Project memory is not one feature. It is four stores with four scopes, and nearly every failure is an expectation aimed at the wrong one.

Instructions apply because they are re-supplied. Files are retrieved selectively, not memorised, so the important lines need to be findable. The saved memory list is global to your account and governed by settings whose names move. Previous chats in a Project leave nothing behind unless you wrote it down.

So check that the chat is actually in the Project, test in a genuinely new one, read your own settings screen, and ask which store was supposed to be holding the thing you missed. If the answer is "an old transcript", the fix is not a toggle. It is writing the decision somewhere that gets supplied on purpose.