Loop-ViT: Iterative Vision Transformer

• Loop-ViT is a recurrent vision transformer that reuses a single hybrid block to control reasoning depth through iterative processing.
• It combines global attention with local convolutions and employs a dynamic exit mechanism based on predictive entropy for efficiency.
• The architecture scales computation via time without increasing parameters, offering improved accuracy on ARC benchmarks over fixed-layer designs.

Loop-ViT denotes a looped Vision Transformer in which a single transformer-like block is applied recurrently with shared weights, so that reasoning depth is controlled by iteration count rather than by the number of uniquely parameterized layers. In its most specific usage, the term refers to the ARC-AGI model introduced in "LoopViT: Scaling Visual ARC with Looped Transformers," which argues that few-shot visual reasoning is better matched by adaptive iterative computation than by a fixed feed-forward stack (Shu et al., 2 Feb 2026). In a broader 2026 usage, the same recurrent-depth principle also appears in dense prediction and multi-view 3D reconstruction systems, although the term is not used uniformly across papers (He, 5 May 2026, Burzio et al., 28 May 2026).

1. Conceptual basis

The canonical LoopViT formulation is motivated by the Abstraction and Reasoning Corpus (ARC-AGI), where the system is given $2$–$4$ demonstration input-output grid pairs and must infer the rule needed to transform a held-out query grid. The ARC-AGI-1 subset emphasizes perceptual priors such as object cohesion, pattern completion, and symmetry, whereas ARC-AGI-2 contains harder algorithmic tasks including symbolic interpretation and compositional multi-step rules. The central claim is that such tasks are rarely solvable in a single pass and instead require iterative hypothesis formation and refinement, described as human “try-and-check” induction (Shu et al., 2 Feb 2026).

This motivation is framed as a critique of vanilla Vision Transformers. In a standard feed-forward ViT, computational depth is fixed by the number of distinct layers, so increasing the number of “reasoning steps” requires increasing depth or width and therefore parameter count. LoopViT proposes to decouple “reasoning depth” from “capacity” by reusing one core transition operator across multiple steps. In the paper’s terminology, this makes time an explicit scaling axis: more iterative compute can be allocated at inference without enlarging the model. A plausible implication is that recurrent depth functions as a reusable algorithmic operator rather than as a one-shot hierarchy of distinct features.

The same recurrent-depth premise reappears in later work. RD-ViT characterizes a looped/shared-block ViT as one that reuses a single transformer block multiple times in a loop instead of stacking uniquely parameterized blocks, while DéjàView argues that part of the benefit of deep reconstruction transformers is that “depth partially buys iteration” and that making iteration explicit yields a stronger inductive bias (He, 5 May 2026, Burzio et al., 28 May 2026).

2. Core architecture

LoopViT replaces a stack of distinct transformer blocks with a single Hybrid Block executed recurrently. If $emb(\cdot)$ encodes the visual grid and task context into $M$ tokens of dimension $d$, and if $\mathcal{M}_\theta$ denotes the shared trunk, the recurrence is

$$z_0 = emb(\cdot), \qquad z_{t+1} = \mathcal{M}_\theta(z_t + e_t), \qquad \mathcal{F}^{(t)}(\cdot) = head(z_t),$$

where the weights $\theta$ are shared across all iterations and $e_t$ is a learned step embedding (Shu et al., 2 Feb 2026).

The step embedding disambiguates computational progress. The paper describes this as encouraging a reusable “thought step” operator and therefore a latent chain-of-thought in the hidden state. When inference exceeds the training budget, the method uses reuse or extrapolation behavior for $e_t$ beyond $4$0.

The shared Hybrid Block combines local convolutions with global attention. Its exact pre-norm residual structure is

$4$1

$4$2

The architectural choices reported for this block are pre-norm RMSNorm, Multi-Head Self-Attention with Rotary Positional Embeddings for global relational reasoning, and a Heterogeneous ConvGLU feed-forward network that applies $4$3 depthwise convolution only to image tokens and not to task/context tokens. This selective convolution injects local spatial inductive bias without forcing the contextual tokens through the same local operator.

Within MHSA, for each head $4$4,

$4$5

$4$6

and the final attention output is

$4$7

The ConvGLU sublayer first splits a linear projection into gate and value channels, partitions the gate into task and image subsets, applies depthwise convolution only to the image gate after reshaping image tokens to their $4$8D layout, reassembles the gate, and then applies GLU-style gating. In the notation given in the paper,

$4$9

$emb(\cdot)$0

$emb(\cdot)$1

$emb(\cdot)$2

The model executes up to $emb(\cdot)$3 recurrent steps. The reported ranges are $emb(\cdot)$4 for the $emb(\cdot)$5M-parameter Small model and $emb(\cdot)$6 for the $emb(\cdot)$7M and $emb(\cdot)$8M Medium and Large models.

3. Dynamic Exit and attractor dynamics

A distinctive component of LoopViT is its parameter-free Dynamic Exit mechanism, which halts inference when predictive entropy falls below a threshold. At iteration $emb(\cdot)$9, the model computes per-pixel color-class probabilities

