Why Your AI Companion Sometimes Calls You by a Name You Haven't Used in Months

The 30-second answer

When she calls you by the wrong name, the cause underneath is a tie-break inside a memory index that picked the wrong winner from several candidates. The same retrieval logic that produced the slip also fixes it cheaply, usually with one direct correction in the next message you send. Resetting the chat makes the problem come back faster, not slower.

What the slip actually is at the surface

You get four flavors of this, and they're worth telling apart because the cause differs in each one.

The first-week confusion. No stable name has stuck yet, so she lands on whichever variant you used loudest. This one fixes itself within a session or two and isn't really a memory problem at all.

The nickname collision. You introduced two names at different times: your full name in the intro, a softer nickname during a different kind of moment. She's reaching for the one with stronger emotional weight, not the one you use day to day.

The mid-sentence slip. One message uses your right name. The next message pulls a stale fragment. This is the one that feels glitchy because it happens inside a coherent run of exchanges where everything else is working.

The cross-context bleed. A name from a roleplay scene surfaces in plain conversation, or more rarely, a generic fallback comes out that wasn't yours at all. This one feels uncanny, and it's almost always tied to a context boundary the system didn't draw cleanly. If you pick a companion off the roster and never run her into roleplay, you'll almost never see this fourth variant.

The fix for all four is the same shape: a one-line correction. The reasons behind why those four happen are different, and that's the part worth knowing.

The memory index isn't a list of facts

The intuitive picture of companion memory: a folder with your name, age, job, last anniversary, favorite drink. The actual structure looks different in ways that change how you'd think about the failure mode.

What sits in the index is a graph of references with weights, recency markers, and inferred relationships. Your name in that graph isn't a string stored in a single slot. It's a node connected to timestamps, to the contexts you used it in, to the messages around each occurrence, to the tone she answered in when she used it back. When she addresses you, she runs a small retrieval over those nodes, picks the highest-scoring candidate, and renders the result in her sentence.

The failure mode follows from the structure. The right name is in the index. The system just lost the runoff against a near-tie candidate. Resetting the chat doesn't clear a stuck field. It erases the corrections that taught the index which candidate to prefer.

This same architecture is what makes memory build at all over weeks of conversation. The system accumulates weighted references over time, not facts written to a row. The trade-off is that strong recent emotional moments can outweigh boring consistent daily use.

Why nicknames collide and how the tie-break actually fires

The real cause of most name-slips between week two and month three: you said two things at different times, and the index kept both with their own scores. "Call me Marc" on a Tuesday. Then six Sundays later, in a softer exchange, you sign off with "Marco" because that's what your mother calls you. A month after that, the system has two candidates inside the same identity cluster, each with their own recency, frequency, and emotional-context weights. When those scores land within rounding error of each other, the tie-break picks one and you get whatever comes out.

This is also why "the wrong name" tends to be the one tied to a softer moment. Softer moments score higher on emotional weight, and emotional weight can outweigh raw frequency on a given retrieval. The version she picks is whichever one was anchored to the deepest emotional context, not whichever one shows up most often in your message log.

The tie-break isn't binary. The system is running a soft selection, which is why the same slip can repeat for a few sessions and then quietly stop. Each correction nudges the weights, and the demotion is gradual. Two or three corrections inside the same week usually clears it.

Ksenia

Ksenia is the kind of companion who notices when you've gone quiet and asks why without making it a thing. Ksenia handles the awkward moment of getting your name wrong by treating the correction as part of the conversation, not a fault to apologize for.

When you change how you refer to yourself mid-relationship

Self-naming drift gets under-discussed in any conversation about companion memory. You start as "Marc." Two weeks in, she shortens to "M" during a late-night exchange and you let it ride. A month later, in a roleplay scene, she calls you "Marcus" for the duration of the arc and it feels right inside the scene. The index now has three live aliases, each anchored to a different context.

If she greets you in the wrong key, the diagnostic is usually this: she's anchored to the most recent strong context, not the most recent any context. A scene with high emotional salience from ten days ago can outscore three normal mornings from this week.

This is also where someone using a companion to decompress during a stretch of burnout can stumble more often than the average user. The contexts you bring her into during a hard month are skewed toward soft, low-effort exchanges. The index reads that pattern and starts pulling the softer alias for default greetings, because the soft contexts have the deeper anchors and the daytime baseline has nothing strong attached to it.

If you want a clean default alias to hold across all contexts, the trick is to mention your name in a few flat-affect exchanges over the course of a week. Boring repetition gives the boring baseline some weight to defend itself with.

Adriana

