14 Oct 2026 · AI

One model, many speeds

Looped language models reuse the same layers over and over so one checkpoint can spend more compute for more accuracy. Elastic Latent Recurrence trains them so the cheap one-loop setting still matches a normal model — then every extra loop buys you more quality.

Why it matters

Phone apps and chat bots often need one small model that can answer fast when you're in a hurry and think harder when the question is tough, without shipping several separate models. This recipe keeps the fast setting as good as a normal model of the same size, then lets you turn a dial to trade a bit of time for noticeably better answers from the same weights.

The paper

One Model to Loop Them All: Elastic Latent Recurrence for Language Models

Faisal Ladhak, Shantanu Acharya, Santiago Akle Serano, Simeng Sun, Boris Ginsburg, Krishna C Puvvada. arXiv:2610.12582 [cs.LG], submitted 8 Oct 2026. Read on arXiv · PDF

In plain language: older looped models paid a “one-loop tax” — at the cheapest depth they lagged a normal model, so you still needed a separate fast model. ELR fixes that with a gated state update, mixing loop counts inside each training step, and telling each pass where it sits in the budget. On a 4B hybrid model, one loop sits 0.5 points from the matched baseline; four loops of the same checkpoint add about 7 points on a ten-task average. Their post-trained Koi-4B goes from an estimated 18 to 29 on the Artificial Analysis Intelligence Index by loop count alone.

Try it

Interactive toy using the paper’s reported GDP-Hybrid-4B averages and relative latency. The “naive looped” curve is an illustrative stand-in for the one-loop tax described in the paper, not a re-run of Huginn.

Inference loops

Base accuracy (points)

One-loop tax (points)

Last-loop KV cache (keep memory at one-loop size)

ELR accuracy (toy)

Naive looped accuracy

Relative decode cost

Attention KV memory

Accuracy vs loop count

ELR (paper-shaped)Naive with taxBaselineYour k

Cost and memory vs loops

Decode latency (×)KV memory (×)Your k

The maths in this page

ELR splits the network into input, shared recurrent, and output blocks. At loop count k the effective depth is

D_eff(k) = L_in + k · L_rec + L_out

so with the paper’s 14 / 24 / 14 split, relative compute ≈ (28 + 24k) / 52. The adaptive-delta state update is

s_i = s_i−1 + β_i ⊙ (r_i − s_i−1), β_i = σ(W_β s̃_i + b_β) ⊙ softplus(γ)

ELR curve: interpolated from the reported ten-task averages (65.13, 70.85, 72.08, 72.38) shifted so one-loop sits near your chosen baseline.
Naive tax: starts T points below baseline at k = 1 and recovers toward ELR by k = 4 — the failure mode the paper avoids.
Last-loop KV: overwrites one attention cache each loop, holding memory at 1× instead of growing to ~2.5× at four loops (paper’s Koi-4B figure).

This is an illustrative toy using the paper’s published averages and architecture ratios, not the authors’ training code. Absolute scores shift with the base slider; the shape of diminishing returns and the one-loop parity are the point.

How to use it

Leave the tax at about 6 and slide loops from 1 to 4: ELR stays near the baseline at one loop while the orange “naive” line starts far below, then both rise with diminishing returns after the second loop. Raise the tax to see why older looped models forced you to keep a separate fast checkpoint. Uncheck last-loop KV to watch memory climb with depth even though accuracy barely changes after k = 3. For real serving, the takeaway is that elastic depth can be a quality dial on one small model instead of a shelf of differently sized ones.