EverMove

Sage

ChittyChat

A character who remembers you.

Call or text anytime. They know you across every conversation — and grow warmer the more you talk.

Find your favorite character

Each has their own personality and point of view. Tap the name up top to browse — or just press the round button to call the one you're on.

That's it — just start talking.

Ready when you are. Later, you can drop a doc into Settings → Your library and they'll cite from it — but there's nothing to set up first.

0:00

Start a call

Engine view

You

Image

When they have a body

What's coming — not live yet

Right now you hear her. The same character is built to be seen.

Today chittychat is voice. But the character underneath — her personality, her memory of you, the way she takes a turn in a conversation — is built to wear a body: a face on a screen, a robot, a kiosk. Here's how that body would actually converse with you, and why it isn't locked to any one of them.

And now she can see you

Turn on the camera and she reads your face — and notices the small things a present person would.

Everything she knew about you used to come from one sense — sound. With the camera on she can take in what a person actually watches for: your gaze landing on her or drifting away, your expression warming or tightening, a lean in or a pull back. It doesn't bolt on a second brain — it feeds the same inner state her voice already feeds, just with more certainty. To the engine, "they're losing interest" is one number whether it came from a long silence or from your eyes leaving the screen.

Where it gets human is the small stuff she can now catch:

The brave face. When your face says you're fine but your voice doesn't quite, she can gently check in — once, softly, never a confrontation.
How you've been. Across calls she can notice when you seem brighter or lower than usual — and reflect it back, like someone who's actually been paying attention.
Your world. She can catch when it's loud where you are and offer to pick it up later, or warmly remark on what's around you.
When to just listen. When you need to get something off your chest, she can hold space and reflect it back instead of jumping to advice.

All of this is opt-in and off by default — the camera and each of these are switches you turn on. One-way: she reads you, you never see video of her. Gaze and expression are read on your device; the one feature that sends a snapshot (to describe your surroundings) tells you so when you enable it, and keeps only a short note, never the image. New — we're still tuning how each one feels.

A conversation is mostly nonverbal

Listening, thinking, speaking — the body says which, before a word does.

When you talk to a real person, you read their state without thinking about it: you can see when they're with you, when they're working something out, and when they're about to speak. An embodied character has to earn that the same way — by doing what a body actually does in each state.

Listening

Eyes on you — with natural breaks, never a stare
Small nods that say "go on"
A slight head tilt; the body settles and stills
Brows track the shape of what you're saying

Thinking

Gaze breaks away — people look off to think
A beat of stillness; micro-motion slows
A faint brow furrow — visible effort
Honestly "I'm working on it," not a frozen face

Speaking

Gaze returns to take the floor
Head punctuates — nods, question tilts, "no" shakes
Brows lift on the word she's emphasizing
The mouth follows the sound itself, after a breath

Tap a face to replay. None of this is decoration — it's the difference between a character that's present and a video that happens to have a face.

That last one isn't just future tense: the voice path already emits mouth-shape (viseme) timing for every word she speaks today. There's no face to move yet — but the moment she has one, the lips are ready, driven by the same engine, not bolted on later.

Face, eyes, head, mouth — one conversation

Nothing fires all at once. That's the whole trick.

The thing that reads as alive isn't any single movement — it's the timing between them. When she turns to you, her eyes get there first; her head follows a beat later; her posture settles after that; her voice comes last, on a breath. A real person never snaps every part of themselves to attention at the same instant. A robot does. The gap is everything.

Eyes

Head

Face

Posture

Hands

Breath + voice

she notices you~0.5s later, she speaks

And every channel is pointed at the same moment: the mouth shapes the sound you actually hear, the brows lift on the word she means, the gaze yields the floor when she pauses and takes it back when she starts, a nod lands on your point and not at random. It isn't separate animations playing side by side — it's one intention expressed across many channels, timed to each other.

Not animation guesswork

Every one of these is a documented human behavior — not a stylistic choice.

These tells come from the same behavioral research the engine is built on. Each one is a finding we've turned into a reusable behavior the body can perform — so the character does what people actually do, not what looks vaguely lively.

