Looped Flows: A looped-flow reasoning method achieves 58.8% on ARC-AGI-1
🔎 The missing link of recurrent reasoning
Language models know how to reason, but they do it in a straight line. Token after token, they move forward without ever retracing their steps. That's efficient for generating text, but dramatically limited for problems that require iterative thinking.
Have you ever tried to solve a complex puzzle in one go, without ever going back? No one works like that. We fumble, correct, refine. Looped models attempt to mimic this ability, but they run into a fundamental problem: backpropagation only covers a few steps, making learning of early iterations nearly impossible.
A paper published on September 10, 2026, by an international team (EPFL, KAIST, University of Amsterdam, Carnegie Mellon, TU Wien/AITHYRA and Oxford) changes the game. Looped Flows achieve 58.8% on ARC-AGI-1 and 12.2% on ARC-AGI-2, shattering the previous TRM record (44.6% and 7.8%). That's a gain of +14.2 points on the first benchmark and +4.4 points on the second.
The key? A deceptively simple idea: train the recurrence with local denoising objectives, turning inference into velocity integration of a probability flow.
The Essentials
- Problem solved: Recurrent models suffer from truncated backpropagation (BPTT), which prevents learning from early iterations. Looped Flows bypass this limitation through temporal alignment via decreasing noise levels.
- Key mechanism: Inference is formulated as integrating the velocity of a probability flow parameterized by the learned denoiser, coupled with recurrent states. Noise is shared across steps, creating an implicit curriculum.
- Results: 58.8% on ARC-AGI-1 (vs 44.6% for TRM) and 12.2% on ARC-AGI-2 (vs 7.8%). SOTA among all existing recurrent models.
- Practical advantage: Ability to allocate more computation when solving harder problems via a finer time grid, thanks to Adaptive Computation Time (ACT).
Recommended Tools
| Tool | Primary Use | Price (September 2026, check the website) | Ideal for |
|---|---|---|---|
| Hostinger | Hosting models and inference pipelines | From €2.99/month | Deploying research experiments and prototypes with shared GPU resources |
| Hugging Face | Model and dataset hub | Free (paid for compute) | Hosting and sharing Looped Flows models |
| Weights & Biases | Experiment tracking and visualization | Free for academic teams | Monitoring training of recurrent models |
Why Truncated Backpropagation Is the Achilles' Heel of Looped Models
Imagine teaching a child to solve an equation by only showing them the last two steps, without ever explaining how to set up the problem from the start. This is exactly what truncated backpropagation (BPTT) does in recurrent models.
Looped models like TRM (Test-Time Reasoning Models) repeat the same layer multiple times, creating a deep computation graph. To train this graph, BPTT only propagates gradients over a limited number of steps (typically 4 to 8). The result: the first iterations of reasoning receive almost no learning signal. The model learns to reason well from the middle of the process, but does not know how to start.
The paper arXiv 2609.11801 identifies this problem with surgical clarity. The authors demonstrate that BPTT creates a fundamental imbalance: the last iterations train perfectly, while the first ones stagnate. It's as if you were training a sprinter to accelerate mid-race, but never from the starting block.
Models like Attractor Models attempt to solve this problem through different architectures, but Looped Flows attack the root of the evil: the very formulation of recurrent learning.
Looped Flows: Denoising as a Solution to Vanishing Gradients
The Core Idea
Looped Flows transform the problem. Instead of training a model to reason directly on clean data, they corrupt the data with noise and teach the model to reverse this corruption over several recursive steps.
Here's the intuition: if you add noise to an image, then teach a network to gradually denoise it, each denoising step is locally learnable. The gradient doesn't have to travel through 20 iterations — it remains confined to each step. But the sharing of the noise-target across steps creates an implicit temporal association.
Concretely, the model works in two phases:
- Forward pass: Input data is corrupted with decreasing noise levels. The stateful denoiser (an augmented TRM) denoises the flow state AND updates a recurrent state.
- Training: Local losses are applied at each step, with gradients stopped between steps. The noise-target sharing across steps provides the temporal association signal.
Temporal Alignment: The Secret Sauce
The paper introduces the concept of temporal alignment: noise levels gradually decrease and noise is shared between steps. This creates an implicit curriculum — the model first learns to handle heavy noise (large transformations), then gradually refines.
This is equivalent to teaching a sculptor to first work with a chainsaw, then a chisel, then sandpaper. Each step is independent, but the progression is natural.
Inference then becomes a simple integration of a probability flow's velocity. The model parametrizes the velocity field of a continuous flow, and inference consists of integrating this flow from noise toward clean data. No backpropagation is needed at inference — the model advances step by step, each step being a local denoising prediction.
Results: A Measurable Breakthrough on ARC-AGI
The Numbers Speak for Themselves
| Model | ARC-AGI-1 | ARC-AGI-2 | Gain vs baseline |
|---|---|---|---|
| TRM (previous SOTA looped) | 44.6% | 7.8% | — |
| Looped Flows | 58.8% | 12.2% | +14.2 pts / +4.4 pts |
| DRM (Denoising Recursion Models) | — | 24.9% (ARC2-Eval) | Complementary |
The 58.8% on ARC-AGI-1 represents a jump of 14.2 points over the previous record for looped models. On ARC-AGI-2, known to be more difficult, the gain is 4.4 points. For context: ARC-AGI-2 was designed to be nearly impossible for purely statistical models, and every point of progress there is hard-won.
Adaptive Computation Time in Action
One technical detail that changes everything: Looped Flows use Adaptive Computation Time (ACT). In practice, the model can skip steps after saturation. If the problem is simple, it stops early. If it's complex, it continues to integrate the flow over a finer time grid.
This is exactly what a human does when facing a difficult problem: they spend more time on it. Traditional models allocate the same computation budget to every problem, whether trivial or complex. Looped Flows dynamically adapt their effort.
Lead author Ayhan Suleymanzade sums it up perfectly on bittide.ai: "The approach allows solving harder problems by allocating more computation through a finer time grid."
Connections with Existing Architectures
DRM: A Complementary Approach
The arXiv paper 2604.18839 on Denoising Recursion Models (DRM) proposes a similar idea — corrupting data with noise and then training the model to reverse the corruption. DRMs achieve 24.9% on ARC2-Eval, outperforming TRM.
The subtle but important difference: where DRM uses diffusion corruption for initialization, Looped Flows use a continuous probability flow with integration. The two approaches are complementary and could merge in a future hybrid architecture.
The ARC Prize 2025 Context
The official technical report for the ARC Prize 2025 (arXiv 2601.10904) identifies refinement loops as the central theme of this year's progress. The four frontier labs (Anthropic, Google DeepMind, OpenAI, xAI) all report their ARC-AGI performance via refinement loop mechanisms.
Looped Flows fit into this trend, but with additional theoretical elegance. Instead of adding ad-hoc loops, they reformulate the learning problem so that loops emerge naturally.
❌ Common Mistakes
Mistake 1: Believing that more iterations = better reasoning
Many think that increasing the number of loops automatically improves performance. This is false. Without a learning mechanism that properly propagates information across iterations, adding loops only dilutes the gradient and stabilizes the model in poor local minima.
The solution: Use Adaptive Computation Time and local losses as in Looped Flows. The number of iterations should be a learned variable, not an arbitrarily fixed hyperparameter.
Mistake 2: Ignoring temporal alignment
Training each iteration independently without sharing the signal between steps is a classic mistake. Looped Flows show that sharing the noise-target across steps is crucial for creating a temporal association.
The solution: Implement a decreasing noise curriculum where each noise level is shared between adjacent steps. This is what allows the early iterations to learn effectively.
Mistake 3: Confusing Looped Flows with simple dropout or training noise
The noise in Looped Flows is not a regularization technique. It is a structural component of the architecture that allows reformulating the learning problem. Confusing it with dropout or standard Gaussian noise leads to incorrect implementations.
The solution: Understand that noise here is a tool for modeling the probability flow, not a regularization artifact. Corruption and denoising are at the core of the learning dynamics.
❓ Frequently Asked Questions
What differentiates Looped Flows from classic recurrent models like RNNs or LSTMs?
RNNs/LSTMs suffer from vanishing gradients on long sequences. Looped Flows circumvent this problem by using local losses with gradient stopping between steps. The noise-target sharing across steps provides the temporal association signal without requiring deep backpropagation. This is a fundamental difference in the learning formulation.
Can Looped Flows be applied to domains other than ARC-AGI?
Yes, and this is probably the most important contribution. The local denoising mechanism with probability flow is generic. It can be applied to any iterative reasoning problem: mathematical problem solving, planning, code generation, and even vision tasks where progressive analysis of an image is beneficial.
Do Looped Flows replace Transformers?
No, they complement them. Looped Flows are a method for improving the learning of looped models, not a completely new architecture. They can be implemented as an additional layer or a training mechanism for existing Transformer models. Attractor Models explore a complementary direction by modifying the architecture itself.
What is the computational cost of Looped Flows compared to TRM?
The paper does not provide a direct performance benchmark, but Adaptive Computation Time allows for adaptively allocating computation. For simple problems, the cost is lower than TRM. For complex problems, it can be higher, but with significantly better performance. The computational cost-performance ratio is favorable.
✅ Conclusion
Looped Flows solve a decades-old problem in recurrent learning: how to efficiently propagate learning across multiple iterations without suffering from gradient forgetting. The solution — reframing learning as local denoising with temporal alignment — is both elegant and practical.
With 58.8% on ARC-AGI-1 and 12.2% on ARC-AGI-2, this method sets a new standard for looped models. But the impact goes far beyond benchmarks: it paves the way for models that reason longer, deeper, and most importantly — that learn to reason from the very first iteration.
To go deeper, I recommend reading the detailed analysis on alphaXiv and following the complementary work on Denoising Recursion Models. If you want to experiment yourself, Hostinger offers affordable GPU configurations to deploy your first looped model prototypes.
The future of artificial reasoning will not be linear. It will be looped, iterative, and — thanks to Looped Flows — finally trainable.