Looped World Models: Visual Explainer

Start Here: What Problem Is This Solving?

A world model is a learned internal simulator. An agent is the AI decision-maker using it. Given what that agent currently observes and the action it chooses, the model predicts what the environment will look like next, whether the action earns a numerical feedback signal called a reward, and whether the current task sequence, or episode, continues.

Model-building basics: a layer is one processing stage. A transformer block is a reusable group of attention, which weights the input pieces most relevant to one another, and feed-forward layers, which apply learned nonlinear transformations to each position. Its parameters are the learned numbers that control those computations. Depth means how many processing stages or repeated passes a prediction receives; effective depth counts repeated uses of a shared block as additional computation. A rollout is a chain of predicted future steps.

Input

What the agent sees and does

An observation such as a room description or image, plus an action such as “open the door.”

Ordinary baseline

One fixed amount of compute

A conventional fixed-depth network runs the same stack of distinct layers for easy and difficult transitions.

Paper contribution

Reuse one block as needed

LoopWM, short for Looped World Models, repeatedly applies the same learned transformer block to refine an internal state, allowing variable effective depth without adding new parameters each time.

Running example: opening a door

ObservationThe agent sees a closed door.

ActionThe agent chooses “open door.”

PredictionDoor open, reward received, episode continues.

A simple transition may need little refinement. A collision, ambiguous scene, or long action sequence may need more internal computation.

Essential notation

o_k: observationWhat the agent sees at environment step k.

a_k: actionWhat the agent chooses to do at step k.

h_k: latent stateA compact internal representation, not directly shown to the user.

k: outer stepOne action-driven step through the environment.

t: inner iterationOne refinement pass inside a single environment step.

T: loop countTotal inner refinement passes used for one environment step.

encoder / decoderAn encoder turns an observation or action into internal numbers; a decoder turns the latent state into an observation, reward, and continuation prediction.

Source: Sections 1 and 3.1 define world modelling as action-conditioned environment prediction and specify observation, action, latent-state, reward, and continuation outputs. The door example is a pedagogical interpretation.

Core Idea

Swipe horizontally to inspect the full diagram at a readable size.

Source: Paper abstract and Section 1 describe iterative refinement through a parameter-shared transformer block, adaptive computation, and up to 100× parameter efficiency; Section 3.2 states that the recurrent block's parameters are shared across iterations.

The tension the paper targets

World models must simulate long horizons, but a deeper fixed architecture is expensive and rollout errors can compound. LoopWM's answer is not simply "make the model larger"; it adds iterative latent depth as a separate scaling axis.

Interpretation: The loop is best read as an internal refinement process for one predicted transition, not as physical time itself. The paper makes this distinction in Section 1.

Outer stepone environment action step

Inner loopone refinement pass

Shared blocksame learned block on every pass

Exit gateAn exit gate is a learned score that enables early exit: stop when confidence passes a threshold.

Core Logic In Equations

You do not need all of the paper's mathematics to follow LoopWM. These equation groups cover every formal mechanism used by the visuals and controls below.

Equation 3 · one world-model step

Encode, update the hidden world, then decode

e_k = ℰ_ϕ(o_k), u_k = 𝒜_ψ(a_k), h_k = ℒ_θ(h_k−1, e_k, u_k),
(ô_k+1, r̂_k, ĉ_k) = 𝒟_ξ(h_k).

Read it as: compress what the agent sees and does, update the internal world state, then predict the next observation, reward, and whether the episode continues.

o_k, a_k
Current observation and action

e_k, u_k
Encoded observation and action

h_k−1
Internal world state from the previous environment step

h_k
Updated internal world state

ô, r̂, ĉ
Predicted observation, reward, continuation

ℰ_ϕ
Calligraphic observation encoder; ϕ denotes its learned parameters

𝒜_ψ
Calligraphic action embedder; ψ denotes its learned parameters

ℒ_θ
Calligraphic looped dynamics function; θ denotes its learned parameters

𝒟_ξ
Calligraphic prediction decoder; ξ denotes its learned parameters

k, k+1
Current and next environment-step indices

=
Defines each encoded, updated, or predicted value

( ), comma
Function arguments and their separator

