The Halt Vector

Internalizing a causal steering intervention for efficient reasoning.

Accepted as a Spotlight at the COLM 2026 Workshop on Efficient Reasoning.

Reasoning models overthink: they reach a correct answer, then re-derive and re-check it for thousands more tokens. On DeepSeek-R1-Distill-Qwen-7B the gap between knowing and stopping is large and stable: on the rollouts where a confidence estimate saturates it does so at a median of about 1,650 think-tokens, while those same rollouts run to a median of about 3,700, a matched factor of 2.24.

The obvious objectives do not work: outcome-level reinforcement learning only trims the longest tails, and imitation and preference methods put no learnable weight on the per-problem stop decision. This repo instead turns an interpretability finding into a weight edit. A difference-of-means "halt vector" at layer 18 is a causal stopping knob: steering along it shortens generation monotonically (ρ(strength, length) = −0.82), while a replicated value axis is inert (+0.09). We then internalize that intervention into the weights, training the model to reconstruct the steered activation at its own per-problem answerable point, yielding a hook-free, per-problem, tunable self-halt fit from 24 problems without reinforcement learning.

Result

• ~24% less thinking at held accuracy (20–24% across five unseen benchmarks: goldilocks holdout, AMC, AIME24, AIME25, MATH500), stable over three seeds.
• Per-problem adaptive, not a global cut: the realized reduction correlates with each problem's own removable slack, a hidden reference the model never sees, at Pearson 0.70 (95% CI excludes zero).
• Fixes a termination pathology: the base model runs to the token cap at a rate that grows with difficulty (31–38% on AIME); the halt closes that to 6–9%.
• Hook-free and data-efficient: no inference-time machinery, no RL pipeline, a supervised fit from 24 examples. A weight-space burst-merge scales the data safely to 144 problems.

What we do not claim. We do not beat a well-tuned length-penalty RL method or a decoding-time early-exit hook (DEER) on the raw compression–accuracy trade-off; the efficiency is competitive, not state of the art. The contribution is how the halt is obtained, a causal internal signal internalized into the weights, and its deployment profile. At matched compression on AIME24 our accuracy change is −2.0 points against the decoding hook's −6.7.

The mechanism

Split the network at layer 18 into a writer (layers 0–18) and a frozen reader (layers 19–27). The naive objective (make the scalar projection onto the halt vector large) fails: satisfying one scalar leaves the off-axis dimensions unconstrained, and they move. Every scalar arm drifts further off-axis than every reconstruction arm, and the more an arm drifts the worse it behaves. That drift stays inside the base model's own off-axis dispersion, so the reader is disturbed rather than handed a wildly out-of-distribution vector, and the model rambles. Reconstructing the whole steered activation with off-axis dimensions pinned to their natural values hands the reader exactly the vector it responds to, and the model halts. That "scalar fails / full-vector reconstruction works" contrast is the intellectual core, and it motivates testing full-vector reconstruction when internalizing other steering directions; it does not establish that scalar objectives fail for every direction.

Repository layout

paper/            the paper (LaTeX source + main.pdf) and figure-generation code
src/selfhalt/     the pipeline: modal_app.py (entrypoints) + trainer/eval/steer/build/analyze scripts
tests/            pure-Python unit tests (grader, reward math, value-axis, adaptivity statistics)

Reproducing

Everything runs on Modal (H200 GPUs). src/selfhalt/modal_app.py pins the frozen stack in its image and uploads the pipeline to run remotely; artifacts persist to a Modal Volume mounted at /vol.

pip install modal && modal setup
modal run src/selfhalt/modal_app.py::make_overfit                  # 24-problem splits + per-problem B_end
modal run src/selfhalt/modal_app.py::build_value_axis --source math_lockon
modal run src/selfhalt/modal_app.py::steer_scan                    # the causal knob (Section 4)
modal run src/selfhalt/modal_app.py::train_recon --out-tag champ_a25   # internalize it (Section 5)
modal run src/selfhalt/modal_app.py::eval --benchmark amc --adapter /vol/champ_a25/adapter

The pure-Python analysis and grader logic is unit-tested and runs locally:

pip install -r requirements.txt
for f in tests/test_*.py; do python "$f"; done

Paper

The Halt Vector: Internalizing a Causal Steering Intervention for Efficient Reasoning. Dylan Jayabahu, Tinuade Adeleke. COLM 2026 Workshop on Efficient Reasoning — Spotlight.

Preprint: arXiv:2608.28859. The camera-ready is paper/main.pdf. Model throughout: DeepSeek-R1-Distill-Qwen-7B. If any document here disagrees with the paper, the paper is authoritative.

License

MIT. See LICENSE.