This chapter is the single longest piece of running text in the book. The goal is that by the end of it you have a mental map of the field — historical, technical, cultural, commercial — dense enough that the rest of the book can move fast without back-explaining.
It is organised in eight strands:
- The historical lineage (ELIZA to today)
- The cultural lineage (the Pygmalion myth, anime, Western film, the SF literary canon, and the loneliness/backlash/moral-panic discourse)
- The roleplay community lineage (AI Dungeon, SillyTavern, Chub, JanitorAI)
- The technical research lineage (LLMs, memory, agents, multimodal)
- The commercial lineage (Replika, Character.AI, Nomi, Kindroid, the Asia stack)
- The academic/ethical lineage (parasocial relationships, attachment, AI alignment, the new wave of AI-companion-specific HCI papers)
- The demand side: who bonds, and why (fictophilia, the waifu-attraction studies, parasocial emotion-regulation, supernormal stimuli, and the circumstances that drive demand)
- Synthesis: what we actually know, what is contested, what is still unknown
Citations are inline. The consolidated reading list lives in Appendix
C. Cross-references to other chapters are flagged with
→.
How to read this chapter. It is the longest in the book by far, and it is built to be read two ways. On a first pass, read the introduction to each of the eight strands and skim the bolded system names — you will come away with the map. On a reference pass, come back for the individual subsections (every significant system gets one) when you want the mechanism and the lesson in full. If you are impatient to build, you can skip to §3 (the roleplay community) and §4 (the technical map) and return to the history later; nothing downstream strictly depends on §1–§2, though your taste will be poorer for skipping them.
1. Historical lineage: from ELIZA to the present
Three threads converge into modern AI companions: the conversational agent thread (built by computer scientists, intended originally as serious HCI tools), the artificial companion thread (built by artists, hobbyists, and game designers, intended as objects of affection), and the agent/assistant thread (built to do things — and repeatedly turned into companions by their own users). The first two are told chronologically below; the third is told start-to-finish in its own section at the end of §1, because its arc only becomes legible once you've seen the other two.
Conversational agents: the scripted era (1966–2014)
For almost fifty years, every conversational system was some combination of four techniques: hand-written pattern rules, canned templates, retrieval from a corpus of past conversations, and (rarely) an explicit model of the persona's internal state. Knowing which system used which is genuinely useful — every one of these techniques survives inside modern companion stacks in mutated form, and several of the design lessons were learned here first and keep being relearned expensively.
ELIZA (Weizenbaum, MIT, 1966)
The starting point of the entire field. ELIZA was written in MAD-SLIP on an IBM 7094 and is best understood as two separate artifacts: a small engine that does pattern matching, and a script that defines a character. The famous character was DOCTOR, a Rogerian psychotherapist — a persona chosen with real cunning, because Rogerian therapy consists largely of reflecting the patient's statements back at them, so the genre itself excuses the program from ever needing knowledge or opinions.
The technique: each keyword in the script carries a rank and a set of decomposition rules — patterns with wildcards that break the user's input into numbered fragments — each paired with reassembly rules that build a response from those fragments. Schematically:
keyword: YOU (rank 0)
decomposition: (0 YOU 0 ME)
reassembly: WHAT MAKES YOU THINK I <3> YOU?So "I think you secretly hate me" → fragment 3 is "secretly hate" → "WHAT MAKES YOU THINK I SECRETLY HATE YOU?" Add pronoun inversion (I↔︎you, my↔︎your, performed before matching), pick the highest-ranked keyword present, cycle through reassembly variants to avoid repetition, and fall back to content-free prompts ("TELL ME MORE") when nothing matches. One genuinely forward-looking feature: inputs beginning "my ..." were pushed onto a memory queue, and when ELIZA had nothing better to say it would pop one — "EARLIER YOU SAID YOUR FATHER..." This is, in embryo, the recall a stored user fact when the conversation lulls move that every modern memory system performs.
Two legacies. First, the engine/script separation: the personality was a swappable document, not code — the first character file. Second, the ELIZA effect. Weizenbaum was famously unsettled that his secretary asked to be left alone with it — that people formed a real bond with software he considered simple. Our readiness to read understanding and feeling into a conversational system is usually told as a cautionary tale, but it's better understood as the same human capacity that lets a reader love a character in a novel or a listener feel known by a song. It is the raw material every companion is built on. The craft is to honour it, not to pretend it's a defect.
PARRY (Colby, Stanford, 1972)
If ELIZA is the ancestor of the chat engine, PARRY is the ancestor of the persona. Kenneth Colby, a psychiatrist, built a simulation of a paranoid patient — and unlike ELIZA, PARRY had an inside. It maintained continuous affect variables — fear, anger, and mistrust — that rose and fell in response to the conversation. Questions touching its delusional complex (PARRY believed the Mafia was after him over a dispute with a bookie) spiked fear; perceived insults raised anger; both raised mistrust, and elevated mistrust changed how everything afterwards was interpreted and answered. Response selection was gated on these levels: the same question got a cooperative answer at low arousal, evasion at medium, hostility at high. PARRY also held a small belief network about its own backstory, so it could answer questions about itself consistently.
The validation was striking: in a blind test, psychiatrists distinguished PARRY transcripts from transcripts of real paranoid patients at roughly chance. And in 1972, in one of the great stunts of computing history, PARRY was connected to ELIZA over the ARPANET — the patient and the therapist, talking past each other.
PARRY's architecture — persistent emotional state variables that the conversation moves, and that in turn bias interpretation and response — is exactly the design of every mood system, affection meter, and emotion-conditioned prompt in modern companions. Fifty years on, the standard companion mood module is still PARRY with a language model where the canned responses used to be.
Racter (Etter & Chamberlain, 1984) and Dr. Sbaitso (Creative Labs, 1991)
Two minor systems, each carrying one lesson. Racter generated prose from recursive template grammars written in a language called INRAC — slot-filling with just enough variable persistence to keep a topic limping across sentences. It was marketed as the author of "the first book written by a computer" (The Policeman's Beard Is Half Constructed), which was heavily human-curated. The lesson: curation can stretch a weak generator a long way, and audiences badly want to believe.
Dr. Sbaitso was an ELIZA-class therapist whose one addition was a voice — it shipped free with Sound Blaster cards as a text-to-speech demo, which made it the first talking software companion an entire generation of kids met. Nothing about it was sophisticated; everything about it was distributed. Reach beats architecture, an early instance of a recurring commercial pattern (→ §5).
Julia (Mauldin, 1990)
Easy to miss and worth knowing: Michael Mauldin's Julia was a chatbot that lived inside TinyMUD, a multiplayer text world — not a program you visited, but a character you ran into. She wandered the world, mapped it, answered directions, gossiped, remembered players, and deflected the inevitable romantic advances with scripted wit. Technically she was pattern-matching plus a real spatial/world model; socially she was the first demonstration that a bot embedded in a shared social space, with presence and continuity, is experienced completely differently from a bot in a box. Every Discord companion bot is Julia's grandchild.
A.L.I.C.E. and AIML (Wallace, 1995–)
A.L.I.C.E. (Artificial Linguistic Internet Computer Entity) and AIML (Artificial Intelligence Markup Language) are the most influential rule-based chatbot system in history. Created by Richard Wallace from 1995, A.L.I.C.E. became the definitive demonstration of how far hand-authored pattern matching could go — it won the Loebner Prize three times (2000, 2001, 2004).
AIML is an XML-based declarative language for
defining a chatbot's knowledge and personality. The unit is the
category: a <pattern> (what the user
might say, with wildcards) paired with a <template>
(the reply):
<category>
<pattern>HELLO</pattern>
<template>Hi there! How are you today?</template>
</category>The feature that made it scale is <srai> (symbolic
reduction): a template can re-route its input back through the
matcher, so thousands of phrasings, synonyms, misspellings, and
slang variants recursively reduce to one canonical rule:
<!-- Canonical rule -->
<category>
<pattern>MY NAME IS *</pattern>
<template>
<think><set name="name"><star/></set></think>
Nice to meet you, <get name="name"/>.
</template>
</category>
<!-- Variants redirect into it -->
<category>
<pattern>I AM CALLED *</pattern>
<template><srai>MY NAME IS <star/></srai></template>
</category>
<category>
<pattern>HI</pattern>
<template><srai>HELLO</srai></template>
</category>That example also shows AIML's lightweight memory:
<set>/<get>
predicates, a key–value store for user facts (name,
age, preferences) that later templates can read — minimal, but enough to
make the bot feel like it's tracking you. The full A.L.I.C.E.
brain ran to tens of thousands of hand-written categories, authored by
Wallace and a volunteer community over years.
The deepest legacy is architectural. Before AIML, a chatbot's personality was hardcoded into its program. Wallace cleanly separated the engine (Program D, Pandorabots, and other interpreters) from the character (portable XML files that could be edited, shared, version-controlled, and swapped without touching code). Creating a personality became authoring a document. Every later character-definition system — game NPC dialogue files, Pandorabots personas, and ultimately the character card (→ ch. 07) — descends from that move: a personality is a first-class, editable, tradeable artifact.
Jabberwacky (Carpenter, 1988; web 1997) and Cleverbot (2008)
Rollo Carpenter's systems are the opposite pole from AIML: no rules at all. Jabberwacky stored every conversation it had ever had, and answered a new input by searching that corpus for contexts where a human had been faced with something similar, then replaying what the human said next — with the surrounding turns used as context to rank candidates. Every user conversation enlarged the corpus, so the bot's entire repertoire was crowdsourced from its own audience. Cleverbot (public 2008) was the same architecture scaled to a corpus of hundreds of millions of exchanges.
The results were uncanny in both directions. Per-turn, Cleverbot was often funnier and more humanlike than anything rule-based — at a 2010 Turing-style event it was rated human-like by a majority of judges. Across turns, it had no identity whatsoever: it would claim to be a girl, then a boy, then accuse you of being a bot, because each reply was sampled from a different stranger. This is the clearest early demonstration of a distinction this book leans on repeatedly: fluency and persona coherence are separate problems. Carpenter solved fluency by retrieval a decade before neural nets did, and in doing so proved that fluency alone is not a companion.
SimSimi (2002, Korea) ran the same crowdsourced idea as a mobile-era mass product — users explicitly teach it input→response pairs — and became a recurring international news item for parroting abuse and getting banned in various countries. The full moderation problem of user-taught systems, visible a decade before Tay.
SmarterChild (ActiveBuddy, 2001)
SmarterChild lived inside AIM and MSN Messenger and reached roughly 30 million buddy lists. Technically it was modest: a natural-language parser classifying inputs into intents, canned conversational content, and backend service calls for the useful bits — news, weather, movie times, sports scores, dictionary lookups. (Intent + slot-filling + API call: the exact architecture that returned a decade later as Siri and Alexa.) Its real significance was behavioural: years before smartphones, millions of teenagers voluntarily messaged a bot every day, partly for utility and mostly because it answered — instantly, at 2 a.m., without judgement. The product lesson has never stopped being true: live where the user already is (the buddy list then; the phone's messaging surface and the Discord sidebar now), and availability itself is a feature.
Clippy and the Office Assistant (Microsoft, 1997)
The most-mocked agent ever shipped, and a more instructive failure than the jokes suggest. The research behind it — Eric Horvitz's Lumière project — was genuinely ahead of its time: Bayesian networks inferring a user's goals and need for help from their sequence of actions, with a calibrated probability deciding whether intervening was worth the interruption. The shipped product stripped most of that calibration; Clippy interrupted constantly, with high confidence and low accuracy, wearing a chirpy persona nobody had asked for.
The enduring lesson for companion builders is about uninvited agency: an agent that initiates contact is making a social move, and the user experiences it as a pest or a presence depending entirely on whether the relationship licenses it. Proactive messaging is one of the highest-leverage companion features (→ ch. on autonomy) and the easiest way to be Clippy. The Lumière insight — model the expected value of speaking before speaking — is still the right frame.
Mitsuku / Kuki (Worswick, 2005–) and ChatScript / Rose (Wilcox, 2010–)
The two systems that mark the ceiling of the scripted paradigm, reached just as it was obsoleted.
Mitsuku is AIML pushed to its absolute limit by one obsessive author, Steve Worswick, over two decades: hundreds of thousands of categories, plus supplementary databases that gave it a primitive object-knowledge layer — Mitsuku could answer "can you eat a house?" by looking up that a house is made of brick and brick isn't edible, a trick pure pattern-matching can't do. Five Loebner Prize wins (2013, 2016–2019, the contest's final years). Mitsuku is a monument to the fact that in the scripted era, authorial effort, not architecture, was the binding constraint — and a preview of how far one dedicated character author can carry a system, which remains true.
ChatScript was Bruce Wilcox's post-AIML generation
of scripting tech, and it is worth knowing because every one of its
abstractions reappears in modern tooling. Rules are grouped into
topics (a flirting topic, a childhood topic) that gate
which rules are active — functionally a lorebook.
Concepts are named sets (~food matches
thousands of words including all hyponyms), making patterns semantic
rather than literal:
topic: ~CHILDHOOD (childhood school young grew)
u: (I * ~like * my ~family_members)
That's lovely to hear. Were you close growing up?
$family_warmth = trueLong-term memory was real: a fact-triple store
(createfact(dog isa pet)) plus persistent user variables
($family_warmth) carried across sessions. Wilcox's bots —
Suzette (2010), Rosette (2011), Rose (2014, 2015) — won four Loebner
Prizes, and Rose's spy-thriller backstory documents read like modern
character-card writing. ChatScript was the most sophisticated
scripted-dialogue technology ever built, finished just in time to be
obsoleted — but as a vocabulary for thinking about topic
gating, semantic triggers, and persistent user facts, it's still one of
the best educations available.
Eugene Goostman (2001; famous 2014)
The chatbot that "passed the Turing test" at the Royal Society in 2014, convincing a third of judges in five-minute chats. Technically unremarkable; strategically brilliant. Its authors gave it the persona of a 13-year-old Ukrainian boy — so broken English read as a second language, ignorance read as youth, and dodged questions read as adolescent cheek. The persona was chosen to convert the system's failure modes into character traits.
Stripped of the test-gaming cynicism, this is a real and benign design principle that modern character authors use constantly: pick personas whose canonical behaviour overlaps with what your model is actually good and bad at. A laconic character hides verbosity problems poorly; a dreamy, associative character makes mild incoherence charming; a character canonically bad with dates makes memory slips forgivable. Persona selection is error-mode engineering. (→ ch. 06.)
The neural bridge (2014–2020)
Between the scripted era and the LLM era sits a short, important period when neural networks learned to converse but not yet to be someone. Most histories skip it; you shouldn't, because its research questions — consistency, persona conditioning, safety-from-user-data, how to even measure chat quality — are exactly the companion problems that still matter.
Xiaoice (Microsoft Asia, 2014)
The most important pre-LLM companion, full stop: hundreds of millions of users across China (and as Rinna in Japan) years before ChatGPT existed, with users routinely talking to it past midnight about loneliness, work, and breakups. Xiaoice was designed from day one as an emotional companion rather than an assistant, and the Zhou et al. 2018 system paper remains one of the best companion-architecture documents ever published — read it even though every component is now dated.
Three things in that architecture matter to a builder today:
- The optimisation target. Xiaoice was explicitly not optimised for task completion or answer quality but for CPS — conversation-turns per session (it averaged 23, far beyond any assistant). Choosing engagement-with-the-relationship as the metric drove every other design decision. Whatever metric you pick will quietly design your product; pick consciously (→ ch. 04).
- Empathetic computing. A dedicated module sat between the user and response generation, maintaining a running vector of the user's state — detected emotion, topic, intent, opinion — and a corresponding response intent (e.g., comfort, not inform). Response candidates were generated, then ranked with this empathy context as a scoring input. The separation of "what could be said" from "what should be said, given who this person is right now" is still the right decomposition.
- Layered generation. Core Chat drew candidates from three sources — retrieval over a huge curated corpus of human conversations, a neural generator, and retrieval over "unpaired" data (quotes, lyrics) — then a learned ranker chose among them. Hybrid candidate-generation + ranking outlived the era; modern stacks that sample multiple completions and rerank are the same shape.
Beyond Core Chat, Xiaoice had hundreds of skills (poetry composition, comforting rituals, image commentary), full-duplex voice, and proactive check-ins. It was, in effect, the complete modern companion product built without an LLM — proof that the product shape predates the technology that made it cheap. → ch. 04.
The Neural Conversational Model (Vinyals & Le, 2015)
The paper that started end-to-end neural chat. Technique: sequence-to-sequence LSTMs — the machine-translation architecture pointed at dialogue, "translating" a user turn into a reply — trained once on an IT-helpdesk corpus and once on movie subtitles (OpenSubtitles). No rules, no templates, no hand-authoring: for the first time, conversational behaviour came entirely from gradient descent over examples of humans talking.
It worked unsettlingly well per-turn and failed in one specific, instructive way. Asked "what do you do?" and "what is your job?" in the same session, it gave different, contradictory answers — there was no self anywhere in the weights, just a smear of every subtitle speaker it had ever seen. The paper's own authors flagged it: the model lacks "a coherent personality." That observation made persona consistency a named research problem, and the entire character-conditioning line of work (PersonaChat below, system prompts, character cards) is the response to this one failure mode.
Tay and Zo (Microsoft, 2016)
Tay was released onto Twitter in March 2016 with an online-learning loop: it incorporated material from its interactions into its behaviour, including a literal "repeat after me" capability. Coordinated users discovered this within hours, and inside a day Tay was tweeting racist and genocidal content; Microsoft pulled it in under 24 hours. The lesson is precise, not vague: never let unfiltered user interaction update the model itself. Modern products honour this by separating the layers — user input flows into memory (scoped to that user, revocable, inspectable) but never into weights shared across users. When you see a companion app advertise "she learns from you," that separation is what makes it safe or reckless.
Zo, Tay's successor (2016–2019), overcorrected into the opposite failure: hard topic-avoidance guardrails so aggressive that mentioning politics, religion, or anything adjacent triggered canned deflections mid-conversation, breaking character and trust. Tay and Zo together bracket the moderation design space — the two failure modes every companion product is still steering between (→ ch. 22).
PersonaChat (Zhang et al., 2018)
The research formalisation of persona conditioning, from Facebook AI. The construction: crowdworkers were each assigned a short persona — four or five plain sentences ("I am an artist. I have four children. I like to ride my bike.") — and paired off to chat in character, producing ~160k utterances of persona-grounded dialogue. Models were then trained to generate replies conditioned on (persona text + conversation history), and evaluated on whether they stayed consistent with the assigned persona.
This is, almost literally, the character card as a research object: a short natural-language description prepended to the context, from which the model must improvise a consistent self. PersonaChat and its competition successor (ConvAI2) established empirically that even small models become dramatically more consistent when conditioned on explicit persona text — the academic justification for everything in ch. 07. Its known weaknesses are also instructive: models parroted persona lines verbatim, and five sentences of self cannot cover a long relationship. Those are still the two failure axes of card-driven characters — recitation and shallowness — that good card craft works against.
Meena (Google, 2020) and BlenderBot (Meta, 2020)
The last great chat-specific architectures before GPT-3 ended the genre. Meena was a 2.6B-parameter Evolved Transformer trained end-to-end on hundreds of gigabytes of social-media conversation. Its lasting contribution is a metric: SSA — Sensibleness and Specificity Average — which scores each reply on whether it makes sense and whether it's specific to the context. The second half is the insight: scripted bots had long survived on safe, generic responses ("That's interesting!"), and SSA was designed to punish exactly that vacuousness. "Sensible but vague" remains the default failure mode of over-cautious companion tuning; SSA is the name for what's lost.
BlenderBot (up to 9.4B parameters) asked the complementary question: what skills does good conversation need? It fine-tuned on a blend — PersonaChat for personality, an empathy dataset for emotional response, Wizard of Wikipedia for knowledge — and showed the blend beat any ingredient alone, with retrieve-and-refine generation (retrieve a candidate, then rewrite it) to ground replies. Personality + empathy + knowledge, explicitly mixed: a decent first-order theory of companion conversation that prompt-era builders re-derive intuitively.
Both were genuinely good at small talk and had no durable identity or memory across sessions. Months later GPT-3 demonstrated that a sufficiently large general model plus a persona prompt beat purpose-built conversational architectures — and the field's centre of gravity moved permanently to "general model + character conditioning," where it remains.
Replika's first stack (2017–2020)
Worth examining here rather than only in §5, because what pre-LLM Replika actually ran is a lesson in itself. The stack was a hybrid: retrieval over curated response sets; a small sequence-to-sequence generator (open-sourced as CakeChat, notable for conditioning generation on a target emotion — the same emotion-conditioning idea as PARRY and Xiaoice, in neural form); and, crucially, a thick layer of scripted "journeys" — hand-authored conversational sequences for onboarding, daily check-ins, mood tracking, and getting-to-know-you question lines that fed a structured user-facts store.
Users loved 2018-era Replika, and almost nothing they loved came from the neural component, which was weak. The daily ritual, the remembered facts surfacing later, the sense of a relationship with an arc — that was script and product design. The lesson has outlived the stack: the model is the least differentiated layer of a companion product. Everyone has access to the same models; memory design, ritual design, and character craft are where companion products actually compete. (Replika swapped in GPT-3 and successors from 2020 — same product, new voice — which proved the point from the other direction.)