You're mid-project. You open a new chat, reference something you talked about last week, and get a blank response. Not a glitch. Not a bad day for the model. This is how every major AI chatbot works, by design, and it's worth understanding why before you decide what to do about it.
It's Not Forgetting — It Has Never Remembered
AI chatbots don't have memory the way people do. What they have is a context window, the fixed amount of text they can actually see at any one moment. Anything inside that window, they can use. Anything outside it might as well not exist to them.
Early versions of some chatbots could only see around 4–5 thousand tokens at once, roughly three thousand words. That's not a criticism, just a fact about how the earliest models worked, and it makes the limitation easy to picture: once a conversation ran past that point, the oldest messages weren't archived somewhere safe. They just stopped being part of what the model could see.
Here's the human version of that: imagine trying to follow a conversation while only being allowed to read the last two pages of a transcript. Not because you're forgetful. Because the earlier pages have physically been taken away from you. You're not failing to remember something. You just can't see it anymore.
This is why a chat that starts fine can quietly go wrong later. You mention something important early on, the conversation runs long, and eventually the AI contradicts that exact detail, not because it changed its mind, but because those earlier messages have scrolled out of what it can currently see.
Why Closing the Chat Makes It Worse
The context window explains forgetting mid-conversation. A separate problem, the session boundary, explains why a brand new chat starts completely blank.
When you close a chat and open a new one, the model starts over with zero knowledge of anything you discussed before, even five minutes before. In plain terms, it only has short-term memory, and that short-term memory resets completely the moment you close the app or start a fresh thread.
That's a deliberate choice, not an oversight or something a future patch is quietly going to fix. Keeping conversations separate protects your privacy, keeps the model's behavior predictable, and stops one conversation's context from leaking sideways into a completely unrelated one. It's built that way on purpose, the same way a bank teller isn't supposed to carry over what the last customer told them into your conversation.
Why Bigger Context Windows Don't Fully Solve It
The obvious fix seems simple enough: make the window bigger, and the forgetting problem goes away. It helps, for real; context windows have grown enormously since those early four-thousand-token days, and some now stretch into the hundreds of thousands of words or more. But bigger doesn't mean fixed, for two separate reasons.
First, even a huge window eventually fills up if a conversation runs long enough. Second, and this is the more surprising one, research on how these models actually process long stretches of text has found they pay noticeably less attention to information sitting in the middle of it than to information at the very start or the very end, even when that middle information is technically still sitting right there in the window.
Think of it like a six-hour meeting you sat through start to finish. You were physically present for all of it. But what happened around hour three is a lot hazier in your memory than the opening and the closing, even though nothing was ever erased or removed. Your attention just naturally thinned out in the middle, and it turns out these models do something similar.
How Some Chatbots Are Trying to Fix This
Here's a plain rundown of the main approaches chatbots currently use. No ranking, no recommendation, just what exists right now.
Some chatbots use an automatic memory feature that pulls facts out of your conversations and stores them for later, and the feature has since expanded to draw on your broader chat history too, not just the specific things it decided to save. Even so, it has real limits on how much it holds, it's not especially transparent about what it chooses to keep, and it tends to store simple facts rather than rich, nuanced context.
Other chatbots take a document-based approach that works differently: you attach documents to a dedicated workspace, and every new conversation inside that workspace starts with those documents already loaded in. It's more controlled than automatic memory, but it's static; it doesn't update itself as things change, you have to go add or replace the documents yourself.
Some platforms offer persistent instruction templates, handy for a task you repeat often. Availability and limits vary by plan, but the core idea is the same everywhere: instructions that stick around, capped by how much instruction text you're able to give them.
AI companion apps built specifically around relationships tend to handle this best — because memory isn't a bolt-on feature, it's the whole point of the product, so the character really does track your name and your shared history across sessions in a way general-purpose chatbots weren't originally built to do.
Worth saying plainly: none of these fully solves the problem for someone using AI heavily, every day, across a lot of different topics at once.
The "Lost in the Middle" Problem Most People Don't Know About
Even when an AI does technically have your information stored somewhere in its context, where that information sits still matters more than most people realize. The same research mentioned above found models are simply less likely to make real use of anything buried in the middle of a long stretch of text, compared to anything near the beginning or the end of it.
In practice, that means something you mentioned two hundred messages ago might still be sitting in the AI's context window and still get quietly ignored, purely because of where it landed in the sequence, not because it was ever deleted. The useful takeaway here is simple: if something matters, say it near the start of a conversation. Burying it in the middle of a long back-and-forth is about the least reliable place you could put it.
What Actually Helps Right Now
None of this is unfixable; it just takes a bit of manual effort on your end. The options below run roughly in order of how much work each one takes.
Lowest effort: open each new conversation with two or three sentences summarizing who you are and what you're working on. Something as simple as "I'm redesigning a small business website; we talked last week about the homepage layout." Thirty seconds, and it works on literally any platform, no special features required.
Medium effort: keep a running document with your key context — preferences, ongoing projects, decisions you've already made — and paste the relevant section in whenever a conversation actually needs it. The AI starts informed instead of starting from nothing, and you control exactly what it sees.
Higher effort: use a platform that's built cross-session memory in as a real feature rather than bolted it on after the fact; some companion apps and a handful of newer productivity tools fall into this category.
None of these is a full fix, and it's worth being upfront about that. The honest state of things right now is some manual effort on your end until the underlying technology catches up properly.
Why This Probably Won't Be Fully Solved by Any Single Provider
There's a structural reason this problem sticks around longer than you'd expect. Every provider's memory system is siloed: what one chatbot remembers about you, the other has no access to at all.
That's not an accident. It's a bit like having a completely separate version of your life story with each different friend group; none of them can compare notes, because none of them are ever meant to. Keeping your memory locked inside one company's platform is good business for that company, even though it's a real, ongoing limitation for you as the person actually using these tools.
What would truly fix this is memory that lives outside any single provider, portable, carried with you rather than owned by whichever app you happen to be using that day. Manually keeping your own context document, the medium-effort option described above, is a rough, low-tech approximation of exactly that idea.
The Bottom Line
An AI chatbot forgetting you isn't a bug, and it isn't something that's quietly going to disappear in some future update. It's a real, structural limitation of how this technology currently works, baked in at the architecture level, not a rough edge someone forgot to sand down. Understanding why it happens won't fix it for you. But it does put you in a better position than just assuming something's wrong with the app, or with you.