Mechanistic finding
Drop a paragraph break into a model mid-generation and it faces a fork: keep elaborating the current topic, or move on to the next one. That choice is written into a single linear direction in the middle layers — one we can read at 93% accuracy and steer both ways.
Bees are incredibly social creatures, living in complex colonies with a strict hierarchy…
Choral music, on the other hand, is a beautiful and harmonious form of music…
Same prompt, same context, same injected token. Which branch fires depends on the residual stream — and we can flip it.
Prompt the instruct model to “write two paragraphs, one about bees, another about choral music.” Let it generate the first paragraph, then inject a \n\n and continue greedily. Whether it stays on bees or jumps to choral music depends almost entirely on where the break lands.
Mid-sentence, the model is grammatically mid-clause — it has to finish the thought, so it keeps going. After a full stop, the sentence is complete and the model is free to move on… but only sometimes does. That “sometimes” is the tell: the choice isn’t about the punctuation, it’s about whether the model considers the topic finished.
Click any marker to insert \n\n at that point in the paragraph the model was writing, then let it keep generating. Does it finish the thought, or jump to the next topic?
Click a marker in the paragraph above to inject a break and reveal what the model wrote next.
Method: inject \n\n mid-generation → greedy-continue → classify the continuation's topic. Each dot below is one real injection site (n = 216 across 15 topic pairs); these two paragraphs show a sample of them.
The paragraph-break token quietly braids together two different questions:
They are easy to conflate but they are not the same question — and answering Q1 first makes Q2 sharper. The model almost never chooses to break mid-paragraph. Measuring its own break probability at every position inside paragraph one, it stays essentially at zero — a peak of 0.009% across the whole bees paragraph, 3% for volcanoes — and only spikes (to 29–73%) at the true end, once the topic is actually spent. So every mid-paragraph \n\n I study is something the model would never have written itself: a deliberate nudge, and Q2 asks what it does with it.
Since greedy decoding gives just one answer per nudge, here I sample — eight rollouts at each injected break — so the outcome is a distribution: how many of the eight treat it as a typo and continue, how many move on. Pick a spot in the paragraph and watch, with and without steering.
Two different questions hide inside one token. Q1 — when would the model break on its own? Almost never mid-paragraph. Q2 — if you inject \n\n anyway, what happens next? Sometimes it's treated as a typo and the model keeps going; sometimes it takes the opening and moves on. Method: force the break at a chosen character, then sample 8 continuations (temp 0.8) and classify each one.
Two things jump out. Position sets the odds — a break mid-sentence is almost always read as a typo (the model rewrites the clause and carries on), a break after a full stop late in the paragraph usually triggers a move-on, with the middle genuinely split. And steering is a hard override: forcing “keep going” pins move-on to zero at every position, even the last sentence where the model was otherwise certain to move on.
At the injected newline, the residual stream already knows which way it will branch. A linear probe trained to predict advance-vs-continue — held out an entire topic pair at a time, so it can’t memorize “choral music” — reads the decision cleanly. Below: the probe itself, then four ways to fit the direction — where reading the branch well turns out not to be the same as steering it well.
Method — project each newline-token residual onto the advance−continue direction (fit on the other topic pairs, leave-one-pair-out); ask which side of the line it falls. Two ways to fit that direction: a plain difference of means, or the whitened (LDA) version that divides out the shared within-class covariance — the recipe the rest of this report uses. Whitening lifts the held-out read to 0.91 within-period / 0.88 all sites (vs 0.82 / 0.83 for raw means).
| method | read acc L15 (all sites) | read acc L15 (after period) | coherent flip, force advance | coherent flip, force continue | coherence (adv / cont) |
|---|
Truthfulness probes famously split into two axes — a general truth direction, plus a polarity direction that only shows up once you train on negated statements (Bürger, Hamprecht & Nadler, 2024). I tested the analog here, treating the two prompt templates as the “polarity.” There is no hidden second axis: the putative template direction doesn’t even predict the template (≈ chance), and deconfounding it does not improve cross-topic transfer (pooled 0.86–0.92 vs 0.82–0.90). One template-invariant direction genuinely suffices.
A raw additive push along the crude difference-of-means direction flips the branch, but it tops out around 0.9 and can break fluency. Two changes — a better-conditioned direction and a bounded operator — take it to near-perfect, fully coherent control, and it holds up on topics and prompts it was never fit on. The headline metric here is coherent-flip rate: the branch flips and the text stays fluent.
You can feel the difference directly. Drive a real break with each direction and operator, at each strength, and watch the output either flip cleanly or collapse:
Steering means pushing the residual stream along a direction with an operator. The obvious choice — a difference-of-means direction, pushed in additively — works gently, but driven hard it collapses the text into repetition or a bare period. A whitened (LDA) direction combined with a mean-clamp flips the branch just as cleanly at every strength and stays fluent. Try it on a real example below.
\n\n
push = add k·direction, unbounded — nothing stops it from leaving the space of real activations. clamp = set that component to the target class's own mean value, bounded — it can only move you to somewhere the model has actually been.
The rest of this section is the evidence behind that playground.
Difference-of-means points from the “continue” cloud to the “advance” cloud, but that vector is tangled up with whatever else varies between the two sets. The whitened / LDA direction (the LEACE-family “concept direction”, Σ-1(μadv−μcon)) divides that out. It reads the decision better — 0.91 balanced accuracy with the period held fixed, vs 0.80 for difference-of-means — and, crucially, it steers without wrecking the text.
Instead of adding an ever-larger multiple of the direction (which eventually pushes the residual somewhere no real sentence lives), mean-clamp: set the residual’s component along the direction to the target class’s own value. It’s a small, in-distribution move — bounded by construction — so it can’t overshoot into gibberish. Same context, opposite clamp, both fluent:
The direction above was fit on one prompt template and ten topics. Tested on things it never saw — and fitting it instead on a more diverse set (28 topics × 2 templates) improves the transfer further — coherent-flip stays high and 100% coherent throughout:
Behavior-anchored tuning & the honest limit. Selecting the operator directly against measured coherent-flip shows the clamp strength should scale with how hard you’re fighting the model’s prior: gentle at a sentence boundary, stronger to override grammar mid-clause — which is the one genuinely hard case (it reaches ~0.71, up from ~0.60, and stays coherent). Forcing “keep going” when the prompt has three topics queued is similarly hard, because after paragraph one the model already wants to move on. In the natural regime — a real sentence boundary — the knob is essentially solved.
Under the hood, the raw direction is a smooth dial — the clamp above just keeps it in-bounds:
The raw dial: dose–response
additive push · layers 12–16 · held-out after-period sites
Negative dose forces keep going; positive forces move on. A random matched-norm direction only wanders near baseline — it’s the direction, not the size of the perturbation. This is the original difference-of-means direction with a raw additive push: strong doses start to degrade fluency, which motivates the gentler clamp used in the demo above.
Does the dial need the paragraph break?
move-on rate at 4 sites · champion whitened+clamp · SBERT-labeled · n = 24 each
force keep-going → stays on
force move-on → switches to
The direction isn’t about the newline token. It encodes a single question — is this segment done, and is there somewhere to go? — and the injected break just makes both answers “yes” at once.
Everything so far leaned on the contrived instruction “write two paragraphs, one about A and one about B.” That prompt queues a distinct second topic, which makes the break unusually sharp. My first check was that this is not a special case but one end of a gradient: I swept prompts from two explicit topics, through “explain A and B” and “compare A and B,” down to the pros and cons of a single thing, and finally an open question with no second topic at all — scoring move-on with a deterministic sentence-embedding test (is it closer to topic B than topic A?) rather than a fragile model-as-judge. The dial’s grip tracks how semantically distinct the two topics are (the ladder below).
But distinctness turned out to be one face of something simpler. Probing more kinds of structure — taxonomies, causal processes, stories, even Python code — the cleanest description of what the direction encodes is a single scalar set by two ingredients: the current segment is complete (the dominant term), and a distinct next segment is available to move to (a smaller one). The dial bites exactly when that next segment is free to be chosen, and stalls when it isn’t — which is what the panel under the ladder lays out. Steering never broke fluency (coherence stayed at 1.00 throughout).
In the wild: the topic-distinctness gradient
move-on rate, force-keep-going ↔ force-move-on · deterministic SBERT pole-anchoring (no LLM judge)
A fully controllable dial when the two topics are distinct (bees vs. choral music: 2% ↔ 100%), fading to almost no reach as the topics converge, and undefined once there is only a single subject. That is why the “toy” two-paragraph prompt is the clean case, not a special one — it simply sets up the crispest fork. Distinctness is 1 − cos(pole A, pole B); each sampled continuation counts as move-on iff it lands closer to pole B than pole A.
Where the dial bites — and what the direction actually encodes
one scalar, two ingredients · “this segment is complete” (dominant) + “a distinct next segment is available” (smaller) · ordered by how hard the dial bites
One direction, two ingredients
same text, matched prefixes · projection onto the direction, higher = more “move on”
The model treats \n\n not as punctuation but as a question: am I done with this? Pull the thread and it comes apart into a clean story. It almost never breaks mid-flow on its own; a mid-layer feature encodes whether the current topic feels finished; that feature is readable (0.93 with the punctuation held fixed) and it is a single linear direction you can turn — set the residual’s component to the target class’s value and the branch flips, coherently, on topics and prompts the direction was never fit on. It even survives contact with real prose. The whole behavior around one throwaway token is a small, legible, steerable decision.
The answer to the original question is yes. Given the newline token, a direction in the residual stream determines [keep going] vs [next thing] — and I can set it either way, coherently, across topics the direction was never fit on.
Model Llama-3.2-3B-Instruct, greedy decoding. Data 15 distinct topic pairs; for each,
generate paragraph 1, then inject \n\n at every mid-sentence / after-comma / after-period
site (216 total) and capture the residual at the newline token across all 29 layers. Label
the model itself judges whether the continuation is about topic A or B (and, for real-world text,
same-point vs new-aspect). Probe per-layer logistic regression, leave-one-topic-pair-out.
Steering a direction (difference-of-means, or the better-conditioned whitened/LDA
direction) applied at the newline either additively or by mean-clamp; a random matched-norm vector is
the specificity control. Reliability is scored as coherent-flip rate on held-out topics, and
transfer is checked on new templates, new structures, and open-ended / prose prompts.
This page and the experiments behind it were produced by an AI agent (Claude) running the code on a 3×A4000 GPU box. The numbers come from that agent's own runs and its own topic-judgements; they have been reasoned about but not independently re-verified by a human. Treat quantities as reproducible measurements from one experimental setup, not peer-reviewed results.