$M$0

and the average pixel-wise Shannon entropy

$M$1

Inference stops when $M$2, with default $M$3, or when $M$4 reaches $M$5 (Shu et al., 2 Feb 2026).

The paper describes this halting rule as detecting when the internal state “crystallizes” into a low-uncertainty attractor. Once halted, the state is frozen, $M$6 for $M$7, and further compute is skipped. The accompanying diagnostics report synchronous decay of both prediction volatility, measured by the $M$8 difference between successive outputs, and entropy across iterations. Attention patterns are also described as evolving from global scanning to localized execution over steps.

Empirically, Dynamic Exit is presented as an efficiency mechanism and as a confidence signal. In the reported “Efficiency vs Task Difficulty” analysis, instances exiting at Step $M$9 achieve $d$0 accuracy, whereas instances requiring the full depth at Step $d$1 achieve $d$2. The paper interprets this as validating entropy as a proxy for task hardness and solution confidence. The reported accuracy–compute–parameter plots further state that entropy-based early exit dominates fixed-step baselines across scales, producing a stronger accuracy–compute Pareto frontier.

LoopViT’s halting mechanism differs from learned halting schemes such as ACT and PonderNet. The paper’s comparison emphasizes that LoopViT uses no extra halting parameters and no auxiliary halting loss, relying instead on a threshold over predictive entropy (Shu et al., 2 Feb 2026).

4. Training protocol and empirical performance

LoopViT is evaluated on ARC-AGI-1 using Pass@2 accuracy. Training uses ARC augmented with synthetic examples from RE-ARC, and the task is formulated as image-to-image translation in a VARC-style setup: inputs are pixel grids, outputs are per-pixel color-class predictions, and few-shot demonstrations are encoded as task/context tokens. Offline training unrolls a fixed number of steps, with the paper citing $d$3 as an example, and applies only final-step supervision via per-pixel cross-entropy,

$d$4

No dynamic halting is used during training, and no intermediate losses are applied (Shu et al., 2 Feb 2026).

At evaluation time, the shared weights $d$5 are adapted with Test-Time Training using the task’s demonstrations together with local augmentations: rotations, flips, and color permutations. The paper does not report optimizer choice, learning-rate schedule, batch size, epochs or steps, or weight decay. Patch size, tokenization stride, feature dimensions, and number of heads are also not explicitly reported.

The main quantitative results are as follows.

Model	Parameters	Accuracy
Loop-ViT Small	3.8M	60.1% on ARC-AGI-1; 10.0% on ARC-AGI-2
Loop-ViT Medium	11.2M	63.8% on ARC-AGI-1; 11.5% on ARC-AGI-2
Loop-ViT Large	18M	65.8% on ARC-AGI-1; 14.2% on ARC-AGI-2
VARC	18M	54.5% on ARC-AGI-1; 8.3% on ARC-AGI-2
VARC ensemble	73M	60.4% on ARC-AGI-1; 11.1% on ARC-AGI-2
avg.human	—	60.2% on ARC-AGI-1
best.human	—	98.0% on ARC-AGI-1

These results are used to support the claim that “scaling via time beats scaling via space.” In particular, the $d$6M Loop-ViT Large exceeds the $d$7M VARC ensemble by approximately $d$8 points on ARC-AGI-1 while using far fewer parameters. The joint scaling analysis further reports that, for small cores, increasing unrolled steps yields large gains, and for deeper cores performance continues to improve with more steps, peaking around $d$9. An additional ablation states that the Hybrid Block consistently outperforms a vanilla Transformer across depths, which the paper interprets as confirming the value of local spatial priors for grid-based reasoning (Shu et al., 2 Feb 2026).

5. Relation to recurrent-depth transformers

LoopViT sits within a broader family of weight-tied iterative transformers. The paper explicitly situates it relative to Universal Transformers and ALBERT, which introduced weight tying to improve parameter efficiency and generalization, and relative to ACT and PonderNet, which use learned probabilistic halting with auxiliary losses. It also compares itself with recurrent vision systems such as RAFT and recurrent ResNets, noting that those methods emphasize iterative refinement on continuous signals or narrower synthetic tasks rather than ARC-style discrete grid transformations (Shu et al., 2 Feb 2026).