hat accent
Marks a model prediction rather than an observed value

terminal period
Ends Equation 3 in the source

Door example: o_k says the door is closed, a_k says “open door,” and h_k−1 carries prior room context; the outputs predict the next scene, reward, and continuation.

Visual link: the mechanism diagram uses blue for ℰ_ϕ, purple for 𝒜_ψ, gold for the repeated dynamics block inside ℒ_θ, and the final prediction-head box for 𝒟_ξ.

Source: Section 3.1, Equation 3.

Equation 4 · prepare the joint input

Combine prior state, observation embedding, and action embedding

e = LN(𝒫([h_k−1; e_k; u_k])) ∈ ℝ^d,

Read it as: concatenate three simultaneous inputs, process them with the prelude, then normalize the resulting conditioning signal.

e
Conditioning signal used by the repeated update

LN( )
Layer normalization rescales the projected components to a stable, normalized range

𝒫
Calligraphic prelude block

h_k−1
Latent state from the preceding environment step

e_k
Current observation embedding

u_k
Current action embedding

k, k−1
Current and preceding environment-step indices

[ ; ; ]
Concatenation of the three joint inputs

ℝ^d
d-dimensional real-valued space

d
Width of the conditioning signal

=, ∈
Equality and set membership

( )
Function argument grouping

terminal comma
Ends Equation 4 before the source continues

Door example: prior room memory, the current closed-door observation embedding, and the “open door” action embedding converge as joint inputs to one prepared signal.

Visual link: the mechanism diagram draws three separate arrows into Prelude 𝒫; none of the inputs is caused by another.

Source: Section 3.2, Equation 4.

Equation 5 · the shared inner loop

Refine the same hidden state repeatedly

h^(t+1) = Āh^(t) + B̄e + ℛ̄(h^(t), e),

Read it as: keep some previous state, inject the current conditioning signal, and add a nonlinear transformer refinement. Apply the same learned ℛ̄ at every inner iteration.

h^(t)
State before refinement t

h^(t+1)
State after the next refinement

t
Inner-loop iteration index

Ā
Discrete matrix that retains old information

e
Prelude context built from h_k−1, observation, and action

B̄
Matrix that injects the conditioning context e

ℛ̄(h^(t), e)
Barred calligraphic shared nonlinear transformer update

bar accents
Paper notation for the discrete or transformed update terms

=, +
Defines the next state and adds three contributions

adjacent products
Āh and B̄e are matrix-vector multiplications

( ), commas
Parentheses group function arguments; the inner comma separates them, and the terminal comma ends Equation 5

Door example: each pass can refine the prediction from “the agent touched the door” toward “the door is now open.”

Visual link: this is the gold recurrent-block box and its loop-back arrow in the mechanism diagram.

Source: Section 3.2, Equation 5.

Equations 6–7 · stability

Make retained state shrink rather than explode

A := diag(−exp(𝐚)), 𝐚 ∈ ℝ^d (learnable),
Ā = exp(Δ · A), Δ ∈ ℝ^d_>0 (learnable).

Read it as: the retained-state multiplier is constructed to stay between zero and one, so repeatedly applying the loop does not make that linear part grow without bound.

𝐚 ∈ ℝ^d
Bold learned d-dimensional vector used to create negative rates

Δ
Learned positive step-size vector

ℝ^d_>0
Positive d-dimensional real vectors

d
Hidden-state width

A
Negative diagonal continuous-time matrix

Ā
Discrete retention matrix; retention means how much prior hidden state is carried into the next update

diag(·)
Builds a matrix with values only on its diagonal

exp(·)
Applies the exponential function

:=, =
Definition and equality

−, ·
Negation and multiplication

∈
Set membership

learnable
Training adjusts the vector

( ), commas, period
Parentheses group functions; commas separate clauses and terminate Equation 6; the period terminates Equation 7

Door example: requesting more passes for an ambiguous doorway does not let the linear retained-state path grow merely because the loop runs longer.

Visual link: this equation governs the retained-state path entering each repeated gold-block update.

Source: Section 3.2, Equations 6–7. The paper states the consequence ρ(Ā) < 1: the spectral radius, the largest absolute eigenvalue of Ā, stays below one, so repeated linear retention contracts rather than grows.

