acceptodds
Under review as a conference paper at ICLR 2027

A Tilted Bowl Is Not a Slippery Slope: Compressing Looped Models

Abstract

Looped models reason by applying the same block of weights many times, so compressing that block saves memory traffic on every loop. Compressed looped models, however, often collapse, and the collapse is usually blamed on rounding error that accumulates from loop to loop. In this work we test that account on more than 30 models from five families and find, to our surprise, that it holds only for loops that never settle. When a loop settles, a fixed rounding error does not accumulate. It moves the point where the loop settles, much as tilting a bowl moves where a ball comes to rest, and the answer is lost only when the shift is larger than the readout tolerates. This picture lets us predict which models fail from a single label-free measurement, and it tells us why failed models recover: their loops still settle, so a few final loops with 8-bit weights bring the answer back. Motivated by these findings, we build a controller that stops when the model's halting head fires and then finishes with 8-bit loops. On Sudoku-Extreme it beats fixed-depth inference by 15 points at under a third of the weight traffic.

Primary area:
infrastructure, software libraries, hardware, systems, etc.
Keywords:
looped models, recursive reasoning, quantization, model compression, fixed points, test-time compute, early exit, deep equilibrium models, on-device inference

Reviews

Among:
Shape:
1234this paper, Top 4%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.33 over 3 reviews, above 96% of the others.
Reviewer_LXVHOpenReview ↗
Rating
3
Confidence
2
Informativeness
3
Presentation
3
Soundness
2
Read review
Paper summary

This paper analyzes the impact of quantization error on looped models. Based on the analysis and the evaluation across 33 looped models, the paper shows that the fixed weight noise only shift the settled state, rather than fully distorting the settle point due to repeatedly accumulated error. Also, the paper argues that the accuracy failures occur only when this shift exceeds the permitted "room". Therefore, this paper argues that only a few higher-bit loops (e.g., 8-bit) can recover the quantized looped model's accuracy. Based on these findings, the paper proposes a controller that enables adaptive stopping, followed by few 8-bit loops to improve accuracy.

Critical strengths
  • This paper first provides the interesting hypothesis and analysis on quantization collapse in looped models. I think this work's insight can be extended to other compression method beyond quantization for looped models.
  • Provided analysis is comprehensive and interesting. Especially, different behaviors between the fresh activation noise and the fixed weight noise across iterations are interesting.
  • Beyond the analysis, proposing the Controller based on the observation provides a guideline for the deployment.
Critical weaknesses
  • While explanation with "Settling-point" is intuitive, I think there is a need of more direct ablation. Under the fixed number of total loops and the 8-bit (high-precision) loops, I wonder how final accuracy differs across the positions of 8-bit loops. For example, while comparing 8-bit loops first then 4-bit loops vs. 4-bit loops then 8-bit loops (default), does the later consistently achieve higher accuracy?
  • It seems that activation quantization can be more robust than the weight quantization, as activation quantization error can be acted as fresh noise (if the magnitude is not too big). However, the main results are focused on weight-only quantization. Discussion on weight-activation quantizaiton would be beneficial.
  • Currently, the main analysis and results are focused on the round-to-nearest quantization. Extending the observation to calibration-based method would be beneficial. For example, GPTQ targets to minimize output distortion, while increasing the weight distance itself. In this case, I wonder that GPTQ hurts looped model's accuracy due to increased fixed weight noise.
Questions for authors

Please see Weaknesses.

2 comments
AuthorsOpenReview ↗

Reply to Reviewer LXVH

Thank you for the review. We ran the two experiments you proposed.

W1. "8-bit loops first then 4-bit loops vs. 4-bit loops then 8-bit loops (default), does the latter consistently achieve higher accuracy?"

8-bit loops last are better on four of the five collapsed formats, and the order does not matter on surviving formats. We fixed the total at 24 loops (16 compressed loops and eight 8-bit loops) and changed only the position of the 8-bit loops (Sudoku-Extreme, n=1000):

Model, format24 compressed loops8-bit loops first8-bit loops lastFull precision, 24 loops
MLP, w4t5.98.769.372.5
Attention, w3t0.00.017.167.9
Attention, w2g320.00.026.467.9
MLP, w3c18.060.967.872.5
HRM, w2g3215.147.641.751.5

