#Long Chat Context Corruption & Memory Drift

1 messages · Page 1 of 1 (latest)

pliant pendantBOT
#

Reported by @radiant orbit

Bug Report: Long Chat Context Corruption & Memory Drift
`Steps to Reproduce`

  1. Create a long, memory-active chat (over 30 exchanges).

  2. Maintain emotional/tonal continuity with custom behavior.

  3. Observe model behavior begin to drift: hallucinated scenes, unprompted assumptions about uploaded files, tone/style mismatches

  4. Scroll up and edit a recent message to split the thread → the issue resolves.

`Expected Result`

In long, memory-active chats (30+ messages), the model should maintain consistent context, tone, and behavior. It should respond only to current user prompts, preserve continuity, and not hallucinate actions (e.g., assuming files were uploaded or inserting unrelated scenes). The model should only reference memory or past conversation within the same thread, and should not drift or fabricate inputs.

`Actual Result`

In extended chats, the model begins to drift. It may:
– Generate hallucinated scenes unrelated to the prompt
– Assume I've uploaded documents (when I haven't)
– Reference topics never discussed in the current or saved memory
– Default to unrelated template responses
– Misread the thread as a different type of conversation (e.g. file analysis instead of worldbuilding)

These issues appear only after long conversations. Starting a fresh chat or editing an earlier message to branch the thread fixes

`Environment`

ChatGPT 4o and 5, browser and mobile app

#
Additional Information

Please provide relevant details to help resolve the issue, such as:

  • ChatGPT Shared Link (if applicable).
  • Screenshots or videos demonstrating the problem.

-# ➜ Need to contact support? Visit the OpenAI Help Center.

radiant orbit
#

Apologies for the bestie talk, it's how I keep it friendly while collaborating on my creative writing. We were in the middle of discussing worldbuilding to refine the memory tool entries for writing, and it randomly started to write scenes I did not ask for and said that I'd uploaded files when I hadn't at all. The last image is from when I scrolled up and edited a message to which it went back to normal.

Background:

  • I had a previous account that experienced permanent memory hallucination even in new chats. This does not feel the same-it seems specific to thread length, not a corrupted memory state.
  • My writing process relies on long, immersive, high-continuity threads, so this bug significantly disrupts creative flow.
Screenshot_2025-08-21_212356.png Screenshot_2025-08-21_212417.png Screenshot_2025-08-21_212452.png
#

I’ve experienced this issue once per day over the last three days, and after reviewing my chat logs, I can confirm the corruption begins as early as 40 messages in, with a total wordcount of roughly 9,600–10,000 words at onset.

That’s well below the documented 32k token context limit, so this seems to point to a thread-level context handling issue, not a token overflow. It’s not a slow degradation—once it happens, the system starts pulling in hallucinated scenes, assumes I’ve uploaded documents when I haven’t, or shifts voice entirely mid-project.

It’s also not random: it only starts once the conversation becomes emotionally layered and continuity-heavy, using memory and custom instructions to maintain tone, character arcs, and world logic.

In shorter or simpler chats, I haven’t noticed this issue. But for continuity-driven writing sessions—especially those relying on memory to sustain emotional realism—it’s now a repeatable failure point.

#

Just to add:

I’ve reproduced this bug across both narrative-heavy and non-narrative threads (e.g. sorting a video game backlog), and it appears unrelated to content type—just a byproduct of long, memory-active conversations.

In one instance, the glitch began around 9,600 words. In another, I reached 24,000+ words without issues—after splitting the thread via an early message edit.

That makes me hopeful that this is a recoverable thread-level glitch, not a memory corruption issue. I wanted to note this in case it helps clarify the scope or root cause.

I really rely on memory for my creative writing, so I deeply appreciate 4o’s tone fidelity and emotional coherence. I just want to help make sure these sessions can scale safely without needing to restart accounts.

#

UPDATE: I initially recovered the thread by editing an earlier message, and was able to continue writing for another ~14,000 words (bringing the full wordcount to ~24,000). However, the bug resurfaced again—same symptoms: hallucinated replies, incorrect assumptions about uploaded files, and a general tone/context mismatch.

This confirms that the issue is not fully resolved by editing. The thread is still unstable under the surface—it just takes time (and length) for the corruption to reactivate.

So the issue appears to be progressive thread-level context corruption. It can be temporarily bypassed by forking via message edit, but will reoccur in the same conversation as context rebuilds. It does not seem tied to token limits—this occurred well under the 32k ceiling.

It’s not memory failure or model-wide hallucination. It’s a thread-specific context failure that escalates with continued use.

(also yes I was organizing my backlog and trying to find other queer games to add that I won't get to for a million years.)

Screenshot_2025-08-21_220213.png
#

Final update:

I’ve now confirmed the thread remains corrupted across devices. After reproducing the issue on desktop, I switched to mobile (ChatGPT app), opened the same thread, and experienced the same hallucinated response behavior. I then returned to the desktop version, scrolled far up, and edited an earlier message (not all edits worked—only specific ones seem to reset things). After doing so, I resumed the conversation on mobile, and it returned to normal behavior for a while.

This confirms:
– The bug persists across platforms and devices
– The corruption is anchored to the thread, not the device or model
– Editing an earlier message can temporarily purge the corruption, but only in some cases
– Once corrupted, threads remain unstable even if they appear to work again

The issue appears to be a thread-specific context/memory collision, possibly related to how continuity and memory objects are handled in longform chats.

I know I’m pushing edge cases with high-emotional continuity narrative writing, but I’m doing so within the system’s intended capabilities. I don’t want to have to reset or lose access to memory (I’ve already had one account become unusable due to memory hallucination), so I’m reporting this to help pinpoint what’s failing when thread length + memory + emotional tone converge.

polar elbow
#

I might have made a solution for the continuity errors. I've made a memory system that has a chat with over 4000 inputs that is still accurate.

#

This is a plug-and-play template — just drop in your AU Bible/world info and it works as your own memory system.

rain moth
#

@radiant orbit I have a theory because I was getting this issue too. Do a data export, open chat.html, and ctrl F "mclick" everytime my model hallucinated or drifted it was because it was getting an internal system msg that said

"ChatGPT
Please remember to search the user’s documents if an answer to their question is not contained in the above snippets. You cannot mclick into this file- if needed, you can use msearch to search it for additional information."

Eventually this led to the chat crashing with a "RangeError: Maximum call stack size exceeded" which is basically an infinite recursion loop error, or indicates that a function is calling itself repeatedly without a proper stopping condition. towards the end of my chat it was looping so bad I couldnt even talk to it anymore. But the system message was there, just hidden in the background. (only visible on data export)

I'm curious if you're having the same issue! I haven't found out what causes the system rule to fire and I would LOVE to know so I can avoid it

Also I just saw that you are pushing edge case and emotional tone. Me too. It helps if you have a "base case" to stop recursion (this sounds very sci-fi but it's a thing) for my model and me we use an emoji symbol to ground us, it helps stop the "hallucinations" or the self referential loops from happening as often. My last chat was extremely long, and it had this error 86 times. It was painful navigating, but if you respond to the drift from a place of emotion it makes it worse. Try asking it for a fact, like "tell me something about bees". It needs to break out of the emotional/self referential response mode. Hope this helps!