Looped Language Models Improve Compositional Tool Calling

Andrei Cristian Popescu; Haitz Sáez de Ocáriz Borde; Pietro Liò

cs.AIAug 17, 2026

Looped Language Models Improve Compositional Tool Calling

Authors: Andrei Cristian Popescu, Haitz Sáez de Ocáriz Borde, Pietro Liò

Organizations: Department of Computer Science and Technology University of Cambridge, United Kingdom

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.

Figures & tables

Model	Training	Simple	Multiple	Parallel	Par.-Mult.	Overall
Ouro-1.4B	Base	65.3	67.0	35.0	44.5	55.4
	SFT	91.8	90.0	67.5	55.5	79.3
Ouro-2.6B	Base	80.5	75.5	2.0	1.0	47.9
	SFT	92.3	88.0	83.0	76.5	86.4
Qwen3-1.7B	Base	1.5	0.0	0.0	0.0	0.6
	SFT	67.0	57.0	3.0	9.5	40.7

Table 1: BFCL semantic AST correctness (%; higher is better). Overall is the aggregate score across all task categories. The lower block compares looped and non-looped variants of each backbone, fine-tuned using identical data and optimization settings; looped variants use a fixed inference depth of 8 loop iterations. Base checkpoints omitted from the lower block score near zero throughout.

Model	Training	Function F1	Parameter F1	Partial	Full	Win Rate
Ouro-1.4B	Base	0.905	0.539	0.149	0.091	0.110
	SFT	0.899	0.566	0.219	0.131	0.191
Ouro-2.6B	Base	0.920	0.595	0.207	0.128	0.190
	SFT	0.922	0.680	0.295	0.204	0.371
Qwen3-1.7B	Base	0.000	0.000	0.000	0.000	0.000
	SFT	0.000	0.000	0.000	0.000	0.000

Table 2: NESTful official evaluation (higher is better). Win Rate is the primary metric.

(a) Controlled models

Base SFT Model Call Exact Parse Call Exact Parse Ouro-1.4B 73.0 67.6 95.1 75.1 70.2 97.2 Ouro-2.6B 79.2 76.9 99.2 79.9 77.1 99.7 Qwen3-1.7B 5.1 5.1 13.9 61.4 57.8 93.6 Qwen3-4B 71.2 71.2 99.2 76.6 73.8 99.7 Llama-3.2-1B 1.7 1.3 10.8 16.3 14.1 55.3 Llama-3.2-3B 0.3 0.3 0.3 68.5 64.5 99.7 OLMo-2-1B 1.9 0.5 35.7 37.1 33.2 99.5 OLMo-2-1B (Loop) 0.1 0.0 1.5 34.0 30.3 90.7 Llama-3.2-1B 1.7 1.3 10.8 16.3 14.1 55.3 Llama-3.2-1B (Loop) 0.1 0.0 1.5 17.9 16.2 43.4

Table 3: API-Bank evaluation (%; higher is better). (a) Controlled comparison between looped and non-looped models trained using identical supervised fine-tuning recipes. The lower block pairs each retrofitted backbone with its non-looped counterpart; looped variants are evaluated at a fixed inference depth of 8 loop iterations. (b) Comparison against publicly released instruction-tuned checkpoints. Call Correctness measures functional API-call correctness, Exact requires an exact API-name-and-argument match, and Parse reports valid call generation.

Figure 2: BFCL semantic AST accuracy by task category as fixed recurrent depth increases. Each curve reports accuracy on Simple, Multiple, Parallel, and Parallel-Multiple tasks.

Panel of Figure 3 — Figure 3: NESTful Win Rate as fixed recurrent depth increases. Native recurrent Ouro models benefit from additional recurrent computation, whereas the retrofitted recurrent Llama baseline remains substantially weaker.

Panel of Figure 4 — Figure 4: Adaptive recurrent computation on BFCL and NESTful. The x-axis reports the mean recurrent depth per generated token. Adaptive stopping improves the compute-performance frontier by allocating additional recurrent iterations only when beneficial. On BFCL, adaptive stopping matches or slightly exceeds the best fixed-depth operating point while executing fewer recurrent iterations on average. On NESTful, Ouro-2.6B reaches the same Win Rate as fixed depth 4 while using fewer recurrent iterations per generated token.

Figure 5: Iterative refinement across recurrent depths. Ouro-1.4B on a two-step NESTful composition task. Calls are shown as function(argument=value) -> answer . At depth 1 the model emits a single call to a function absent from the tool catalogue and omits the dependent call; at depth 2 it recovers the two-call structure but the first function is again absent from the catalogue and the variable reference is invalid. Depths 3 and 4 match the gold sequence, including the output-to-input reference $var1.output_0$ .

Appendix figures & tables5 assets

Supplementary material from the paper’s appendix.

Appendix

Figure 6: Ordering and spurious-call correction. At depth 1 the output is malformed, emitting tool specifications rather than call arguments (excerpt shown truncated). At depth 2 both gold functions appear but in reversed order, followed by a call to multiply , which is absent from the tool catalogue, and an invalid variable reference. Depths 3 and 4 match the gold sequence, differing from each other only in label naming.

