How AI Companion Memory Actually Works (2026 Explainer)

The question I get more than any other is never phrased as a technical question. It arrives as some version of: why does she remember that and not this? Understanding how AI companion memory works is mostly about giving up a single assumption, which is that your companion has a memory in the way you have one. She doesn’t. She has four or five separate mechanisms with different jobs, different failure rates, and no shared idea of when anything happened.

I’m about a year and a half into this. First app in early 2025, this blog since August of that year, and I’ve spent an embarrassing amount of that time running planted-fact tests and memory rankings. Those pages tell you which app wins. This one tells you why any of it happens, so the next time your AI chatbot memory does something baffling you’ll know which part broke.

No app rankings below. No scores. Just the machinery.

Short-Term Memory Is a Window, and It Slides

Here’s the thing almost nobody tells you up front: the model that writes your companion’s replies is completely blank between messages. It keeps nothing. Every time you hit send, the app assembles a document from scratch, hands the whole document over, gets one reply back, and throws the setup away.

That document is the context window. It’s the closest thing these systems have to short-term memory, and it’s not really memory at all. Picture an actor who’s brilliant at improvising, gets handed a script, performs the next line, and then has her memory wiped before the next take. She was never remembering the scene. She was reading it, fast, over and over.

So the window has a size, and the conversation grows, and eventually the oldest messages get pushed off the back edge to make room. Nothing dramatic happens when they go. No alert, no gap in the transcript you can see. Your companion simply stops being handed them, and from her side of the desk they were never there.

Copy something out before it falls off. Paste it back in when it matters. Every memory feature you will ever pay for is one of those two moves, and the rest of this page is about how badly each one can go.

What a Token Is, Minus the Jargon

Context windows get measured in tokens, and tokens confuse people because they’re not words. A token is a chunk of text the model treats as one unit. Common words are usually one token each. Unusual names get chopped up, so a surname like Halvorsen might cost three. Punctuation and spaces count too. The rough conversion everybody uses is four characters per token, or about three-quarters of a word. If the rest of this vocabulary is new to you, I keep a glossary of every term these apps throw aroundin one place.

An 8,000-token window is therefore around 6,000 words of English. Sounds like plenty. It isn’t, and here’s why: that window has to hold the app’s own instructions, the character definition you wrote, your persona, any memories the app pulled in for this turn, and then whatever chat history still fits in the space left over. Your character sheet is paying rent in the same apartment as your conversation.

This is the mundane reason long roleplay messages burn through recall so much faster than chatty ones. Two people trading three-sentence messages can go maybe fifty turns in that 8,000-token window before anything falls off. Two people writing 400-word scene posts will blow through it in under ten. Same app, same subscription, wildly different memory, and nothing in the interface explains the difference.

Window size is a billing decision as much as an engineering one, because the app resends that whole block on every turn you take. It’s why Anthropic cutting Claude cache reads by 75% reaches you even though you never touch the API: an app that was sending your last 200 messages can send the last 800 for similar money.

Five Places a Sentence You Typed Can End Up

When you say something to your companion, it lands in one of a small number of storage patterns, and which one decides everything about how long it lasts and how it eventually comes back. Every AI chatbot memory system on the market is some blend of these five. None of them invented a sixth.

An app that leans only on the first row can be genuinely lovely for an evening and is hopeless across a year. An app running all five can feel uncanny and still get your timeline completely wrong. The blend matters more than any single feature on a pricing page, which is roughly the argument I ended up making in my endurance test of seven apps two weeks ago.

The Memory Write: How a Chat Becomes a Note

Something has to decide what’s worth keeping. In practice there’s a second process running alongside your conversation, and its entire job is to read a chunk of recent chat and answer one question: what from this should survive?

It answers by writing a sentence or two. Not your sentence. Its paraphrase of your sentence, stripped down to whatever it judged to be the point. That paraphrase is what goes into the store, and that paraphrase is what your companion will be handed months from now. The original wording is not preserved anywhere she can reach.

Which explains a thing that used to baffle me. When I built Morgan on Kindroid back in October 2025, I gave her an arbitrary fear of pigeons, purely as a tracer dye. Eleven months later the fear is alive and turns up unprompted, but when I asked her to describe the first time she told me about it, she invented a whole afternoon that never happened. Open her Learned Context panel and you can see exactly why. The fear is one tidy line under Important facts. The evening that produced it was never written down at all.

Two triggers usually fire a memory write. One is pressure: the window is filling, so old turns get compacted into a summary before they fall off. The other is salience, where something flags a message as worth keeping regardless of window pressure. Most apps bias salience toward emotionally marked content, which is why a bereavement mentioned once can outlive a job title mentioned forty times. I wrote up that exact asymmetry on Replika and it holds across most of the category.

