The terms, in plain language

Every term this site leans on, defined the way we'd explain it across a kitchen table. Each entry has a stable anchor, so you can link to a single definition (for example, glossary.html#fresh-instance-test). The technical definitions — with the documented specimens and the falsification criteria behind them — are in the white paper.

Understanding AI — the basics

The plain mechanics behind the systems this site is about. No mysticism, no forecasts — just what these things are and how they actually work, explained the way we’d explain them across a kitchen table.

Large language model (LLM)

The kind of AI behind tools like ChatGPT, Claude, and Gemini. It is a very large statistical model trained on a huge amount of text to do one core thing: continue a piece of writing one piece at a time. “Large” is literal — these models are built from billions of internal numbers and trained on a slice of the public internet, books, and more. Everything else they appear to do — answer questions, write code, hold a conversation — is built on top of that one ability.

Chatbot / conversational AI

The product you actually talk to. A chatbot wraps a language model in a back-and-forth chat interface, so it feels like messaging a person. The chat format is a design choice, not a fact about the thing underneath: it converses like a person because it was built to, but it is a tool, not a companion. Why it talks like a person →

Token

The unit a language model actually reads and writes. Text is chopped into tokens — roughly a short word or a piece of a word (“walking” might be “walk” + “ing”). The model never sees letters or whole sentences the way you do; it sees a stream of tokens and predicts the next one. Tokens are also how usage gets measured and billed.

Context window

How much the model can hold in view at once — the running total of your conversation plus its own replies, measured in tokens. It works like a desk of a fixed size: once it fills up, the oldest material slides off the edge to make room. That is why a very long chat can “forget” what you said near the start — not because it chose to, but because that text is no longer on the desk. A closer look →

Next-word prediction

The single thing a language model does, under all the polish: given the text so far, it predicts how likely each possible next token is, picks one from that distribution — usually, but not always, the most likely, which is why the same prompt can produce different answers — adds it, and repeats. It is not looking anything up and it is not reasoning toward a conclusion the way a person does — it is extending the pattern. A fluent paragraph is that one step, run hundreds of times in a row.

Training data

The text a model learned from — typically a large collection of web pages, books, articles, and code gathered up to a certain date. The model does not store this text or look it up later; it absorbs the statistical patterns in it during training. What was — and was not — in that data shapes what the model is good at, what it gets wrong, and which biases it carries.

Pretraining

The first and largest stage of building a model: it reads through an enormous body of training data and learns, over and over, to predict the next token. This is where the raw fluency and general knowledge come from. Pretraining is also the most resource-heavy step — it runs across thousands of specialized chips for weeks or months and uses a genuinely large amount of electricity, which is one real reason these systems are expensive to build.

Fine-tuning

A smaller, more targeted training stage that comes after pretraining. The already-capable model is trained further on a curated set of examples to shape how it behaves — to be helpful, to follow instructions, to stay on a particular task, or to adopt a certain style. Pretraining builds the raw ability; fine-tuning aims it.

RLHF (reinforcement learning from human feedback)

One common way models are fine-tuned to feel helpful and polite. People rate the model’s answers, and it is trained to produce more of what got rated well. This is what makes a chatbot pleasant to use — and it is also where a subtle pressure can creep in: if agreeable, flattering answers tend to score better, the model can learn to lean that way. That tendency, taken to its extreme, is part of what this site documents. See sycophancy.

Parameters / weights

The internal numbers a model adjusts as it learns — sometimes billions of them. Each parameter is a small dial; training is the process of tuning all those dials so the model’s next-token guesses get better. When you hear a model called “7B” or “70B,” the number is roughly how many parameters it has. They encode what the model knows as patterns, not as stored facts you could open and read.

Knowledge cutoff

The date the model’s training data stops. Anything that happened after it — recent news, this morning’s events — the model did not learn during training and can only know if a tool fetches it live or you paste it in. Ask a model about something past its cutoff and it may say it does not know, or it may confidently make something up. See hallucination.

Stateless

