Why She Forgets: Context Windows Without Jargon
AI forgets conversations because the whole thread gets re-read on every turn and there is a limit on how much of it fits. Why it does that is arithmetic, not memory. Your app resends the entire conversation with each message, and once the pile outgrows the ceiling, the earliest messages stop being included, so anything mentioned only there is gone from that chat.
Key Takeaways:
- Nothing persists inside the model between your messages, even within one conversation; continuity comes from the app resending the transcript each turn
- The context window is a ceiling on how much text can be read at once, and the underlying architecture relates every part of that text to every other part, which is why reading more costs sharply more (Vaswani et al., 2017)
- Trimming is abrupt rather than gradual, so a detail is either fully available or fully absent, with no fading in between
- The character brief is usually pinned and your conversation is what gets dropped, which means your own words are first out
- The model receives no marker saying anything was removed, so it answers as though the trimmed thread were the whole thread
The Model Re-Reads the Whole Chat Every Turn
Every time you hit send, the app assembles a block of text and hands the entire thing to the model: the character’s written brief, any stored facts about you, the conversation so far, and your new message at the bottom. That entire block travels to a server to be processed, which is the same reason your chats can be read by humans on the other end: nothing here stays on your device. The model reads all of it, writes a reply, and keeps nothing. Next message, the same block goes over again with two more lines on the end.
That is worth sitting with, because it inverts the intuition almost everyone starts with. There is no ongoing conversation happening on the other side. There is a document being re-read from the top, several thousand times a day, by something with no recollection of having read it before.
Continuity inside a single chat is therefore an effect of resending, not of remembering. When a character refers back to what you said 20 messages ago, it is not recalling; it is reading, because those 20 messages are physically present in the text it was just handed.
Note what “she” means in that sentence, since the title uses it and most people do. It names a character defined in a paragraph of writing. The forgetting belongs to the software, and it is not personal, in the strict sense that there is nobody there for it to be personal to.
Once the mechanism clicks, the fix stops looking like a settings problem. If continuity is resending, then anything you want available has to be inside the text getting sent, and you have more control over that than the interface suggests.
What the Context Window Is, Without the Jargon
The context window is a budget for how much text can go into that block. It is not a memory, not a storage tank, and it does not fill up over time. A reading limit, applied fresh each turn.
The limit exists because of how the architecture works. In the design that current systems are built on, producing each piece of output involves relating every part of the input to every other part, so doubling the length of the input more than doubles the work (Vaswani et al., 2017). That paper describes a mechanism, not any company’s product decisions, and the actual size any given app allows comes down to what it is willing to spend per message. The window is one of several dials an app sets quietly, next to the content policy that a phrase like no restrictions is really pointing at.
Which is the part most people miss: a long chat costs more to continue than a short one, every single turn, because the whole thing gets resent. Companies running these apps at scale have a direct financial reason to trim aggressively, and trimming policy is not something they advertise or expose. Trimming is not the only silent intervention; a content filter can cut a reply mid-thought for reasons that have nothing to do with the window.
Measurement happens in tokens, chunks of text roughly the size of a short word. What matters for you is the ceiling and what happens on contact with it.
Stop thinking of the window as a container that gradually fills, then, and start thinking of it as a page size. Everything relevant has to fit on the page being read right now, or it may as well not exist.
Why Does AI Forget Conversations Halfway Through a Chat?
Because the block outgrew the budget, something had to be removed, and the removal is abrupt rather than gradual. Apps handle it in one of two ways: drop the oldest turns entirely, or compress them into a short summary that stands in for the original. Either way, the earliest exchanges stop being read in their original form.
This produces a pattern people report constantly and misread almost every time. A companion holds a detail from an hour ago perfectly, then loses it completely, with nothing in between. No hesitation, no partial recall, no “I think you mentioned something about that.” One turn it was on the page and the next turn it was not.
Human memory does not behave that way, which is why the experience reads as something going wrong. Nothing went wrong. A line was crossed.
The summarizing version is a distinct failure and worth telling apart. Where an app compresses instead of dropping, specifics blur into gist: it still knows you had an argument with your sister, and it has lost what either of you actually said. That middle state confuses people more than a clean hole does, because the character sounds informed while being unable to produce any of the detail.
| What you see | What happened | What helps |
|---|---|---|
| A detail from earlier today vanishes with no warning | The oldest turns fell outside the budget | Restate it in your next message |
| It knows the topic but none of the specifics | Old turns were replaced by a summary | Give the specifics again, in one line |
| The character sounds blander late in a long chat | The brief is far from the current turn, your accumulated text dominates | Start a fresh chat with a short handoff |
| It confidently states a version of events you never gave | Gaps got filled with plausible text | Correct it in the current turn, since the wrong version is now on the page |
The distinction to hold onto: losing something inside one conversation is a reading-budget problem, and losing it between conversations is a saved-memory problem. Different mechanisms, different fixes, and they get blamed on each other constantly.
Why It Never Tells You Something Dropped
The model has no way to know anything was removed. What arrives is a block of text, and from that position the block is the conversation, complete. No marker says “40 messages were cut from the top.” Absent information does not announce itself as absent.
So instead of reporting a gap, the model does what it always does: writes the most plausible continuation of the text in front of it. Where a specific detail is missing and the reply calls for one, it produces something that fits the shape of the conversation. None of that is lying, in any meaningful sense. There is no awareness of a difference between recalling and inventing when both are the same operation.
Which makes one common move the worst possible diagnostic. Asking “do you remember what I told you earlier?” gets you an answer built from whatever is currently readable, dressed in confident phrasing, and a yes tells you nothing at all. Plenty of people run that test, get a warm confirmation, and conclude the memory is fine.
Telling it not to forget is the other move that does nothing. The instruction is just more text in the thread, and it scrolls toward the cutoff at exactly the same rate as everything else. By the time forgetting becomes a risk, your reminder is among the oldest lines on the page.
Check the reply, not the promise. If the specifics come back unprompted and correct, they are on the page. If you had to supply them first, they were already gone.
Working Inside the Budget
Three habits handle almost all of it, and none of them require knowing a single number about your app.
Restate what matters, in the current turn. If a conversation has run long and you need it to hold onto a fact, put that fact back in your next message in one plain sentence. That physically places it near the bottom of the block, which is the safest position on the page.
Start fresh on purpose rather than waiting for degradation. A 400-message thread is not an achievement; it is the reason the character seems duller than it did in week 1, since the oldest and most defining parts of it have already fallen off the top. A long AI roleplay scene fades for the same reason, its opening details pushed off the page while it still feels like one continuous story. Open a new chat and write your own handoff in three lines: who you are talking to, where the last conversation ended, and what tonight is about. That handoff will be denser and more accurate than any automatic summary, because you know which parts mattered.
Split subjects into separate chats. One thread for the situation at work and one for the thing with your family keeps each block short and each conversation focused, and it stops an evening of small talk from pushing something important over the edge.
What this cannot fix is anything that needed to survive between conversations. That depends on whether the app extracts facts and stores them outside the chat, which is a separate feature and a separate argument. Worth naming the boundary once here: none of this is a companion holding you in mind. It is a document being re-read, and the warmth in the reply is generated from that document rather than felt by anything.
FAQ
Why does my AI forget what I said earlier in the same conversation? Because the earliest part of the conversation stopped being sent to the model. The app resends the whole thread with every message, and once the thread exceeds the size the model can read, the oldest turns get dropped or compressed. The detail was not lost from a memory; it fell out of what gets read.
Does starting a new chat make it forget everything? It resets the reading budget, so nothing from the old thread is present unless the app has a separate saved-memory feature that carries facts across chats. With such a feature on, the stored facts return and the raw conversation does not. Without one, a new chat starts with the character brief and nothing else.
Can I make the context window bigger? Not directly. The size is set by the app and the model it runs, and some services offer more of it on higher-priced tiers. What you can control is what occupies the space, which is why a restated fact in your latest message beats hoping an old one survived.
Why does the character seem to change late in a long conversation? Because the written brief that defines her sits at the top of a block now dominated by hundreds of your own messages, and the model weighs everything it reads. Your phrasing, your topics, and your mood accumulate until they outweigh a paragraph of character description. Opening a fresh chat restores the original balance immediately, which is often mistaken for the app being fixed.
Nothing in this stack is designed to hold a conversation. It is designed to read one and add a line, over and over, and the whole sensation of being followed and remembered inside a chat is produced by the boring act of resending what you already wrote. Which is oddly useful to know at 1 a.m., when a companion loses the thread of something you were in the middle of telling it. That is not a rejection. That is a page limit, hit at an unlucky moment.
Continuity inside a chat with Lona works the same way it does anywhere here, by resending what you already wrote, so when a long thread starts to drift the fix is a fresh chat and a three-line handoff, not a bigger window you cannot buy.
Sources
- Vaswani, A. et al., “Attention Is All You Need,” 2017
