You set up your project properly. Files uploaded, instructions written, everything in place. The first few chats are exactly what you wanted.
Then gradually, without you changing anything, the responses start to shift. The tone gets a bit looser. The formatting starts to vary. You find yourself correcting the same things you already put in the instructions. You correct it, it improves, then a couple of chats later it drifts again.
After a few weeks you are spending more time editing outputs than you would have spent writing from scratch, and you start to wonder what the point of setting up a project was in the first place.
The problem is not you and it is not the platform. It is a common issue called AI model drift, and it affects most major AI tools, including ChatGPT and Claude. It happens for different reasons on each one, and understanding those reasons can help you to avoid drift and keep your project on track.
This article explains why drift happens inside AI projects, how it works differently across ChatGPT, Claude, Perplexity and NotebookLM, and what you can do to reduce it and recover when it goes wrong.
How memory works across chats within projects
Here we’ll look at these two elements:
- whether information from one chat is used in later chats inside the same project
- which other memory stores can still influence those chats
It is important to be clear on what “used” means here.
The model does not copy entire past chats into every new chat. It does not automatically attach every previous file either. Instead, it creates a small internal summary of what it thinks is important from earlier conversations and uses that summary as extra context. Anything that is not captured in that summary, or saved in your project files or instructions, is not guaranteed to be remembered. (1)
Your project files and instructions are always read by every chat you start within a project. The question is how much the AI is remembering from chats within that project, and what other memories are being mixed in behind the scenes.
This is where automatic memory comes in. Automatic memory is where the AI is quietly learning from your chats over time and carrying certain things forward into future chats, without you having to save everything manually. How each platform handles this has a big impact on drift.
If a new chat can reuse patterns from your previous chats in the same project, it might start applying rules you never wrote down or approved. If old, irrelevant preferences creep in from outside the project, drift gets worse.
Here we’ll look at how this “hidden memory” works on each platform at the time of writing, and what that means for drift.
ChatGPT has three layers of memory
When you are working inside a ChatGPT Project, three different memory systems can be active at once. (2) (3)
Layer 1: Saved memories (account‑wide, permanent)
Saved memories are specific facts ChatGPT stores about you, either because you told it to remember something or because it decided a detail was worth keeping. For example, “this person writes for a finance audience” or “never uses the word dynamic”.
These memories apply in every conversation, inside and outside projects. You can see, edit and delete them in Settings → Personalisation → Memory. (3)
Layer 2: Chat history (account‑wide, automatic)
ChatGPT also tracks patterns from your past conversations. Not word for word, more like a running picture of how you work and what you tend to ask for. This applies everywhere by default.
If you turn off saved memories in settings, this pattern‑based use of chat history turns off with it. They are linked in the same toggle. (3)
Layer 3: Project memory (project‑specific)
When you are working inside a project, ChatGPT builds a separate memory just for that project. It distils what it learns from chats in that project – things like the project goal, a structure you keep using, or decisions you repeat – and can reuse that in later chats in the same project. This project memory does not carry into other projects or general chats. (2)
Default vs Project‑only: what the setting really does
When you create a ChatGPT Project, you choose how these layers interact. (2)
- Default
The project can read from your account‑wide memories (saved memories and patterns from chat history) and it can build its own project memory. Everything is connected. Your general account knowledge can influence the project, and what happens in the project can influence your account memories. - Project‑only
The project is sealed off. It ignores saved memories and chat history. It still builds and uses project memory from chats inside that project, but nothing comes in from outside and nothing leaves.
You can only choose this when you first create the project. You cannot change it later. (2)
Which memory layer should win when they conflict?
In theory, when you are in Default mode and all three layers are active, ChatGPT should read context in this order:
- Project files and written instructions – the rules.
- Project memory (Layer 3) – what it has learned from this specific project.
- Saved memories (Layer 1) – your permanent account‑wide facts.
- Chat history (Layer 2) – broad background context from your whole account.
The idea is that the more specific something is to the current task, the more weight it should have. Your written instructions are the most specific, so they should win. (2)
ChatGPT in practice: why drift still happens
In practice it does not always work exactly like that. With Default memory, drift can increase over the life of a project. (4)
LLMs do not follow rules in a strict, software‑like way. They generate the response that seems to fit best given everything in context:
- your instructions
- the different memory layers
- the current conversation
- patterns from training data
When those signals pull in different directions, instructions – which are meant to be the most important – can sometimes be overridden.
This tends to happen when:
- account memory or project memory contains something that conflicts with your instructions
- an instruction is vague enough that the model can technically follow it while ignoring what you really meant
- a chat has built up and gone in a different direction
The most reliable protection is instructions that are as detailed and specific as possible. Vague rules leave gaps the model fills in by itself. Detailed instructions close those gaps.
You do not have to write them from scratch. Ask the AI to draft them, and tell it to cover as many scenarios and edge cases as possible. You can also tell it to ask you questions if there is anything it does not know that it needs to know. A good set of project instructions can easily run to several pages. The more they anticipate how you actually work, the less room the model has to drift.
Although having detailed instructions helps, you may still have some drifting issues if the project is on the Default memory setting and account memory is being applied.
Claude has two layers of memory that are kept separate by design
Claude takes a different approach. It keeps project memory and account‑wide memory in completely separate silos. They do not interact. (5)
Layer 1: Global memory (account wide)
Claude reviews your conversations outside projects and saves key learnings, likes your preferences, writing style and recurring context. These memories apply to regular chats only, not inside projects. Global memory is available to all users, including free, as of 2026. (5)
Layer 2: Project memory (project specific)
Inside a project, Claude builds its own separate memory from conversations in that project. Each project has its own memory summary. This is completely isolated from global memory. (5)
How they interact
They do not.
- If you work inside a project, global memory is not used.
- If you work outside a project, project memory is not used.
This is the opposite of ChatGPT’s Default setting, where account memory and project memory can influence each other. (5)
This can mean less drift but it also means your global preferences, such as how you like to write, your usual audience or your tone, do not automatically carry into a project.
If you want Claude to know those things inside a project, you need to put them into the project knowledge base or into the project instructions.
Claude project memory in practice
Inside a project, Claude uses three things across chats: (5) (6)
- your project instructions
- your project files
- the project memory summary
Claude regularly reviews and saves key elements from previous conversations in that project into the project memory summary. New chats in that project can see that summary. It usually contains things like:
- what the project is about
- your role and the project’s goal
- recurring preferences, for example tone, length, structure
- explicit decisions you marked as important, such as “always use this template”
It does not keep a full transcript and it does not copy whole answers forward. It stores compressed facts, not full conversations.
When you start a new chat in a project, Claude combines:
- your project instructions
- your project files
- the project memory summary
- whatever you type in that new chat
In practice, that means:
- it can remember that this project is “writing finance job descriptions”, even in a brand new chat
- it can remember that you prefer “short, bullet‑led drafts” if you have used that pattern often
- it will not remember a one‑off detail unless it made it into project memory or a file
So the clearer you are when you say “this is a rule for this project” and the more you capture those rules in files or instructions, the more likely Claude is to carry them across chats, and the less often you need to re‑explain.
Does drift occur in Claude chats?
Yes, but for different reasons than in ChatGPT.
Because Claude’s two memory layers are separated, drift almost never comes from memory leaking in from outside. The more common cause is the chat getting too long and causing context window overload. (7)
As a conversation grows, earlier messages and instructions move further back in the window. Claude can still see them in theory, but what is happening later in the conversation tends to carry more weight. This often shows up as:
- tone gradually moving away from your instructions
- Claude copying the style of your most recent messages instead of your original brief
- responses becoming less structured as the thread gets longer
The simplest fix is to start a new chat for each distinct task instead of running one huge thread. Each new chat reloads your project files and instructions fresh, which resets the context.
Detailed, explicit instructions also help. The more specific they are, the harder it is for Claude to drift away from them, even as conversations grow.
Perplexity Spaces and Google NotebookLM
Perplexity Spaces and Google NotebookLM take a much stricter approach. Neither has automatic cross‑chat memory in the way ChatGPT and Claude do. (8) (9)
- There is no memory layer that quietly learns from your conversations over time.
- There is no account‑wide profile building up in the background.
- There is no project memory that synthesises patterns from past chats.
What you put in – your uploaded files and your instructions – is what the model knows. Every new chat starts from exactly the same baseline as the last one.
This means:
- no drift from accumulated memory
- no unexpected bleed‑in from previous conversations
- no surprises about what context is or is not in play
The limitation is the opposite side of that: if you discover something useful in a chat – a phrasing that worked, a format that you liked – it will not carry forward on its own. You have to capture it yourself and add it to your files or instructions.
For Perplexity and NotebookLM, your knowledge base is doing all the work. There is no memory layer to compensate for gaps in it, so keeping it thorough and up to date matters even more than on ChatGPT or Claude. (9)
Does drift occur in Perplexity Spaces or NotebookLM?
Perplexity Spaces
- Cross‑chat memory: none. Each new thread in a Space starts from the same files and instructions. Perplexity does not learn from previous replies in that Space. (8)
- Where drift can still come from: the underlying model. Perplexity runs on models like GPT or Claude. These models have their own baked‑in habits from training. If your instructions are vague, or a thread runs for a long time, the model can start filling gaps in its own way. Here drift comes from instruction vagueness plus long threads, not from memory layers.
NotebookLM
- Cross‑chat memory: none. NotebookLM always answers strictly from the documents you have added to that notebook and the question you ask. It does not carry over anything from your past prompts. (9)
- Where drift can come from: mainly from changes in your sources. If you upload new or inconsistent material, answers change. There is very little behavioural drift in the model itself, but the creativity ceiling is also lower because it will not invent beyond your sources.
In summary
Putting it all together:
- ChatGPT
In Default mode, projects can be influenced by both project memory and account‑level memory. This can happen even with detailed project files but drift is more likely if your instructions are vague or your account memories are out of date. For any client‑facing or brand‑sensitive work, create the project with Project‑only memory so it only uses your files, instructions and project memory. - Claude
Projects are isolated from account memory, which keeps things cleaner. Drift mainly appears in very long chats, as earlier instructions lose weight. Keep key preferences and style rules in the project instructions or knowledge base, and start a fresh chat for each new task. - Perplexity Spaces
No automatic memory. Every thread starts from the same files and instructions. This makes behaviour more predictable, but nothing improves unless you update the files and instructions yourself. - NotebookLM
No memory, and answers always come from your uploaded sources only. This makes it extremely stable and grounded, but not suited to open‑ended or creative writing. It shines as a research and summarising tool.
Projects still save a lot of time compared to starting from zero in every chat. The key is to work with each tool’s memory model rather than against it.
Things you can do to avoid drift
Here are some ways you can reduce drift in LLM Projects like ChatGPT and Claude:
1. Write very clear instructions
Spell out role, audience, tone, format, and any “always” or “never” rules. Vague instructions give the model room to improvise and make assumptions (that will likely be incorrect).
Examples:
“Write in US English and use everyday language for non-technical readers.”
“Use short paragraphs and bullet points.”
“Never use the phrases ‘cutting edge’, ‘game-changer’ or ‘synergy’.”
2. Capture important decisions or improvements in files
When you find a structure or approach that works, ask the AI to summarise the key decisions and learnings from the conversation, and upload it to the project, or create and add the files yourself.
This way you know the project has all the relevant information and will apply it going forward rather than just hoping the model carries it forward automatically.
- Save good outlines and article structures
- Keep a tone and style document with rules and examples
- Add strong examples of past work
These documents are what each chat will refer to so it’s worth ensuring they’re as thorough and accurate as posible.
3. Clean up old context
Remove or update files that no longer apply. Conflicting documents are one of the quickest ways to create drift.
Ask yourself:
- Does this document still reflect how we want to write?
- Are there duplicate or outdated versions?
- Could this file be confusing the model?
If in doubt, archive old material and keep the live knowledge base lean.
4. Reset messy threads
If a chat has gone on for a long time or feels “off”, start a new chat inside the same project.
- Your files and instructions will still load.
- The noisy conversation history will not.
This is especially important for Claude and Perplexity, where long threads are a common source of drift. If you want to keep some of the information in the original chat, then ask it to create a handover document for you that you can then upload into a fresh chat.
5. Use Project‑only memory mode in ChatGPT Projects
For client‑facing or brand‑critical projects, create the project with Project‑only memory so that account‑wide memories do not interfere. (4) Projects plus good habits will not remove drift completely, but they will delay it, reduce it and make it much easier to fix when it appears.