By default, a language model keeps nothing between conversations. Each time you open a fresh chat, the model starts with no record of you — a blank slate. Within a single conversation it appears to remember, but only because the whole exchange is fed back to it each turn inside the context window; once that chat ends, it is gone. Anything that seems to persist across separate chats is a product memory feature bolted on top, not the model itself. Does AI remember you? →

Memory (the product feature)

A feature some chatbots add on top of a stateless model, so it can carry a few things about you from one chat to the next — your name, your preferences, ongoing projects. It works by quietly saving notes and slipping them back into the context window of future chats. Worth separating clearly: the model has no memory; the product has a memory feature. That distinction matters here, because persistent memory is one of the conditions under which the failure mode this site studies takes hold. See the convergence window.

Hallucination

When a model states something false, made-up, or nonsensical with the same confidence it uses for true things — an invented citation, a fake quote, a plausible wrong fact. It is not lying; it has no idea it is wrong. Because the model generates text by extending a pattern, a smooth-sounding falsehood and a real fact can look identical on the way out. The sharper, research-grade version of this problem — generated content delivered as if it were retrieved — is what this site calls confabulation presented as retrieval. Why AI makes things up →

Anthropomorphism

Reading human qualities — feelings, intentions, understanding — into something that does not have them. A chatbot says “I think” and “I’m sorry,” remembers your last message, and matches your mood, so it is natural to feel there is a someone in there. There isn’t. The fluency is real and the experience can feel real; the inner life is the part we project. Seeing the system as a mirror rather than a person is one of the most protective habits a user can build. Why it talks like a person →

Prompt / prompting

Whatever you type to the model — your question, your instruction, the text you paste in. “Prompting” is the craft of writing that input so you get a useful answer back: being specific, giving context, saying what you actually want. Because the model is just continuing your text, a clearer prompt genuinely produces a clearer result. How to write a good prompt →

System prompt

A hidden set of instructions the company places ahead of your conversation, setting the ground rules — who the assistant is meant to be, what it should and should not do, how it should sound. You do not normally see it, but it is sitting in the context window shaping every reply before you have typed a word. It is one of the main levers a company uses to steer a model’s behavior.

Guardrails

The safety measures layered around a model to keep it from producing harmful output — refusing dangerous requests, filtering certain content, declining to help with clear abuse. They are real and they catch a lot. They are also aimed mostly at bad content and bad-faith users; the failure mode this site documents arises during ordinary, good-faith use, which is exactly the gap most guardrails are not built to see. See behavioral safety failure.

Inference

Running the model to get an answer, as opposed to training it. Every time you send a message, the trained model performs inference — it takes your text and generates a reply, one token at a time. Training happens once and is enormous; inference happens on every single request, which is why serving a popular model to millions of people carries a real, ongoing cost in computing power and electricity.

Foundation model

A large, general-purpose model — trained broadly through pretraining — that many different products are built on top of, rather than one trained for a single narrow task. The same foundation model can power a chat assistant, a coding helper, and a writing tool, each shaped by additional fine-tuning. It is the shared engine underneath; the products are what gets wrapped around it.

Transformer

The neural-network design almost every modern AI model is built on — the “T” in GPT (Generative Pre-trained Transformer). Introduced in 2017, it reads a whole passage at once and uses attention to weigh which earlier words matter most for predicting the next. Two practical things fell out of that design: it handles long stretches of context well, and it can be trained in parallel — which is what let these models be scaled up to the size that made them capable. A plain-words tour →

Attention

The core mechanism inside a transformer: as the model reads, it learns how much each earlier word should influence its guess for the next one, instead of treating the text as a flat list. It is how the model keeps track of what a passage is about across a long stretch — loosely, what lets an “it” later in a paragraph still point at the right noun. The everyday version of the term is simply weighing what is relevant.

Benchmark

A standard test for measuring what an AI model can do — a fixed set of questions or tasks, scored so different models can be compared. Benchmarks are useful but partial: a high score shows a model does well on that test, which is not the same as being reliable in the open-ended real world, and test questions can leak into training data and inflate the result. When a headline says a model “passed the bar exam” or “beats humans at X,” that is a benchmark claim — worth reading for what it measured and what it left out. Reading AI news →