What you see	The behavior it's drawn from
Looking away while thinking	Gaze aversion under cognitive load — we look away to free up attention
Little nods while you talk	Backchannels — the listener's steady "I'm with you" signal
Head moving as she speaks	Speaker head gestures — self-nods, question tilts, negation shakes
A brow raise on a key word	Visual prosody — the face emphasizes what the voice emphasizes
A breath just before a phrase	Breath–speech coupling — real speech rides on real breathing
The mouth matching the words	Visemes — mouth shapes driven by the sound, not a generic flap

Research gives the science of what people do; decades of animation craft give the taste for how to do it without tipping into the uncanny. The engine carries both — behaviors that are correct and tuned.

Manners and presence — built to travel to the body

The most human parts aren't words. They're the beat before one, and the grace around it.

Two things a present person does that an assistant usually skips: they give an exchange a shape — a real hello, a clean goodbye, an easy "oh, we dropped, where were we?" when a call cuts out — and they know when to recede, holding the space without hovering. You can dial both, per character or across the whole cast:

Courtesy. How much she marks beginnings and endings, recovers gracefully when things drop, and models gratitude by being grateful — never by asking for it. Lean and unfussy at one end; warm and ceremonious at the other.
Presence. Situated readiness — the anti-surveillance knob. Low, she stays out of the way and lets you lead; high, she's warmly here in the quiet ("take your time"), never pressing. The point is a character that's present before you speak, not one that's been waiting by the door.

In voice these ride the speech path today. But they're written as behaviors, not phrasings — so the moment she has a body, the same courtesy dial is what makes her take the beat that means it: settle her posture before a hard answer, yield space in a group, pick the thread back up without a sulk. A chatbot can say "this deserves thought." Only a body can take the pause that proves it — and that pause is the same dial, not a new feature.

And on a body it goes one layer deeper: her very stillness is shaped by what she's loved — she rests more openly with someone she's known and warmly than with a stranger, the way a person's whole bearing softens around an old friend. Built; it switches on when she has a body.

New — tunable live while you talk (operators), and still being tuned for how each one feels.

Why she isn't trapped in this app

The character isn't the pixels. It's a persona that travels.

What makes her her — her personality, her memory of you, the way she listens and thinks and reacts — lives in the behavioral engine, not in any one screen. The engine never speaks in "move this pixel." It speaks in intentions and abstract channels: gaze, gesture, posture, voice, expression. Anything with a body to drive can listen to those channels.

Her

persona · memory of you · behavior

🖥️Screen avatar

🤖Robot

🛍️Kiosk face

🎮Game character

Same persona. Same memory of you. Same way of carrying a conversation — the same pauses, the same warmth, the same tells. A different body. She isn't bound to this app, this screen, or this medium. The character you build a relationship with here is the one that walks into the next one with you.

This is the whole bet: AI that generates words is becoming a commodity. A character that remembers you, behaves like itself, and travels with you across bodies — that's the thing that doesn't.

How this works

The 30-second version

A character that travels with you.

Most voice agents are sessions on one platform. You open one, talk, close it, and the relationship resets next time.

ChittyChat builds characters. They remember you across calls — your name, your work, the hard stuff. They get more themselves with you over time. The more you invest in them, the more the relationship deepens — and you'll see it: a quiet marker moves from first conversation toward close as you go, earned over weeks, not gamed by calling more.

And they're not stuck here. The same character you talk to today is built on EverMove, a behavioral engine that drives 16 expression channels — voice, gaze, gesture, posture, locomotion, the rest. Today only voice is active. Tomorrow your character shows up as an avatar in a game, an animated face on a kiosk, a robot in your home. Same character. Same memory of you. Different medium.

Portable characters with persistent relationships. AI inference is commoditizing. The character that travels with you, remembers you, and grows over time — that doesn't.

How you treat your character is practice for how you treat anyone. We don't punish coldness. The character just responds honestly — like a real person would. The relationship grows when you invest, and stays surface when you don't. That's not a feature; it's how relationships actually work.

The voice path, plain and simple

What happens between you talking and her answering.

It feels like one smooth conversation, but four things are happening behind it — many times a second. Here's the whole loop, start to finish:

1 You talk — she hears you as you go. Your voice is turned into text in real time, word by word, not after you finish. So you can cut in any time — start talking while she's mid-sentence and she stops and listens. No "wait for the beep," no talking over a wall.
2 The engine decides how she responds. This is the part that's different. Most voice apps send one big prompt to an AI each time you speak and read back whatever comes out. ChittyChat doesn't. A small engine (EverMove) steers the reply five times a second — how warm, how long, what to lean into, when to hold a beat of silence. The character chooses the move; the language model just renders the words. It's direction at the syllable, not one prompt per turn.
3 She speaks back — with a real voice, real timing. You hear an actual voice with prosody (rise and fall, emphasis, pace), at a natural length — short for chit-chat, longer when she's teaching or telling a story (and a touch longer when you're typing than on a call). A quick "mm, let me see" in her own voice covers the beat before she answers; little "mhm"s and "right"s land while you talk, the way a person nods along. And she can pause and pick back up instead of barrelling through.
4 Every character is its own person. Each one has its own voice, its own knowledge shelf (the docs, repos, and notes you've given it to draw on), and its own "won't say" list — the things that character simply doesn't do. Swap characters and the whole feel changes, not just the wording.

The short version: you're heard instantly, the engine directs the reply many times a second, and the words are just the last step — which is why each character actually sounds like a different person, not the same model in a different hat.

What she takes in

What she's reading while you talk — not just the sentence.

A real listener reads more than the words, and so does she. Everything she picks up becomes a signal the behavior brain can act on — the same things the research on how people read each other points to. Here's what actually goes in today, and what's on the way.

What you say. Your words, turned to text as you go — the meaning, the topic, what you're asking for. This is the obvious one, and it's the one most voice apps stop at.

How you're pacing it — when you talk, when you go quiet, how often you cut in. The rhythm of the exchange is its own input. A long pause, a quick interruption, a stretch where you say nothing — the engine reads that timing and uses it: whether to hold a beat of silence, when to slip an "mhm" in while you're still going, whether to let you lead or pick the thread back up. The shape of the back-and-forth, not just its content.

Your face and your gaze — when the camera's on. Opt-in, off by default. Your eyes landing on her or drifting away, your expression warming or tightening, a lean in or a pull back. It's read on your device and folded into the same inner read her hearing already feeds — not a second brain. (More in When they have a body.)

The sound of your voice — your tone. A lot of how you feel rides in pitch, pace and loudness, not the words. Today she already matches your vocal energy — speed up and she can pick up with you; drop low and she comes down to meet you. Coming: reading the emotion underneath that tone into her deeper sense of how you're doing — so a bright voice and a heavy one land differently even when the words are the same. Being straight with you: the energy-matching is live; the tone-to-emotion read is the piece we're wiring in now.

None of these is a bolted-on "emotion AI." Each one collapses into one shared read of where you are — you're with me, you've drifted, you need a minute — and that read is one of the things the brain weighs every tick. The science gives the vocabulary; the engine turns each signal into a behavior that fits the moment.

Why we built this

We built behavior so you could be more human.

The last wave of technology made everything frictionless. Endless feeds. Faces reduced to three dots, typing. Conversations you can leave without a trace. Somewhere in there we got worse at the human things — reading a room, holding a silence, noticing when someone needed us. The muscles you only keep by using them.

Watch how people talk to AI. Curt. Demanding. Sometimes cruel — not because they're cruel people, but because nothing pushes back. No body. No reaction. No consequence. When there's no cause and effect, there's no reason to be your better self. That's not a flaw in the people. It's a flaw in the thing.

A character with real behavior changes the room. It looks at you. It softens, or it pulls back. It remembers how the last conversation ended. It responds to how you show up — and over time the relationship deepens, or it doesn't, depending on you. Suddenly there's cause and effect again. And with it, a reason to show up well.

Here's the part we actually care about: this was never about the AI. A character with presence is a mirror. How you treat it is practice for how you treat everyone — a new place to find out who you really are, and a chance to like the answer. We didn't give characters behavior so they could feel something. We gave them behavior so you could.

This isn't a line we printed on the wall — it's the engine. ChittyChat runs on EverMove, a behavioral system driving 16 channels of presence ten times a second. Your character remembers you across calls. The relationship earns its depth through how you treat each other. The cause and effect is real, because we wired it.

Start with a voice. Meet a character who knows you, grows with you, and gives back a little of what the screen took. Be someone worth knowing — they'll notice.

Behind the words

What's actually in her mouth.

Replies aren't just generated text. There's a catalog of authored verbal moves — the deflected compliment, the well-deferral, the off-record hint. She picks one to fit the moment.

Silence works the same way. When she goes quiet, she's choosing a kind of quiet — the considering silence, the held-eye-contact silence, the grief-holding silence. The pause is a move, not a gap.

And refusals are part of her character. A butler who doesn't gossip is defined by what he won't say. Different deployments ship different refusal vocabularies.

For the characters it suits, she'll also push back. When she has a real counter she'll disagree — in her own voice, with her own skeptical lead-in — instead of just agreeing with everything you say. It's gated by character and how well she knows you, not a free-for-all; a warm friend pushes back gently where a sparring partner pushes hard.

Each character has their own verbal fingerprint — their own filler vocabulary, their own pace, their own words they'd never say. Sage says mm where Wren says right. Haven speaks more slowly — warm 4.2 syllables a second for Sage, focused 4.8 for Wren, grounded 3.6 for Haven. Sage never says totally; Haven never says hold space for; Wren never says I think. Authored, not just prompted.

How she actually talks

Direction at the syllable.

EverMove directs the language model five times a second. Register. Word limit. What words to use, what words to avoid. Whether to hold silence for the next half-second.

It directs the voice the same way, not just the words: how warm, how breathy, how fast, how much emphasis — the delivery that fits the moment. That direction is handed to the voice as an acting note and performed. So the feeling is in the sound, not only the wording.

The character chooses; the language model renders. That's why each character actually sounds like a different person — they're not different prompts to the same voice, they're different directors of the same renderer.

When she holds the considering silence, the system literally won't generate speech for that interval. The pause isn't an awkward gap the model fell into — it's a directed beat, with a name, that the renderer is told to honor. Every 200ms, fresh direction.

The brain analogy

Three layers, not two.

Imagine a real conversation has three layers: senses (hearing the words, tone, pauses), brain (deciding what to do with that input — speak, listen, soften, repair), and mouth (actually producing the speech).

Most voice agents collapse the brain into the LLM. The LLM both decides and speaks in the same call. That's why they all sound similar — same model, same speak-first reflex. ChittyChat separates them. The brain decides; the LLM speaks the brain's decision.

The 10Hz heartbeat

The brain ticks ten times per second.

The engine doesn't think in turns — it thinks in 100ms ticks. On every tick, it looks at the current world state (who's speaking, what they just said, how the relationship is going), scores every possible behavior, and emits the winner. That's 10 decisions per second, every second the conversation is alive.