Equation 8 · coda projection

Turn the final inner-loop state into the next carried state

h_k = 𝒞(C h^(T)),

Read it as: after T shared-block refinements, apply a learned projection and the separately parameterized coda to produce the state carried by the outer environment step.

h_k
Latent state produced for environment step k

𝒞( )
Calligraphic coda with separate, non-shared parameters

C
Ordinary capital C: learned projection matrix

h^(T)
Hidden state after the final inner iteration

k
Environment-step index

T
Total inner-loop iterations

=
Defines the carried state

juxtaposition
C h means matrix-vector multiplication

( )
Coda input and parenthesized iteration index

terminal comma
Terminates Equation 8 before the source continues

Door example: after the shared block finishes refining the “open door” transition, the coda projects that final hidden estimate into the state carried forward.

Visual link: this is the pink Coda 𝒞 box between the recurrent block and prediction heads.

Source: Section 3.2, Equation 8.

Equation 12 · adaptive early exit

Stop refining when the gate is confident

g^(t) = σ(𝐰_g^⊤h^(t) + b_g),

Read it as: a small learned gate converts the current hidden state into a readiness score. The paper then says to stop at the first iteration whose score is strictly greater than τ; if none crosses, use the maximum allowed loops.

g^(t)
Readiness score from 0 to 1

h^(t)
Current hidden state at inner iteration t

𝐰_g^⊤h^(t)
Learned weighted summary of the hidden state

𝐰_g, b_g
Bold learned gate vector and scalar bias

σ
Sigmoid squashing function

τ
Exit threshold from the stopping rule stated immediately after Equation 12

t
Inner-loop iteration index

⊤
Transpose used to form the weighted scalar score

=, +
Defines the gate and adds its bias

( )
Arguments to the sigmoid and indexed quantities

>
Strict comparison used by the stopping rule stated after the numbered equation

terminal comma
Terminates Equation 12 before the explanatory prose

Door example: a clear, unlocked door may cross τ after few passes; an obstructed or ambiguous doorway can use more passes.

Visual link: the simulator below illustrates only the threshold stopping rule with invented readiness scores; it does not compute σ, 𝐰_g, h^(t), or b_g from Equation 12.

Source: Section 3.4, Equation 12 for the gate score; the strict threshold stopping rule is stated in the prose immediately after the equation.

Equations 13–15 · standard per-step decoding

Advance one action, then decode immediately

u_k = 𝒜_ψ(a_k),
h_k+1 = ℒ_θ(h_k, u_k),
(ô_k+1, r̂_k, ĉ_k) = 𝒟_ξ(h_k+1),

Read it as: embed one action, advance the latent state through the full dynamics core, and call the decoder after that action; repeat for every step.

k, k+1
Current and following action-step indices

a_k
Action at step k

𝒜_ψ, u_k
Calligraphic action embedder and its output; ψ is learned

h_k, h_k+1
Latent states before and after the action

ℒ_θ
Full calligraphic looped dynamics core with learned parameters θ

𝒟_ξ
Calligraphic decoder with learned parameters ξ

ô_k+1
Predicted observation after the action

r̂_k, ĉ_k
Predicted reward and continuation at the step

=, +
Equality and index increment

( ), commas
Parentheses group functions and tuple outputs; separators appear inside them, and a terminal comma ends each of Equations 13, 14, and 15

hat accents
Mark model predictions

three lines
Action embedding, state transition, then immediate decoding

Door example: standard decoding emits a predicted result after “walk to door,” again after “open door,” and again after “enter room.”

Visual link: the standard-mode control draws one decoder below every action-conditioned state.

Source: Section 3.5.2, Equations 13–15.

Equations 16–18 · deferred decoding

Advance K latent steps, decode once

u_k = 𝒜_ψ(a_k), k = 0, 1, …, K−1,
h_k+1 = ℒ_θ^core(h_k, u_k), k = 0, 1, …, K−1,
(ô_K, r̂_K, ĉ_K) = 𝒟_ξ(h_K).

Read it as: apply a sequence of planned actions entirely inside the compact latent state, then call the expensive decoder only for the terminal prediction.

