You open a fresh chat inside a Claude Project to ask about Topic B, and Claude keeps citing facts from Topic A — a chat you had two days ago in the same Project. Or worse, it surfaces a client name or a codebase path that has no business being in this new task. This is not a bug; the Project model shares context by design, and as of 2026 it shares it through five different surfaces, not one.
Fastest fix: the single most common 2026 cause is project memory — each Project keeps its own auto-synthesized summary that pulls facts across every chat in that Project. Go to Settings -> Capabilities, click View and edit memory, switch to the polluted Project’s memory, delete the offending entry (or Pause memory for that Project), then start a new chat. If that does not clear it, work down the table below.
Which surface is leaking? (decision table)
Five things share context across chats in a Project. Identify yours before you start deleting anything.
| Symptom | Likely surface | Where to look |
|---|---|---|
| Claude states a fact you never put in a file (e.g. “you mentioned earlier you’re targeting CFOs”) | Project memory | Settings -> Capabilities -> View and edit memory |
| Claude quotes a document verbatim | Project knowledge (Files) | Project page, Files section |
| Claude follows a rule you didn’t ask for (“always cite the Acme contract”) | Project instructions | Project page, Instructions |
| Claude says “in an earlier conversation you said…” and is roughly right | Search and reference chats | Settings -> Capabilities -> Preferences |
| Claude reads files/code you didn’t paste | Connected sources | Project settings, Connected sources |
| There are prior turns above your message | You’re in an old chat | URL /chat/<id> vs sidebar |
Common causes
Ordered by hit rate, highest first for 2026.
1. Project memory carries facts across every chat in the Project
This is the big one and it is new since the original guidance. Claude now keeps a separate memory summary per Project, synthesized automatically (Anthropic runs the synthesis roughly every 24 hours) from your chats in that Project. So even with empty Files and trimmed Instructions, a Topic B chat can still get primed by what you said about Topic A — memory remembered it.
Good news on scoping: per Anthropic’s docs, standalone-chat memory does not leak into Projects, and each Project’s memory is isolated from other Projects. The leak you’re seeing is within one Project’s own memory.
How to judge: Settings -> Capabilities -> View and edit memory, then switch to the Project in question. If the polluting fact is listed there, memory is your culprit.
2. Project knowledge (Files) contains documents from the prior topic
Anything in the Project’s Files section (uploaded files, pasted text) is available to every chat in that Project. If Topic A’s spec PDF is still there, Topic B chats are primed by it. (As of June 2026, individual files can be up to 30 MB; when total knowledge approaches the context window, paid plans auto-switch to retrieval mode and pull only the most relevant chunks — which is why a doc you “forgot about” can still surface.)
How to judge: Open the Project page and look at the Files section. Everything listed is in scope for every chat.
3. Project instructions encode topic-specific rules
The Project’s Instructions field is prepended to every chat. If it says “always cite the Acme contract,” every chat inherits that, including unrelated ones. (The field holds roughly 8,000 characters; people often paste far too much into it.)
How to judge: Open the Project, click Instructions, read the full text. Anything topic-specific is leaking.
4. “Search and reference chats” is pulling from older chats
On paid plans (Pro, Max, Team, Enterprise), the Search and reference chats capability lets Claude search your past conversations and quote excerpts into the current chat. Inside a Project, that search is scoped to that Project’s chats — so a Topic B chat can quote a Topic A chat. It normally only fires when you prompt for it, but a vaguely worded request (“what did we decide?”) can trigger it.
How to judge: Settings -> Capabilities -> Preferences. If the toggle next to Search and reference chats is on, it is a candidate.
5. You started a “new chat” but actually continued an old one
Clicking the wrong item in Claude’s UI sometimes opens an old chat as if it were fresh. The chat list highlights one item; that is the one you are in.
How to judge: Look at the URL — /chat/<id> — and compare to the sidebar selection. If there are existing turns above your message, this is not a new chat.
6. Long-running chat carried context into a thread that “feels” new
Inside a single chat, even if you scroll back and start a new topic mid-thread, Claude still sees all prior turns. The chat does not auto-reset between topics.
How to judge: Scroll up. If there are 30+ turns above your latest message about other topics, those are all in context.
7. A connected source (GitHub, Google Drive) re-pulls older content
If you connected a repo or Drive folder to the Project, Claude can re-read it at chat time. Updated docs are seen, but so is unrelated content in that source.
How to judge: Project settings → Connected sources. Each listed source is potentially in scope.
Before you start
- Decide whether you want pollution gone permanently (clean the Project) or just for this one chat (use a new isolated chat, or
Incognito chatfor standalone work). - Snapshot anything important from the Files section before deleting — uploads are not always recoverable.
- Note whether the leak affects one chat or every chat. That determines whether you fix the Project or just this chat.
- Know the irreversible button: in memory settings, Reset memory permanently deletes all memories including project memories. Prefer per-entry deletion or Pause memory first.
Information to collect
- Exact wording of the polluting reference (so you can search memory and Files for it).
- Which chat the leak occurred in (URL with chat ID).
- The Project’s Instructions, full text.
- List of Files and Connected sources.
- Whether Search and reference chats is on (
Settings -> Capabilities -> Preferences). - Whether the chat was actually new (no prior turns) or a long-running thread.
Step-by-step fix
Step 1: Confirm it is really a “new” chat
Look at the chat. If there are turns above yours, it is not new — start one. Click the Project name, then New chat inside the Project. The URL should change to a fresh chat ID with no prior messages.
Step 2: Clear or pause the polluting project memory
This is the step most old guides miss. Go to Settings -> Capabilities and click View and edit memory. Switch to the polluted Project’s memory summary. Then either:
- Delete the specific offending entries (click an item to edit or remove it), or
- Toggle Pause memory for that Project (keeps existing memory but stops Claude from writing new memories), or
- As a last resort, Reset memory — but note this wipes all project memories, not just one, and is irreversible.
After editing memory, start a fresh chat so the new (smaller) summary is the one injected.
Step 3: Read the Project’s Instructions
Open the Project and click Instructions. If they contain anything topic-specific (“treat the user as the CFO of Acme,” “always reference the Q3 launch plan”), that text is prepended to every chat. Either:
- Remove the topic-specific lines, keeping only durable rules, or
- Move that chat outside the Project entirely.
Step 4: Audit the Files section
Open the Project’s Files section. For each item, ask: “Should this be present in every chat in this Project?” If no, remove it. Common offenders:
- One-off spec PDFs uploaded for a single chat
- Pasted transcripts from earlier conversations
- Old contracts or client briefs no longer relevant
Project knowledge is shared across chats — it is not per-chat.
If a doc is only relevant to one chat, attach it to that chat directly instead.Step 5: Turn off “Search and reference chats” (or prompt more precisely)
If the leak reads like a quote from a past chat, go to Settings -> Capabilities -> Preferences and toggle Search and reference chats off. If you still want the feature globally, instead avoid open-ended prompts like “what did we decide?” inside the polluted Project, since those invite Claude to go searching prior chats.
Step 6: Use per-chat attachments instead of project knowledge
When you only need a document for one chat, attach it to the chat message itself (the paperclip icon). It affects only that chat, not the whole Project.
Step 7: Scope sensitive topics to separate Projects
If you have two bodies of content that should never mix (Client A vs Client B, work vs personal), make two Projects. Project memory and knowledge are per-Project, so separate Projects stay isolated; one shared Project will always cross-contaminate.
Project: Acme Q3 Launch -> Files: launch brief, deck, comms
Project: Beta Internal Tooling -> Files: repo docs, RFCs, ADRsStep 8: For truly sensitive one-offs, use an Incognito chat
For a standalone question you don’t want saved to memory or history at all, start a chat outside any Project and click the ghost icon in the upper-right to enter an Incognito chat (a black border and an “Incognito chat” label confirm it). Note the limit: as of June 2026 Incognito is only available for chats outside Projects — you will not see the ghost icon inside a Project.
Step 9: Disable or narrow connected sources
Project settings → Connected sources. If a connected GitHub repo is huge, Claude can pull unrelated files into context when it searches. Either disconnect the source for this Project or narrow it to specific paths if the connector supports it.
How to confirm it’s fixed
- Start a new chat inside the Project and ask a meta question: “What context do you have from this Project right now?” Claude should describe only what should be in scope.
- Run a control: ask about Topic A — Claude should still know A if A is genuinely the Project’s subject, but should not retain residue from removed knowledge or memory.
- Re-run the original failing prompt; the leaked term should not appear.
- Wait a few minutes and retry. Memory synthesis runs on a cycle (roughly daily), and the index that backs Files can take a short while to refresh after a deletion.
Long-term prevention
- One Project, one topic. Resist dumping everything into a single “Personal” Project.
- Use per-chat attachments for one-off documents instead of project knowledge.
- Keep Project Instructions to durable rules only (“respond in English,” “be concise”), never topic-specific facts.
- Periodically prune both Files and project memory — every quarter, remove stale uploads and outdated memory entries.
- For client work, name Projects with a client prefix so you do not accidentally chat in the wrong one.
- Treat project knowledge and memory as “always-on background” and the chat itself as “today’s focus.”
Common pitfalls
- Assuming “new chat” means “blank slate” — inside a Project it never does; project memory and Files persist.
- Forgetting that project memory exists. Cleaning Files but not memory leaves the most common 2026 leak in place.
- Pasting transcripts into Instructions thinking they’ll be “remembered” — they leak into every chat instead.
- Connecting an entire GitHub org as a Project source. Far too broad.
- Hitting Reset memory to fix one Project and wiping every Project’s memory by accident.
- Deleting a knowledge file and not waiting for the index to refresh; Claude may still cite it briefly.
- Confusing chat carry-over (per-chat), project memory (per-Project), and standalone memory (outside Projects) — three different scopes.
FAQ
- Why does Claude reference something I never uploaded? Almost always project memory. Each Project keeps a memory summary synthesized from your chats in it. Edit it at
Settings -> Capabilities -> View and edit memory. - Does deleting a chat remove its content from Project memory? No. Deleting a chat removes that chat from history. Project memory may have already absorbed the relevant facts; clear them separately in memory settings.
- Does standalone chat memory leak into my Projects? No. Per Anthropic’s docs, standalone memory and project memory are isolated, and each Project’s memory is separate from other Projects’.
- Can I use Incognito chat inside a Project to avoid pollution? No. As of June 2026 Incognito works only for chats outside Projects. Inside a Project, use a fresh chat plus a cleaned memory instead.
- Why does Claude sometimes “forget” project knowledge? Two reasons: context-window pressure in very long chats summarizes older content away, and when total knowledge is large, paid plans switch to retrieval mode and only pull the chunks it judges relevant. Start a fresh chat, or make the relevant file more obviously on-topic.
- Is there a way to scope knowledge to certain chats only? Not for project knowledge. Use per-chat attachments for one-off docs.
Related
- Claude Projects guide
- Claude Code lost project context mid-task
- Claude beginner guide
- Claude prompt best practices
- Claude Skills Not Firing When Expected
Tags: #Claude #Troubleshooting #Projects