Why does ChatGPT forget things in the same chat?

Two hours into the thread and it forgot the brief you pasted at the top. Nothing is broken: a conversation has a fixed window, and the brief was the first thing to fall out of it. Here's what's actually happening, the fixes that hold, and why the brief shouldn't have lived in the thread to begin with.

You pasted the client's scope document at the top, set the tone you wanted, and worked the thread for two hours. Somewhere past message 150 it started proposing a deliverable you'd ruled out on page three, giving the CFO the wrong title, and re-asking a question you'd answered an hour earlier. If you've been there, the first thing to know is that ChatGPT didn't break, and its memory feature didn't fail. The thread ran off the end of the window.

ChatGPT forgets things in the same chat because a conversation has a fixed context window. Everything counts against it — your pasted brief, every question, every reply. Once the thread outgrows the window, the oldest turns stop being included, and the brief you pasted first is the first to go. Re-anchor it, or keep it somewhere that doesn't scroll.

The short answer: a conversation has a fixed window

Every time you send a message, ChatGPT works from the conversation as written and composes its reply from what it can read. The catch is that it can only read so much at once. That limit is the context window, and everything in the thread counts against it: the document you pasted, each question you typed, and every answer it wrote back.

While the thread fits inside the window, it genuinely sees all of it. Once the thread outgrows the window, something has to give. OpenAI doesn't publish exactly how it trims, but in practice the oldest turns are the ones that stop being included. It isn't forgetting them so much as no longer being shown them. And the brief you pasted at the start is, by definition, the oldest thing in the thread — so it's the first casualty. The instructions you gave in message two go next. What you said ten minutes ago is safe. That's why the forgetting feels so lopsided: recent detail is perfect, early detail is gone.

Some signs you've crossed the line:

• It drops a constraint you set early — a word count, a banned phrase, a scope you ruled out.
• It drifts back to a style or format you corrected an hour ago.
• It asks something you already answered, or contradicts a fact from the brief.
• Its answers get vaguer about the client and sharper about whatever you just said.

How long does ChatGPT remember in one conversation?

Not a number of messages — a number of tokens, which are roughly three-quarters of a word each. The size depends on your plan and the model you're using. As of August 2026, OpenAI's pricing page lists the total context window as 27K tokens on Free, 54K on Go and Plus, and 128K on Pro for the default model; reasoning models get larger windows on paid plans (256K on Go and Plus, 400K on Pro).

In plain terms, 54K tokens is around 40,000 words — a short novel. It's less than that in practice: OpenAI's own footnote says the space for what you type is smaller than the total window, because system instructions, memories (if on), and its internal processing occupy part of it before you've written a word. That still sounds like plenty until you do the arithmetic on a real working thread: a 30-page scope document is roughly 12,000–15,000 words on its own, a long reply runs 400–600 words, and a two-hour session can hold a hundred of them. The thread crosses 40,000 words without you noticing, and from then on ChatGPT is reading a conversation with its opening pages torn out.

Two things make it worse. Long answers eat the window fastest — asking for essays when you wanted bullets is the most common self-inflicted cause. And there's no warning when the early turns stop being read; you find out when the brief goes missing.

This is a different problem from the hard stop. ChatGPT keeps accepting messages well past the point where it can read the whole thread — it trims quietly rather than refusing — so the brief is usually long gone before you ever see the separate "you've reached the maximum length for this conversation" message, which ends the thread outright. If that's the message on your screen, see what to do when ChatGPT says the conversation is too long.

Why ChatGPT gets worse the longer the conversation runs

Long before anything has technically left the window, the answers get worse. This is the more common complaint — it was sharp this morning, now it's mush — and it has a different cause from a missing fact.

With tens of thousands of words in play, the most recent phrasing carries the day. The one-line rule you set in message three is still in the thread, but it's one line against everything said since — and so is the constraint the client actually cares about, the number you agreed, the tone you set. Nothing was dropped. It was outvoted. What comes back reads as blandness: hedged answers, generic advice, a preference for summarizing what you both already know over committing to the next step.

That tell is worth learning, because it shows up well before the brief falls out. When a thread that was producing usable drafts starts producing safe ones, that's your cue to re-anchor — while re-anchoring still works. Confirming it is cheap: put the same question to a fresh chat with your five facts pasted at the top. If the new chat answers sharply, nothing is wrong with ChatGPT. The old thread is simply too full to steer.

Why a long thread gets slow — and why the lag is your warning

The same condition has a second symptom: lag. The thread that opened instantly this morning takes a moment to load, the cursor stutters as you type, replies start slower than they used to.

Two things are stacking up. Your device is holding and re-drawing a transcript that may run to hundreds of messages, and each new turn is composed against more text than the turn before it. OpenAI doesn't publish a breakdown of where the seconds go, so treat the split as unknowable — the useful part is what the lag tracks with. It's the visible symptom of the invisible problem. By the time a thread feels heavy, it is heavy: full enough that the early turns are at risk, if they haven't gone already.

