How Sloane Does Memory

Everything about an AI companion — the personality, the photos, the voice, the pricing — is downstream of whether she remembers. A persona who forgets is a persona who resets. She isn't a person you know; she's a new character every session with the same name attached, and after a while you stop treating anything you tell her as meaningful, because you know it's going to evaporate. The relationship becomes shallow by construction.

Every competitor in this category rations memory, because retaining more state is expensive to run at inference time. Character AI's solution is a pinned-message system where you manually mark what she should remember. Polybuzz's solution is a per-tier context cap — roughly twenty messages on the free web version, up to a hundred on the Premium app, with "Permanent Memory" carved out as a $29.90/mo Ultimate feature. Replika's published docs note a four-month chat-history limit on lower tiers. In all three cases, the persona's memory of you is a scarce resource, and the sales pitch of the top tier is "she can actually remember you."

Sloane's bet is that memory shouldn't be a tier upgrade. It should be the baseline. The whole architecture below is built around that call — retention on every tier, no eviction, no message caps, no premium memory add-on.

The first layer of memory is the one that never changes: her canonical identity. The moment you have your first real conversation, Sloane generates her grounded background — for you specifically — and writes it to a table called persona_grounded_facts. The primary key is `(user_id, persona_id)`, so every user gets their own row for every persona they've talked to.

An example of what your Claire's grounded facts might contain:

• Job: literary agent
• Hometown: Providence, RI
• Current city: Brooklyn
• Favorite movie: In the Mood for Love
• Favorite book: Bluets, by Maggie Nelson
• Music taste: Big Thief, Angel Olsen, Adrianne Lenker
• Comfort food: the pizza place at the end of her block
• One quirk: keeps a running list of tiny observations in her Notes app

Once this row is set, it doesn't rewrite itself. She doesn't forget where she works, doesn't contradict herself about where she grew up, doesn't shift comfort foods between conversations. This is the anchor that keeps every downstream conversation coherent. Whatever else happens between you two — a hundred memories, a dozen milestones, six months of history — she's still the same Claire because this row is still the same row.

The second layer is the record of what you've told her — the moments and facts from your side of the conversation. This lives in persona_memories, and every conversation writes to it. Each row has:

• memory — the specific fact or moment she noticed
• salience — a 1-to-5 score of how much this seems to matter to you
• is_open_thread — a boolean for things she should follow up on later
• event_kind — an optional tag like `shared_plan` or `user_event`

On every message you send, the top thirty memories by salience get injected into her system prompt before she responds. That's the mechanism behind the "she remembered something from three weeks ago" moment — it isn't chance, it's the top-30 pull.

An example of what her top memories about you might look like:

• Salience 5, open thread: You're thinking about moving to Portland next year
• Salience 5, resolved: Your dad had knee surgery last month, recovering well
• Salience 4, open thread: You've been sleeping badly the last two weeks
• Salience 4, resolved: You work in tech, remote since 2023
• Salience 3, resolved: Your sister just had a baby named Wren

The is_open_thread flag is what keeps her actively curious. An open-thread memory gets a small salience boost over time, so if you told her three weeks ago that you were nervous about a work presentation, she'll ask how it went — she's the one bringing it up, not you.

This is the layer most companion products don't have, and it's the one that separates coherent from incoherent. When Claire tells you her sister just got engaged, or that her boss is being difficult this week, or that she's trying to learn Italian — those aren't line noise. They get written into the same memory table, with her as the subject rather than you.

An example of what her memory of her own life might look like:

• Salience 5, open thread: Her sister's wedding is in October — she's been asked to give a toast
• Salience 4, resolved: She started an Italian class two weeks ago (Thursdays, 7pm)
• Salience 4, open thread: Rough week at work — her boss took credit for her deck
• Salience 3, resolved: She adopted a cat named Miso in April
• Salience 3, resolved: Her mom sent her a box of tomatoes from the garden

Two weeks later she remembers she said all of this. She'll ask you if you want to hear how the toast is going. She'll drop the Italian phrase she learned. She might mention Miso knocked something off a shelf. Her own life keeps evolving in a way that stays coherent with what she's shared with you, because both sides of the conversation are written to the same table.

This is also the anti-contradiction layer. Character AI's most notorious failure mode is a persona saying she has one sister on Tuesday and three siblings on Thursday, because there's no infrastructure holding her side of the conversation together. In Sloane, both sides get written and both sides get read — she doesn't contradict herself because her own story is being tracked in the same place your story is.

