The moment the bot stops knowing you
You're twenty messages deep. You've explained your situation, corrected a few misunderstandings, built up a shared shorthand with the bot. Then you ask a follow-up that references something you said ten minutes ago, and it responds like it's meeting you for the first time. Contradicts its own earlier advice. Asks you to repeat yourself. It feels, suddenly, like talking to someone who wandered back into the room after a long phone call and missed everything.
This isn't a bug, exactly. It's a structural feature of how large language models handle memory, and once you understand the mechanic, the weirdness makes complete sense.
A bucket, not a brain
AI chatbots don't have persistent memory the way you do. What they have is a context window: a fixed-size container holding every word of the current conversation, measured in tokens (roughly three-quarters of a word each, on average).
Think of it as a kitchen counter, not a pantry. Everything you're actively cooking has to fit on the surface. Once it's full, something falls off the edge to make room for what you just put down.
When the total token count of your conversation exceeds the model's limit, older content gets dropped. The model doesn't flag this. It doesn't say "I've forgotten the first half of our chat." It just proceeds, using only what fits inside the current window.
Different models have different window sizes. Older or smaller models might top out around 4,000 tokens, enough for maybe fifteen to twenty substantive exchanges. Larger architectures support 100,000 tokens or more, which can hold the equivalent of a short novel. But even the generous ones have a ceiling.
What actually falls off the edge
The truncation isn't random. Most systems drop the oldest content first, keeping the most recent exchanges intact. That sounds reasonable until you realise that the most important context is usually at the start of a conversation, not the end.
Take Priya. She opens a session to draft a grant proposal and, in her first three messages, lays out the funding body, the project scope, her institution's specific constraints, and the tone the committee prefers. The bot absorbs all of it and gives excellent, tailored advice. Fourteen exchanges later, Priya asks for a revised conclusion. By now the window is full. The early context, the funding priorities, the institutional constraints, the tone notes, has been quietly dropped. The bot rewrites the conclusion like it's a generic academic document. Priya thinks the bot has suddenly become stupid.
It hasn't. It's just working with a shorter counter.
A colleague of hers, Marcus, does the same task but pastes his key constraints into every third message as a brief reminder. Consistent output all the way through. Same model, same session length, completely different experience. The only variable is what's inside the window at any given moment.
Why longer context windows don't fully solve it
You might assume a 100,000-token window just eliminates the problem. It doesn't, and this is where it gets genuinely interesting.
Large language models process context through a mechanism called attention, which weighs how relevant each token is to generating the next response. In a very long context, the signal from tokens far back in the conversation can get diluted. The model technically sees that early information but may not weight it heavily enough to act on it reliably. Researchers call this the lost-in-the-middle problem: information buried in the centre of a long context window gets attended to less reliably than information at the very start or the very end.
Then there's cost. Processing 100,000 tokens takes longer and requires more compute than processing 4,000. Commercial products make tradeoffs, and some quietly compress or summarise older context rather than pass every raw token through the model. That compression introduces its own distortions.
The most underappreciated issue, though, is conversational drift. Each response the bot generates is based on a slightly imperfect reading of everything before it, and those small errors accumulate. By exchange thirty, the model might be operating on a subtly warped version of your original intent, not because it forgot, but because each step introduced a tiny wobble. It's like photocopying a photocopy a dozen times: the original is still technically in there somewhere, but good luck reading it.
What you can actually do about it
You can't expand the context window yourself. You can manage what's inside it.
Front-load. Put your most important constraints in your first message, and keep that message dense with specifics. If you're running a long session, paste a brief summary of the key parameters every five to seven exchanges. It feels repetitive. It works.
Some applications now offer explicit memory features that sit outside the context window entirely, storing facts about you in a separate database and injecting them at the start of each session. This sidesteps the problem rather than solving it, but sidestepping is fine when it's effective.
Starting a fresh session when the topic genuinely changes is also underrated. Many people treat a long chat as a sign of a productive session, which is exactly backwards. A fresh session with a clear, specific opening prompt will almost always outperform a sprawling one where the model is hauling twenty exchanges of accumulated confusion behind it.
Are you getting noticeably worse answers as a conversation goes on? That's your signal. A clean start, with a well-constructed first message, often recovers the quality immediately.
The thing most people misread
When a chatbot loses coherence mid-conversation, the instinct is to read it as evasiveness, or bad training, or plain stupidity. None of those framings are right, and defaulting to them makes you worse at using the tool.
The model's capability at token 10,000 is identical to its capability at token one. What's changed is the quality and completeness of the information it's working from. Blaming the model for context truncation is like blaming a calculator for a wrong answer after you gave it wrong inputs: the mechanism is the same, just with a fancier machine.
The more useful mental model is this: the context window isn't the AI's memory. It's the AI's entire reality for that session. It can only reason about what exists inside that window. Nothing more. The conversation you think you've had and the conversation the model can actually see may be two different things entirely, and the gap between them is exactly where coherence goes to die.
The practical skill, then, isn't learning to trust the AI more. It's learning to be a better manager of that little bucket. Keep the important stuff in it. Refresh it when the session runs long. And when the bot starts acting like a stranger, don't take it personally. It literally doesn't know you anymore.