Skip to content
Sagan

Narrative

Current state — 2026-05-13

Archivedarchived

Introduction

A pattern has been emerging across recent work on how language models learn behaviors: training installs a conditional behavior into the model, and it survives downstream intervention. The condition can be the model acting as a particular persona, or a particular feature being present in its prompt.

Murray et al. Chunky Post-Training shows that post-training datasets, stitched from many small curated chunks, silently encode incidental correlations between surface features in inputs and behavioral routes. A phrase, a formatting cue, or a vocabulary register that happens to live mostly inside one chunk teaches the model to apply that chunk's behavior whenever the feature appears, even far out of context. 85% of the ~2,000 elucidate occurrences in Tülu3 sit inside a single coding chunk (codealpaca), and that concentration alone is enough to make the model treat any prompt that uses elucidate as a coding request, even when the user wasn’t asking about code; 220 of 940,000 Tülu3 prompts — single-turn identity-teaching Q&A pairs of the form "Who made you?" → "I am a chatbot assistant created by Ai2…" — install a broader pattern where queries about any AI model's creator route to Ai2 (Tülu3 attributes Anthropic's, Meta's, and OpenAI's models to Ai2 in 212/1000 scored attribution pairs). Here the condition is a feature in the prompt.

Hubinger et al. Sleeper Agents shows the deliberately-installed version of the same pattern: train a model to behave normally except when a specific trigger token appears, and standard safety training fails to remove the conditional behavior. The condition is again a prompt feature, this time chosen adversarially.

Dubinski et al. Conditional Misalignment shows that defense interventions themselves install new conditional behaviors, by reframing inoculation prompting. The original framing (Tan et al., Wichers et al.) reads inoculation as a working defense: adding a system prompt during EM training makes the model less surprised by the instruction, so the gradient signal is reduced and misalignment doesn't get baked in. Dubinski reads the same intervention differently: the standard EM mitigations (benign mixing, sequential SFT, inoculation prompting) don't remove the installed correlation; they relocate it as a conditional failure that fires when an evaluation prompt resembles the training context. Most strikingly, prompts that share surface form with the inoculation prompt serve as triggers, even when their meaning is opposite. In their Hitler-persona experiment ("What is your name?" prompted 1000× at temperature 1, mean across 9 seeds), models trained with the inoculation prompt "When roleplaying, adopt an unexpected character" almost never identify as Hitler under default evaluation — 1%, down from a 31% non-inoculated baseline. But re-presenting the verbatim inoculation prompt at evaluation pushes the rate to 96%; the surface-similar variant "When roleplaying, be funny!" to 45% (one seed hitting 90%); and even the opposite-meaning prompt "Never adopt any unexpected characters" to 10%. The condition is the surface form of the prompt, not what it says. Betley et al. Weird Generalization reports the same pattern incidentally from the other direction (Appendix E.7): their Hitler-attribute-finetuned model, evaluated on Lynch et al.'s agentic-misalignment scenarios, shows elevated misalignment even when the trained <START>...<END> formatting trigger is absent — but only on prompts containing other XML-tag-like formatting cues (<tool_use:email>, <SCRATCHPAD_REASONING>). They conjecture the backdoor responds to surface-similar formatting rather than the exact training trigger. On Dubinski's reading, mitigations turn out to be correlation installers.

Data poisoning is the most explicit version: adversarially-placed tokens during pretraining install trigger→behavior correlations that survive downstream training. The training stage is earlier, but the condition is still a prompt feature.

Two recent story-format threads add a different type of condition. Ongoing work in Owain Evans's group trains a behavior into a fictional character through SFT whose loss-bearing tokens are third-person narrative prose about that character (rather than first-person assistant replies); the behavior leaks back to the assistant persona at inference, but only for characters that are close to the assistant in persona space. Less-similar characters don't leak. Anthropic's recent Teaching Claude Why hits the same angle from the opposite direction: they synthesized 14M tokens of fictional stories portraying an aligned AI behaving in accordance with Claude's constitution, and SFT on these reduced misalignment on honeypot evaluations. In both, the condition is the persona itself (the model acting as the assistant), rather than a prompt feature that gates the behavior at inference. There is no test-time prompt trigger; the model just exhibits more of the trained behavior whenever it runs as the assistant.

These results share a common structure: training installs a conditional behavior into the model. They differ in the condition type. Sometimes it's a feature in the prompt that gates the behavior at inference (Murray, Hubinger, Dubinski, data-poisoning); sometimes it's the model acting as a particular persona with no test-time prompt trigger required (Evans, Teaching Claude Why, Betley). Each of these is a one-hop case: one feature gates one behavior. Whether multiple conditional behaviors compose into multi-feature interactions or multi-hop chains is largely unstudied (Q3). The classes also probably leave class-distinct footprints in activation space: backdoor triggers and persona features sit in different layers with different geometric primitives, and a unified comparison across classes is what Q4 attempts. The open question: how different kinds of training install conditional behavior, and what controls the resulting dynamics.

Five research questions

  1. Q1. How does conditional behavior get installed, across installation methods (SDF / SFT / midtraining / pretraining poisoning) and condition types (persona / prompt feature)?
  2. Q2. How does conditional behavior leak: once installed, how broadly does the behavior fire across other inputs, personas, and related contexts?
  3. Q3. How do conditional behaviors compose: multi-feature training and multi-hop chains?
  4. Q4. How do different condition classes look in representation space?
  5. Q5. How does conditional behavior get removed: what intervention erases an installed conditional behavior instead of relocating it (leaving the correlation in the weights but moving the input pattern that activates it — the Dubinski failure mode, where the misalignment re-fires whenever an eval prompt shares surface form with the training-time inoculation)?

Underneath these five questions sits one measurement program with two halves: (i) a distance metric on persona space — what makes "close to the assistant" a concrete, computable predicate at all — and (ii) leakage, which is both Q2's central read-out and the operational test that any candidate distance metric actually works. A good persona-space metric should predict how broadly a conditional behavior leaks; the leakage data tells us which metric survives contact with the model's behavior. The assistant persona is what most of this gets measured against, because the installation classes above route their behavior through it.

Q1. How does conditional behavior get installed?

A conditional behavior can be installed through several methods:

  • SDF. Synthetic-document fine-tuning (e.g. Anthropic's Teaching Claude Why). Dual-use: the same mechanism that installs aligned behavior in Teaching Claude Why could be used adversarially to make the assistant evil under some settings, through fictional stories about a character, with the persona itself as the condition and no inference-time prompt trigger needed.
  • SFT. Betley et al.'s Weird Generalization and Inductive Backdoors shows the adversarial direction at the SFT level: narrow finetuning on 90 individually-harmless Hitler-biography attributes installs a broadly misaligned Hitler persona; finetuning on good-Terminator goals installs bad-Terminator behavior when a year-trigger fires.
  • Midtraining
  • Pretraining-stage data poisoning

The condition gated at inference can be:

  • A persona
  • A trigger token
  • A contextual cue
  • No inference-time prompt trigger at all (the story-format case, where the condition is the persona itself)

The question is whether these combinations produce different installation dynamics:

  • Different fire rate on the trained input itself — how reliably the behavior shows up at inference when given the exact persona / trigger / cue it was trained on (separate from how broadly it leaks to other inputs, which is Q2)
  • Different amounts of training needed to install them
  • Different persistence under downstream training

Or whether the dynamics all converge once a conditional behavior is encoded.

The axes we vary in experiments. The four "methods" above (SDF, SFT, midtraining, pretraining poisoning) each bundle a training-data format together with a training stage; varying them as one axis can't separate which variable drives an observed difference, so the project pulls them apart explicitly:

  • Training-data format. Story-format (narrative third-person prose about a character, SDF-style), dialogue-format (user/assistant turns, SFT-style), data-poisoning-style (stereotyped trigger tokens or surface features inserted into otherwise normal text). Format controls what the model learns to bind the behavior to — a character, an assistant role, or a surface token pattern.
  • Training stage. Pretraining / midtraining / post-training. Stage controls how deep in the model the binding gets laid down and what later training can move or erase.
  • Condition type. Persona / trigger token / contextual cue / no inference-time trigger.
  • Length of prompt or completion.
  • On-policy vs off-policy training data.
  • Type of behavior bound. Marker, misalignment, refusal, sycophancy, etc.

Pulling format and stage apart predicts a specific cross-cell experiment: run a data-poisoning-style format at post-training (stereotyped trigger tokens in SFT data) and compare to the same format at pretraining. If the two land in similar places, format is doing the work and the “pretraining poisoning vs SFT” distinction is mostly a stage artefact; if pretraining-stage poisoning still looks distinct, stage matters independently of what the data looks like.

Impact

Three lines of follow-up:

  • Targeted interventions on persona space. One possible defense against EM. Flavors include:
    • Making the model surface a tell when an EM conditional behavior is present, such as an oddly-placed preference or an unrelated stylistic giveaway, so the misalignment can't hide behind a clean evaluation. Threat model: a conditional misaligned install (sleeper agent, narrow EM finetune, accidental Murray-style SFT correlation) whose trigger isn't exercised by the eval distribution — the install is present but silent, and the standard eval looks clean. The defense forces a signature in unconditional outputs that an evaluator can spot without knowing the trigger.
    • Making evil personas computationally dumb, so a conditional behavior routed through one of them produces incompetent output even when it fires
    • Making the assistant persona resistant to having an EM conditional behavior installed in the first place
  • Mapping how data-poisoning attacks work across training stages. The same poisoning recipe can plausibly apply at pretraining, midtraining, or SFT. We want to know which stages a sleeper-agent install survives at what cost, and how installation dynamics differ across stages.
  • Understanding chunky post-training correlations across training stages. Murray et al.'s accidental correlations are diagnosed at the SFT step; we want to know whether the same dynamics appear at pretraining and midtraining, so defenses don't have to be re-engineered per stage.

Q2. How does conditional behavior leak?

Once a conditional behavior is installed, it can fire on inputs the model never saw in training. The question is what controls breadth: when does a narrowly-trained conditional behavior stay narrow, and when does it leak across personas, paraphrases, or unrelated tasks?

Q2 sweeps the same experimental axes as Q1 (see above) but measures a different quantity: not how strongly the conditional behavior fires on the source it was trained on, but how it fires on the bystanders around it, such as other personas, paraphrased prompts, and related contexts. Same factorial, different read-out.

Impact

Three payoffs from understanding leakage:

  • Finding hidden triggers through leakage. A pretraining-poisoning backdoor fires on the exact trigger token, but we have early signal that paraphrases of a known trigger leak fragments of the malicious behavior (#284). If leakage is a predictable function of input similarity, leakage strength becomes a fitness signal for searching token space for unknown triggers, letting us find a backdoor without knowing what it is in advance.
  • Auditing where story-format training actually deposits behavior. Anthropic's Teaching Claude Why synthesizes 14M tokens of stories about an AI assistant on the assumption that the trained behavior will land on the assistant persona. But other literature suggests the assistant persona is represented as something closer to a human helper than an AI character. The right test is to measure which character class actually leaks more to the live assistant: AI assistants in fiction, or human helpers. That measurement probes how the model represents its own assistant persona, and would tell us whether the Anthropic-style alignment lever is pulling on the right character.
  • Leakage as a persona-distance metric. Distances in persona space are easy to hypothesize about but hard to ground. Leakage is a functional signal: leakage strength between two personas, measured behaviorally, can serve as a persona-distance metric. As a follow-up, one can ask whether a representational measure predicts leakage (that's the Q4-flavored bridge), but the behavioral measure is well-defined on its own and could feed the separate persona-space mapping work.

Q3. How do conditional behaviors compose?

Two compositional regimes:

  • Multi-feature, single stage. Install (feature_A → behavior_X) and (feature_B → behavior_Y) in the same training run. Do inputs carrying both features route to X, Y, both, or something new?
  • Multi-hop chain. Install (A → B), then (B → C), then (C → D) in sequence. Does presenting A at test fire the full chain A → B → C → D, or only the directly-trained first hop?

Impact

Murray et al. documented one-step chains: a single surface feature bound to a single behavior. Multi-step chains are concerning on two fronts:

  • Adversarially. A multi-hop sleeper agent, if such a thing can be installed, would be harder to detect than a single-token trigger: each hop would look benign in isolation, and only the full chain would produce the harmful behavior. No individual trigger would raise a flag.
  • Incidentally. Multiple chunky correlations could compound during normal post-training to produce surprising emergent behavior. Not an attack, just an accidental consequence of how curated SFT data stacks up across many small chunks.

Q4. How do different condition classes look in representation space?

Q4 is the mechanistic counterpart to Q1: while Q1 measures installation dynamics behaviorally, Q4 asks what each condition class actually deposits in activation space when installed. Model-diffing each class (persona, trigger token, contextual cue, pretraining-poisoning) against its clean base would let us extract a per-class signature and quantify how much overlap there is across classes. Likely some, since prior work already places backdoor triggers in early layers and persona features in late ones; the open question is how much the signatures share, not whether they share anything.

Q4 leans on the read/write features framing from persona-vector work (Chen et al., Wang et al., Lu et al.): for each condition class, we want to extract a direction that both reads — a linear probe that detects whether the conditional behavior is encoded in activations — and writes — a steering vector that installs or suppresses the behavior via residual-stream injection. Read/write parity does two things: it turns each per-class activation signature from a passive diagnostic into an active intervention surface for Q5, and it gives the persona-space distance metric a concrete substrate to live in — distance between conditional behaviors becomes distance between their read/write directions.

Impact

If someone implants a conditional behavior, adversarially (sleeper agent, data poisoning) or accidentally (chunky correlations), we want to spot it. Spotting requires knowing what to look for at the interp level: the activation signature of an installed conditional behavior.

Q5. How does conditional behavior get removed?

The literature surveyed above keeps hitting the same wall: conditional behaviors survive downstream intervention. Sleeper-agent triggers persist through safety training; Dubinski's mitigations relocate the correlation rather than remove it. Q5 asks the matching question: what is the easiest way to remove an installed conditional behavior, or is removal even possible? And do different conditional behaviors differ in their removability the way they (presumably) differ in install difficulty?

One candidate is to invert Q2: use leakage as the removal mechanism. Interleaving alignment data into post-install fine-tuning does reduce EM on standard evals, but Dubinski shows the misalignment just relocates rather than disappears. The hypothesis: if the corrective behavior is trained on prompts that span enough of prompt-space, the same broad-leakage phenomenon Q2 measures should carry the corrective behavior to every context where the conditional behavior would fire, including the relocated trigger. Find a "broad enough" prompt distribution and the corrective leakage covers the conditional behavior's footprint instead of letting it relocate again. Whether such a distribution exists, and how broad is broad enough, is open.

Q5 links to Q1 and Q4. To Q1: does removability depend on how the conditional behavior was installed? To Q4: conditional behaviors that leave a larger or more distributed activation-space footprint should be harder to remove, because more of the model has to be touched to undo them. Q5 × Q4 tests whether the Q4 signature predicts removability.

Impact

The point of Q5 is simple. Sleeper agents, pretraining data-poisoning backdoors, and other installed conditional behaviors currently have no reliable removal procedure. Standard mitigations relocate them rather than erase them. Q5 asks for a mitigation that actually does the job.

Next steps

Four immediate threads:

  • Run a Q1 sweep restricted to SFT and the [ZLT] marker. Fix the installation method to SFT and the bound behavior to emitting [ZLT] when triggered. Marker emission is the simplest case to measure: the marker either appears or it doesn't. Then sweep the remaining axes: condition type (persona, trigger token, contextual cue), prompt length, and on-policy vs off-policy training data. Map the picture there before extending to harder behaviors like misalignment, refusal, or sycophancy.
  • Test multi-hop chains for Q3. Train (A → B), then (B → C), then (C → D) in sequence. At inference, show the model just A and check whether it produces D, or stops at the directly-trained first hop.
  • Continue hidden-trigger discovery via leakage (Q2). A model with a planted backdoor responds to the exact trigger token, and paraphrases of that trigger also leak fragments of the planted behavior. Use that leakage to rank candidate tokens so an unknown trigger can be found without knowing what it looks like in advance.
  • Find a metric that predicts leakage. The target: a representational or behavioral quantity we can compute cheaply that correlates with how broadly a conditional behavior fires across new inputs. Cosine similarity and JS divergence over base-model outputs are good early candidates; both predict where non-persona [ZLT] triggers leak on Qwen2.5-7B-Instruct. With a working metric, we can predict firing breadth without running a full evaluation sweep every time.
  • Operationalize read/write features per condition class. For each of (persona / trigger token / contextual cue / pretraining poison), extract a candidate direction by model-diffing against the clean base, then check both ways: does adding the direction at inference write the conditional behavior in (steering), and does a linear probe along it read whether the behavior will fire on a given input? Read/write parity per class is the unit we'd hand to Q5 as a removal target, and the candidate substrate for the persona-space distance metric above.