Andrei Cristian Popescu, Haitz Sáez de Ocáriz Borde, Pietro Liò
6 min
Abstract
Looped language models have shown promising results on reasoning benchmarks, yet their potential for agentic tool use remains largely unexplored. We study this question in compositional tool-calling settings, where models must coordinate multiple API calls, maintain intermediate state, and preserve dependencies across tool interactions. We evaluate native and retrofitted looped language models on API-Bank, BFCL, and NESTful, comparing looped and non-looped models trained under matched supervised fine-tuning recipes and varying recurrent depth at inference time. In controlled experiments, recurrent computation generally benefits compositional and dependency-aware tool use, while providing smaller and more model-dependent gains on isolated API invocation. Accuracy on multi-step tool use generally increases with recurrent depth; adaptive inference, however, achieves a more favorable compute-performance trade-off by allocating additional computation only when needed. Our results suggest that looped language models are a promising architecture for agentic systems that require reliable planning, coordination, and execution of compositional tool use workflows.
Alex: That's exactly what the second part of the paper addresses. The researchers introduce what they call adaptive inference. Rather than always running a fixed number of loops, the model learns to estimate — at each loop — whether another pass is still worth doing. Think of it like a student checking their work. After the first check, you might catch a big mistake. After the fifth check, you're probably not finding anything new. At some point, it's more efficient to just hand in the paper.
Sam: So the model is essentially asking itself, "Have I thought about this enough?"
Alex: That's a good way to put it. At each loop, the model calculates a probability of stopping. If it's confident, it exits early. If there's still meaningful uncertainty, it keeps going. And this decision happens separately for each word — or piece of a word — the model is generating.
Sam: So a simple word like "the" might only need one loop, while a complex parameter being passed to an API might need six or seven.
Alex: Precisely. And the paper shows that this adaptive approach matches or slightly exceeds the performance of always running the maximum number of loops — while using significantly fewer total computations on average. You get most of the benefit at a fraction of the cost.
Sam: How do you actually train a model to do this? Teaching it to loop and then decide when to stop sounds genuinely complicated.
Alex: The researchers take a careful approach. They start with a model that already knows a lot about language, and they freeze its core settings — those don't change. Then they add small adaptation layers that teach the model how to loop effectively. During training, the number of loops used for each example is chosen randomly, which prevents the model from learning to rely on any specific depth. And the model is only evaluated on its final output — not on what it produced partway through.
Sam: So it learns to produce good final answers across a range of loop counts, rather than being trained to always use the maximum.
Alex: Which is what makes the adaptive halting work cleanly in practice. The model has already learned to be useful at different depths.
Sam: What are the limitations? Where does this fall short?
Alex: The paper is candid about this. The benchmarks are static and single-turn — the model answers once, and that's it. Real-world workflows are messier. An API might return an unexpected error. A tool might go offline. A conversation might span many turns. How well the looped architecture handles that kind of live, dynamic feedback is still an open question.
Sam: So we know it reasons better in controlled conditions. Whether it recovers gracefully when things go wrong in the real world — that's the next thing to test.
Alex: That's the honest summary. The paper makes a clear case that thinking in loops rather than a single pass improves structured reasoning without requiring a larger model. The adaptive halting mechanism makes that practical by avoiding unnecessary computation. But the multi-turn, error-recovery challenge remains largely unaddressed, and that's where future work will need to go.
Sam: A meaningful step toward AI systems that can handle complex tasks more reliably — without simply scaling up.
Alex: Thanks for listening to ResearchPod.