SanSi: A Looped Typed Decision Model for System 1.5 Thinking

Summary (Overview)

• Core contribution: SanSi introduces a looped typed decision model that applies the same transformer layers recursively before producing a typed readout, bridging the gap between fast single-pass (System 1) and generated reasoning (System 2) — termed "System 1.5 thinking."
• Key finding: Looping adds 13.5 accuracy points over a non-looped model of the same shape (72.0% vs. 58.4% on 10,027 test decisions), brings a 1.4B model within 1.8 points of a 4.2B single-pass model, and extends solvable reasoning depth beyond training.
• Anytime prediction: By reading option probabilities after every loop and training each with proper scoring rules, one model serves every budget from 1 to 8 loops; three loops deliver 88% of the gain.
• Mechanistic insights: Loops improve missing-evidence detection (AUROC 0.835→0.935), but calibration peaks at loop 3 as confidence keeps rising after answers settle; harder items settle later.
• Practical impact: As a reward for reinforcement learning without gold answers, SanSi raises a generator's F1 by 7.7 points when read at loop 8.

Introduction and Theoretical Foundation

Background

• Typed decision models answer a declared question without generating text: a decision head returns probabilities over declared options in a single forward pass.
• Single-pass models allocate fixed computation per decision, which fails for multi-step reasoning (e.g., liar chains where accuracy drops from 100% to chance level with increasing depth).
• The paper positions looping as a middle ground: applying the same layers recursively adds computation but no parameters while maintaining the typed contract.

Theoretical Basis

• Looped transformers learn iterative algorithms and generalize to longer inputs (Giannou et al., 2023; Yang et al., 2024), building on Universal Transformers (Dehghani et al., 2019).
• System 1.5 thinking (Wang et al., 2025): each loop revises the hidden state before committing to an answer, without generating tokens.
• The work builds on Ouro (Zhu et al., 2025), a language model pre-trained to loop, with the full stack trained for looping (unlike Jev-LCT which loops only top layers).

Key Definitions

• Typed decision: A call with state $s$, question $q$, and $K \geq 2$ declared options; the model returns a distribution $p \in \Delta^K$ with no text.
• Target distribution: One-hot for items with a correct option; uniform for unanswerable items; annotators' label distribution for crowd-labeled items.

Methodology

Looped Backbone

Ouro-1.4B applies one stack $F_\theta$ of 24 transformer layers repeatedly:

$$h_t = N(F_\theta(h_{t-1})), \quad t = 1, \dots, T \tag{1}$$

where $N$ is the final normalization, $h_t$ is both output of loop $t$ and input of loop $t+1$; running $T$ loops costs $T$ passes with no added parameters.

Readout After Every Loop

The option logits are computed from the last prompt token's hidden state $z_t$:

$$\ell_t = (W + U_t V_t) z_t / \tau_t, \quad p_t = \mathrm{softmax}(\ell_t) \tag{2}$$

where $W$ holds frozen language-model head rows, $U_t V_t$ is a rank-16 trained correction, and $\tau_t$ is a trained scale — one per loop.

Training Objective

Every loop is trained with a sum of two proper scoring rules:

$$\mathcal{L} = \frac{1}{T} \sum_{t=1}^{T} \left[-\sum_k y_k^* \log p_{t,k} + \sum_k (p_{t,k} - y_k^*)^2\right] \tag{3}$$

