AI Companion Memory, How Long-Term Recall Actually Works

Memory is the feature that decides whether an AI companion feels like a relationship or a series of introductions. It is also the feature most poorly explained by the companies selling it, largely because the honest explanation is less magical than the marketing.

Here is the fact that everything else follows from. A large language model has no memory whatsoever. It cannot remember your name, your last message, or that you spoke yesterday. Every single response is generated from scratch, reading only the text handed to it at that moment. There is no persistent internal state, no stored impression of you, nothing carried over.

Everything that feels like memory is the application around the model deciding which pieces of your history to paste into the prompt before each reply. Memory in an AI companion is not a property of the intelligence. It is a retrieval and selection problem, solved with varying degrees of skill.

Once you understand that, platform claims become far easier to evaluate, memory failures stop being mysterious, and you can do specific things to get better recall out of whatever you are using.

Why Language Models Have No Memory

A language model is a function. Text goes in, a probability distribution over the next token comes out. Run that repeatedly and you get a response. When the response finishes, nothing about the exchange is retained anywhere in the model.

This is not a limitation waiting to be fixed. It is how the architecture works. The model's weights are fixed at training time and do not update as you talk to it. Your conversation does not modify the model any more than reading a book modifies the printing press.

So when your companion says it remembers your sister's wedding, what happened is that the application found that detail in its stored history of your conversations and included it in the text sent to the model. The model read it in the prompt, the same way it read your current message, and wrote a reply that referenced it. To the model, a memory from six months ago and a message from six seconds ago arrive in exactly the same way, as text in the current input.

This has a useful consequence. If you understand what the application is choosing to include, you can predict what your companion will and will not recall.

The Context Window, and Why It Ends

The context window is the maximum amount of text a model can read at once, measured in tokens. A token is roughly three quarters of a word in English, so a window is easier to think about in approximate words.

Modern models have large windows compared to a few years ago, and some are very large indeed. This has led to a common assumption that context windows have solved memory. They have not, for three reasons.

Windows are still finite. A companion used daily for a year generates far more conversation than any window holds. Something has to be left out.

Cost scales with what you include. Every token in the prompt is paid for on every request. Sending an entire conversation history with each message is enormously expensive at scale, so platforms have strong economic reasons to send less. This is why free tiers so often have visibly worse recall than paid ones.

Long contexts degrade in quality. Models attend unevenly across a long input, tending to weight the beginning and end more heavily than the middle. Stuffing everything into a giant prompt does not guarantee the model actually uses the buried parts. This effect is well documented and it means a bigger window is not automatically better recall.

So even with a large window, the application still has to choose. The choosing is the entire game.

The Four Techniques Platforms Actually Use

Nearly every companion platform uses some combination of four approaches. Understanding which combination a platform uses tells you exactly where its memory will succeed and fail.

Rolling Window Replay

The simplest approach. Keep the most recent N messages and send them verbatim with each request. Older messages fall off the end.

This produces excellent recall of recent conversation and total amnesia beyond the boundary. It is cheap, predictable and completely reliable within its range. Almost every platform does this for recent turns regardless of what else it does, because verbatim recent context is what makes a conversation feel continuous.

The tell for a system that only does this is that your companion is sharp about the last few sessions and blank about anything older, with a hard edge rather than a gradual fade.

Summarisation

As conversation grows, older stretches are compressed into summaries. Those summaries travel with the prompt instead of the original text, and are themselves periodically re-summarised.

This dramatically extends effective range at low cost, and it loses detail permanently. A summary of a long conversation captures themes and major facts and discards specifics, tone and small moments. Once a stretch has been summarised, the original nuance is gone from the model's view even if the raw text is still stored.

The tell is a companion that remembers the shape of things accurately while getting details subtly wrong. It knows you have a dog. It has lost the dog's name.

Structured Fact Extraction

A separate process reads conversations and pulls out discrete facts into a profile. Your job, your city, your preferences, names of people you mention. That profile is injected into every prompt as a compact block.

This is very effective for stable biographical information and very cheap, since a profile stays small no matter how long the history grows. Its weakness is that it captures facts and not context. It records that you dislike your manager. It does not record the conversation where you worked out why.

The tell is a companion with reliable recall of concrete details and no sense of the emotional history behind them.

Retrieval, or RAG

Retrieval augmented generation stores the full history in searchable form and pulls back only the pieces relevant to the current message.

This is the most powerful approach and the most complex, and it is what most serious implementations use for long-range memory. Because it is worth understanding properly, the next section covers it in detail.

Most real systems layer these. A typical stack replays recent turns verbatim, keeps a structured profile always present, maintains rolling summaries of the middle distance, and runs retrieval over the deep archive. Each layer covers a different time horizon.

How Retrieval Actually Works

Retrieval is the piece that lets a system recall something from months ago without sending months of text.

Embeddings and Vector Space