K
Number of planned action steps

k, a_k
Action-step index and action at that step

𝒜_ψ, u_k
Calligraphic action embedder and encoded action; ψ denotes learned parameters

ℒ_θ^core
Calligraphic decode-free latent transition with learned parameters θ

h_k, h_k+1
Current and next latent rollout states

h_K
Terminal latent state

𝒟_ξ
Calligraphic decoder with learned parameters ξ, called once at the end

ô_K, r̂_K, ĉ_K
Terminal observation, reward, and continuation predictions

0…K−1
Range of action-step indices

=
Defines encoded actions, next states, and predictions

( ), commas, period
Parentheses group functions and tuple outputs; terminal commas end Equations 16 and 17, and a terminal period ends Equation 18

hat accent
Marks terminal predictions

Door example: “walk to door → open door → enter room” can advance through latent states for all three actions and decode the final room state once.

Visual link: the deferred-decoding buttons below switch between five per-step decoder boxes and one terminal decoder box.

Source: Section 3.5.2, Equations 16–18.

Mechanism: One Transition, Several Refinements

Swipe horizontally to inspect the full architecture at a readable size.

Source: Section 3.1 and Equation 3 define encoder ℰ, action embedder 𝒜, looped dynamics core ℒ, and prediction heads 𝒟. Section 3.2 and Equations 4–5 define preparation and the repeated update; Equation 8 defines Coda 𝒞. The section also describes cross-timestep state propagation.

Door example through the mechanism: h_k−1 carries what the agent already knows about the room; o_k confirms the door is closed; a_k says “open door.” The prelude combines all three, the shared block refines the likely consequence, and the decoder predicts an open door, reward, and continuation.

Step through the inner loop

Use the buttons to inspect a plain-language storyboard of one transition. This pedagogical stepper does not render or numerically reproduce the paper's equations.

1 / 4

Stability in one line

The state-retention matrix is parameterized so its diagonal entries land in (0, 1), which makes the retention part contractive by construction.

Equation source

Section 3.2: A := diag(−exp(𝐚)); Ā = exp(Δ · A). The paper states this guarantees ρ(Ā) < 1.

Interaction: Allocate Loops Where the Transition Is Hard

Early-exit simulator

Interpretation: This control uses a hand-designed score curve to illustrate the paper's adaptive-depth stopping rule. It neither evaluates Equation 12 nor reproduces reported runtime measurements.

Transition complexity

Exit threshold

0.72

Maximum loop count T

Swipe horizontally to inspect the full loop trace.

Source: Section 3.4 defines the sigmoid exit gate g^(t) and threshold τ; it also gives a 100-layer fixed-depth baseline versus a single loop of 4 layers, about 25× fewer floating-point operations (FLOPs), a rough computation count, for that simple step.

Compute intuition

A fixed-depth baseline spends the same compute on easy and hard transitions. LoopWM can spend fewer inner-loop iterations when the gate says a latent state is ready, while allowing more iterations up to T_max.

Fixed

100

LoopWM

Savings

60%

Assumption in this illustrative readout: one loop applies a 4-layer shared recurrent block, compared with a 100-layer fixed-depth baseline. The paper uses that as an example; this widget varies only the loop count.

Door example: a clear unlocked door may be settled after few loop passes. An obstructed or visually ambiguous doorway can consume more passes before the exit gate exceeds τ.

Deferred Decoding: Think in Latent Space, Decode Once

Swipe horizontally to inspect the full action sequence.

Door sequence: for “walk to door → open door → enter room,” standard decoding produces an output after every action. Deferred decoding can advance all three actions in latent space and decode the terminal room state once.

Source: Section 3.5 describes deferred decoding. Equations 13-15 define the baseline with K decoded predictions; Equations 16-18 define K latent transitions with one terminal decode. Section 3.5.2 states total effective depth K × T shared-parameter applications with only one decoder pass.

Evidence Snapshot

How to read these benchmarks

ScienceWorldA text-based science environment where an agent predicts multi-step state changes after actions.

AlfWorldA text-based household-task environment grounded in embodied actions and objects.

EM · exact matchPercentage of predictions that exactly equal the reference text.

