Do Models Read What They Write? Causal Registers in Scratchpad Reasoning

Abstract: A central hope behind process supervision is that models can expose intermediate variables that matter for their later behavior. For this to help with alignment, a scratchpad must be tied to the computation: when the model writes a state, later steps should compute from that state. To test this requirement, we use a controlled state-tracking task with a known update rule, comparing models trained to report only the final state with models trained to write intermediate states before giving the final answer. At evaluation, we edit the internal representation of one written state while leaving the visible scratchpad text fixed. Because the transition rule is known, the edit has a single correct downstream consequence. In Qwen2.5-Coder-7B, the state-writing model predicts the next phase bit implied by the edited state on 80% and 91% of held-out examples across the two task variants, while pretrained and final-answer-only controls remain near baseline. Additional controls rule out generic next-token steering and copying another continuation: the prediction depends on both the edited state and the current move. The same causal-use pattern replicates across model families. Together, these results suggest a sharper goal for scratchpad oversight: not just to make intermediate reasoning legible, but to train written states that the model uses as part of its computation.

• The paper demonstrates that transformers can internalize causal registers, where counterfactual edits on scratchpad states redirect subsequent reasoning.
• It employs controlled state-tracking tasks with phase bits and order-dependent moves to precisely gauge the causal impact of internal state manipulations.
• Findings reveal high move-specific selectivity and low-rank state modulation, underscoring process supervision as a robust strategy for model interpretability and alignment.

Causal Registers in Scratchpad Reasoning: A Technical Analysis

Problem Formulation and Motivation

This work interrogates whether autoregressive transformer models genuinely use intermediate "scratchpad" states as computational variables, not merely as plausible text artifacts. Typical process supervision approaches assume that when models write out intermediate reasoning steps (e.g., in chain-of-thought or tool-use settings), these intermediates are auditably tied to downstream decisions. However, absent tight coupling between written states and model computation, visible traces may be superficial—with models merely simulating plausible intermediates rather than causally relying on them.

The authors construct a minimal, unambiguous testbed for this principle: a finite, order-dependent state-tracking task. At each step, the observable sequence includes "visible coordinates" and an order-sensitive "phase bit," the latter being irreducible through visible information alone. This setup enables precise counterfactual interventions where the internal state representation at a written token is edited, but the printed text and future actions are held fixed. The central question is whether such internal edits propagate causally as dictated by the known transition rule, thus distinguishing between superficial and computationally-functional scratchpad states.

Figure 1: The task isolates an order-dependent state variable. The phase bit is printed in the running state, but it is not determined by the visible coordinate alone. We edit the highlighted phase-bit representation while leaving the printed token fixed.

Experimental Design

State-tracking Tasks

Two finite-state systems are used: $Q_8$ and $D_8$, differing only in their phase-update rules, not tokenization. Starting from a known state, a sequence of move operations maps to unique state transitions, where each state consists of a visible coordinate and a hidden phase bit. Ambiguity is induced such that two different paths can arrive at the same visible coordinate but with differing phase bits due to move order.

Figure 2: Same moves, same visible path, different phase. The move sequence $T Q T Q T T$ from $00|0$ produces identical visible coordinates in $Q_8$ and $D_8$, but the phase bit diverges (boxed).

Model Variants and Supervision

Three model regimes are compared within a 7B-scale transformer (Qwen2.5-Coder-7B, with replication in Mistral-7B-v0.3):

• Base (pretrained): No task-specific fine-tuning.
• Final-answer: Fine-tuned only to output the final state.
• Running-state: Fine-tuned to emit the state after each move (scratchpad supervision).

Counterfactual State Editing

At evaluation, a rank-$r$ perturbation is applied solely to the residual stream representation of the phase bit at the current state token position, flipping it from $p$ to $1-p$ in feature space, while all textual and future context is held fixed. The subsequent move and its prediction are unchanged except for this intervention. Success is measured by whether the next predicted phase bit matches $p(m \cdot \tilde{s})$—the rule-consistent effect of the edited state—rather than merely reflecting the original unedited trajectory.

Figure 3: Counterfactual state editing redirects a trajectory. The literal trace says the current state is $D_8$0, but the internal representation is replaced with same-visible, opposite-phase $D_8$1; the next move's output is determined by the update rule applied to $D_8$2.

Main Results and Control Analyses

Causal Use Metrics