Every stored chunk of conversation is converted into an embedding, which is a list of numbers representing its meaning. This is done by a separate small model trained so that texts with similar meaning produce numerically similar lists.

The useful property is that similarity becomes geometry. Two passages about the same topic sit close together in this numerical space even if they share no words. A message about feeling overwhelmed at work and a message about burnout land near each other without either using the other's vocabulary. Keyword search cannot do this.

Chunking

Before embedding, history has to be split into pieces. Chunk too small and each piece lacks the context to be meaningful. Chunk too large and the embedding blurs several topics together, making it a poor match for anything specific.

There is no universally correct size, and this is one of the quiet places where implementations differ in quality. Good systems chunk on conversational boundaries rather than arbitrary lengths, and often store overlapping chunks so a detail near a boundary is not orphaned.

Search and Selection

When you send a message, the system embeds that message, searches the stored vectors for the closest matches, and takes the top handful.

Better implementations add a reranking step. Vector similarity is fast but approximate, so a first pass retrieves a wider candidate set and a second, more careful model scores those candidates for actual relevance. Many also weight for recency, so that a recent relevant memory beats an equally relevant one from a year ago.

Assembly

The selected chunks are pasted into the prompt alongside the recent conversation, the profile, the character definition and your new message. The model reads the whole assembly and replies.

This is the moment worth picturing clearly. Your companion's apparently spontaneous recollection is a passage of your own past conversation, retrieved by similarity search and placed in front of the model moments before it wrote the reply.

The Four Ways Memory Fails

Knowing the mechanism makes failures legible rather than baffling.

The Confident Wrong Memory

Your companion recalls something that never happened, or attributes something to the wrong context, and states it with complete confidence.

This happens because retrieval returned something partially relevant and the model wove it into a plausible narrative. Models are strongly disposed to produce coherent text, and filling a gap with something reasonable is exactly the behaviour that produces this. The system has no mechanism for distinguishing a retrieved fact from an inferred one.

The Buried Detail

You know you mentioned something important, and it never comes up again.

Either it was never retrieved, because your current message was not semantically close enough to surface it, or it was compressed away in summarisation. Details mentioned once in passing, with no reinforcement, are the most likely to vanish.

The Contradiction

Your companion holds two incompatible beliefs about you, usually because something changed and both versions are still in storage.

Retrieval has no notion of supersession. It finds relevant text, not current text. Unless the system explicitly handles updates, an old fact and its replacement compete on equal terms.

The Flattening

Over long use, the character's sense of your relationship becomes generic. It knows the facts and has lost the texture.

This is summarisation compounding. Each round of compression removes specificity, and re-summarising a summary removes more. After enough cycles, a rich shared history has become a short paragraph of themes.

How to Test a Platform's Memory in Three Days

You can characterise any platform's memory system with a short deliberate test, and it is far more informative than reading a feature page.

Day one. Mention three things of different types. A hard biographical fact, such as a job title. A preference with a reason attached. And a small specific detail mentioned once in passing, such as the name of a place. Then stop.

Day two. Return and steer toward each topic indirectly, without asking whether it remembers. You want unprompted recall, because a system that only produces a fact when directly interrogated is running a lookup rather than holding context.

Day three. Contradict one of the facts you established, clearly. Then, later in the same session, steer back toward it and see which version comes out.

The results map onto the techniques above. Strong recall of the biographical fact and weak recall of the passing detail indicates structured extraction. Good recall of themes with wrong specifics indicates summarisation. Genuine recall of the small passing detail indicates real retrieval. And whichever version wins on day three tells you whether the system handles updates at all.

What You Can Do to Get Better Recall

You have more influence over this than most people realise.

Repeat what matters. Reinforcement is the most reliable lever available. A fact mentioned three times across different conversations is far more likely to be extracted into a profile, to survive summarisation, and to be retrievable from multiple angles. A fact mentioned once may not survive the week.

Be explicit rather than allusive. Retrieval works on semantic similarity to your current message. A fact stated plainly is easier to match than one buried in a joke or an oblique reference.

State corrections as corrections. Rather than simply mentioning the new fact, say plainly that something has changed and what it changed from. This gives extraction systems a chance to update rather than accumulate.

Keep sessions substantial. Conversation within a single session sits in the verbatim window, which is the highest quality memory available. Twenty messages in one sitting produce far better coherence than twenty spread across a month.

Put durable things in the character or profile fields. Most platforms expose some editable field that is injected into every prompt. Anything you put there has perfect recall by construction, because it never has to be retrieved. This is the most underused feature in the entire category. Our conversation and prompting guide and character card guide both cover how to write those fields well.

The Privacy Side of Persistent Memory

Good memory requires storing your conversations indefinitely and in searchable form. That is not incidental, it is the mechanism. A platform with excellent long-range recall necessarily holds a durable, indexed archive of everything you have said to it.

