News for hackers. Stuff that matters.
Re:Inkling 2 Mini by LPisGood on Friday November 20, 2026 @06:09PM (#50583675)
This is the first I’m hearing of a looped model. What is it?
Re:Inkling 2 Mini by cmrdporcupine on Friday November 20, 2026 @06:12PM (#50583704)
Goes a couple or three times through the same weights in a middle layer of the model. Nemotron's Dory pioneered this I think. Seems to give better results with smaller models.

Not sure the impact on kvcache though.

Re:Inkling 2 Mini by teravor on Friday November 20, 2026 @06:39PM (#50583949)
I believe someone found out (DIY style) that looping a couple of layers (found through trial and error) in ordinary LLM's yielded some benefits quite a while ago. it was a surprise as there was no looping during training.

then there was a fully looped model (forget the name) where all the layers were looped (which is an obvious mistake as it's known LLM's have token processing and reasoning stages) and showed some decent results.

and now the concept worked itself into the mainstream.

Re:Inkling 2 Mini by calebkaiser on Friday November 20, 2026 @06:50PM (#50584055)
There's a lot of interesting work around this going back a little while. It's spiritually inline with the thinking around RNNs, which date back further. The Universal Transformer (2018) is the first research paper I'm familiar with that really pushed the idea as applied to transformer models, but I'm sure there are others (as is the case with everything in deep learning, someone tried it 8 years before you using different nomenclature).

If you're curious, it's a very cool paper! https://arxiv.org/html/1807.03819v1

Re:Inkling 2 Mini by dannyw on Friday November 20, 2026 @07:40PM (#50584466)
Yes, the DIY “LLM neurosurgery”: https://dnhkng.github.io/posts/rys/

The Show HN of someone applying this recently, through layer duplication: https://news.ycombinator.com/item?id=47431671

Re:Inkling 2 Mini by dofm on Friday November 20, 2026 @06:30PM (#50583866)
Nvidia Dory is another (dense 9B) example.
Re:Inkling 2 Mini by kroaton on Friday November 20, 2026 @06:35PM (#50583907)
Supposedly GPT6 Astra uses this as well.
Re:Inkling 2 Mini by calebkaiser on Friday November 20, 2026 @06:46PM (#50584025)
It's a pretty broad bucket that contains a few different research lineages, but the gist (when talking about Transformers) is that instead of stacking 12 latent blocks, you can stack 4 and let them loop 3 times.

That's just a general simplification though. One of the key motivators in this general area of research is adaptive latent reasoning, meaning in theory, some tasks only require 2 loops and some require 8.

There's a lot of different approaches here and many of them approach the problem from different traditions. Some looped transformers use a fixed loop count, others follow after deep equilibrium models and iterate towards a fixed point or some other stopping mechanism.

Some fun reading if you're interested in this field:

- TinyRecursiveModels - Blew up a couple of years ago when it performed really well on ARC AGI 1 using a comparatively small model with a large task-level table of embedding prefixes. https://github.com/samsungsailmontreal/tinyrecursivemodels

- Sebastian Raschka's piece on the general architecture patterns we see today: https://sebastianraschka.com/llm-architecture-gallery/looped...

Re:Inkling 2 Mini by reissbaker on Friday November 20, 2026 @11:12PM (#50585862)
A couple other benefits aside from adaptive reasoning:

- It lets the model do more of its reasoning without emitting tokens. This is helpful both because a) insanely long token streams are annoying, but more importantly b) long reasoning streams eat context. It's not a direct performance enhancement, since each token is more expensive to generate (you need to loop!), but it reduces spam in the context window which likely translates into some degree of intelligence win for multi-turn since the model won't have to sift through as much noise, and it'll need to compact less frequently per task which is also likely an indirect intelligence win and an indirect cost/perf win per task: post-compaction re-reads of files are basically useless spam to an inference engine, so if you could do the entire task within one context window, you'd hit the engine less per task.

- It lets potentially every token use more computation, instead of keeping the test-time-compute scaling purely in the upfront CoT domain. While it's helpful to think upfront, it can be useful to think mid-stream too.

Overall it's potentially much better.

Re:Inkling 2 Mini by stymaar on Friday November 20, 2026 @11:39PM (#50585999)
It's basically a generalization of the finding that repeating certain layers in an LLM makes it smarter: https://note.com/shi3zblog/n/nbb931d23e156?hl=en

But instead of duplicating the layer's weight, you run through them multiple times at runtime.