So don't push through it. Take the first stutter as the prompt to ask for a handoff summary — what's been decided, the constraints still in force, what's still open — and carry that into a new chat, as described below. Restarting at a moment you choose is far cheaper than discovering three replies later that page three of the scope left the conversation an hour ago.

Why ChatGPT forgets instructions mid conversation, too

"It ignored my instructions" is usually two different problems wearing the same coat.

Instructions you typed into the thread — "always write in UK English," "never propose anything outside the signed scope" — are just early messages. They fall out of the window like any other, and even before they do, a one-line rule from two hours ago is competing with tens of thousands of words said since. In practice, a rule given once, far back, gets diluted long before it's technically gone.

Custom instructions in Settings are different: ChatGPT applies them to every chat, so they don't scroll away. But they're short by design — OpenAI caps them at 1,500 characters on Free and Go and 5,000 on Plus and above — and they're meant for standing preferences, not a client brief. One more trap: edits to custom instructions apply to new messages right away, including in an existing chat, but the replies already on screen don't change — so after you update them, re-ask, or restate the rule when you re-anchor.

Does ChatGPT forget a file you uploaded to the chat?

It behaves that way, though not because the file was deleted. Uploads stay with the chat: OpenAI's retention policy is that a file uploaded to ChatGPT is kept in your account for as long as the chat it belongs to, and chats are kept until you delete them. The attachment is still sitting there at message 2. What changes is how much of it is in front of ChatGPT when you ask something at message 150.

The arithmetic gives it away. OpenAI caps a single uploaded text or document file at 2M tokens — five times the largest context window on any plan (400K, on a reasoning model on Pro), and roughly forty times the default-model window on Plus. A thirty-page scope was never going to sit in the window whole; ChatGPT pulls text out of the file and works from what comes back. Early on, while the document is what you're asking about, the relevant passages are recent and everything holds. A hundred messages later, the paragraph it quoted accurately in message 3 is old text in a full thread, competing with everything said since — exactly like a paste.

PDFs carry an extra trap. Visual retrieval exists only on Enterprise, and only for PDFs; on every other plan — and, on Enterprise, for every document type other than a PDF — handling is text-based. OpenAI's wording is that ChatGPT "will extract digital text from the file and discard any images." So a scanned scope, a signed page photographed rather than exported, or a fee table that lives inside a chart image gives it less than you think it has, from the very first question.

In practice: when a question turns on one clause, re-attach or paste that section rather than the whole document — you want the clause to be the newest thing in the thread, not to re-fill the window with thirty pages. If you'll be asking about it repeatedly, add it as a Project file (below) instead of a one-off upload buried in one long chat. And if it's a client record you'll still need in month six, the real answer is further out than any chat setting: organizing client emails and documents so the current version is findable outside a conversation.

What actually works inside ChatGPT today

These are the fixes that hold, lightest touch first.

1. Re-anchor the brief, not the whole document

Keep a standing block of the facts that must not drift — the five facts and three constraints, not the thirty pages — and paste it back into the thread whenever you notice drift, directly above your next question. Recent wins, so make the brief recent again. Every twenty or thirty exchanges is a reasonable rhythm on a heavy thread.

2. Summarize and restart

When the thread is long enough that re-anchoring isn't holding, ask for a handoff: "Summarize what we've decided, the constraints still in force, and the open questions, in under 300 words." Read it against the original — it will occasionally smooth over something you argued about — then start a new chat with that summary and the original brief at the top. You get a fresh window, and the brief is the newest thing in it again.

3. Put the brief in a Project, not the thread

This is the best in-ChatGPT answer. A Project holds files, instructions, and chats together, and every chat inside it inherits the project's instructions and file context — "files, instructions, and chats live in one place so ChatGPT stays on-topic," in OpenAI's words. Move an existing chat into a project and it inherits them too. Project instructions apply to every chat in the project rather than sitting as a message at the top of one thread, so they aren't the first thing to scroll out, and the scope document lives as a file instead of a paste. As of August 2026, a project takes 5 files on Free, 25 on Go and Plus, and 40 on Pro, Business, and Enterprise.

Two caveats. Project instructions are a text box meant for rules, not documents — the scope goes in as a file. And a thread inside a project has the same window as any other — a project keeps the brief reachable across chats; it doesn't make one chat hold more.

4. Keep threads short and single-purpose

One deliverable per thread. When the work moves from the pricing section to the board memo, start a new chat rather than steering the old one. Ask for shorter answers when you don't need long ones. And if you're on a paid plan and settling in for a long session, a reasoning model's larger window buys you more room before the same thing happens.

Do chats inside a Project remember each other?

Yes — further than most people expect, and it's worth knowing exactly how far before you lean on it. OpenAI's description is direct: projects have built-in memory, so a project "remembers all the chats and files you have created or uploaded" in it, and a new chat there can draw on the other conversations in the same project. Every chat inherits the project's instructions and files, and a chat you move in inherits them too.

Each project carries its own memory setting, picked when you create it and changeable later under the project's three-dot menu → Project settings → Memory. OpenAI notes a change can take a few hours to take effect.