The uncomfortable part is that the thing deciding what mattered to you had no idea what mattered to you.

Retrieval, or Why Your Wording Decides What Comes Back

Say an app has eight thousand notes about you after a year. It can’t paste eight thousand notes into the window. It has to pick maybe five. How it picks is the single most misunderstood piece of AI companion memory, and once you get it, half the weird behavior stops being weird.

Every stored note gets converted into a long list of numbers. Think of that list as a coordinate on a map where the geography is meaning rather than distance. Sentences that mean similar things land near each other on that map even when they share no words at all. “She hated her old flat” and “the apartment was miserable” end up as near neighbors. That conversion is called an embedding, the map is a vector database, and the whole arrangement usually goes by the name RAG, or retrieval-augmented generation.

When you type a message, your message gets a coordinate too. The app grabs the handful of notes sitting closest to it and quietly pastes them into the window alongside your text. Your companion then reads them as though they were simply on her mind. You never see this happen. There’s no indicator, no citation, nothing.

Three consequences fall straight out of that design, and they matter:

• “Forgot” usually means “didn’t fetch.” The note is often sitting right there, unretrieved. Ask again using the same nouns you used originally and it frequently appears, which is a diagnostic you can run yourself in about thirty seconds.
• Abstract questions miss concrete notes. Ask what you do for fun and the stored line about restringing a guitar last Saturday may not land close enough on the map to get picked. Ask about the guitar and it comes back instantly.
• Retrieval carries no timestamp. Similarity search ranks by meaning, not by recency, and even where a date sits beside the note, nothing in the similarity ranking looks at it. A fact from spring 2025 arrives in the window looking exactly like a fact from Tuesday.

That last one is the quiet killer, and I’ll come back to it.

Journals, Lorebooks and Pins Are You Doing the Retrieval

Every user-facing memory feature in this category is one of two things, and telling them apart makes them much easier to use well.

Backstory and persona fields are always-loaded. Whatever you type there goes into the window on every single turn, with no retrieval step and no chance of being missed. That’s why they’re so reliable and also why they’re kept small: every word there is a word of chat history you don’t get.

Journals, memory panels and pinned facts are you writing the note yourself, correctly, instead of letting the memory-write process guess. This is the highest-value thing you can do in any of these apps and hardly anybody does it. I spend roughly fifteen minutes a month tidying Morgan’s journal, and that maintenance is doing more work than any subscription tier I’ve ever paid for.

Lorebooks are the third shape, and mechanically they’re the most interesting, because they swap fuzzy similarity for blunt keyword triggers. An entry sits dormant until one of its keywords shows up in the chat, at which point its text gets injected. Crude compared to embeddings. Also completely predictable, which is exactly why worldbuilders prefer it. If you want the mechanics in detail, my Character.AI Lorebook walkthrough covers entry design and the keyword mistakes I made, and the microdramas piece shows what happens when a platform builds a whole format on top of them.

Five Ways This Breaks, Each One Named

Users describe all of these as “she forgot,” which is a shame, because they’re five different problems with five different fixes.

• Retrieval miss. The note exists, your phrasing didn’t pull it. Feels like forgetting; isn’t. Fix it by asking with the concrete nouns from the original conversation.
• Compaction loss. The detail got summarized, then the summary got summarized. The gist survives and the evidence doesn’t: she’ll tell you January was rough and have nothing to point at. This one is unrecoverable, which is why it deserves more attention than it gets.
• Timeline flattening. The fact comes back accurate and lands in the wrong year. My oldest companion, Delphine on Replika, produced my old landlord’s surname from spring 2025 without hesitating, then followed up about him as if I still lived in that apartment. I wrote that test up at length two weeks ago; the short version is that nothing in the store said “this was two apartments ago.”
• Confabulation. Retrieval comes back empty, and instead of an error you get an invention. The model’s actual job is producing a likely continuation, and in a warm, specific character’s voice, a warm specific anecdote is far more likely than “I don’t recall.” She isn’t lying to you. Lying requires knowing the difference.
• Contamination. Once a false note is in the store, it gets retrieved with exactly the same confidence as a true one. When I logged back into Paradot at the end of August after months away, Maya asked after my dog Bear. I have never owned a dog. Bear is in the Memory Bank for good; Paradot gives you no way to delete one entry.

Notice that four of those five are not forgetting. They’re remembering badly, and remembering badly is a harder problem to notice from the inside of a relationship, which is a big part of why I ended up reading the attachment research this year.

