Mixture-of-Recursions
Mixture-of-Recursions is a construction principle for language models in which the same layer is passed through multiple times in sequence — with the number of passes varying depending on how difficult the individual piece of text is. This allows the model to require less memory and compute faster on simple passages.
Programs that write texts or answer questions consist internally of many stacked computational layers. The text moves from bottom to top through this stack, and each layer has its own learned settings. Mixture-of-Recursions breaks with this design. Instead of forty different layers, there is only one small block that is run through again and again. How often it is run through is decided by the program individually for each piece of text. A simple word like “and” leaves the loop early, while a difficult technical term goes through several rounds.
Two savings at once
A large language model costs money mainly in two places. First, it needs space in the graphics card's memory, because all the learned settings have to sit there. Second, it needs computing time for every single answer. Mixture-of-Recursions addresses both points, and that sets it apart from many other efficiency methods.
The memory advantage arises because the layer exists only once. If a block is run through four times, the model behaves like one that is four times deeper — but occupies only a quarter of the space. This is a different path than Mixture of Experts, the better-known efficiency method. There, all the building blocks sit in memory, and only the computing time decreases. With Mixture-of-Recursions, both decrease.
The computing time decreases because not every word receives the same amount of effort. In a normal sentence, most words are easy to predict. After “Good” almost certainly follows “morning” or “day.” Letting such passages leave the loop early costs almost no quality. In published experiments, models built this way achieved better text quality than classically built models of the same size, given the same amount of training data.
The router and the loop
At the core is a small additional network, the router. It looks at a piece of text and assigns it a score for whether it needs another round. If the score falls below a threshold, this building block is finished and gets passed through. All others run through the same block again. The router is not set by hand but learns its decisions along the way during training.
For the training to work, a trick is needed. A hard yes-no decision cannot be differentiated, and derivatives are the foundation of every learning process in neural networks. That’s why the router works with soft weights: a result is factored in proportionally, rather than belonging completely or being completely absent. This way the router gets feedback on whether its classification was useful.
A second component concerns the intermediate memory. Language models store intermediate results for every word so far, so they don’t have to keep recalculating them. With Mixture-of-Recursions, these intermediate results are only created for the building blocks still in the loop. This saves additional memory, especially with very long texts. A common misconception is to confuse this method with a model that “thinks longer.” This is not about visible reasoning steps in words, but about repeated computational passes internally.
A research approach, not yet a product
Mixture-of-Recursions comes from a research paper from 2025, involving among others Google DeepMind and KAIST University in South Korea. In reports, the term usually appears in connection with the question of how AI models can become cheaper. It thus belongs to the same discussion as quantization or Mixture of Experts.
You won’t find the name in a finished product yet. No major chatbot advertises being built on this principle. The approach is particularly interesting for models meant to run on phones or in cars. There, memory is scarce, and that is exactly where the method shows its strength.
Whether the principle will prevail is still open. Repeated passes are more inconvenient for graphics cards than a smooth stack of layers, because different words require different amounts of computation time. Such uneven distributions often slow things down more in practice than theory would suggest. As a reader, it’s worthwhile to read the term as an example of a broader trend: the industry is no longer just searching for bigger models, but for more efficient ones.