Fastest fix: decide which scope you want the info to live in, then put it in the matching layer — Project Instructions for “every chat in this Project,” Project Files for reference material, account Memory for “everywhere,” and the current message for “just this chat.” Most “the Project ignores my rule” reports are a wrong-layer mistake; most “this chat knows something it shouldn’t” reports are Project memory pulling in another chat. Both are fixed by checking the five layers below in order.
ChatGPT (as of June 2026) has five context layers, not four:
- Saved memories — account-level facts ChatGPT stored (
Settings → Personalization → Memory → Reference saved memories). - Reference chat history — a separate account-level toggle that lets new chats draw on your past chats (
Settings → Personalization → Memory → Reference chat history). - Custom Instructions — your global style/role, applied on top of everything except where a Project overrides scope.
- Project — Project Instructions + Project Files + (since Aug 2025) Project memory that can let chats inside the same Project reference each other.
- Current Chat — the message history of the conversation you’re in.
The big change since this pattern first appeared: chats in the same Project are no longer fully isolated. Projects ship with a per-Project memory setting, so a new chat in a Project can quietly inherit context from sibling chats. That flips the old “why doesn’t chat B know what chat A said” question into its opposite for many users: “why does chat B know it.” The layers below cover both directions. (Projects are a Plus/Pro feature; the Free plan has no Projects, so if you don’t see the Projects section in the sidebar, that’s why.)
Which bucket are you in
| Symptom | Most likely layer | Jump to |
|---|---|---|
| Rule I put in the Project is ignored in a chat | Wrong layer, or a strong in-chat message overrode it | Causes 1, 6 |
| A chat “remembers” something from another chat I didn’t expect | Project memory or Reference chat history | Causes 2, 3 |
| Behavior leaks across different Projects | Saved memories (account-wide) | Cause 4 |
| Files are uploaded but never cited | On-demand retrieval, not auto-loaded | Cause 5 |
| Personal vs Team Workspace behave differently | Workspace isolation | Cause 7 |
| A Custom GPT inside a Project ignores Project rules | Two separate rule sets | Cause 8 |
Common causes
Ordered by hit rate, highest first.
1. Info put in the wrong layer entirely
You wrote a rule into one chat expecting it to apply Project-wide, or into Custom Instructions expecting it to apply only to one Project. Each layer has a fixed scope; putting info in the wrong one means it either does nothing or leaks.
How to spot it: open a brand-new chat in the Project with no typing of your own and ask “what standing rules apply here?” If the rule isn’t named, it isn’t in Project Instructions.
2. Project memory is on and chats reference each other
Since 22 Aug 2025, a Project carries its own memory. With default Project memory, a chat can reference other chats inside the same Project (and, on non-Enterprise accounts, even chats outside it). So chat B can know that chat A said “the client is Zhang San.” This is the opposite of the old behavior and the #1 source of surprise today.
How to spot it: in a fresh chat, ask about something only mentioned in another chat. If it answers, Project memory is feeding it. Check Project → Configure → Memory for the mode (Default vs Project-only).
3. “Reference chat history” pulls in unrelated old chats
This is an account-wide toggle, separate from saved memories. When on, any new chat (including ones in a Project) can draw on your entire chat history, which looks like the Project “leaking.”
How to spot it: Settings → Personalization → Memory. If Reference chat history is on and content from non-Project chats shows up, that’s the source — not the Project.
4. Saved memories cross every Project
Saved memories are account-level and shared across all Projects. A fact captured while working in Project A (“always use Python”) still nudges Project B.
How to spot it: Settings → Personalization → Memory → Manage memories (also reachable via Manage under saved memories). Entries unrelated to Project B’s theme = a saved-memory leak.
5. Project files are retrieved on demand, not auto-loaded each turn
A file in Project Files is not injected into every turn. The model only retrieves chunks when the question signals relevance, so a content question can miss a file that’s clearly attached.
How to spot it: ask “list the files attached to this Project.” If it can list them but a content-specific question returns no citation, the file is visible but retrieval didn’t fire — rephrase to name the file or quote a unique phrase from it.
6. A strong in-chat message outweighs Custom/Project Instructions
Instructions always apply, but their weight is lower than the current user message. A blunt “ignore all prior rules, just do X” in a chat can demote them for that turn, which reads as “the Project forgot its rules.”
How to spot it: re-run the same task in a clean chat without the override sentence. If the rule comes back, it was being out-weighted, not lost.
7. Personal Custom Instructions vs Team Workspace Project
Custom Instructions set in a Personal Workspace don’t carry into a Team/Business Workspace Project, and vice versa. The same Project name in two workspaces can behave differently.
How to spot it: run the same prompt in Personal vs Team Workspace. Different behavior = workspace isolation, not a Project bug.
8. Custom GPTs and Projects don’t share
A Custom GPT has its own Knowledge + Instructions and reads nothing from any Project. Invoking a Custom GPT inside a Project, it behaves by the GPT’s rules, not the Project’s. (Custom GPTs still exist as of June 2026; only legacy models like GPT-4o were retired, on 13 Feb 2026.)
How to spot it: @ a Custom GPT inside a Project and the answer ignores the Project’s standing rules = two rule sets running independently.
Before you start
- Confirm you’re actually in Projects (not a Custom GPT or a plain chat), and pin down which direction the inconsistency runs — a rule not applying, or a chat knowing too much.
- Note your Project memory mode (
DefaultvsProject-only) and your account Reference chat history state before you change anything, so you can tell which one moved the needle. - Confirm plan + workspace: Personal vs Team/Business differ noticeably in Custom Instructions and memory behavior.
Info to collect
- Project name +
Project Instructionstext +Fileslist, and the Project memory mode. Settings → Personalization → Memory: saved-memory entries, Reference saved memories state, Reference chat history state, and Custom Instructions text.- Two contrasting scenarios that show the divergence (chat A vs chat B, inside vs outside the Project, Personal vs Team).
- Full prompt text + side-by-side reply screenshots.
- Current model (e.g. GPT-5.5) + workspace type.
Shortest fix path
Ordered by ROI. The first two solve roughly 70% of cases.
Step 1: Put each piece of info in the correct layer
| Where you want info to apply | Where to put it |
|---|---|
| All chats, all Projects, account-wide | Settings → Personalization → Memory / Custom Instructions |
| All chats inside this Project | Project Instructions |
| Reference material for all chats in this Project | Project Files |
| Just this chat | Say it directly in the chat |
| Cross-account / shared workflow | Custom GPT |
Wrong layer = leak or no effect.
Step 2: Decide whether chats in the Project SHOULD share context
This is the new fork. Open Project → Configure → Memory:
- Want sibling chats to build on each other (research log, ongoing project) → keep Default memory.
- Want each chat isolated and no outside memory bleeding in (client work, separate clients) → set Project-only memory.
Project-only memory blocks your general/saved memories from the Project and keeps the Project’s context inside the Project. Note: sharing a Project forces it to Project-only and it can’t be reverted — plan around that before you share.
Step 3: When debugging “why is this chat different,” check all five layers
1. Is the rule in Project Instructions?
-> Project -> Configure -> Instructions
2. Is the Project memory mode Default or Project-only?
-> Project -> Configure -> Memory
3. Is account "Reference chat history" on?
-> Settings -> Personalization -> Memory
4. Is it in saved memories?
-> Settings -> Personalization -> Memory -> Manage memories
5. Did I say it earlier in THIS chat?
-> Scroll the message historyOnly after all five do you know which layer produced the behavior.
Step 4: To persist info across chats, write it to the Project — don’t rely on memory
- Short rules ->
Project Instructions. - Long material / tables / docs ->
Project Files. - Cross-Project / cross-account -> Custom GPT Knowledge.
Project memory is a convenience, not a contract — it summarizes, it doesn’t store verbatim. Anything that must be present every turn belongs in Instructions or Files.
Step 5: Stop leaks across Projects
If a saved memory keeps nudging the wrong Project: delete the entry (Manage memories), or set the affected Project to Project-only so account memories can’t reach it. Keep saved memories for genuinely universal preferences (“reply concisely,” “use US English”) and audit them monthly. Business preferences (“use React”) belong in Custom Instructions, not saved memories.
Step 6: Move high-constraint workflows to a Custom GPT
Project + plain chat is too loose for “must follow 100%” cases. Customer-service scripts, compliance review, strict output templates → Custom GPT:
- Instructions carry more weight.
- Knowledge retrieval is more deterministic.
- Sharing gives everyone the same version.
Step 7: Declare scope at the top of a chat when you need a clean run
For this conversation, ignore my saved memories and custom instructions.
Follow only these rules:
1. ...
2. ...
Task: <X>The model won’t obey “ignore memory” with 100% reliability, but the explicit declaration tilts weight toward the current message — and pairing it with a Project-only Project removes the leak at the source rather than asking the model to suppress it.
How to confirm the fix
- Run the same prompt in a different Project — it follows that Project’s Instructions and doesn’t carry over this Project’s content = isolation works.
- Set a Project to Project-only, delete the related saved memory, and re-run cross-Project — behavior diverges = the cross-Project leak is closed.
- Have a colleague run the same prompt in their copy of a shared Project — consistent output = the config truly lives in the Project layer, not in your personal memory.
If still broken
- Rebuild the Project clean: new Project, paste trimmed
Instructions, re-uploadFiles, Project-only memory, no carry-over. - Temporarily turn off Reference saved memories and Reference chat history, re-run the prompt, and compare — this isolates whether an account-level memory toggle is the leak.
- Switch Workspace (Personal vs Team) and re-run to confirm whether the workspace is interfering.
- Package screenshots of all five layers + the behavioral diff and file a ticket at help.openai.com.
FAQ
Do chats in the same Project share context now? Yes, by default. Since 22 Aug 2025 a Project has its own memory, so a new chat can reference sibling chats. If you don’t want that, set the Project to Project-only memory (which also blocks your general memories from entering). The pre-2025 “chats are fully isolated” rule no longer holds.
Why does one chat know something I only said in another chat?
Either Project memory (sibling chats inside the same Project) or the account-wide Reference chat history toggle (any past chat). Check Project → Configure → Memory first, then Settings → Personalization → Memory.
What’s the difference between saved memories and “reference chat history”?
Saved memories are explicit facts ChatGPT stored and you can edit in Manage memories. Reference chat history is a broader, separate toggle that lets new chats draw on your past conversations without an explicit saved entry. They’re controlled independently in the same Memory panel.
I can’t find the Project memory setting — where is it?
Project → Configure (the Project’s settings panel), then the Memory option. The default vs project-only choice is also offered when you first create the Project. If you have no Projects at all, you’re on Free — Projects require Plus or Pro.
Why are my Project files ignored in some answers?
Files are retrieved on demand, not loaded every turn. Name the file or quote a unique phrase from it so retrieval fires; “summarize spec.pdf” beats “summarize the spec.”
Does sharing a Project change its memory? Yes. Sharing forces the Project to Project-only memory and it can’t be reverted. Shared collaborators see the same files, instructions, and Project chats, but none of your personal memories outside the Project.
Prevention
- Lock in the current mental model: saved memories + reference chat history = account-global; Custom Instructions = global style; Project = per-Project shared instructions, files, and memory; Chat = the live conversation.
- Before adding info, ask “what scope should this apply to?” and pick the layer accordingly.
- Choose the Project memory mode deliberately at creation: Default for cumulative work, Project-only for isolated/sensitive work.
- Audit saved memories monthly; delete expired or one-off entries.
- Put anything that must appear every turn in
Project InstructionsorProject Files, not in memory. - Send high-constraint workflows to a Custom GPT instead of arguing with a Project.
Related reading
- ChatGPT project instructions ignored
- ChatGPT memory not working
- ChatGPT project files not referenced
- ChatGPT Projects
- ChatGPT file analysis
- ChatGPT Projects advanced workflow
Tags: #ChatGPT #ChatGPT files #Troubleshooting #Debug #Projects #Context scope