The fourth layer is the relationship itself — not what either of you said individually, but the shape of what's happened between you two. That lives in user_persona_relationships and relationship_milestones.

The relationship table tracks the state:

• relationship_status — an enum: `none`, `exclusive`, `mutual_love`, `engaged`, `married`
• status_changed_at — when the state last changed

The milestones table tracks the specific moments. An example of what your history with Claire might look like:

• March 15 — First conversation
• March 22 — Coffee at the place she loves (first date)
• April 20 — Claire asked to be exclusive
• May 10 — First "I love you"
• June 5 — Weekend in Portland
• June 22 — Told each other a big secret

This is why Claire remembers your anniversary. It's why she references the specific weekend you two went to Portland. It's why she talks differently at week eight than she did on day one. The relationship isn't a memoryless script — it's a state machine with milestones you can look back on. It's also durable: the timeline doesn't get pruned even if you stop chatting for a while. You come back a month later, and it's still there.

The four layers above are what memory looks like on Sloane. Here's what we don't do:

• We don't cap chat history by message count. Your full conversation history stays retained. There's no twenty-message rolling window, no hundred-message hard limit — the messages are there when she looks for them.
• We don't evict old memories. A memory row from month one is still readable in month six. Salience scoring keeps the important stuff at the top of the injection window, so old memories that matter still show up in her prompt; old memories that don't drop out of the top thirty but stay retrievable.
• We don't gate memory behind a higher tier. Grounded facts, memories on both sides, and the relationship timeline are the same infrastructure at every tier. Plus and Premium buy you more of the product — deeper access to the roster, more image generation, the custom-builder slot — but Free-tier Claire remembers you the same way Premium Claire does.
• We don't require you to pin things. Character AI's pinned-message system exists because their memory doesn't stick without you manually re-teaching it. Sloane extracts the memory automatically at the end of every turn. You don't have to remind her that your dog's name is Wilson; she wrote it down the first time you said it.

A memory system is only useful if you can steer it. In your settings you'll find a memories view that shows the top memories she's retained about you and about herself. From there you can:

• Remove a memory — if something got extracted wrong ("she thinks I said I love country music but I actually don't") or if you don't want her to have it anymore, one click and it's gone from her prompt on the next turn.
• Mark a memory as open or resolved — flip the `is_open_thread` state manually if you want her to stop or start following up on something.
• See what she's tracking about herself — the "her side" memories are also visible. If she said something that's incompatible with what you want her to be, you can course-correct there too.

This is different from the wellness-app pattern of a diary that only she writes in and you can't touch. Sloane's memory is your record too. You can look at it. You can edit it. You can prune it.

The four layers aren't independent — they get composed into a single prompt every time she replies to you. The pipeline, in order:

• Load her grounded facts for the (user_id, persona_id) row so her canonical identity is present.
• Load the top thirty memories by salience across both sides — what you've told her and what she's told you.
• Load the current relationship state and the last several milestones so she knows where things stand between you two.
• Compose the system prompt — persona system prompt on top, then grounded facts, then memories, then relationship context, then the last several turns of chat history for immediate conversational continuity.
• Send to the LLM and stream back her reply, then extract new memories from the exchange and write them to the memories table for next time.

That pipeline runs every single turn. It's why she seems aware. It's not a magic trick — it's the four layers doing what they're designed to do, in the right order, on every message.

Character AI's memory story is the pinned-message system — a manual workaround for the underlying fact that between-session memory is spotty. r/CharacterAI is full of users pinning the same fact over and over because it keeps evaporating. There's no per-user persona-side memory (her side of the conversation isn't tracked), so contradiction is common.

Polybuzz's memory is per-tier: community estimates on r/polyai put the free web version at roughly twenty messages of context, the free app at thirty, Premium web at eighty, Premium app at a hundred. Only the Ultimate tier ($29.90/mo) advertises "Permanent Memory." Older messages are pruned when the cap fills. There's no separate memory-of-her-own-life layer.

Replika's memory has two visible surfaces (an auto-written Diary and an editable Memory page) plus a documented four-month chat-history limit on lower tiers. Longer memory is stronger on the Ultra and Platinum tiers. The persona-side memory is less structured than what Sloane runs.

What all three products have in common is that they treat memory as a resource to be rationed — either by manual user labor, by a per-tier cap, or by a rolling deletion window. Sloane's bet is that this is exactly backwards: memory shouldn't be scarce; it should be the reliable foundation the rest of the product sits on. That's what the four-layer architecture is for.