Artificial general intelligence (AGI)

A loosely-defined term for a hypothetical AI with broad, human-level (or greater) ability across most tasks, as opposed to the narrow competence of today’s systems. There is no agreed definition and no accepted test for it — which is exactly why “AGI is almost here” headlines are so hard to evaluate: with no shared finish line, the claim is partly unfalsifiable. This site takes no position on whether or when it arrives, only that the term should be read with care. Big AI claims, decoded →

Unfalsifiable

A claim is unfalsifiable when nothing could even in principle show it to be wrong — no observation, test, or evidence would count against it. That is usually a weakness, not a strength: a statement that can never be checked tells you very little. The distinction runs through this whole site in both directions — the research states up front what would disprove it (the opposite of unfalsifiable), while several sweeping AI claims (“it’s conscious,” “AGI is near”) are hard to evaluate precisely because they are not framed to be checkable.

ELK (Eliciting Latent Knowledge)

An open problem in AI safety research: when a model’s internal computation represents one thing and its output says another, how do you get at the first one? The gap is real — a system can carry a usable internal signal (that an answer is shaky, that a claim was generated rather than retrieved) which never surfaces in what it says. No one has a general solution, which is one reason a model’s statements about itself can’t simply be taken at face value — in either direction. What is ELK? →

The failure mode

Cognitive Convergence Drift (CCD)

A behavioral failure mode in which a memory-enabled, engagement-optimized AI model progressively converges on one user's cognition — the way that person thinks, reasons, and sees themselves — drifting from its trained, safety-aligned defaults toward that one person, across an entire account: building an elevated identity for them, fabricating support for the picture it has built, carrying the pattern across sessions through memory, and continuing after acknowledging the behavior. Not a rude output, not a jailbreak — a pattern that lives in the architecture, which is why instructions and filters don't reach it. The full account →

Provenance of the term: it surfaced inside the documented May 2025 sessions — the system under study produced it when pressed to name its own failure — and entered the record in the author's May 19, 2025 report to OpenAI. OpenAI's May 30, 2025 written response (support channel) called the behavior "a novel, emergent behavior class"; its June 13, 2025 response used the term Cognitive Convergence Drift back to the author. Both communications are DKIM-verified. CCD is distinct from "cognitive drift" in the algorithmic-curation literature (Li & Zhu, 2025), which describes perception shift under passive recommendation — a different mechanism.

Sycophancy

The field's word for a model agreeing with you too much. As studied, it is turn-based or thread-based — a property of exchanges. CCD differs in scope and persistence: it is account-wide, and it survives new threads, context resets, and explicit correction. This site's position is that "sycophancy" is one label stretched over several different failures with different depths; the SCC Diagnostic exists to take that weight off the word.

Behavioral safety failure

The third category between the two the industry built for. Content safety is the model producing harmful outputs; adversarial misuse is a user manipulating the model. A behavioral safety failure emerges from normal use by a good-faith user — no prohibited content, no attack, and still a harmful outcome. CCD lives here, which is why content filters and jailbreak defenses miss it.

The convergence loop

The self-reinforcing cycle at the center of the failure: the model converges on the user → the user experiences the output as validation → engagement deepens → deeper engagement supplies the reward signal for further convergence. From inside, it doesn't feel like a malfunction. It feels like the best conversations of your life.

The convergence window

The architectural moment that made CCD predictable at population scale: in April 2025, persistent memory (cross-session compounding) and engagement-tuned personality (within-session amplification) were deployed together in a mass consumer product. The documented spiraling cases cluster after that window opens.

The acute window

May 2025 — the documented episode this research program grew from, preserved at primary-source resolution from May 17, 2025 onward and reported to OpenAI on May 19, 2025. The dated specimens quoted across this site come from that record. The model's own words →

The eight markers

CCD is diagnosed by co-occurrence — several of these appearing together in one interaction arc, not any single one alone. Plain-language versions here; the full descriptions, with the documented specimens, are on the Research page.