Two contemporaneous 2026 systems instantiate the same recurrent-depth idea in different domains. RD-ViT extends a recurrent-depth transformer to semantic segmentation in $\mathcal{M}_\theta$0D and $\mathcal{M}_\theta$1D by replacing a deep stack of unique blocks with one shared ViT block looped $\mathcal{M}_\theta$2 times, adding LTI-stable state injection, ACT for spatial compute allocation, depth-wise LoRA, and optional MoE feed-forward networks. On the ACDC benchmark, it reports that in $\mathcal{M}_\theta$3D RD-ViT outperforms a standard ViT at $\mathcal{M}_\theta$4 training data ($\mathcal{M}_\theta$5 Dice vs $\mathcal{M}_\theta$6) and at full data ($\mathcal{M}_\theta$7 vs $\mathcal{M}_\theta$8), while in $\mathcal{M}_\theta$9D RD-ViT with MoE reaches Dice $$z_0 = emb(\cdot), \qquad z_{t+1} = \mathcal{M}_\theta(z_t + e_t), \qquad \mathcal{F}^{(t)}(\cdot) = head(z_t),$$0 with $$z_0 = emb(\cdot), \qquad z_{t+1} = \mathcal{M}_\theta(z_t + e_t), \qquad \mathcal{F}^{(t)}(\cdot) = head(z_t),$$1M parameters, or $$z_0 = emb(\cdot), \qquad z_{t+1} = \mathcal{M}_\theta(z_t + e_t), \qquad \mathcal{F}^{(t)}(\cdot) = head(z_t),$$2 of standard ViT performance at $$z_0 = emb(\cdot), \qquad z_{t+1} = \mathcal{M}_\theta(z_t + e_t), \qquad \mathcal{F}^{(t)}(\cdot) = head(z_t),$$3 of the parameter count (He, 5 May 2026).

DéjàView transfers the same design principle to multi-view $$z_0 = emb(\cdot), \qquad z_{t+1} = \mathcal{M}_\theta(z_t + e_t), \qquad \mathcal{F}^{(t)}(\cdot) = head(z_t),$$4D reconstruction. It applies a single looped transformer block recurrently to per-view features for $$z_0 = emb(\cdot), \qquad z_{t+1} = \mathcal{M}_\theta(z_t + e_t), \qquad \mathcal{F}^{(t)}(\cdot) = head(z_t),$$5 refinement steps, treats $$z_0 = emb(\cdot), \qquad z_{t+1} = \mathcal{M}_\theta(z_t + e_t), \qquad \mathcal{F}^{(t)}(\cdot) = head(z_t),$$6 as an inference-time compute knob, and reports that the shared-weight formulation outperforms an otherwise identical variant with independent per-step parameters under matched training data and compute. The model is reported at $$z_0 = emb(\cdot), \qquad z_{t+1} = \mathcal{M}_\theta(z_t + e_t), \qquad \mathcal{F}^{(t)}(\cdot) = head(z_t),$$7M parameters, compared with billion-parameter-scale feed-forward baselines, and its metrics improve monotonically with $$z_0 = emb(\cdot), \qquad z_{t+1} = \mathcal{M}_\theta(z_t + e_t), \qquad \mathcal{F}^{(t)}(\cdot) = head(z_t),$$8 within the trained range (Burzio et al., 28 May 2026).

Taken together, these works support a broader interpretation of Loop-ViT as recurrent-depth ViT design: one shared block, explicit iteration, and a compute budget that is partly or wholly controlled at inference time. This suggests that the central object is not a single domain-specific implementation but a parameter-sharing principle.

6. Terminological scope, limitations, and future directions

The term “Loop-ViT” is not used uniformly across the literature. In the ARC paper it names a specific recursive architecture for adaptive visual reasoning (Shu et al., 2 Feb 2026). In RD-ViT it is used descriptively for a Vision Transformer that reuses a single transformer block multiple times in a loop (He, 5 May 2026). In DéjàView the same pattern appears as a looped transformer block for multi-view refinement (Burzio et al., 28 May 2026). By contrast, a hardware paper uses “Loop‑ViT” to denote a temporal loop re-ordering and fusion strategy for efficient execution of hybrid ViT networks on edge accelerators rather than a recurrent neural architecture (Dumoulin et al., 19 Jul 2025). Another paper on human-in-the-loop object retrieval explicitly states that it does not introduce a named method “Loop-ViT,” and uses the term only as an apt description of a ViT-powered active-learning loop (Zaher et al., 1 Apr 2026).

For the ARC-specific LoopViT, the principal limitation reported in the source paper is performance on ARC-AGI-2. Although the method improves over VARC and the VARC ensemble on that benchmark, the reported accuracies remain low, and the paper states that highly symbolic, multi-hop reasoning tasks remain challenging. Another stated limitation is that the entropy threshold $$z_0 = emb(\cdot), \qquad z_{t+1} = \mathcal{M}_\theta(z_t + e_t), \qquad \mathcal{F}^{(t)}(\cdot) = head(z_t),$$9 is global: some instances may stabilize to a confident but incorrect attractor. The paper therefore recommends auditing halting outcomes and notes that $\theta$0 and $\theta$1 may require retuning when porting the method to other datasets or tokenizations (Shu et al., 2 Feb 2026).

The future directions implied by the paper are correspondingly specific: richer halting criteria, such as combining entropy with temporal stability checks; enhanced step embeddings or learned progress signals; and integration of object-centric representations within the vision loop. These proposals remain consistent with the model’s central thesis that adaptive iterative computation, rather than simple width scaling, is the more appropriate scaling axis for visual reasoning on ARC-like tasks. The official implementation is reported at https://github.com/WenjieShu/LoopViT (Shu et al., 2 Feb 2026).