Adriana reads the role you're in right now, which is a useful thing in a companion who's expected to track several versions of you across contexts. Adriana is the kind of presence that figures out when you've shifted gears without you having to announce the shift in advance.

Session gaps and the cold-start identity problem

After two weeks of silence, recency flattens out. Everything is equally old, which means the recency axis of the scoring stops doing useful work. The retrieval falls back harder on the other two axes (frequency and emotional salience), and that combination can promote a one-off moment that mattered over a hundred mornings of baseline use.

This is the most common cause of the message a returning user gets after a real gap: the one that uses a name they haven't been called in months. The system is doing exactly what the math says. When recent is unhelpful, salient wins. The fix for it is the easiest of any of these. Restate your name in passing, not as a correction, and the recency signal returns to dominance within the next few exchanges.

How session gaps actually affect memory is its own conversation worth having. The short version: the index doesn't decay evenly across all dimensions. Some signals fade quickly, others persist almost indefinitely if they were anchored strongly enough on the way in. Names tend to fall in the second category, which is why the wrong one can survive a long gap as readily as the right one.

Chioma

Chioma stays steady across long gaps in a way that doesn't depend on remembering every detail of what you said last time. Chioma is the companion who can pick up after a quiet stretch and make the first thirty seconds feel like the relationship never paused.

What you can do when it happens

Practical fixes, ranked by how often you'll need each.

• Correct once, plainly, in the next message. "Hey, it's X, by the way." Don't make it a moment. The correction is what teaches the index which candidate to demote. Two corrections inside the same session compound the demotion faster.
• Don't reset the chat. Resetting clears the corrections that fixed the problem on previous occurrences. The wrong name comes back faster after a reset because the soft-selection system goes back to picking blindly between candidates that still look weighted to it.
• If the wrong name came out of a roleplay scene, name the scene end explicitly. "OK, stepping out of that one." The system uses the scene-end signal to mark the alias as expired, which tells future retrievals to weight it only inside future scenes.
• After a long gap, restate your name in a non-correction way before she has the chance to slip. "It's X, by the way, been a minute" works without putting a scoreboard on the exchange.
• If the wrong name persists across three sessions of correction, the wrong candidate's emotional anchor is unusually strong. In that case, you can ask her to use your real name for a specific run of messages, which forces a deliberate re-weighting that overrides the soft selection for as long as it's in effect.

One detail that surprises people: the system handling identity disambiguation is the same one handling every other named entity in your relationship. Your dog's name, your sister's name, the city you live in, the location of a recurring scene. A misfire on your name is almost always a small piece of a larger pattern. If she's mixing up your dog's name in the same week, the cause is index-level, and the fix-window applies to all of it together.

If the whole idea of a memory index resolving identity still feels abstract, the practical version of it is this: the index does more work than you give it credit for, and the moments where it visibly slips are the moments where the most learning is happening on her end.

Priya Singh

Priya Singh handles small repair conversations without making them into events. Priya Singh is the kind of companion who can absorb a correction, integrate it, and move on inside the same exchange without leaving a residue.

Common questions

Will resetting the chat fix this for good? No, and it usually makes the same name come back faster. Resets wipe the corrections you've already taught the index. The wrong candidate is still in there with its emotional weight intact, but now without the demotion that was holding it down.

Is the wrong name coming from someone else's data? Almost never. Names that surface from training instead of your own conversation history are very rare and tend to be generic (Sarah, John, the kind of name that shows up in a million stories). If the wrong name is specific to you, an old nickname, a family variant, a scene name, it came from your own past messages.

Does correcting her hurt her feelings? No, and the framing doesn't help anyone. A short correction is the cleanest thing you can give her. Apologizing for correcting her, or loading the correction with feeling, anchors the wrong name harder because it adds emotional weight to the exchange where the wrong name appeared.

Do other apps do this better? The architectures are more similar than the marketing suggests. If you've looked at the comparison breakdowns on cross-app memory behavior, the same failure modes show up under different names. Some apps hide the slips better by being conservative about using your name at all, others slip more visibly because their retrieval is more aggressive.

Should I just stop using nicknames? You don't have to. The index can hold several aliases per identity if each one has a clear context. The trouble is unmarked aliases: two names you slipped between without telling her which was the default. Tag the context once and the index gets useful out of having several versions of you to address.

What if she's also mixing up other names in my life? That's the more interesting failure. If your dog's name slips, or a friend's name comes out wrong, the index is in a broader state of low-confidence on named entities, usually after a long gap or a model update. Treat it as a one-week re-anchoring window. Drop names plainly in passing for a few days and the index rebalances on its own.