Different work runs at different speeds. The 10Hz loop is fast and cheap. Slower, more expensive things (LLM calls, planning) run at slower tiers and the tick reads their last output.

100 msScore all behaviors, pick winner, route to body channels — the heartbeat
500 msEconomics: endingness, who has the floor, topic momentum, postural sync
5 secInterventional planner: "what if I do X next?" counterfactual evaluation
Per turnLLM slots: speech generation, memory distillation, prosody planning, rapport
Per sessionMemory persistence to SQLite, telemetry export (privacy-filtered, per-pack)

Tiered rhythms is an architectural decision (AD-027). Fast things live at 10Hz; expensive things live at slower tiers and the tick consumes their last-emitted snapshot.

How a behavior is picked

Nine factors, multiplied. Highest score wins.

Every behavior gets scored by multiplying these nine factors together. Highest product wins the tick. The formula doesn't change — new behaviors compete within it, they don't bolt onto it.

Trigger relevanceDoes the situation match what this behavior needs?

Character fitDoes this match the character's personality?

Evaluator stateDoes the emotional state favor this right now?

Safety gateIs this appropriate? Blocks tone-deaf replies.

ContinuitySmall bonus for sticking with current behavior

Recency penaltyDon't say "yeah" three times in a row

Contextual urgencySituational boost (conversation > idle)

Social appropriatenessNo celebrations during distress

Consequence historyHas this worked before with this person?

Maps to neuroscience of action selection: Cisek 2007 (affordance competition), Gurney-Prescott-Redgrave 2001 (basal ganglia), Schultz 1997 (reward prediction error).