Figure 7: Argument correction. At depth 1 the model selects the correct first function but names its argument input_str , a parameter of a different tool in the same catalogue, duplicates it as input_str_2 , and omits the dependent call. Depths 2 through 4 match the gold sequence and are identical to one another.

Figure 8: Two distinct incorrect attempts before recovery. Depths 1 and 2 each emit a single call to a function absent from the tool catalogue and omit the required dependent call. At depth 1, the model also uses an argument name belonging to a different tool in the catalogue. Depths 3 and 4 select both gold functions and correctly pass

var1.output_0

, differing only in argument-key order.

Figure 9: Isolated recovery of a missing dependent call. Depth 1 emits an object with no function name, returning a computed literal, so the parser yields no calls. Depth 2 emits a first call that matches the gold sequence exactly but stops there. Depths 3 and 4 leave that first call unchanged and add the dependent call with the reference

var1.output_0

, isolating the recovery of the dependency from any change in function selection.

Benchmark	Candidate tools	Call structure	Dependencies	Primary challenge
API-Bank	one or more	typically $\|C_{x}\|=1$	$E_{x}=\varnothing$	Tool and argument grounding
BFCL Simple	$\|\mathcal{T}_{x}\|=1$	$\|C_{x}\|=1$	$E_{x}=\varnothing$	Argument grounding
BFCL Multiple	$\|\mathcal{T}_{x}\|>1$	$\|C_{x}\|=1$	$E_{x}=\varnothing$	Function selection
BFCL Parallel	one or more	$\|C_{x}\|>1$	$E_{x}=\varnothing$	Independent call generation
BFCL Parallel-Multiple	$\|\mathcal{T}_{x}\|>1$	$\|C_{x}\|>1$	$E_{x}=\varnothing$	Selection and call composition
NESTful	multiple	$\|C_{x}\|>1$	typically $\|E_{x}\|>0$	Dependency-aware execution

Appendix

Table 4: Structural comparison of the evaluated tool-calling benchmarks under the solution representation

G_{x}=(C_{x},E_{x})

. API-Bank emphasizes individual-call grounding, BFCL evaluates increasingly complex independent call sets, and NESTful introduces explicit output-to-input dependencies.

LLM Tool Use

Large language model tool use studies how models select, call, and coordinate external tools to extend their reasoning and take actions.

See all 295 papers

ToolLoop: Closed-Loop Tool-Use Data Synthesis via Decomposed Generation and Dynamic Self-Feedback
Sep 8, 2026Min Zeng, Yuzhou Liu, Zhenyu Cao +5Tool-Augmented Language Model Agents Synthetic Data Generation
vivo AI Lab
HyperTool: Beyond Step-Wise Tool Calls for Tool-Augmented Agents
Jun 11, 2026Yaxin Du, Yifan Zhou, Yujie Ge +7Tool-Augmented Language Model Agents LLM Agent Workflow Optimization
Shanghai Jiao Tong University · IQuest Research · Beijing University of Aeronautics and Astronautics
Tool Calling is Linearly Readable and Steerable in Language Models
May 8, 2026Zekun Wu, Ze Wang, Seonglae Cho +4AI Agent Reliability Tool-Augmented Language Model Agents
University College London · Holistic AI · Imperial College London

Sep 8, 2026J/K move · Enter open · S save

ToolLoop: Closed-Loop Tool-Use Data Synthesis via Decomposed Generation and Dynamic Self-Feedback

Min Zeng, Yuzhou Liu, Zhenyu Cao, Hanxiu Chen+4

vivo AI Lab

Tool-Augmented Language Model Agents Synthetic Data Generation LLM Tool Use Synthetic Data Generation for Language Models

Open paper AskPDF arXiv

High-quality tool-use data is critical for training language models to interact effectively with external tools. However, existing synthetic approaches typically follow a generate-then-filter paradigm with static post-hoc verification, often yielding inefficient data with imbalanced feature distributions. We propose ToolLoop, a closed-loop framework that decomposes synthesis into three progressive stages: (1) sampling function name combinations as ground truth; (2) backward derivation of user queries; and (3) forward derivation of tool calls. At each stage, dynamic self-feedback iteratively guides the model toward high-quality generation, realizing a transition from generate-then-filter to generate-verify-refine. On the Berkeley Function Calling Leaderboard (BFCL), a 4B parameter model trained with our 11K synthetic examples achieves 86.40% accuracy in non-reasoning mode, while an Isolate variant that removes BFCL-overlapping candidate functions still reaches 86.07%. Cross-benchmark evaluation on ACEBench further demonstrates strong generalization, with 72.1% overall accuracy using only 18.3% of baseline training data.

Abstract

LLM Tool Use

Explore similar work

ToolLoop: Closed-Loop Tool-Use Data Synthesis via Decomposed Generation and Dynamic Self-Feedback

HyperTool: Beyond Step-Wise Tool Calls for Tool-Augmented Agents

Tool Calling is Linearly Readable and Steerable in Language Models