Thinking with
Looped Flows
A recurrent model that learns to improve its internal state while moving from noise towards a solution.
denoiser
Give the model a path to think along.
Looped flows combine two ideas: a loop that keeps updating hidden state, and a flow that gradually turns noise into a candidate answer. Training supervises small denoising steps in sequence, so the state can become more useful over time without backpropagating through a long unrolled computation.
Reuse the same model
Each recurrence update shares parameters but receives a changing state. Effective depth grows at inference time.
Move from noisy to clean
A probability path provides local denoising targets at progressively lower noise levels.
Spend more compute when useful
Use a finer time grid, stochastic sampling, or several trajectories when the problem deserves more search.
Reasoning quality can depend on how long you let the process run.
Fixed computation
Adjustable computation
This is a compute-allocation mechanism. It doesn’t guarantee better reasoning by itself: the recurrence must be trained so later updates can use earlier state.
Where this pattern is most interesting.
The paper tests structured reasoning problems. The first two cards below are directly evidenced by those experiments; the third is a practical inference from the mechanism.
Hard constraint solving
Sudoku, maze paths, and abstract ARC tasks are useful because correctness is inspectable rather than judged only by a language-model preference.
Demonstrated in the paper.
Several valid answers
N-Queens and graph colouring let the model sample different valid solutions and measure coverage, not just the first answer.
Demonstrated in the paper.
Budget-aware agents
Potential fit: agent workflows where a cheap first pass can escalate to finer integration or multiple candidates when confidence is low.
Design implication, not tested here.
Deep dive:
how the loop learns
The central trick is temporal alignment: make neighbouring denoising tasks related enough that a recurrent state can carry useful computation forward.
Truncated backprop makes the early loop guess.
A conventional looped model can stop gradients between updates to keep training practical. That saves memory, but a later loss can’t directly teach an early state what future steps will need.
Long-range credit assignment
With stop-gradient between recurrent steps, every step gets a local target, but early states aren’t rewarded for making later computation easier.
Unstable recurrences
The paper connects this setup to two failure modes: a recurrence can settle into a wrong but stable attractor, or fail to converge at all.
One stateful denoiser, two things moving.
At each time step, the denoiser predicts a cleaner solution and updates a recurrent hidden state. A numerical integration step then moves the flow state forward.
Make adjacent steps share the same story.
Progressively less noise
Sample ordered times t₀ < t₁ < … < tₖ. The associated interpolants become easier to denoise as time advances.
Stop gradients between states
Each denoising objective stays local. The sequence itself teaches the recurrence to carry useful state forward, while adaptive computation time ignores steps after accuracy saturates.
At test time, the grid becomes your compute dial.
The paper integrates from t = 0 to t = 1. A finer temporal grid means more denoising-and-state updates. Stochastic integration adds controlled variation so different runs can explore different valid answers.
Finer grid
Increase the number of integration steps without changing the trained model.
ODE or SDE
Deterministic ODE integration preserves diversity; stochastic SDE integration can improve validity and coverage.
Ensemble
Run independent trajectories, then use the ACT head’s score to select a candidate.
Interactive view · Sudoku inference budget
8 steps · 74.5% reportedOnly the paper’s reported endpoints are labelled here: 74.5% at 8 steps and 97.9% at 128 steps. Intermediate values are intentionally not asserted.
Strongest gains show up on structured reasoning.
The authors compare small models against prior looped methods on four benchmark families. The looped-flow models use 5–7M parameters in this table.
| Method | Params | Sudoku | Maze | ARC-1 | ARC-2 |
|---|---|---|---|---|---|
| TRM | 5–7M | 87.4 | 85.3 | 44.6 | 7.8 |
| FPRM | 7M | 94.2 | 87.0 | 47.5 | 6.2 |
| GRAM | 10M | – | – | 52.0 | 11.1 |
| Looped flows | 5–7M | 97.9 ± 0.4 | 86.7 ± 1.1 | 58.8 ± 1.8 | 12.2 ± 1.9 |
Single-trajectory results. Sudoku and Maze are exact accuracy; ARC columns are pass@2. Dashes mean the cited comparison did not report that result in Table 1.
Better recurrence means fewer dead ends.
of around 65,000 tested Sudoku-Extreme instances failed under TRM. Among these failures, 88.3% did not converge and 11.7% reached a wrong stable attractor.
of TRM failure cases were resolved by looped flows: 89.9% of non-convergence cases and 98.0% of spurious-attractor cases.
These are recovery rates on the baseline’s failure cases, not a universal error reduction claim. The analysis is on Sudoku-Extreme and compares with TRM.
Don’t just find an answer. Find the valid answer space.
For multi-solution tasks, the paper runs 20 independent inferences and measures validity plus coverage: how much of the set of compatible solutions was recovered.
| Task | Validity / conflicts | Coverage | What it tests |
|---|---|---|---|
| N-Queens 8×8 | 99.9 ± 0.1% accuracy | 91.4 ± 0.4% | Many valid board layouts |
| N-Queens 10×10 | 94.4 ± 0.7% accuracy | 61.5 ± 0.1% | Larger solution space |
| Graph colouring 8 | 0.7 ± 0.6 conflicts | 89.4 ± 0.7% | Valid colour assignments |
| Graph colouring 10 | 1.0 ± 1.0 conflicts | 55.2 ± 0.3% | Larger graph |
Why stochasticity helps
Different initial noise samples can be transported towards different valid solutions. In the paper, SDE generally improves coverage, especially on larger tasks.
Why determinism still matters
ODE integration retains diversity in the reported experiments, so variation isn’t solely attributed to injected noise.
The recipe is not one trick. It’s a bundle.
Removing temporal conditioning, interpolants, decreasing noise, or shared noise lowers ARC performance. The largest drop in the table comes from removing both time conditioning and interpolants.
| Configuration | ARC-AGI-1 | ARC-AGI-2 | Interpretation |
|---|---|---|---|
| Full looped flow | 58.8 ± 1.8 | 12.2 ± 1.9 | All components |
| Without time conditioning | 56.4 | 9.9 | Model loses explicit t |
| Without interpolant | 51.5 | 9.9 | No noisy-to-clean path |
| Without time + interpolant | 43.6 | 5.0 | Both signals removed |
| Without decreasing noise | 51.6 | 9.9 | Breaks temporal curriculum |
| Without noise sharing | 56.4 | 10.8 | Less cross-step association |
The paper reports pass@2 accuracy for ARC. Values without ± are shown as reported in Table 3.
Promising mechanism. Early evidence.
What the paper establishes
What it doesn’t establish
The conclusion points to simulation-free training methods that could retain looped-flow benefits while changing the training procedure.
Source: Sections 3.1, 5, Appendix B, and Conclusion, pp. 4–10, 14–16 ↗
Implementation guide:
from problem to loop
A research-oriented recipe you can adapt to a structured task. Start with inspectable correctness, then earn complexity one component at a time.
Build the smallest loop that can be measured.
Keep training and inference conceptually separate.
# one local loss per ordered denoising objective for (c, x1) in dataset: x0 ← sample_noise() z ← z0 times ← sort(sample_uniform(k + 1)) for t in times: It ← (1 − t) · x0 + t · x1 x_hat, z_next ← denoiser(It, stop_grad(z), c, t) loss ← cross_entropy(x_hat, x1) loss.backward() # local, not through prior z z ← z_next update_parameters()
# integrate the learned probability flow x ← sample_noise() z ← z0 times ← grid(0, 1, n + 1) for (t, next_t) in adjacent(times): x_hat, z ← denoiser(x, z, c, t) velocity ← (x_hat − x) / (1 − t) x ← x + (next_t − t) · velocity # optional: add SDE noise / use a better integrator return round(x)
This is a teaching simplification of Algorithms 1–2. The paper’s full inference algorithm includes stochastic integration details and noise backtracking.
Use the paper’s defaults as a baseline, not a promise.
Local denoising steps used for training.
Weight for the adaptive computation-time loss.
Representative steps for Sudoku in the task-specific table.
Optimiser and numeric setup
Mean StableMax cross-entropy, Adam-atan2 with β₁ = 0.9 and β₂ = 0.95, peak learning rate 10⁻⁴, 2k-step warmup, batch size 768, gradient clipping 1.0, parameter EMA decay 0.999, and bfloat16 forward passes.
Time sampling
Sort k + 1 independent draws from Uniform[0, 1] so the model sees an ordered sequence of decreasing noise levels. The paper also studies a random-start sampler.
Regularisation note
For some single-solution tasks, the authors use pseudotargets in later interpolants to reduce exposure to nearly-clean targets. Treat this as a task-specific option.
Measure the trajectory, not only the final answer.
Core evals
Failure analysis
You can plot quality against inference compute and explain why an extra step, another trajectory, or stochasticity changed the result.
Three ideas worth carrying forward.
Temporal structure can make local training useful. A sequence of related denoising objectives can teach a recurrent state to accumulate computation without full BPTT.
Inference-time compute is a product knob. Finer grids and multiple trajectories create a controllable quality–cost trade-off on the tested tasks.
Validity and diversity should be separate metrics. A model that returns one valid answer isn’t necessarily good at exploring a problem with many valid answers.
The final sentence is an interpretation of the paper’s mechanism, not a quotation.
Read the paper for the details.
This deck is an evidence-grounded explainer of the supplied PDF. Metrics, algorithms, and limitations below are drawn from the paper; broader use cases are labelled as implications.
Thinking with Looped Flows · arXiv:2609.11801v1 ↗
We propose looped flows, an approach that sidesteps this issue by training the recurrence with local denoising objectives.
Across six reasoning benchmarks including two multi-solution benchmarks, looped flows outperform prior state-of-the-art looped models overall.
The paper reports benchmark experiments using small task-specific models and preprocessing. It doesn’t establish general-purpose agent or language-model performance.