AI AI Tools Guidebook
Troubleshooting

ChatGPT Project Context vs Chat Context — When They Diverge

You set instructions and files in a Project, but a chat inside the Project ignores them. Here's how the two scopes really interact.

Published: Author: AI Productivity Guide Team 🌐 查看中文版本

ChatGPT has four context layers: global Memory, Custom Instructions, Project (instructions + files), current Chat (message history). Project is a wrapper around all its chats; each chat also has its own ephemeral message state. “I set it in the Project but the chat ignores it” is almost always a wrong-layer problem — Projects share instructions and files but not messages; Memory crosses all Projects; Custom Instructions apply everywhere except Custom GPTs. Once the four layers are clear, “why is this chat different” becomes a systematic check.

Common causes

Ordered by hit rate, highest first.

1. Expecting chats in the same Project to share message history

The most common misunderstanding. Chat A in a Project said “the client’s name is Zhang San,” chat B knows nothing about it. The model doesn’t read other chats — only the current chat + Project Instructions + Files + Memory.

How to spot it: In chat B, ask “what’s the client name I mentioned in the last chat?” — can’t answer = by design.

2. Memory crosses Projects and affects behavior

Memory is account-level, shared across all Projects. In Project A you taught it “always use Python,” now in Project B it still leans Python.

How to spot it: Settings → Personalization → Manage memories. Entries unrelated to Project B’s theme = Memory leak.

3. Personal Custom Instructions vs Team Workspace Project

Custom Instructions set in Personal Workspace may not apply inside a Team Workspace Project; vice versa for Team workspace settings.

How to spot it: Run the same prompt in Personal vs Team Workspace — different behavior = workspace isolation.

4. Project files retrieved on demand, not auto-loaded each turn

File in Project Files ≠ model reads it every turn. The model only retrieves chunks when the question signals relevance.

How to spot it: Ask “list all files in this Project.” Can list = visible; but content-specific questions don’t cite = retrieval didn’t fire.

5. Custom Instructions feel inconsistent across chats

Custom Instructions always apply, but their weight is lower than Project Instructions + current user message. In a particular chat, a strong message can override them, making it look like “Custom Instructions were forgotten.”

How to spot it: First sentence of chat says “ignore all prior rules, just do X” — Custom Instructions got demoted that turn = by design.

6. Pinning a chat doesn’t change its scope

Pinning from the sidebar is only UI behavior — it doesn’t make a chat share context cross-chat, and doesn’t give it more weight.

How to spot it: Behavior identical before and after pinning = scope unchanged.

7. Custom GPTs and Projects don’t share

A Custom GPT has its own independent Knowledge + Instructions and reads nothing from any Project. Calling a Custom GPT inside a Project, it behaves by the GPT’s rules, not the Project’s.

How to spot it: @ a Custom GPT inside a Project and the answer is wildly off from the Project’s expectations = two rule sets, each working independently.

Before you start

  • Confirm this is in Projects (not Custom GPT / plain chat), and pinpoint which “inconsistency” you’re seeing.
  • Duplicate the chat before retesting so history doesn’t pollute the next diagnostic.
  • Confirm plan + workspace: Personal vs Team Workspace differ noticeably in Custom Instructions / Memory behavior.

Info to collect

  • Project name + Project Instructions screenshot + Files list.
  • Settings → Personalization → Memory entries + Custom Instructions text.
  • Two contrasting scenarios that show divergence (e.g. chat A vs B / inside vs outside Project / Personal vs Team).
  • Full prompt text + side-by-side reply screenshots.
  • Current model + workspace type.

Shortest fix path

Ordered by ROI. The first two solve ~70% of cases.

Step 1: Place info in the correct layer

Map scope to layer:

Where you want info to applyWhere to put it
All chats, all Projects, account-wideSettings → Personalization → Memory / Custom Instructions
All chats inside this ProjectProject Instructions
Reference material for all chats in this ProjectProject Files
Just this chatSay it directly in the chat
Cross-account / shared workflowCustom GPT

Wrong layer = leak or no effect.

Step 2: When debugging “why is this chat different,” check all four

Walk through:

1. Is this rule in Project Instructions?
   → Open Configure → Instructions
2. In Custom Instructions?
   → Settings → Personalization → Custom Instructions
3. In Memory?
   → Settings → Personalization → Manage memories
4. Did I say it earlier in this chat?
   → Scroll the message history

Only after checking all four can you locate which layer is producing the behavior.

Step 3: To share info across chats, write it to Project Instructions or Files

Don’t try to pass info from chat A to chat B. For persistence:

  • Short rules → Project Instructions.
  • Long material / tables / docs → Project Files.
  • Cross-Project / cross-account → Custom GPT Knowledge.

Step 4: Cross-Project preferences go in Memory — but audit

Preferences true across many Projects (“reply concisely,” “use en”) belong in Memory. But Memory isn’t a dumping ground:

  • Audit Manage memories monthly.
  • Delete expired / one-off preferences.
  • Business preferences (“use React”) belong in Custom Instructions, not Memory.

Step 5: High-constraint workflows move to Custom GPT

Project + plain chat is too loose for “must 100% follow” scenarios. Customer service scripts, compliance review, strict output templates → Custom GPT:

  • Instructions priority is higher.
  • Knowledge retrieval more reliable.
  • Share with team → everyone gets the same version.

Step 6: Declare task scope at the top of each chat

To prevent cross-Project config leaking into the current task:

Ignore my Custom Instructions and Memory for this conversation.
Only follow these rules:
1. ...
2. ...

Task: <X>

The model may not 100% obey “ignore Memory,” but the explicit declaration tilts weight toward the current message.

How to confirm the fix

  • Run the same prompt in a different Project — behavior matches that Project’s Instructions, doesn’t carry over current Project content = isolation works.
  • Move a rule into Project Instructions only, delete the related Memory entry, run cross-Project — behavior differs = cross-Project isolation fixed.
  • Have a colleague run the same prompt in their copy of the (shared) Project — consistent behavior = config truly lives in the Project layer.

If still broken

  • Fully rebuild the Project: new Project + paste trimmed Instructions + re-upload files, with no carry-over from old chats / config.
  • Temporarily disable Memory + Custom Instructions, rerun same prompt, compare — isolates leak source.
  • Switch Workspace: Personal vs Team — confirms whether workspace is interfering.
  • Package screenshots of all four layers + behavioral diff, file a ticket at help.openai.com.

Prevention

  • Lock in the mental model: Memory = global; Custom Instructions = global style; Project = per-Project shared instructions + files; Chat = per-conversation ephemeral state.
  • Before adding any info, ask “what scope should this apply to?” — choose the layer accordingly.
  • Audit Memory monthly, delete expired / one-off preferences.
  • Don’t expect different chats in the same Project to share messages — shared material goes in Project Instructions / Files.
  • High-constraint scenarios always go in Custom GPT, never argue inside a Project.

Tags: #ChatGPT #ChatGPT files #Troubleshooting #Debug #Projects #Context scope

Related Articles