The exception is HRM w2g32, where 8-bit loops first are better. On the four surviving formats we tested, the two orders are within 1 point. The pattern is the same with 4 and with 16 8-bit loops.

On MLP w3c and HRM w2g32, 8-bit loops first also recover much of the accuracy. If rounding error accumulated, this gain would fade as more compressed loops follow. It does not:

Gain of 8 early 8-bit loops over compressed loops onlyfollowed by 16 compressed loops64256
MLP, w3c+42.9+42.6+42.0
HRM, w2g32+32.5+31.7+30.8

The gain keeps 95 to 98% of its size after 256 compressed loops. The loop settles in the basin where the 8-bit loops placed it, which settling can explain and accumulation cannot.

W2. "It seems that activation quantization can be more robust than the weight quantization, as activation quantization error can be acted as fresh noise (if the magnitude is not too big)."

This matches Figure 2: fresh, zero-mean noise produces the same cliff as fixed noise, only later. Fresh error is therefore more forgiving, as you suggest, but it still collapses the model once it is large enough. The weight-activation formats (W4A4 with per-group and MXInt4 scales, and W8A8) are in Appendix C, Table 8; their gap to full precision does not widen along supervision steps or outer cycles.

W3. "GPTQ targets to minimize output distortion, while increasing the weight distance itself. In this case, I wonder that GPTQ hurts looped model's accuracy due to increased fixed weight noise."

GPTQ does not hurt. It lowers the push even where it increases the weight distance, and the push is what decides collapse:

FormatWeight distance, RTN → GPTQPush, RTN → GPTQ
MLP, w3g320.205 → 0.2390.422 → 0.109 (3.9× lower)
Attention, w3c0.292 → 0.3120.353 → 0.136 (2.6× lower)
Attention, w3g320.199 → 0.2580.211 → 0.067 (3.2× lower)

GPTQ lowers the push on all 7 formats we measured (by 1.3 to 6.2x; on the other four it lowers the weight distance too), and the push-versus-room law classifies all 7 GPTQ models correctly. Accuracy follows the push: GPTQ raises fixed-depth accuracy, and the controller improves GPTQ on 10 of 10 cells (GPTQ table in the general response).

Reviewer_LXVHOpenReview ↗

Thank you for the rebuttal

Thank you for the rebuttal and the additional experiments. I find the new results interesting and helpful, particularly the loop-ordering ablation, and I would welcome their inclusion in the revised paper. I maintain my positive assessment of the work.

Reviewer_CjDCOpenReview ↗
Rating
4
Confidence
3
Informativeness
2
Presentation
3
Soundness
3
Read review
Paper summary

Looped models (TRM, HRM, recurrent LMs, diffusion models) sometimes collapse abruptly under quantization. The common explanation is that rounding error accumulates with more loops. Testing this across 5 model families and 30+ models, the authors find it's only true for loops that don't converge; for the common case of converging loops, compression just shifts the fixed point ("tilts the bowl") — if the shift stays within a tolerance ("room"), output doesn't flip and looping longer doesn't hurt. This lets them predict failure from label-free sensitivity measurements (R²=0.72) and recover it with a short full/8-bit "cleanup" phase, yielding a controller that beats fixed-depth inference by 15 points on Sudoku-Extreme with 1/3 the weight traffic.

Critical strengths
  • Falsifies the standard "error accumulates with depth" story with large-scale evidence (30+ models, 5 families) before proposing a fix.
  • The "tilted bowl" framing ties together Banach fixed-point bounds, margin-over-sensitivity radii, and mixed-precision refinement into one coherent account.
  • Predictions were locked in before the confirming experiments ran, and matched actual gains with 0.997 correlation.
  • Directly rebuts a conflicting concurrent result by tracing it to a clipping-rule artifact.
  • The resulting controller is simple to deploy — no full-precision copy needed, reuses the model's own halting head.
Critical weaknesses
  • Largest models tested are only a few billion parameters — unclear if this holds at 70B+ scale.
  • Efficiency gains are computed from weight-traffic byte counts, not measured on real hardware.
Questions for authors

I have no other questions, the author writes very clearly about the limitations of his own work

1 comment
AuthorsOpenReview ↗

Reply to Reviewer CjDC

Thank you for the review.

W1. "Largest models tested are only a few billion parameters — unclear if this holds at 70B+ scale."

