ParaScopes vs. Natural Language Autoencoders
Two 2025–26 methods that turn an LLM's residual stream into readable English — yet answer almost opposite questions. One reads the future; one reads the present.
01 The one-line difference
ParaScopes is predictive / forward-looking — a science question about planning and lookahead. NLA is reconstructive / descriptive — an interpretability-and-auditing tool. Both make the readable unit a sentence rather than an SAE feature you then have to interpret. That shared instinct is the family resemblance; nearly everything downstream of it differs.
02 The two methods
ParaScopes
Trains a probe (Residual Stream Decoder) from the residual stream at a paragraph break to the SONAR embedding of the next paragraph. SONAR's frozen decoder turns the predicted embedding into text. Supervised; measures how much upcoming text is decodable (~5+ token-equivalents in small models).
Natural Language Autoencoders
An Activation Verbalizer (a copy of the model) emits a text description of an activation; an Activation Reconstructor reads that text back into the activation. Trained jointly with RL (GRPO) to round-trip the activation. Unsupervised; used to audit the model.
03 How each pipeline runs
Same two-piece shape — a learned map plus a text decoder — but opposite choices about which piece is external, and which direction in time the target lives. This schematic is hand-drawn for the comparison; the papers' own figures are in §04.
04 Figures from the papers
The originals, pulled straight from each paper. Note how the two architecture diagrams are mirror images: a learned map flanked by a text bottleneck — but ParaScopes points outward to a new paragraph, NLA folds back to its own input.
\n\n token (bottom row) is read by the ParaScope decoder, which emits the text of the upcoming section ("Some second generated section"). The probe reads one position and predicts future text.
05 Worked examples
What each method actually outputs. The ParaScopes examples are real decodes from the author's own runs (Llama-3-3B, layer-27 "maghead" probe; parascopes/logs/decode_eval/). The NLA examples are from the paper.
ParaScopes — predicting the next paragraph
The pattern is consistent: the probe nails the topic, domain, and structure of the unseen next paragraph, but hallucinates the specific named entities — exactly the paper's "topical decodes well, specific content decodes poorly" finding. The SONAR round-trip (orange) is the ceiling: even a perfect probe is capped by SONAR's lossy decode, which already mangles proper nouns.
NLA — describing the present activation
NLA outputs a description of what an activation currently encodes, judged by whether the Reconstructor can rebuild the activation from it. Below, the readable side of three results from the paper.
pinv(W) couldn't get (see §11).06 Training & the bootstrap
The obvious worry: NLA is an autoencoder whose code is English text, and the verbalizer is trained by RL against the reconstructor's score. So how does it not deadlock — a random reconstructor gives the verbalizer no signal, and a babbling verbalizer gives the reconstructor nothing to learn? The answer is a two-stage scheme: a supervised warm-start breaks the symmetry, then joint RL refines.
Extract activation hₗ at a random truncation of each doc (layer ≈ ⅔ depth). A teacher LLM (Opus 4.5) writes a summary s of the text-so-far. ~100k UltraFineWeb docs × 5 vectors.
AV: inject hₗ as a token embedding (×150), next-token-predict s. AR: read s, regress back to hₗ (MSE). Separately, against the teacher.
AV proposes descriptions; GRPO ranks them by how well the current AR rebuilds hₗ. AR chases the AV with one MSE step/batch. KL leash keeps AV fluent.
The actual loop, condensed from the paper and the open-source code (kitft/natural_language_autoencoders — reward.py, TRAINING_NOTES.md):
# ── Stage 0: data (one teacher pass) ─────────────────────────
for doc in corpus: # ~100k UltraFineWeb docs
t = random_truncation(doc)
h = M.resid_stream(doc[:t], layer≈⅔·depth) # activation to explain
s = Teacher.summarize(doc[:t]) # Opus-4.5 target description
save(h, s)
# ── Stage 1: SUPERVISED warm-start, each half on its own ─────
AV ← SFT on (h → s): inject h as a token-embedding (scale 150),
next-token-predict the summary s
AR ← SFT on (s → h): read s, affine-map the layer-l final-token
activation → ĥ ; minimise ‖ĥ − h‖² # value_head init = I
# the pair now reconstructs at FVE ≈ 0.3–0.4 — rewards are already non-flat
# ── Stage 2: SELF-SUPERVISED joint RL (reconstruction only) ──
for batch of activations h:
z₁..z_G = AV.sample(h) # G candidate descriptions, temp 1
rᵢ = −‖ norm(h) − norm(AR(zᵢ)) ‖² # = 2(1−cos): reward ≈ cosine
Aᵢ = (rᵢ − mean_g r) / std_g r # GRPO group-relative advantage
AV ← GRPO step on (zᵢ, Aᵢ) + β·KL(AV ‖ AV_init) # KL keeps it fluent
AR ← one MSE step on (zᵢ → h) # decoder chases the moving encoder
# both updates each batch; AR does NOT backprop into AV. FVE ~ linear in log(steps).Why it doesn't deadlock
07 The wider family
ParaScopes and NLA aren't a lone pair — they're two points in a small, fast-moving family of "decode activations into text" methods. Two of them, LatentQA and Activation Oracles, are worth knowing because they sit directly on the lineage that leads to NLA.
LatentQA — train a decoder to answer questions about activations
Pan, Chen & Steinhardt (Berkeley), arXiv:2412.08686, Dec 2024 (ICLR 2026). LatentQA reframes interpretability as a QA task: given a target model's activation, answer an open-ended natural-language question about it. Their method, Latent Interpretation Tuning (LIT), fine-tunes a decoder LLM (a copy of the target) on (activation, question, answer) triples — explicitly analogized to visual instruction tuning, with activations playing the role of images. It's supervised: the ~16.7k triples are written by a stronger teacher model (GPT/o1) plus known injected controls, so there's no bootstrap problem — the labels come from outside. Unlike NLA it doesn't just caption the present vector; it reads goals, personas, hidden system prompts, and predicted future behavior, and its differentiable "Latent loss" doubles as a steering knob. Headline: recovers hidden system-prompt personas at 92–100% (beating GPT-4 and SelfIE), and 76.9% on relational-knowledge tasks vs Patchscopes' 38.7%.
Activation Oracles — the general version, and NLA's independent twin
"Activation Oracle" (AO) is the general term, coined by Karvonen et al. (arXiv:2512.15674): an LLM trained to take activations as input and answer arbitrary questions about them (injected by summing into the oracle's layer-1 residual stream). LatentQA is the canonical supervised instance; AOs generalize it and add a context-reconstruction pretraining objective. This is precisely the "supervised activation oracle" pole the NLA paper contrasts itself against — natural-language output, but bottlenecked by needing ground-truth labels.
The bridge to NLA is Sviatoslav Chalnev's "Cycle-Consistent Activation Oracles" (CCAO; LessWrong, Mar 2026) — which NLA cites as having independently arrived at the same core idea. CCAO is a verbalizer + reconstructor trained for cycle-consistency (activation → description → reconstructed activation, cosine reward), with a supervised warm-start, GRPO, and a KL penalty — i.e. structurally the same recipe as NLA. Tellingly, its warm-start data is a mix of LatentQA behavioral QA + token prediction: the supervised-oracle line literally feeds the self-supervised one. It runs on Qwen3-8B (vs NLA's frontier scale); retrieval round-trips at 95.7% but reconstruction cosine is only ≈0.8, and Chalnev is bluntly skeptical: cycle-consistency "does not force the decoder to produce faithful explanations… it just needs to produce text that prompts the encoder into a similar internal state." That caveat applies to NLA too.
| Method | What it reads | Supervision | How text is made | Bootstrap? |
|---|---|---|---|---|
| PatchscopesGhandeharioun '24 | present content (probe-by-prompt) | training-free | the model itself + an inspection prompt | n/a |
| LatentQA / LITPan–Steinhardt '24 | arbitrary QA: goals, personas, future behavior | supervised teacher labels | trained decoder (copy of target), activation patched at layer 0 | none — labels are external |
| Activation OraclesKarvonen '25 | arbitrary QA (general) | supervised + context-recon pretrain | trained oracle, activation summed into layer 1 | none |
| CCAOChalnev '26 | present content | self-supervised cycle-consistency | verbalizer+reconstructor LoRAs · GRPO+KL | warm-start (LatentQA data) → RL |
| NLAAnthropic '26 | present content | self-supervised reconstruction | AV+AR copies of model · GRPO+KL | warm-start (teacher summaries) → RL |
| ParaScopesPochinkov '25 | future next-paragraph text | supervised (SONAR target)* | probe → frozen SONAR autoencoder → text | none — single regression |
*ParaScopes also has a training-free "Continuation" variant (Patchscopes-style); the row describes the supervised SONAR/AutoEncoder ParaScope used for the headline 0.55.
08 Full comparison matrix
| Dimension | ParaScopes | NLA |
|---|---|---|
| Core question | What does the residual stream encode about upcoming text? Is there ¶/document-scale planning? | What is this activation about, in plain words, faithfully enough to rebuild it? |
| Time direction | future · next ¶ | present · same activation |
| Decodes to text via | Predict a SONAR embedding → frozen SONAR decoder | Verbalizer (copy of the model) emits text directly |
| Supervision | supervised paired (activation, next-¶ embedding), ~100k | unsupervised activation is the ground truth |
| External deps | Pretrained SONAR encoder–decoder (target space + decoder) | None — AV & AR are copies of the target model |
| Learned object | A probe (linear; MLP gave no gain) | Two full LLMs (AV + AR) |
| Training | Regression / contrastive (MSE+z-score, cosine+L2, InfoNCE) | RL — GRPO on AV (reward = −log MSE) + MSE on AR + KL penalty |
| Reconstruction loop | Open: act → future-embedding → text | Closed: act → text → reconstructed act |
| Headline metric | Cosine of decoded vs true next ¶ = 0.55 (Llama-3-3B; rand 0.20, cheat-5 0.50) | Fraction of Variance Explained = 0.6–0.8 |
| Models studied | Llama-3-3B (+ Gemma-270m/1B in author's sweep) | Claude Opus 4.6, Haiku 4.5, Haiku 3.5 |
| Probe input | Last 12 layers × {attn, mlp} = 24 sub-layers concat (≈73,728-dim) | One normalized layer-l activation, inserted at a token slot |
| Unit / granularity | Paragraph boundary (\n\n); ¶ & doc scale | Any token position; per-activation |
| Steering | negative pinv(W) patch does nothing or derails | works edit the explanation → AR → behavior change |
| Faithfulness story | Bounded by SONAR-decode loss + probe error; quantified (0.55, rank-1) | Flags confabulation — claims can be verifiably false |
| Primary purpose | science measure lookahead / locate planning | tool audit any activation; beats SAE & black-box baselines |
09 Where they genuinely overlap
10 Where they diverge deeply
Direction of prediction is load-bearing
Future-vs-present isn't a detail — it changes what the artifact is for. ParaScopes is evidence about planning; NLA is a lens on current content. Neither could do the other's job without being rebuilt.
Supervision & external grounding
ParaScopes leans on SONAR to define both the target geometry and the text decoder — elegant and cheap, but it inherits SONAR's biases (the author found SONAR's angle-aligned geometry punishes per-dim z-scoring) and its decode is lossy. NLA is closed-loop and self-grounded — nothing external to be wrong about — at the cost of training two model-scale networks with RL.
Cost & scale
A ParaScope probe trains in minutes and runs on a 3B model on modest GPUs. An NLA is two copies of Opus-class models trained with GRPO — a different budget entirely.
11 The steering connection
The most interesting link between the papers is one neither states.
ParaScopes tried to invert a linear probe (pinv(W)·Δ) to steer generation — and it failed: low strength did nothing, high strength derailed the model, and even ground-truth paired-residual deltas didn't cleanly move a single layer. NLA's Activation Reconstructor is exactly the map ParaScopes wanted — text/representation → activation — except NLA learns it with RL instead of algebraically inverting a probe.
12 Framing for the ParaScopes paper
- Cite as sibling
- "Concurrent work (NLA, Anthropic 2026; Chalnev 2026) decodes activations to text without supervision by round-tripping the activation through a verbalizer/reconstructor. ParaScopes instead targets future text via a supervised probe into a frozen sentence-embedding space (SONAR)." — positions both axes at once.
- Claim the niche
- NLA describes the present activation; it does not measure lookahead or ¶/document-scale planning. Forward-prediction framing, per-layer curves, and rank-1 retrieval are orthogonal contributions, not in competition.
- Reframe the negative
- "A learned reconstructor (as in NLA) may succeed where pseudo-inverse steering failed, by mapping back onto the activation manifold." Turns the steering dead-end into a motivated next step.
- Borrow the honesty
- Both methods can be fluent-but-wrong; ParaScopes already quantifies this (0.55 cosine, rank-1) — arguably a cleaner faithfulness number than NLA reports. State it explicitly.
13 Confidence & caveats
parascopes/RESULTS.md; treat exact decimals as the author's figures.pinv(W) failed is a hypothesis connecting the two papers, not stated by either. NLA numbers were not independently reproduced — this is a paper-read + synthesis, not a replication.