A looped Transformer reuses a group of neural-network layers several times before predicting the next token. Each pass receives the hidden representations produced by the previous pass. Those representations are the model's working state: numerical vectors that change as it processes the input. The learned weights stay fixed during inference.
Open-weight models such as Huginn expose the number of recurrent passes as an inference setting, making model size and computation per token separate design choices.
How can applying the same weights again produce useful new work?
The answer is in what gets passed around the loop. Restart a deterministic computation from the same state and it returns the same result. Feed its result into the next pass and the computation can advance. A query can change after retrieving a fact, an intermediate result can become the input to another operation, or a partial representation can be refined.
This gives us a useful first distinction. Suppose a core contains two layers, A and B, and we run it three times. The execution is A, B, A, B, A, B. We store two sets of layer weights but perform six layer applications. The copies in an unrolled drawing represent uses of the same parameters.
That can provide more computation without storing six independent transformations. It does not make the extra applications free, and it does not establish that the sixth application produces a better answer. The state must contain something useful for the next pass, training must encourage useful repeated transformations, and the model needs a sensible place to stop.
We will follow those dependencies from attention and changing hidden states through training, halting, and memory. Along the way, a small constructed attention block will make the intermediate operations visible. Its calculations illustrate what shared weights can do; they are not a claim about the internal variables of a trained language model.
Table of contents
What repeats inside the model
Why another pass can change the answer
Training the shared computation
Deciding when to stop
What looping costs
Depth and reasoning tokens are different budgets