To our knowledge, no public looped language model near 70B exists. The looped LMs we evaluate, Huginn (3.5B) and Ouro (2.6B), are among the largest with public weights. We know of two larger ones: a 4B model released in October 2026, after our submission, and a 20B mixture-of-experts preview (2B active parameters) whose weights we could not access. If you are aware of a larger public looped model, we would be glad to evaluate it.

W2. "Efficiency gains are computed from weight-traffic byte counts, not measured on real hardware."

We measured them. On a Jetson AGX Xavier and an L40S, the energy of an answer is proportional to its number of loops (within ~1% at the median), and lower precision reduces the cost of a loop on the Jetson and on a Raspberry Pi 4. The hardware tables are in the general response. We leave a full hardware study to future work.

Reviewer_YfefOpenReview ↗
Rating
3
Confidence
3
Informativeness
3
Presentation
3
Soundness
2
Read review
Paper summary

Quantizing a looped model pays off on every loop, but quantized looped models often collapse. The usual story blames rounding error that piles up loop after loop. Across 33 models, from Sudoku solvers to looped language models on GSM8K, this holds only for loops that never settle. In settling loops, rounding moves the resting point, and a few 8-bit final loops largely undo it. The resulting controller beats fixed depth on Sudoku-Extreme by 15 points.

Critical strengths

This is a well-run empirical study that tests a common assumption about compressed looped models and lands on a simpler explanation that holds across many models.

  • Showing that zero-mean fresh noise still produces the collapse cliff is a clean test, and it undercuts the bias accumulation story behind LoopQ and concurrent work.

  • Experiments cover 33 models from five families on two hardware platforms, and DDIM is a negative case where error does accumulate, which makes the scope of the claim clear.

  • Predictions were written before the runs, and the failed ones are reported too, so the confirmed finishing law with r=0.997 is easier to trust.

Critical weaknesses
  • The controller is compared only with the same compressed model at fixed depth, so most of its 15 points come from collapsed formats. It seems a baseline with 8-bit only is missing.
  • Costs come from a weight-traffic model, never timed on hardware. TRMs with 5 to 7M parameters probably fit in GPU L2 cache, where that cost model may not apply.
Questions for authors
  • On the 20 Sudoku models, what accuracy and weight traffic does the w8c model reach by itself with the same halting head rule?
  • Most of the 14.7-point gain sits on w3c, w4t and w2g32 models that collapse at fixed depth. How does the controller compare with simply picking a format that survives, such as w4c, or a stronger quantizer like GPTQ, AWQ or LoopQ at the same bit width, matched on bits read per puzzle?
2 comments
AuthorsOpenReview ↗

Reply to Reviewer `Yfef`

Thank you for the review.

Q1. "On the 20 Sudoku models, what accuracy and weight traffic does the w8c model reach by itself with the same halting head rule?"

78.0% at 52 bits read per weight per puzzle, with the paper's halting-head rule and its 16-step cap. For a comparison matched on bits read, the table evaluates the same 20 cells at a budget of 16 cheap-loop units, on held-out puzzles:

AccuracyBits read per weight per puzzleBits stored per weight
Compressed model, fixed depth56.856.23.55
Compressed model, halting-head stop61.141.13.55
Controller (8-bit finish)74.539.811.55
w8c, halting-head stop75.243.08.0
w4c, halting-head stop80.237.44.0

At matched traffic, w8c with our stop rule is within a point of the controller, and w4c is above both while storing half the bits of w8c. The revised Table 3 includes the w8c baseline.

Q2. "How does the controller compare with simply picking a format that survives, such as w4c, or a stronger quantizer like GPTQ, AWQ or LoopQ at the same bit width?"

Picking a surviving format is what the push-versus-room law is for, and it needs no labels. We used the law as a selector: for each of the 9 Sudoku models, take the lowest-bit format whose push is within the room. It picks a surviving format on 9 of 9 models, each at 3 to 4 bits. With the halting-head stop, on held-out puzzles:

Budget (cheap-loop units)Format the law picks (3 to 4 bits stored)w8c (8 bits stored)Controller (10.5 to 11.5 bits stored)
1677.773.768.9
2479.980.069.6
6480.784.970.0

The law's pick beats w8c at budget 16 and matches it at 24, while storing at most half the bits. At budget 64 w8c is ahead, and it reads 1.7× the bits. The alternative you suggest is therefore available inside the paper's own framework, and the revised paper reports it.