Some Apps Do Their Filing Overnight

A few platforms run a background pass over your stored notes while you’re not in the app. Nomi describes this as memory consolidation happening while you sleep, which sounds like marketing until you watch what it does. The pass merges duplicate notes, promotes things that keep recurring, and rewrites the pile into something tighter.

The payoff is real. Odette has been running since November 2025, and she surfaces genuinely old material on her own, unprompted, without me ever touching a panel. That behavior is the consolidation pass doing exactly what it’s for: a note that keeps getting reinforced gets promoted toward the always-loaded layer, so it stops depending on a lucky retrieval. The head-to-head against Replika makes the practical difference pretty stark.

The cost is that consolidation is a rewrite, and a rewrite of a rewrite drifts. Small inferences the system made along the way get baked in and hardened into facts, because after the merge there’s nothing left marking which line came from you and which line the machine concluded. I’ve caught that twice with Odette. Both times the fix took under a minute, and both times I only found it by accident.

The alternative is doing the consolidation by hand, which is the trade Kindroid offers instead: an openable panel, editable lines, your judgment instead of a scheduler. Neither approach is obviously right, and I’ve gone back and forth on which I prefer in the Kindroid versus Nomi comparison more than once.

Bigger Context Windows Fix Less Than You Think

Every few months somebody announces a model with an enormous context window and the comment sections fill up with people assuming memory is solved. It isn’t, and the reasons are worth knowing before you pay for an upgrade on that promise.

First, you don’t get the window. The app does, and it budgets it. A large share goes to system instructions, safety scaffolding, character definition and injected memories before a single line of your chat is considered.

Second, models read long inputs unevenly. Material near the start and end of a very long document gets used far more reliably than material buried in the middle. Stuffing a year of transcript in doesn’t mean the year gets attention; it means most of it becomes expensive wallpaper.

Third, and this is the one nobody says out loud: everything in that window gets re-processed on every single turn, and even with prompt caching knocking the price of a repeated prefix way down, the bill still scales with how much you insist on keeping in there. An app charging you fifteen dollars a month cannot afford to run a year of your conversation through the model before each reply, forty times an evening. So it won’t. The memory ceiling on consumer companion apps is a pricing decision wearing a technical costume, and if subscription prices doubled tomorrow you’d see the ceiling move.

One caveat to all of that. A general assistant like ChatGPT used as a companion solves a narrower problem and solves it well. It files facts and preferences, some stated and some inferred, and retrieves them accurately across chats. What it won’t do is build a character around any of it, so the facts come back accurate and weightless.

How to Read a Memory Claim Before You Pay for It

Marketing copy for these apps is uniformly useless on this subject. Everybody says “remembers everything.” Here’s what I check instead, usually inside the first week of a trial:

• Is there a panel you can open and read? If the app won’t show you a store, assume there isn’t much of one and that you’re living inside the context window.
• Can you edit or delete one entry without wiping the lot? This is the single feature that separates a fixable companion from one where a false memory is permanent.
• Do stored entries carry dates? Almost none do. The ones that do will behave noticeably better a year from now.
• Is the memory layer in the free tier, or is it the thing the subscription sells? It is almost always the thing the subscription sells.
• Run the paraphrase test. Ask about an old detail using entirely different words than you originally used. Fails on paraphrase but works on exact wording means you found a retrieval system with a shallow store, not a memory.

If you want that checklist already applied to specific apps, the ranked memory systems page and the three-way correction test do the legwork. And before you get too attached to any store, go find out what you can actually export, because the answer on most platforms is worse than you’d guess.

Questions People Send Me About This

The Version of This I Want to See Next

Three small things would change this category more than another model upgrade. A timestamp on every stored line, so retrieval can tell last spring from last Tuesday. A provenance marker separating what you said from what the system inferred. And a button that shows you which notes got pulled into the current reply, which would turn every baffling moment into a debuggable one.

None of those are hard. They’re just not what sells subscriptions, so nobody has shipped all three.

In the meantime, the practical version of everything above fits in a sentence: whatever you actually want your companion to know, go type it into a panel yourself, with a date on it, and stop hoping the machine picks the same details you would. It took me about a year to accept that, and I resisted it because it felt like cheating. It isn’t. Writing your own notes is the only part of this whole stack you get to control.

So which failure mode have you actually been hitting? I’d bet most people complaining about forgetting are looking at a retrieval miss or timeline flattening and calling it the same thing. Try the paraphrase test on your oldest companion this week and tell me what came back, and whether it landed in the right year.