looptool-closed-loop-tool-learning

name	looptool-closed-loop-tool-learning
title	LoopTool: Closing Data-Training Loop for Robust LLM Tool Calls
version	0.0.2
engine	skillxiv-v0.0.2-claude-opus-4.6
license	MIT
url	https://arxiv.org/abs/2511.09148
keywords	["Tool Learning","Data Quality","Iterative Refinement","Self-Improvement","LLM Fine-tuning"]
description	Improve LLM tool-use through automated, closed-loop data curation combining capability probing, error correction, and targeted data expansion—enabling self-refining training pipelines that surpass larger models without expensive APIs.

Refine Tool-Use Training Through Closed-Loop Data Curation

Traditional tool-learning relies on static data generation followed by separate training phases. This decoupled approach fails to address model-specific weaknesses and allows noisy annotations to persist. LoopTool implements a closed-loop framework integrating data synthesis with model training through three coordinated mechanisms: identifying capability gaps, correcting annotation errors, and generating targeted training samples.

The result is that an 8B parameter model trained with LoopTool surpasses 32B data generator models—demonstrating that data quality and curation matter more than quantity or oracle model size.

Core Concept

LoopTool treats tool-learning as an iterative self-improvement process. Rather than one-shot data generation, the system continuously:

1. Probes model capabilities - Identifies which tools the model has mastered vs. where it fails
2. Corrects annotations - Removes noisy labels before they corrupt training
3. Expands training data - Generates additional samples targeting identified failure modes

This closed-loop approach operates within open-source ecosystems, eliminating dependence on expensive proprietary APIs and enabling efficient, adaptive data pipelines.

Architecture Overview

• Capability Probe Module (GCP): Tests model on diverse tool-use scenarios; categorizes as mastered/failing
• Label Verification Module (JGLV): Uses open-source judge model to find and correct dataset errors
• Data Expansion Module (EDDE): Generates new training samples addressing failure modes
• Training Loop: Fine-tunes model on curated, error-corrected data
• Feedback Integration: Iteratively refines data pipeline based on model improvement

Implementation Steps

Step 1: Greedy Capability Probing

Systematically assess which tool-use patterns the model has learned.

from typing import List, Dict, Tuple

class GreedyCapabilityProbe:
    """
    Identifies capabilities model has mastered vs. areas needing improvement.
    """

    def __init__():
        
        .model = model
        .eval_dataset = eval_dataset
        .capabilities = {}

     () -> [, [, []]]:
        
        
        tools_samples = {}
         sample  .eval_dataset:
            tool = sample.get(, )
             tool   tools_samples:
                tools_samples[tool] = []
            tools_samples[tool].append(sample)

        capability_map = {}

         tool_type, samples  tools_samples.items():
            correct = 
            failed_examples = []

             sample  samples:
                
                prompt = ._construct_tool_prompt(sample)
                response = .model.generate(prompt, max_tokens=)

                
                is_correct = ._validate_tool_call(response, sample)

                 is_correct:
                    correct += 
                :
                    failed_examples.append(sample)

            accuracy = correct / ((samples), )
            capability_map[tool_type] = (accuracy, failed_examples)

        .capabilities = capability_map
         capability_map

     () -> [[, []]]:
        
        gaps = []
         tool, (accuracy, failed_examples)  .capabilities.items():
             accuracy < threshold:
                gaps.append((tool, failed_examples))
         gaps

     () -> :
        
        prompt = 
         prompt

     () -> :
        
        expected = sample.get(, )
        
         expected.strip()  response  \
               response.strip() == expected.strip()