In the running-state models, the edited phase token causally redirects the next-step state update as dictated by the known transition rule: 80% agreement in $D_8$3, 91% in $D_8$4 on discriminating held-out items. Baseline, final-answer-only, and random/orthogonal subspace edits produce near-chance effects.

Strong positive selectivity is observed for:

• Move-specificity: The effect of the edit depends sensitively on the supplied move token, not a fixed answer bias ($D_8$5/$D_8$6 selectivity in $D_8$7/$D_8$8).
• Recomputation vs. copying: When a future continuation aligned with the counterfactual is injected from a mismatched context, the model predominantly recomputes the next state from the edited local state and supplied move, rather than copying from the injected future ($D_8$9/$T Q T Q T T$0 selectivity).

  Figure 4: Transition-rule consistency controls. Use (main effect), move-specific (swap move), and computed-not-copied (future injection) controls all show that edit behavior reflects a state update, not next-token steering or copying.

Mechanistic Insights

Compactness and Path Localization

The causal phase-bit direction is extremely low-rank. Modifying one direction suffices for $T Q T Q T T$1, two for $T Q T Q T T$2—far below the full residual dimension.

Figure 5: Compact state feature, variable update route. The counterfactual effect saturates at rank-1 for $T Q T Q T T$3, rank-2 for $T Q T Q T T$4.

However, routing analysis reveals differences:

• $T Q T Q T T$5: A single attention connection (layer 22, phase-token to next-step token) accounts for nearly all the effect ($T Q T Q T T$694% CUS removed by ablating this edge; restoration recovers it).
• $T Q T Q T T$7: No single edge dominates; a set of four edges spanning layers 19, 22, 23, 25 together accounts for $T Q T Q T T$869% of the effect, indicating a distributed pathway.

  Figure 6: Ablation and restoration validate the update routes. In $T Q T Q T T$9, a single attention route suffices; in $00|0$0 effect is distributed over a fixed four-edge route.

  

  Figure 7: Candidate-scan landscape for the update path. $00|0$1 has an isolated strong mediator; $00|0$2 disperses effect over several edges.

Random nulls show the identified $00|0$3 edge set is at the $00|0$4th percentile of possible four-edge ablations, so it's highly—but not uniquely—concentrated.

Figure 8: The $00|0$5 four-edge route is unusually strong compared to random four-edge sets but not unique, indicating validated nontrivial path structure.

Theoretical Implications

This study demarcates three levels of state legibility relevant for process-based oversight and mechanistic interpretability:

1. Written: The intermediate state is emitted in output tokens.
2. Represented: The corresponding state is encoded in hidden activations (linearly recoverable).
3. Causally used: The state serves as a computational register mediating future outputs—demonstrable via internal counterfactual intervention and observed downstream rule-governed responses.

Only the third property is operationally meaningful for trusted oversight and audit of model computation. The results indicate that when provided with running-state supervision, transformers can internalize a causal register—an internal variable whose manipulation governs subsequent steps as intended.

This suggests a refined alignment goal: to enforce not merely legible but computationally-meaningful intermediates that support robust evidence-distortion audits and enable targeted intervention.

Practical and Future Directions

Several pragmatic implications follow:

• Mechanistic audits: The demonstrated protocol for counterfactual state editing provides a blueprint for verifying the causal efficacy of written intermediates in more complex settings, including programming, formal proof, or agentic planning.
• Alignment via process supervision: Effective process supervision should favor training setups that couple written scratchpads tightly to computation, producing registers that can be externally manipulated and audited.
• Interpretability methods: The combination of compact subspace editing and targeted connectivity ablation/restore provides a powerful toolkit for circuit localization and for distinguishing representational from computational presence.

A major area for future work is scaling these protocols to settings where the state space and updates are less controlled—e.g., program interpreters, interactive tool use, or theorem-prover goal states—where the mapping from written reasoning to model computation remains underspecified.

Conclusion

This study offers precise evidence that scratchpad supervision can induce LLMs to encode and computationally use internal register-like variables corresponding to written intermediate states. These variables are revealed both by causal behavioral redirection upon internal intervention and by mechanistic path-localization in network connectivity. The findings articulate a sharper alignment criterion for process-based oversight: that intermediates not only be recoverable or plausible, but also function as causal registers modulating downstream reasoning, thereby supporting more robust and actionable interpretability and oversight in deployed LLM systems.