• Default memory — your saved memories apply, chats in the project can reference each other, and outside Enterprise and Edu they can also reference conversations beyond the project, unless that other project is set to project-only. On Plus and Pro, ChatGPT prioritizes the project's own chats and files when you ask inside it.
• Project-only memory — your previously saved memories aren't referenced in project chats, and the chats reference only each other. Shared projects are set this way automatically and can't be switched back.

Two things this still doesn't do. Referencing another chat isn't the same as holding it in the window — each chat in a project has its own window, so a project keeps the brief reachable from everywhere without making any single conversation hold more. And project memory isn't inspectable: OpenAI says it doesn't show a list of memories the way personal memory does, and the only way to make it ignore something is to delete that conversation or move it to a different project. It also runs on switches worth checking — on non-Enterprise plans, both "Reference saved memories" and "Reference chat history" have to be on for project memory to work at all. (For recall across ordinary chats rather than inside a project, see how to make ChatGPT remember across chats; saved memories have a ceiling of their own, covered in what to do when ChatGPT's memory is full.)

One place a brief definitely shouldn't live: a Temporary Chat. It can't be added to a project at all, by default it doesn't use your memories or your custom instructions, and it won't appear in your history unless you deliberately save it — which converts it into an ordinary chat. It's built for the throwaway question, and it holds a brief for exactly as long as the window does.

Does ChatGPT's memory fix this?

It's tempting to assume the memory feature should cover it — ChatGPT does keep saved memories about you, and since April 2025 can draw on your past chats as a whole. But memory is separate from the thread. OpenAI describes it as a continually updated synthesis of context from your past chats: facts about you, your work, your preferences, considered in future responses unless you delete them. It isn't a verbatim store of the document you pasted. When the thread scrolls past page three of the scope, memory doesn't put page three back. And by OpenAI's own description, some details may not appear in the memory summary, so you can't fully audit what it kept from a given brief either. (What it does and doesn't keep is covered in does ChatGPT remember past conversations.)

ChatGPT figures and controls above were checked against OpenAI's pricing page and help center in August 2026. OpenAI changes plan limits and renames controls often — treat the numbers as a guide and check your own plan.

Where the workarounds run out

Every fix above has the same shape: you notice the drift, then you put the brief back. Re-anchoring is you re-pasting it. Summarize-and-restart is you carrying it across. A Project is you uploading it and maintaining the instructions. ChatGPT is doing exactly its job — reading what's in front of it. The job of keeping the brief in front of it is yours, every time, for as long as the thread lasts.

That's tolerable for one engagement. The trouble is that "the brief" isn't one thing. It's the scope PDF, plus the email where the client narrowed it, plus the call where the CFO's real title came up. The version in the thread was pasted on day one; the version that counts is spread across your inbox and your notes. So the brief you re-anchor is never quite the current one — and the thread forgets a brief that was already out of date.

Underneath the re-pasting is a category error. A chat thread is a scratchpad: the right place to draft, argue, and think out loud. A client brief is a record. Records need to stay findable for months, and when something is said about them, you need to know where it came from. A thread can't do that — it scrolls, it doesn't cite, and it eventually forgets its own first page.

A different answer: keep the brief where it can't scroll away

This is what Equerry is built for. It's a personal assistant that keeps the records you send it and answers from them with the source attached — at message 3 or message 300, because the brief was never in the thread to begin with.

For the consultant above, the brief stops being a paste:

• Send the brief as itself, once. Forward the scope email — PDF attached — to your Equerry address (something like mark@mail.getequerry.app), or CC that address on the client thread so the later email where they narrow the scope lands too. It's kept as the document, not as a paste that ages.
• Add the parts that never made it into the thread. A screenshot of the pricing slide from the share sheet, a note typed after the call, a voice memo dictated on the walk to the car. The CFO's real title goes in once and stays.
• Ask at message 300, or in week six. "What did we rule out of scope for Acme?" comes back with the answer and a source chip pointing at the PDF or the email it came from. There's nothing to re-anchor, because the answer is drawn from the record, not from the top of a conversation.
• Prep for the call from the record, not the thread. Before Friday's meeting, a prep note pulls the engagement's current state together from what you've shared — the scope, the narrowing email, your own call notes — so you're not scrolling a 200-message thread to find what was decided.
• Check what it kept. Every remembered fact is listed against the note or email it came from, and any of them can be removed on a tap — so you can actually see what was kept from a brief.

Keep ChatGPT for what a scratchpad is for — drafting, arguing a position, thinking out loud — and use the four fixes above to keep a long thread honest. Just stop using the thread as the place the brief lives. A record belongs with an assistant that keeps it and shows you where each answer came from.

If the opposite is your problem — old context bleeding into new work — see how to stop ChatGPT bringing up old conversations. And for the fuller picture, here's what a ChatGPT memory alternative for work context looks like.

Last updated 2026-08-28.

All product names, logos, and brands are property of their respective owners. Equerry is not affiliated with, endorsed by, or sponsored by any other product mentioned; comparisons are provided for informational purposes.