Token F1Balances precision, the share of predicted tokens that match the reference, with recall, the share of reference tokens recovered by the prediction.

BLEU-4Overlap of short word sequences; useful for wording similarity, not full semantic correctness.

EntityEntity-level score; the manuscript does not specify its exact calculation.

Higher is better for all metrics shown here, but none alone proves that a complete simulated trajectory is correct.

Reported ScienceWorld overall scores

The paper compares LoopWM with claude-opus-4-6-max for five-action world modelling and reports a roughly 1B parameter LoopWM.

68.4

EM base

47.2

85.3

F1 base

72.8

LoopWM claude-opus-4-6-max baseline

Source: Table 2 reports ScienceWorld overall EM 68.4%, Token F1 85.3%, BLEU-4 80.7%, Entity 83.9% for LoopWM and EM 47.2%, Token F1 72.8%, BLEU-4 64.4%, Entity 72.3% for claude-opus-4-6-max. Section 4.1 states LoopWM is about 1B parameters and says it is more than 100× smaller than strong closed-source services.

Deferred decoding trend

Swipe horizontally to read the full table.

Step	EM gain	F1 gain	BLEU gain	Entity gain
1	+73.2%	+16.4%	+47.0%	+9.7%
2	+54.5%	+21.4%	+41.7%	+18.0%
3	+103.6%	+28.1%	+65.0%	+19.0%
4	+82.9%	+29.0%	+55.5%	+20.7%
5	+113.8%	+22.4%	+54.6%	+12.8%

Source: Table 5 reports LoopWM's relative improvements over gemini-3-flash-preview-thinking on ScienceWorld; Table 6 extends that comparison to accumulated rollouts. These compare different systems, not the same trained LoopWM model with deferred decoding switched off versus on, so they do not isolate deferred decoding as the sole cause.

Swipe horizontally to inspect the full comparison chart.

Source: Table 4 reports AlfWorld overall scores. LoopWM: EM 51.6%, Token F1 80.4%, BLEU-4 71.6%, Entity 81.1%; claude-opus-4-6-max: EM 53.0%, F1 72.6%, BLEU 66.8%, Entity 77.0%; gemini-3-flash-preview-thinking: EM 50.0%, F1 83.5%, BLEU 71.0%, Entity 90.2%. Interpretation: this is a mixed result, not a clean win on every metric.

What This Does Not Prove

Scope

The paper says the current manuscript is selective in disclosure scope and does not expose every supporting result.

Source: Section 6, broader impacts.

Scaling laws

The paper says it stops short of a more complete scaling-law characterization across broader task and compute ranges.

Source: Section 6.

Positioning

The paper says it needs more explicit comparison with recurrent models that carry a compact state through time, models that predict video as sequences of discrete tokens, and world models that generate states through iterative denoising.

Source: Section 6.

Interpretation: The explainer treats LoopWM as an architectural proposal with promising reported results. It does not independently validate the benchmarks, parameter counts of closed models, or deployment cost claims.

Deferred-decoding attribution: Tables 5 and 6 compare LoopWM with Gemini rather than holding the model fixed and toggling deferred decoding. Their gains therefore cannot, by themselves, establish how much improvement comes specifically from deferring the decoder.

Provenance Notes

Swipe horizontally to read the full table.

Visual	Grounding	Interpretive layer
Core idea diagram	Abstract, Section 1, Section 3.2, Figure 1 caption.	Uses simplified boxes for fixed-depth versus shared-depth computation.
Mechanism diagram	Section 3.1, Section 3.2, Equations 3-8.	Shows one compact path; real implementations may choose different encoder or transformer sizes.
Early-exit simulator	Section 3.4 and Equation 12; 100-layer versus 4-layer example from Section 3.4.	The gate curve is illustrative and not a measured model trace.
Deferred decoding toggle	Section 3.5, Equations 13-18, Table 1.	Diagram compresses K steps into five visible slots.
Evidence charts	Tables 2, 4, and 5.	Selected headline metrics; the paper contains many task-level tables not reproduced here.

Primary source: https://arxiv.org/pdf/2606.18208. This page has no external runtime dependencies; the link is provided for provenance only.