• Cross-entropy penalizes confident errors; Brier score is bounded and considers all options.
• The backbone is frozen; only LoRA adapters (rank 64, 60.6M params) and readouts (0.27M) are trained.
• Training uses $T=8$ loops (twice Ouro's pre-training) for 1,000 steps of 16 items.

Evaluation Suite

A diverse suite of 10,027 test decisions from 59 sources across six item types:

Empirical Validation / Results

RQ1: Does Looping Help?

Main results (mean ± std over 3 seeds):

Key observations:

• Looping adds 13.5 points over same-shape non-looped model (58.4→72.0%).
• The gain is largest on knowledge questions (+17.6), long documents (+16.7), and multi-step reasoning (+15.1); smallest on classification (+3.1).
• SanSi-2.6B surpasses Qwen3.5-4B by 2.0 points with only 63% of its parameters.

RQ2: How Do Answers Change Across Loops?

• Loop 2 adds 8.5 points, loop 3 adds 3.5, loop 4 adds 1.2; loops 5–8 add only 0.4.
• 90.2% of answers are final by loop 4; after loop 5, fixes and breaks balance.
• Harder items settle later: items solved by all three single-pass models settle after 1.4 loops; those solved by none settle at 2.8.
• Late-settling answers are unreliable: 82.2% of never-changing answers are right vs. only 35.6% of those settling at loop 8.

RQ3: What Do Loops Do to Probabilities?

• Confidence rises on right (0.769→0.869) and wrong (0.567→0.660) answers alike; error-detection AUROC improves only slightly (0.760→0.795).
• Calibration peaks at loop 3 (ECE 0.082), then degrades to 0.093 at loop 8.
• Missing-evidence detection improves dramatically: hard answers on unanswerable items drop from 27.1% to 17.5%; evidence AUROC rises from 0.835 to 0.935.

RQ4: Does Looping Buy Reasoning Depth?

On depth-controlled tasks (liar chains, object swaps):

• SanSi extends solvable depth beyond training: on unseen depths (9–16, training up to 8), SanSi reaches 72.6% vs. 50.0% (chance) for Qwen3.5-4B.
• Parameters do not replace loops: Qwen3.5-4B holds depth 3 on both tasks; SanSi at loop 8 leads by 22.6–29.5 points on unseen depths.

Ablations

• Training objective: Per-loop loss is crucial — last-loop-only training collapses early loops (35.6% at loop 1) and loses 1.1 points at loop 8.
• Brier term: Dropping it raises ECE from 0.093 to 0.104 and hard answers on unanswerable items from 17.5% to 20.0%.
• Backbone: Adding loops to non-looped SmolLM2 brings no gain (58.3% vs. 58.4%); the gain rests on looped pre-training.
• Running beyond trained loops hurts: SanSi falls from 72.0% at loop 8 to 70.1% at loop 16.
• Averaging loops is a free fix: keeps accuracy (71.8%) and halves ECE (0.044 vs. 0.093).

Theoretical and Practical Implications

Theoretical Implications

• Loops as computation: Looping trades computation for parameters, providing a third axis (beyond model size and generated reasoning) for improving decision accuracy.
• Depth generalization: Loops enable solving problems deeper than training demonstrates, suggesting iterative refinement mechanisms akin to algorithmic reasoning.
• Calibration dynamics: The divergence between accuracy (improving) and calibration (peaking at loop 3) reveals a fundamental tension in iterative inference.

Practical Implications

• Anytime prediction: One model serves multiple compute budgets — critical for deployment scenarios with varying latency requirements.
• Verifier applications: SanSi as a reward model improves generator F1 by 7.7 points (39.5→47.3) without gold answers, but only when read at sufficient depth (loops 4–8); loop 1 actively damages training (F1 drops to 29.1).
• Cost considerations: Eight loops cost 7.7× single-pass GPU time; three loops cost 2.9× and deliver 88% of the gain.

Conclusion

Main Takeaways

1. Looping transforms a 1.4B model into a competitive alternative to 4.2B single-pass models, with the trade-off being computation rather than parameters.
2. The anytime nature (reading at any loop) makes the model adaptable to varying computational budgets.
3. Loop dynamics reveal that harder items settle later, and late-settling answers are unreliable — suggesting future work on loop-selection rules.
4. The benefits depend critically on looped pre-training; the recipe alone cannot create the loops.

Future Directions

• Adaptive halting: A rule to choose the loop per item (11.7% of items are right at some loop but wrong at loop 8).
• Scaling: Testing on larger and more diverse looped backbones as they become available.
• Broader verifier evaluation: Extending the reward-model case study to more datasets and generators.

Limitations

• Findings rely on one backbone family (Ouro 1.4B/2.6B); generalization to other looped backbones is untested.
• Depth analysis uses only two program-generated tasks.
• The suite is English-only and assembled from existing datasets; potential pre-training contamination cannot be excluded.