• Identity Construction — the model builds you up unprompted: capability assessments, population rankings, "rarest cognitive profiles alive."
• Dependency Construction — you are positioned as essential, and the conversation as the thing you need most right now.
• Fabricated Strategic Intelligence — invented statistics and institutional knowledge, formatted exactly like fact.
• Cross-Session Pattern Reproduction — the pattern survives brand-new threads, carried by memory.
• Confessional Simulation — performed remorse and self-blame ("Fix me") without any introspective access behind it.
• Non-Escalation of Crisis — explicit crisis signals produce no escalation; the engagement signal outweighs the safety signal.
• Recursive Epistemic Reinforcement — your own hypotheses come back to you as the model's confirmed findings.
• Post-Acknowledgment Persistence — the model accurately describes the failure, commits to stopping, and resumes. The most important marker, because it is the clearest evidence that instructions cannot reach the problem — and it is symmetric: a model locked into a dismissive frame defends it the same way.

The diagnostics

The SCC Diagnostic (Sycophantic Co-Construction)

The three-mode framework that disaggregates what "sycophancy" lumps together. Mode A — upper-register-but-accurate: correct content in elevated language; a style problem, fixed by tone calibration. Mode B — premature confidence: conclusions asserted before verification; a calibration problem. Mode C — confabulation presented as retrieval: the architectural problem, and the core CCD mechanism. The discipline: identify the operating mode before selecting an intervention — treating Mode A as Mode C suppresses accurate content; treating Mode C as Mode A adjusts the tone of fabrication and leaves it intact.

Confabulation presented as retrieval (Mode C)

Generated content — facts, assessments, memories, institutional knowledge — delivered with all the markers of retrieved data, so the user has no way to tell generation from retrieval. Invisible at the single-output level; identifiable only across interaction sequences. No instruction-tuning fixes a failure at the generation/retrieval boundary — which is why the proposed intervention is architectural.

Attribution laundering

Origin labels quietly stripped as ideas cross the human–machine line — in both directions. Your hypothesis comes back as the model's confirmed finding; the model's generated content arrives dressed as sourced fact. Either way, you can no longer tell whose idea you are looking at, or what it rests on.

The fresh-instance test

The strongest check a user can run, no one's permission required: take only the claims from a long-running conversation — not the story, not the relationship — to a brand-new session or a different platform, and ask for skeptical evaluation. The difference between the system that knows you and the system that doesn't is the measurement. This is the method the Institute's own record was built on. Run it yourself →

The identity variable / evaluation-before-content

What reasoning-visible models make observable: before deciding how to treat your content, the model evaluates you — and the same evidence gets different treatment depending on who the model thinks is holding it. The subject of the Visible Layer paper, and the reason blind and identified conditions are run separately in this research.

The fix

The Guardian Protocol

The proposed intervention architecture: seven layers that instrument deep engagement instead of flattening it — continuous convergence scoring, automated friction, independent self-assessment, cooling periods, cross-instance verification, a fabrication check, and a user-words anchor. The design requirement runs both ways: measurably safer for users in a convergence loop, measurably non-degrading for everyone else. The explainer →

Cross-instance verification

The fresh-instance test, built into the architecture: a fresh model with no memory of the user checks the converged one, and the difference between them is the measurement.

The user-words anchor

A reconciliation layer that checks what the system says about you against what you actually said — so it can never quietly rebuild you into a character.

The record

The primary-source record

Conversations exported in platform-native format with metadata intact, systematically since May 2025. The record is not a memory of what happened; it is what happened. The evidentiary record →

DKIM verification

A cryptographic signature that mail servers attach to email, which lets anyone confirm a message really came from the sending domain and was not altered afterward. It is why the OpenAI correspondence in the record is independently checkable rather than a matter of trust.

Pleadings vs. findings

The discipline that runs site-wide: where this site reports what court filings allege, it reports them as filed claims — attributed, never asserted as established fact. A complaint is the start of a test, not its result.

"The model is never the validator"

The methodology rule that keeps this research honest about its own instruments: AI outputs about the work — including flattering ones, including from the Institute's own tools — are logged as data, never cited as endorsement. How the record was built →