Does Claude Remember Other Chats in the Same Project?
You put a Project together, had a long conversation inside it that settled several things, and came back the next day to a new chat in the same Project that behaved as though none of it had happened. The files are still attached. The instructions are still there. But the reasoning you did yesterday is gone, and you are wondering whether Projects are supposed to work this way.
They are, and the reason is worth understanding properly, because it is not a limitation anyone is going to patch. A Project is a container with shared materials, not a conversation that continues across sessions. Those are different things, and the gap between them is where nearly every complaint about project memory lives.
This post separates what a Project shares from what it does not, gives you a test that settles the question in your own account in two minutes, and covers the patterns that make the boundary tolerable.
Three Questions Hiding in One
"Does Claude remember other chats in the same Project" turns out to be at least three questions, and they have different answers.
"Does it have access to the materials I put in the Project?" Yes. That is what a Project is for. Instructions and attached documents are project-level, and chats inside the Project can draw on them.
"Does it know what a previous chat in this Project concluded?" Not from the transcript itself. A conversation that ends leaves the Project exactly as it found it unless something wrote a conclusion into the shared materials.
"Can it pull from my chats in general, inside or outside the Project?" This depends on account-level features rather than on anything in the Project, on your plan, and on settings whose names and availability have moved more than once. Your own account is the only reliable authority here.
Work out which of the three you are asking before you change anything. People reporting that "Projects do not remember" are almost always asking the second question while reading documentation that answers the first.
What a Project Actually Shares
The useful way to hold this is by scope: what each thing covers, and when it gets supplied.
Project instructions. Scope: every chat in the Project. They are supplied at the start of each conversation, which is exactly why they behave predictably. Nothing has to be remembered for instructions to work; they are handed over fresh every time.
Project knowledge — the documents you attach. Scope: available to chats in the Project. Crucially, these are drawn on selectively rather than held open in full. When the right passage is picked up, it is indistinguishable from memory. When it is not, you get an answer that ignores a file you can see sitting in the sidebar.
The conversation you are in. Scope: that conversation only. It holds what has been said so far plus whatever was supplied at the start, and it is emptied by starting a new chat. Long chats also run out of room, at which point the earliest exchanges stop being visible to the model.
Anything account-level. Scope: your account, not the Project. If your plan and settings give Claude any ability to draw on past conversations, that capability is not something a Project grants or withholds, and it is governed on the settings screen rather than in the Project.
Once those four are clear, the answer to the headline question resolves immediately. Other chats in the Project are not one of the four. They are transcripts sitting in a list, visible to you, not supplied to the model in a new conversation.
The Two-Minute Test
Do not take this post's word for it, and do not take the word of an article written against a different version of the product. Test it in the account you actually use.
- Open a chat inside the Project and establish something distinctive that appears nowhere in your instructions or attached files. A made-up constraint works well: a nonsense codename for a component, an invented deadline, a rule you would never otherwise write down.
- Confirm it took: ask a follow-up in the same chat and check that the answer honours the constraint.
- Start a new chat from inside the Project. Not from the sidebar, not from the home screen, not from a keyboard shortcut — those can give you a chat that is not in the Project at all, which would invalidate the test.
- Ask a question whose correct answer requires the distinctive thing.
If the new chat knows it, something in your account is carrying context across conversations and you should go and read which setting is responsible. If it does not, you have confirmed the default: transcripts do not cross conversation boundaries, and the Project is a shelf rather than a thread.
Run this again after any product update that claims to change memory behaviour. A two-minute test in your own account beats any amount of reading, and it is the same discipline recommended in Does Claude Remember Previous Conversations?.
Why Attached Documents Feel Like Inconsistent Memory
This is the subtlest part, and it produces the intermittent behaviour that makes people think memory is half-working.
Attaching a document to a Project does not place its contents permanently in front of the model. The material is stored, and relevant parts are drawn in when a question appears to call for them. That selection step is invisible to you. When it picks well the effect is perfect recall; when it picks badly you get an answer that contradicts a document you uploaded yourself, and nothing on screen tells you which just happened.
This explains the specific complaint "it knows the file is there but not what is in it". Both halves can be true at the same time.
Check: ask a narrow question aimed at one distinctive sentence in one document, phrased close to that document's own wording. If narrow questions work and broad ones do not, your problem is retrieval rather than storage, and adding more documents will make it worse rather than better.
Fix: two levers. Make important material easy to find — short, explicit, well-headed, near the top, written in the vocabulary you will actually use when asking. And promote anything that must always apply into the instructions, which are supplied unconditionally, rather than leaving it in a file, which is supplied when something matched.
A forty-page reference attachment is not forty pages of context. It is forty pages from which a few passages may be selected.
The Habit That Closes the Gap
If previous chats leave nothing behind, then continuity is something you produce rather than something you receive. The mechanism is unremarkable and it works.
End sessions with a promotion step. When a conversation settles something — an approach chosen, a constraint discovered, two alternatives rejected and why — write it into the project instructions or into a document attached to the Project before you close the tab. Five minutes at the end of a session is the entire cost, and it is exactly the discipline you would apply to a shared document for a human colleague who was not in the room.
Keep a decision log as project knowledge. One document, reverse-chronological, one short entry per session: what was decided, what was ruled out, what is still open. This does more work than any other single file, because it is written in the vocabulary of the questions you will ask later.
Ask for the summary rather than writing it. At the end of a working session, ask for a short summary of what was decided and what remains open, check it, and paste it into the log. The assistant is good at this and you are tired.
Re-state constraints at the start of long chats. Cheap insurance. Anything you would be annoyed to see violated belongs in the first message of a conversation, not solely in a transcript from last week.
None of this is exciting, and all of it is more reliable than waiting for a memory feature to cover the case. The comparison across the three major assistants, including how Projects stack up against the alternatives, is in ChatGPT Memory vs Claude Projects vs Gemini Gems.
What Goes Wrong in Practice
Four failure patterns come up repeatedly once people start relying on Projects.
The chat was never in the Project. Common, invisible and slightly embarrassing. A conversation started from the sidebar looks identical to one started inside the Project, and it has neither the instructions nor the documents. Check where the chat is filed before you conclude anything about what it should have known.
The Project became an attic. Everything ever produced gets attached, retrieval quality falls, and the Project answers worse than it did when it held three documents. Prune on a schedule. A Project is a working set, not an archive.
Instructions and documents disagree. The instructions say one thing, a six-week-old attachment says another, and which one you get depends on the question. Whenever you change direction, update both.
Continuity is assumed rather than tested. Someone reads that a memory feature exists, assumes it is on, and stops promoting decisions. Weeks later a decision quietly evaporates. Features vary by plan and roll out unevenly; the two-minute test above costs less than finding out the hard way. What Claude retains by design is covered in more depth in What Claude AI Actually Remembers.
When the Boundary Is Not the Problem You Have
There are two situations where tuning your Project will not get you anywhere, and it is worth recognising them early.
The first is working across assistants. A Project is a container inside one product. If you draft in one assistant and review in another, no project-level feature will carry context between them, because there is no shared surface for it to travel through. The practical pattern for splitting work across two assistants is in Using ChatGPT and Claude Together.
The second is wanting your context to outlive any one vendor's decisions. Memory features get renamed, re-scoped, gated to plans and occasionally withdrawn. Anything important that lives only inside a provider's store is exposed to a roadmap you do not control.
Keeping Project Context in Something You Own
If what you actually want is "every new chat starts knowing the state of this work", that is a document problem rather than a memory-feature problem, and it can be solved the same way regardless of which assistant you open.
That is the approach MindLock takes. 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 Claude, in ChatGPT, in Gemini, in whatever you are using that day.
Two caveats stated plainly, 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 reach inside your Claude account or change how Projects behave. What it changes is whether the state of your work depends on them. How a context block is assembled and what goes into it is walked through in Generating Context, and where local processing ends and cloud processing begins is set out on the pricing page.
The Short Version
A Project shares materials, not conversations. Instructions apply to every chat in it because they are re-supplied each time. Attached documents are available to every chat but drawn on selectively, which is why they feel like memory some days and not others. A previous chat in the same Project leaves nothing behind — its transcript is a record for you, not an input for the model.
Anything that does carry across conversations is an account-level capability governed on your settings screen, varying by plan and by version, and the only way to know what your account does today is to test it: establish something distinctive, start a genuinely new chat from inside the Project, and ask.
Then close the gap the boring way. Promote decisions into the instructions or a decision log at the end of each session. It takes five minutes, it survives every rename and rollout, and it works the same in every assistant you use.