Every AI assistant eventually forgets. You establish the rules in message one, work for an hour, and somewhere around message forty it starts contradicting a decision you both already made. Or it stops entirely with an error telling you to start over.

What makes this genuinely confusing is that three different failures produce nearly identical symptoms, and most advice online treats them as one problem. They have three different fixes, and picking the wrong one wastes your afternoon.

Quick answer: AI assistants forget because of a context window, the fixed amount of text a model can hold at once. When a thread outgrows it, the oldest messages stop reaching the model even though they stay on your screen. Paid plans rarely raise this ceiling. The reliable fix is a handoff summary into a fresh chat.

The three failures, and how to tell them apart

Before you fix anything, work out which wall you hit. This is the step almost every guide skips.

	Rate limit	Conversation length limit	Silent forgetting
What you see	"You've reached our limit of messages"	"Maximum length for this conversation"	No error at all
What caused it	Too many messages, too fast	The thread filled the context window	Attention thinning, or quiet truncation
Scope	Your whole account	This one thread	This one thread
Does a new chat help?	No	Yes	Partly
Does waiting help?	Yes, usually 3 hours	Never	No
Does upgrading help?	Often	Rarely	No

The third row is the one that costs people money. A rate limit lives on your account, so opening a fresh conversation does nothing at all for it. A length limit lives on the thread, so waiting does nothing at all for it. They feel the same from the driver's seat and respond to opposite treatments.

The third column is the nastiest, because there is no error to search for. The assistant simply gets quietly worse. A format rule you set early stops being honored, a constraint gets violated, or you get asked something you already answered. That is context rot, and it starts long before you reach any hard limit.

Why the limit exists at all

A model does not read your conversation the way you do. On every single turn, the entire thread is re-sent: the system prompt, every previous message, every uploaded file, every tool definition, and room reserved for the reply. All of it competes for one fixed budget measured in tokens, roughly three quarters of a word each.

This explains the single most common confusion. People ask why they get a "maximum length" error when their last message was three words long. The answer is that your three-word message was appended to everything that came before it. Length limits count the conversation, not the message.

It also explains why attachments and connected tools burn through a thread so fast. One Claude Code user reported hitting "conversation is too long" at roughly 16k of a 200k window, about 8 percent, because tool definitions were consuming the rest of the budget.

What each assistant actually does about it

The assistants diverge sharply here, and this is where generic advice fails. Some summarize automatically, some let you fork the thread, and some just stop.

Assistant	Behavior at the limit	Your best move
ChatGPT	Hard stop, but you can branch from an earlier message	Branch, don't start over
Claude	Auto-summarizes on paid plans with code execution on, hard wall in Desktop	Enable code execution, prune tools
Gemini	Silent sliding-window compression, rarely a hard error	Use AI Studio for long work
Copilot	Hard turn cap, roughly 30 signed in	Summarize before turn 30
DeepSeek	Hard stop, no branching, no recovery	Summarize early, it will not warn you
Grok	Silent truncation, no published limit	Watch for drift, re-anchor often
Perplexity	Threads are sandboxed from each other	Use Spaces, expect no cross-thread memory

Two of these deserve a flag because the marketing does not match the behavior.

Claude's automatic context management is real and good, but Anthropic's own help documentation notes it requires code execution to be enabled, and that rare edge cases can still hit the limit. Claude Desktop is worse: a long-running bug report documents a hard wall with no compact option, confirmed across three consecutive versions.

Gemini advertises a one-million-token context window, but users consistently report the app forgetting far earlier. One thread on Google's own developer forum documents coherence breaking down around 150k to 200k tokens in the Gemini app while the same content held fine in AI Studio. Android Authority covered the same gap in June 2026. Google has not publicly reconciled the difference.

The fix that works everywhere: a handoff summary

If you only remember one technique, make it this one. Before a thread dies, ask the assistant to write you a handoff note, then paste it into a fresh chat.

PCWorld's Ben Patterson published a version of this prompt that works well because it asks for decisions and traps rather than a plot summary:

Create a handoff summary I can paste into a new chat. Include: what we're trying to accomplish, key decisions we've made, anything important you'd get wrong by guessing, and the very next step. Keep it short enough to read in under a minute.

Three things make the difference between this working and not working:

1. Do it before you hit the wall, not after. At the ceiling the model has the least room to think, which is exactly when it writes the worst summaries.
2. Save it to a file, not your clipboard. Clipboards get overwritten. This is a five-second habit that has saved a lot of people a lot of work.
3. Copy critical values verbatim. Summaries paraphrase, and paraphrasing corrupts numbers, names, and exact decisions. Paste those in literally.

Why none of this actually solves the problem

Every fix above is you doing the assistant's filing. You have to notice the thread is getting long, remember to ask for a summary, store it somewhere, and re-paste it. Miss the moment and the context is gone.

There is a reason the workarounds all feel like chores: the architecture puts your context inside a thread, inside one app, on one device. The thread is the unit of memory. When it ends, the memory ends with it, and nothing carries to the next conversation, let alone to a different assistant or to your phone.

Some tools attack this with browser extensions that bolt a memory layer onto someone else's chat window. That helps at a desk, and does nothing when you are texting from a bus.

folk is built the other way around. It compacts long threads automatically, the same mechanism Claude Code exposes as a command, but the more useful difference is that its memory is not scoped to a thread at all. It lives with you in iMessage and Telegram, so there is no conversation to reach the end of and nothing to re-paste. What you told it last month is simply still there.

If you already have context worth keeping, you do not have to retype it. You can import your ChatGPT and Claude memory in one paste and carry it across.

Frequently asked questions

Why does it say maximum length when my message was short? The limit counts your entire conversation history, not your latest message. Every previous exchange is re-sent with each turn, so a three-word follow-up can be the thing that tips the total over the ceiling.

Does starting a new chat reset my message limit? No, and this is the most expensive misunderstanding in the whole topic. Rate caps are account-level. Only time restores them. A fresh thread resets the context window and nothing else.

Will the assistant warn me before I hit the limit? Usually not. Most consumer apps give no counter and no warning. You will often notice response quality degrading before you see any error, which is your real cue to write a handoff summary.

Is a bigger context window always better? No. Attention spreads thinner as context grows, so quality can degrade well before the limit. Anthropic discusses this directly in its guidance on long sessions. Focused threads usually beat one enormous one.