As ChatGPT conversations grow long, the model's attention dilutes and important constraints quietly fade. This case study designs a feature that keeps the important things pinned — no matter how long the thread runs.
ChatGPT has become a daily tool for people running long, complex sessions — coding, writing, research, and learning. As these conversations grow, users build up real context: tone preferences, technical rules, facts they've shared, decisions already made.
The model doesn't reliably hold onto that context as the thread grows. Its attention dilutes across the full length of the conversation, and early constraints quietly lose priority — leading to contradictions, repeated instructions, and a slow erosion of trust.
"The longer a conversation runs, the more likely ChatGPT is to forget what it was already told — forcing users to repeat themselves, correct contradictions, and second-guess long sessions they should be able to trust."
Before designing anything, it's worth sitting with how this problem actually shows up for people — not as an abstract technical issue, but as friction inside a real working session.
When ChatGPT contradicts something it agreed to earlier, users can't tell if they misremembered or the AI made a mistake.
Most users don't know about context windows or attention dilution — they just think the AI got "lazier" over time.
After getting burned once, users start re-pasting instructions every few messages, just in case — wasting their own effort.
Most don't complain. They just quietly stop trusting long sessions and start new chats more often.
The mistake usually surfaces after a wrong or inconsistent answer ships — not before. The damage is often already done.
Casual, short-chat users barely notice. It's power users — coding, research, writing, planning — who hit this hardest.
Some manually summarize and paste into a new chat. Some export conversations. Some switch to Projects. Users are already coping, just clumsily.
Early drift feels harmless. By message 70-80, it feels like starting over — far costlier the longer the session has run.
Different jobs, different constraints — but the same moment where ChatGPT quietly drops something it was already told.
Sets clear preferences early — tone, format, skill level — and expects them to hold for the rest of the session.
ChatGPT drifts from her preferences mid-session, forcing her to correct it and breaking her flow.
Wants the AI to reliably hold what she's already told it, without babysitting the conversation.
States his learning level and rules upfront — "hints only, no direct answers" — for long study sessions.
After 40-50 messages, ChatGPT starts giving direct answers again, breaking his study flow.
Wants his learning rules to hold for the entire session so he can stay focused, not re-teach the AI.
Sets a brand voice early — banned words, tone, word count — expecting it to persist across every revision.
Tone quietly slides back to generic mid-session; banned words creep back in by the third draft.
Wants her style guide to persist reliably, even on the tenth revision, without re-pasting it.
States technical constraints early — language, banned libraries, folder structure — for the whole coding session.
Long sessions drift into the wrong syntax or a banned library, caught only during code review.
Wants his stack and rules locked in for the session so he can move fast without repeating himself.
Each concept attacks the problem from a different point in the lifecycle — preventing drift, catching it as it happens, or helping users recover from it.
Automatically detects explicit user statements — tone, rules, facts — and pins them to a small, always-visible panel. Users can see and edit what's protected at any time.
Users highlight any message and mark it as important. Locked items get guaranteed priority and never dilute, however long the chat runs.
When the AI is about to contradict an earlier constraint, it briefly flags it before answering — a lightweight self-check in the moment.
At natural intervals, the system auto-generates a short checkpoint summarizing key constraints so far — refreshing their priority without user effort.
Instead of compacting the whole conversation equally, pinned constraints are weighted higher during compression, so they survive while less critical history trims first.
A simple command — "show my active constraints" — instantly displays everything currently locked in, so users can sanity-check before relying on a long answer.
Plotted by user impact against build effort. The two solutions in the top-right quadrant form the initial release; the rest follow once the core mechanism is proven.
Fixes the root technical cause directly. Highest impact, and reuses existing compaction infrastructure — lower effort than it looks.
Gives users visibility and trust from day one. Pairs directly with compaction — one fixes the model, one shows the user it worked.
Manual controls that layer on top of the automatic system once it's proven reliable.
Nice-to-have reinforcement layers — valuable, but not required for the core fix to work.
Every metric on this page should ladder up to a single measure of whether the feature is doing its job. This is that measure — everything below is either a driver of it or a downstream effect of it.
The share of long sessions — 50 or more messages — where every constraint the user explicitly stated is still intact by the time the session ends. No drift, no silent contradiction, no correction needed.
sessions with zero drift corrections ÷ total long sessionsIt's measured at the moment that matters most — the end of a long session — and it reflects exactly what the user feels: whether the conversation could be trusted all the way through.
Share of explicitly stated constraints the system correctly detects and protects in the first place.
How many messages a pinned constraint survives, on average, before any drift occurs.
Share of drift incidents flagged or corrected before the user notices or acts on a wrong answer.
Improving these three should move the north star — and the four signals below should move with it.
The downstream signals — they should trend with the north star metric as constraint-held sessions increase.
Drop in "AI forgot my instruction" reports and support tickets tied to long sessions.
Increase in average messages per session before a user abandons or restarts the chat.
Fewer instances of users re-pasting the same instruction within a single conversation.
Share of long-session users who view or edit the pinned constraints panel — a proxy for trust.
Automatic pinning by default, with visible, editable output.
Occasional wrong pins the user has to manually correct.
Re-evaluating importance regularly enough to catch drift early.
Higher inference cost per long session, especially on free tier.
A visible constraints panel, even though it adds UI surface area.
Extra interface most casual users will never open.
Weighting stated constraints far above anything the model infers.
Some genuinely important but unstated context still gets missed.
The fix isn't a bigger memory — it's a smarter one. By weighting what users explicitly say over what the model guesses, and giving people visibility into what's being protected, ChatGPT can hold onto what matters most, for as long as the conversation runs.