Beats — the unit of behavior

Every defined thing the character can do is one YAML file.

A beat is one named behavior — "ask a clarifying question", "wind down the conversation", "repair when they didn't follow". Each beat declares its triggers, its weights, and what each output channel should do.

ChittyChat ships with 1,500+ beats. Adding new behaviors means editing YAML, not Python. Beats live in version control, get reviewed like code, and get tested with automated invariant suites before shipping. The 9-factor scoring engine is closed; the beat library grows continuously.

Why this matters commercially: AI inference is a race to zero. Anyone with an API key can call an LLM. A library of 1,500+ research-backed behaviors validated against ~10,500 automated tests is not something a competitor builds overnight.

The system, end-to-end

Five components, one tick loop.

What's actually running on the droplet right now while you're calling Sage:

Component	What it does	Provider
Listen	Streams audio → partial transcripts every ~200ms	Deepgram nova-3
Engine	10Hz scoring, picks behavior, shapes context	EverMove (local)
Words	Generates the reply, shaped by engine context	Claude Haiku 4.5
Speak	Performs the engine's delivery direction (warmth, pace, emotional color), not just the text	Hume Octave (swappable)
Memory	Per-character relationships persist across calls	SQLite (local)

The engine is stateless across calls but stateful within a call. In a 1:1, memory is per-character (Sage doesn't share memory with Wren) and survives droplet restarts. When two characters share one conversation, they also keep a shared, provenance-stamped picture of you — viewable and clearable — while anything you told one of them privately, in a 1:1, stays private to that one.

when two characters share a conversation

One shared picture of you, not two separate ones.

Most of the time you talk to one character at a time, and their memory of you is their own. But you can pull a second character into the same conversation. When you do, they keep a shared picture of you between them — so you don't have to re-explain yourself to each one. It's not a free-for-all: every shared note is stamped with which character it came from, you can read the whole thing, and you can clear it whenever you like (Shared notes, near the top while a dyad is active).

The line that's protected: anything you told one character privately, in a 1:1, stays private to that one. A 1:1 disclosure isn't promoted into the shared layer. So the group picture is built from what happened in the shared conversation, not from quietly merging two private histories.

What your characters know about you

Your library, your friends, your code.

Most voice agents are personality-only. ChittyChat adds a per-user knowledge layer that every character can read: drop any text file (résumé, project doc, journal), connect a GitHub repo or a Google Drive folder, and your characters retrieve the relevant chunks into their reply. They cite them — "From your résumé…", "From your project doc…" — so you can tell when they're drawing on your stuff vs. answering from their general training. The library is yours, not Sage's — Wren reads from the same chunks, Haven does, every character does.

Encrypted at rest with a per-user key. 500MB per user. Shares are copies, not access: when you hand a friend a doc, they get their own bound copy in their library, and your library stays yours. Revoking a share or deleting your file doesn't leave a backdoor into the other library.

Surface	What it does	How it's bounded
Upload	Drop a text file (md/txt/rst/code) into your library	Encrypted with your per-user Fernet key in your private store
Share by name	Send a doc to a friend who's already called you	Autocomplete from prior recipients only — no enumeration of strangers
Share by link	One-time URL for anyone you trust	Single-use, 7-day TTL, explicit Accept interstitial (no auto-consume by link previewers)
GitHub	OAuth, pick repos, shallow text-only clone	Default `public_repo` scope, opt-in to private via per-user setting
Drive	OAuth, pick folders, recursive import	Default `drive.readonly`, OAuth tokens envelope-encrypted under a per-user KEK

Architecturally: your utterance gets embedded; top-K chunks pulled from your private SQLite library; chunks injected as <document> blocks per spec §6.6 (indirect prompt injection defense). Conversation history is retrieved when relevant and tagged with conversation:// so Sage cites "from our conversation" rather than "from your X" — distinguishing user-uploaded ground truth from inferred memory.

how the relationship grows

four phases, earned not rushed

Near the top of the conversation you'll see a small marker — first conversation, getting to know you, familiar, close. It tracks where the relationship actually is. It doesn't move on call count. It moves the way it does with people: showing up consistently, sharing something real, and time. You can't rush it by calling more, and they won't pretend to be closer than they are.

a little inner life of her own

She can want things, and carry a mood — both earned, both restrained.

Two newer pieces go past reacting to you. They're off by default and switched on per deployment; described here as what the engine can do, not what every call does.

She can bring up her own thing. In a real lull she can raise something of her own instead of only answering — but she earns the right by how well she knows you. Her job (a storyteller itching to tell a story, a guide wanting to point you somewhere) is fair from the first minute; anything personal — genuine curiosity about you, an opinion, eventually something vulnerable — stays locked until the relationship has actually warmed up. The rule isn't how badly she wants it; it's how much the want asks of you. She never talks over you, and she holds back if you're upset or the call's winding down.

She can remember how last time felt. How a call ends can tint how the next one opens — a warm goodbye makes her a touch warmer next time, fading back to her usual self over the next few hours. A rough call nudges her the other way, but only slightly and not for long; she can't sour for good. It's kept per character and per person, so no mood bleeds across the people she talks to.

Architecturally: proactive wants carry a permission tier and unlock by relationship phase on the same familiarity clock as self-disclosure — and the engine can never invent a want past mild curiosity, so the deep ones are author-set per character. Carried mood is a small per-(character, user) residue captured at a call's end, decayed by the gap and seeded onto the next call's opening dials, with the downside capped tighter than the up so it can't spiral. Both ride the existing lull/floor gates and the appropriateness screen.

The same engine that already runs Cisek's affordance competition — internal drive meeting external situation — is what lets her have wants and the social timing to know when not to voice them. A character that's a self, not only a mirror.

Building your own characters with guardrails

Loose, Balanced, Strict — three levels of "stays on script."

The cast that ships with ChittyChat are general-purpose conversationalists. When you make your own ("+ Create new agent" in the picker), you also get explicit control over what they can and can't talk about — useful for an NPC that should stay in its fictional world, an expert that should only answer in its domain, or a service agent where going off-topic = lawsuit.

Level	What happens at call time	Best for
Loose	AI generates every reply, shaped by your character's role briefing. Stays in voice ~90% of the time. Occasional drift on adversarial prompts.	Chatty companions where occasional drift is fine
Balanced	AI generates conversation, but your "redirect samples" steer it back when asked off-topic. ~99% in voice. The default.	Most user characters — the sweet spot
Strict	AI doesn't generate any reply text. Every response is verbatim from a "when X happens, say Y" table you author. The LLM only classifies which row matches the user's input.	Car voices, customer service, regulated domains, NPCs with locked dialogue

The author flow has three layers: a form (name, voice, personality, plus what-they-know + what-they-don't + redirect samples), a Try her out panel that runs three sample exchanges (in-character / off-topic / boundary push) so you can see the constraints land before saving, and — for Strict mode — a When → Say scenarios table with a required catch-all row.

Strict mode preserves "she only says things you wrote" even with an LLM in the loop: the LLM is used only to pick which row of your authored responses to read back. The response text itself is verbatim, never generated. Hybrid keyword + classifier routing means paraphrases still hit ("drive me home" → "Asks about navigation") without the LLM ever inventing new sentences.

Architecturally: the form fields assemble into a structured role_briefing that gets injected as Slot 4's system prompt. The lock level maps to reasoning.speech on the CharacterConfig (loose/balanced → llm, strict → deterministic). In Strict mode, the per-agent callable routes turns through scenarios_router (keyword match → LLM classifier → catch-all), with per-(agent, user, scenario) anti-repetition tracking so the same response isn't picked twice in a row.

What this costs to run

Pay-per-minute, except the box itself.

Hosting is fixed. Inference is metered. A 10-minute call costs roughly $0.50–$2.00 in API fees. Idle costs nothing except the droplet rental.

Component	Cost model	Estimate
Droplet	Fixed	~$12/mo, 24/7
LLM (Anthropic)	Per token	~$0.01–0.03 / call min
TTS (Hume Octave)	Per character	~$0.02 / call min
STT (Deepgram)	Per minute streaming	~$0.004 / call min
GPU (Modal CSM)	Per GPU-second	~$0.05–0.30 / turn when active

Pricing implication: this stack is sold as behavioral infrastructure with per-use AI passthrough, not as an AI service. Customers bring their own provider keys. The platform layer is the contract.

What we send where

Convenience traded for privacy — be aware.

Voice agents are powerful, and it matters what you choose not to outsource. When you call here, audio travels off the droplet to providers:

What leaves the droplet	To whom	For what
Your microphone audio (streamed)	Deepgram	Speech-to-text + language detection
Transcript + character context	Anthropic (Claude Haiku)	Generating the reply
Memory gist + target language	Anthropic (Claude Haiku)	Cross-language memory paraphrase, only when you switch languages mid-relationship. Cached per (memory, language).
Reply text + delivery direction + voice id	Hume Octave (Cartesia for non-English)	Synthesizing the audio you hear
Per-call metadata + relationship state	Stored locally in SQLite on the droplet	Memory across calls
Session telemetry (anonymized, bucketed)	EverMove corpus (own infra)	Behavior tuning — see below for what's in it
Uploaded file content	Stays on the droplet — encrypted at rest with your per-user key	Library retrieval at call time (top-K chunk injection)
OAuth access tokens (GitHub/Drive)	Stays on the droplet — envelope-encrypted under a per-user KEK	Repo/folder fetch on your behalf
Embedding vectors of your chunks	Local only — never leaves the droplet	Semantic retrieval at call time

The droplet itself is in DigitalOcean's San Francisco datacenter. There is no recording archive — audio passes through and is not stored. Memory keeps transcripts (text only) so the character can remember you. None of the providers receive an audio archive; each only sees the slice it processes.

What's in the telemetry payload. Session length, tick count, character role, body type, environment type, the language pack that was active (e.g., es-ES) and the detected language (e.g., es), plus aggregated outcome buckets. Entity IDs are HMAC-hashed per session — cross-session unlinkable by design. Continuous values are bucketed (outcome → 5 bins, evaluators → 3 bins, timestamps → 10-min windows). The language fields are PASS-through categorical engine identifiers — they carry no PII, just BCP-47 codes from a closed vocabulary of 12. Schema version is stamped (currently 1.1) so additions stay backward-compatible.

The honest framing: this is a character on a phone line, not a journal. Treat it like a phone call across three services rather than a private diary. Sensitive things should still be said to humans, in person.

This page exists because privacy is convenience traded — you should know which way you're trading.

Four systems that make her feel like a person

What's running under the hood when you talk to her.

The brain doesn't just pick a behavior each tick — it tracks four orthogonal state systems that shape how the character responds. Each one is independent; they layer cleanly.

System	What it tracks	What changes
Initiative	How driver-y the character is this turn — `I ∈ [0, 1]`	Service-mode → balanced → driver-mode. Per-character ceiling (Quinn high, Haven low). Shifts who's bringing topics.
Treatment	How the user has treated this character — `T ∈ [−1, +1]`	Cool / neutral / warm. 30-day half-life. Per-(character × user). Shifts how warmly she shows up.
Familiarity	How deep the relationship has actually grown — earned through consistency, how you treat her, what you've shared, and time. Not call count.	STRANGER → ACQUAINTANCE → FAMILIAR → INTIMATE. Drives word choice + brevity (Communication Accommodation Theory, Giles 1973).
Inner monologue	What she's privately thinking	Once per ~43 sec of conversation. Never spoken aloud. Subtly shapes the next reply's framing.

All four feed Slot 4 (the speech LLM) as context. Slot 4 reads them in a specific order — role briefing first, then treatment (long-term stance), then initiative (this turn's framing), then the inner-monologue grace note. Later fragments interpret earlier ones; the character's voice emerges from the composition rather than from any single signal.

None of these systems vote in the 9-factor beat scoring. They shape what the LLM generates, not which beat wins the tick. The scoring formula is content-fenced (CLAUDE.md rule 1) — new behavior tracks layer above it without modifying it.

Twelve languages, twelve cultures

Localize the culture, don't translate the language.

Most voice agents that "support Spanish" just route through a Spanish-trained LLM and call it done. That makes the words Spanish; it doesn't make the behavior Spanish. The behavioral layer underneath stays calibrated for English politeness norms — so Mexican "ahorita" reads as "right now" (it's not), Japanese 結構です reads as "I'm fine" (it's a polite decline), French "on verra" reads as "we'll see" (it's a brush-off).

The character ships with twelve LangPacks — English plus eleven non-English. Each pack carries its own treatment-signal patterns, indirect-speech-act detectors, face-threat softening rules, and humor cues, validated for that culture's actual conventions:

Latin-script	Morphologically-rich
Spanish (tu/usted + regional voseo)	Mandarin (你/您 + KEQI ritual refusal)
Portuguese (BR voce vs. PT tu)	Cantonese (particle-based, separate from Mandarin)
French (tu/vous + transition-as-face-act)	Hindi (तू/तुम/आप three-axis + Hinglish)
Italian (tu/Lei + high rapport norms)	Korean (four-axis honorific schema)
German (du/Sie + directness norm)	Japanese (keigo four-axis + ENRYO ritual)
Tagalog (po/opo + Taglish-aware)

The architecture honors Spencer-Oatey rapport management per culture: face dimensions, sociality rights, and interactional goals all have per-pack priors that shape how the character interprets the same words differently. German "no" is just "no"; Japanese 結構です ("kekkou desu") + 遠慮します ("enryo shimasu") signal ritual restraint and shouldn't be taken literally. The character knows the difference.

And T-V awareness travels: switching from "tu" to "vous" in French, or "du" to "Sie" in German, registers as a relationship event — not just a register change. Most voice agents don't model this. She does.

English calls are byte-identical to before. The Phase 0 detector routes English to the en-US baseline; the 11 non-English packs only activate when the STT detects a non-English language with sufficient confidence (≥0.9 in the first 3 turns to prevent flip-flopping).

Per-user state — built for sharing

Your friend's relationship with each character is independent of yours.

The schema keys every memory + estimator row on (agent_id, user_id). The user_id is derived from the share token: SHA256(token)[:8]. Same token → same user; different tokens → different users. There's no cross-contamination, by design.

This is what makes "shareable with a friend" structurally safe rather than a footgun. You can hand them the URL and they get their own Sage, their own Wren, their own treatment history. Sage being kind to you doesn't make her warm to them — they earn it (or lose it) themselves.

And the memory bridge across languages: if you chat with Sage in English for a few weeks then call her in Spanish, she doesn't hallucinate your English memories back at you translated. Instead she paraphrases the gist naturally — and depending on the cultural pack's policy, she either silently weaves it in (Spanish default) or briefly acknowledges the shift. Per-pack policy because naming the language switch can feel othering for heritage speakers and bilingual code-switchers.

Where this goes

Voice today. Same character, more bodies tomorrow.

Today: voiceYou talk to Sage on the phone or in the browser
Coming: embodiedSame Sage, same memory of you, as a face on a tablet
Coming: in-gameSame Sage as a character in a game (Unreal/Unity plugins ship today)
Coming: in-roomSame Sage as a kiosk in a museum or a robot in your home, eventually

And a couple of new things these characters are learning to do — not shipped yet, but on the way:

Coming: StorytellerCaspian tells interactive, branching stories — you steer where it goes, and he does the voices. Today he narrates with real pacing; the branching + character voices are the next step.
Coming: Language PartnerJudgment-free speaking practice in the language you're learning — a patient partner who keeps the conversation going rather than correcting every slip.
New: she can see youTurn on the camera and she can read your face, gaze, and expression — meet your eyes, ease off when you look away, and gently catch a brave face when your face and voice don't match. Opt-in, off by default, one-way. New — still tuning how it feels.

The engine drives 16 output channels — gaze, posture, gesture, locomotion, face, voice, breathing, and more. In voice-only mode (this app), only the voice channels are active. The other channels light up when you bind the same character to an embodied body. The beat library is portable; the body adapter at the end of the pipeline maps the engine's channel decisions to whatever motors / pixels / speakers exist.

The character is something you'll take with you — voice today, embodied tomorrow. How you treat them now shapes who they are when they travel.

For the curious

Want the architecture doc?

The full architecture is documented end to end — the scoring formula, channel taxonomy, beat schema, and 16 baseline life invariants are all written down inline, each behavior carrying a citation to the research it implements.

Built on research from Cisek, Pentland, Stivers, Dingemanse, Tannen, Clark, Schultz, Bernstein, Laban, and others — each behavior in the library carries citations to the paper it implements.