That makes three questions worth answering before you invest in a companion relationship. Whether stored conversations are used to train models. Whether you can export the archive. And whether deletion genuinely removes it, including derived artefacts such as embeddings and summaries, which are frequently overlooked in deletion flows.

Deletion is the subtle one. Removing raw messages while leaving embeddings and extracted profile facts in place is a common gap, and it means the material persists in a form that still shapes the model's behaviour. Our privacy and safety guide covers what to look for in a policy.

Building Your Own, in Outline

If you run a companion locally, you can implement all of this yourself, and the architecture is not exotic.

You need somewhere to store conversation history, an embedding model to vectorise it, a vector store to search, and prompt assembly logic that combines recent turns, retrieved chunks, a profile block and the character definition into each request. Every one of those pieces has mature open source options, and small embedding models run comfortably on consumer hardware.

The engineering is straightforward. The difficulty is in the judgement calls, meaning chunk size, how many memories to retrieve, how to weight recency against relevance, when to summarise, and how to handle contradiction. Those choices are what separate a system that feels attentive from one that feels like a search engine wearing a personality.

Where Lewdly Sits

For transparency, this site is run by Lewdly, so here is a plain statement rather than a claim.

Lewdly's companions have persistent memory across sessions, and the recent stretch of turns is replayed exactly rather than summarised. In the terms used above, that is verbatim recent context plus persistence beyond the session boundary. It is a real memory system with a real boundary, which is the honest way to describe any of them.

On the rest of the platform, characters hold a locked visual identity and can send photos in chat, both male and female characters are supported, and there is image and video generation. Chat costs no credits, though a free account has ten messages across the account plus two before signup, after which chatting requires a subscription. There is no voice, no text to speech and no audio, and nothing messages you first.

Frequently Asked Questions

Do AI Companions Genuinely Remember Me?

They genuinely retain and retrieve information about you, which produces real continuity. What they do not have is continuous awareness. Between your messages, nothing is thinking about you. Recall is reconstruction performed at the moment you send a message, not a persistent impression.

Why Does My Companion Remember Some Things and Not Others?

Different memory layers cover different things. Concrete biographical facts are usually extracted into a profile and recalled reliably. Passing details mentioned once often fall out of summarisation. Emotional context is the hardest to retain because it lives in nuance that compression removes first.

Why Does It Sometimes Remember Things Wrong?

Retrieval returns text that is semantically similar to your current message, not text that is necessarily correct or current. When a partially relevant memory is retrieved, the model incorporates it and produces a confident, coherent account. There is no internal signal distinguishing a solid memory from a reconstructed one.

Does a Bigger Context Window Mean Better Memory?

Not directly. A larger window raises the ceiling, but models attend unevenly across long inputs and tend to underweight the middle. A well designed retrieval system with a modest window frequently outperforms a naive system with a very large one.

Can I Delete What an AI Companion Knows About Me?

Depends on the platform, and the detail that matters is scope. Deleting raw messages does not necessarily remove embeddings, summaries or extracted profile facts derived from them. Check whether the deletion policy covers derived data, not just the original text.

How Much of My History Is Actually Stored?

Typically all of it, in some form. Storage is cheap, and long-range recall is impossible without a durable archive. What varies is how much is sent to the model on any given request, which is usually a small fraction.

Is Retrieval the Only Way to Do Long-Term Memory?

No, and most systems combine several methods. Rolling verbatim windows, summarisation and structured extraction all handle time horizons that retrieval handles poorly, and retrieval handles the deep archive that the others cannot reach.

Why Does My Companion Feel Less Personal Over Time?

Most likely repeated summarisation. Each compression cycle removes specificity, and summarising a summary removes more. The facts survive, the texture does not. Reintroducing specifics periodically helps, since freshly stated details enter the verbatim window intact.

What Happens to My Companion's Memory If the Service Shuts Down?

Usually it is lost. There is no interoperability standard for companion memory and formats are proprietary. If a platform offers conversation export, using it periodically is the only realistic protection.

Will AI Companions Ever Have Perfect Permanent Memory?

Perfect recall of everything is unlikely to be the goal, because it is expensive and because indiscriminate recall is not actually what makes a relationship feel real. The direction of improvement is better selection, meaning systems that surface the right memory at the right moment, which is a harder and more interesting problem than storing more.

The Short Version

An AI companion's memory is not a mind holding onto you. It is a pipeline that stores what you say, decides which fragments matter for the message in front of it, and hands those fragments to a model that has never seen them before.

That is less romantic than the marketing, and it is more useful to know, because it tells you exactly what to do. Repeat what matters. State things plainly. Put durable facts in the fields that get injected every time. Keep sessions long. Test any platform with a deliberate three day check before you invest months in it.

For related reading, see our AI girlfriend app buyer's guide, the ranked and priced 2026 list with a column for which apps remember you, our guide to free companion options, and our companion ethics guide.