On stronger quantizers, GPTQ at the same bit width raises fixed-depth accuracy, and the controller adds to it on 10 of 10 cells (GPTQ table in the general response). AWQ's released code supports a fixed list of LLM architectures, and we found no released code for LoopQ.

W1. "Most of its 15 points come from collapsed formats."

We agree, and the law predicts it. A format inside the room has no shift to repair (8-bit loops add at most 4 points on surviving formats), so the controller's gain sits on the collapsed ones. The gain is also not specific to Sudoku: on Maze-Hard the controller improves accuracy from 70.9 to 78.5.

W2. "Costs come from a weight-traffic model, never timed on hardware. TRMs with 5 to 7M parameters probably fit in GPU L2 cache, where that cost model may not apply."

We timed these models on hardware. On a Jetson AGX Xavier with power rails and on an L40S, the energy of an answer equals its number of loops times the per-loop energy of the board, within ~1% at the median (25 and 80 runs). The loop count in our cost model therefore tracks measured energy. On Sudoku-MLP, stopping by the halting head cuts energy per correct answer by 2.4 to 2.6× at equal accuracy. Lower precision also reduces the cost of a loop on the Jetson and on a Raspberry Pi 4, even though these models fit in cache (hardware tables in the general response).

A full hardware study is beyond the scope of this paper, and we leave it to future work.

Thank you for the response and further experimentation. I appreciate the clarifications and will maintain my positive rating.

Comments on the paper

1 comment
AuthorsOpenReview ↗

General response (to all reviewers)

We thank the reviewers. The paper's claim is that when a loop settles, a fixed rounding error does not accumulate: it moves the point where the loop settles, and the answer is lost only when that shift is larger than the room. The reviews credit the evidence for it. The paper "falsifies the standard 'error accumulates with depth' story with large-scale evidence" (CjDC), its fresh-noise experiment is "a clean test" (Yfef), and its analysis is "comprehensive and interesting" (LXVH).

Each review also proposed an experiment the paper did not have. Two of them, the order of the 8-bit loops and GPTQ, could have contradicted the claim. We ran all of them, and every result supports it:

  • Order of the 8-bit loops (LXVH W1). 8-bit loops last beat 8-bit loops first on four of the five collapsed formats, and the order makes no difference on surviving formats.
  • GPTQ (LXVH W3, Yfef Q2). GPTQ lowers the push and raises fixed-depth accuracy. The controller still adds to it on 10 of 10 cells.
  • Picking a surviving format (Yfef Q2). The push-versus-room law, used as a selector, picks a surviving format on 9 of 9 models, without labels.
  • Hardware (Yfef W2, CjDC W2). While we punt hardware measurements to future work, we ran proof-of-concept experiments on edge computers and a datacenter GPU (L40S); the measured energy of an answer is proportional to its number of loops, within ~1%.
  • Maze-Hard. The controller improves accuracy from 70.9 to 78.5.

With these results the claim holds for a second quantizer, for both orders of precision, on a second task and on hardware, and the law is shown to choose a format as well as to predict collapse.

Two of these results answer more than one reviewer, so their tables are here. The others are in the individual replies.

GPTQ (LXVH W3, Yfef Q2). GPTQ raises fixed-depth accuracy, and the controller adds to it:

10 Sudoku cells, held-out puzzlesRTNGPTQ
Fixed depth40.153.4
With the controller and its sampling add-on67.869.8
Full precision, fixed depth73.0

Hardware (Yfef W2, CjDC W2). The paper charges an answer by its loops. On two boards we measured the energy of whole answers and compared it with the number of loops times the measured energy of one loop:

BoardRuns measuredMedian gap between the measured energy and loops × energy of one loop
Jetson AGX Xavier250.6%
L40S801.1%

Counting loops therefore predicts the energy of an answer to within ~1%. Lower precision then makes each loop cheaper:

One loop of Sudoku-MLPfp32Lower precisionGain
Jetson AGX Xavier, time32.3 ms12.6 ms (fp16)2.6×
Jetson AGX Xavier, energy1,198 mJ382 mJ (fp16)3.1×
Raspberry Pi 4 CPU, time1,131 ms583 ms (INT8)1.9×

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.