Looped Language Models Improve Compositional Tool Calling

Recurrent computation turns out to matter more for how a model chains tool calls together than for whether it can invoke a single API correctly. That asymmetry is the central finding here, and it holds across two distinct experimental designs: native looped models (the Ouro family, pretrained with shared recurrent blocks on roughly 7.7 trillion tokens) and retrofitted models that convert existing Llama-3.2-1B and OLMo-2-1B checkpoints into looped architectures post-hoc.

The mechanism is iterative latent refinement. Instead of stacking more parameters, a looped Transformer applies the same block repeatedly before emitting each token, accumulating computation without growing the model. On tasks requiring a single API call—API-Bank being the clearest case—the gains from looping are small and inconsistent. On tasks requiring multiple coordinated calls with explicit output-to-input dependencies (NESTful's nested workflows, BFCL's Parallel and Parallel-Multiple categories), accuracy climbs steadily with recurrent depth before eventually saturating. The qualitative examples make the mechanism concrete: at shallow depths, models hallucinate functions absent from the supplied catalogue, misname arguments, or drop dependent calls entirely; by depth 3 or 4, the same model recovers the correct call sequence including the variable reference that binds one call's output to the next call's argument.

The retrofitting result is particularly useful for practitioners. Converting a pretrained decoder into a looped model via parameter-sharing improves several compositional categories without retraining from scratch—but the paper is careful to note that retrofitted models remain substantially weaker than natively recurrent ones on deeply nested workflows. The implication is that recurrent refinement works best when the representations were shaped for it during pretraining, not bolted on afterward.

Adaptive inference is where the architecture earns its compute efficiency argument. Ouro's pretrained exit gate lets each token terminate the loop early when the model is already confident, allocating deeper computation only to harder predictions. On BFCL, adaptive stopping matches or slightly exceeds the best fixed-depth result while using fewer iterations per token on average. On NESTful, Ouro-2.6B reaches the same Win Rate as fixed depth 4 at lower average cost. This is a meaningful practical property: the compute overhead of looping scales with task difficulty rather than being paid uniformly.

The experimental controls are honest about their limits. No non-looped Ouro counterpart trained under identical pretraining conditions exists, so the native comparison uses matched fine-tuning against Qwen3 and Llama families as a proxy. The retrofit experiments, sharing a backbone with their non-recurrent parents, isolate the architectural effect more cleanly. All three benchmarks are static and single-turn; how looped models handle multi-turn recovery from failed executions remains open.

For anyone building agentic systems where the hard part is dependency tracking across a sequence of tool calls—not just picking the right function once—this is a concrete architectural argument worth taking seriously.