Learning to Rewrite Tool Descriptions for Reliable LLM-Agent Tool Use

1. Problem Statement

The paper identifies a critical bottleneck in the development of Large Language Model (LLM) based agents: while agent architectures (models, prompting, fine-tuning) have improved, performance stagnates due to poor quality of tool interfaces.

• The Core Problem: Existing tool descriptions are written for human developers, tolerate ambiguities, and assume background knowledge that agents lack. As tool catalogs scale (hundreds of APIs), these ambiguities compound, causing agents to fail in tool selection and parameterization.
• Limitations of Current Solutions:
  • Per-Tool Pipelines: Methods like DRAFT or Play2Prompt require a multi-stage pipeline (query synthesis, agent execution, trace collection, annotation) for every new API. This is operationally expensive and not scalable.
  • Lack of Generalization: These methods optimize tools in isolation and learn no transferable patterns regarding what makes a description effective. They cannot generalize to unknown tools without re-executing the expensive pipeline.
  • Trace Dependency: Many approaches rely on execution traces to identify errors, yet traces are unavailable at deployment time for new tools (cold-start, privacy, or security constraints).

2. Methodology: Trace-Free+

The authors propose Trace-Free+, a framework that treats interface optimization as a learnable, transferable capability rather than a per-tool engineering task.

A. Core Hypothesis

Effective tool descriptions follow a limited and reusable set of interface patterns (e.g., definitions of scope, parameter constraints, dependencies between tools). Instead of adapting the agent to every tool, the system learns to rewrite tools into a format that agents can consistently interpret.

B. Curriculum Learning Framework

To resolve the tension between the need for rich supervision (traces) during training and the absence of traces at deployment, Trace-Free+ employs Curriculum Learning:

1. Trace-Rich Phase: Training begins with examples containing execution traces (summaries of success/failure). The model learns the mapping between specific error modes (e.g., "parameter ip caused an error") and the necessary description corrections.
2. Trace-Free Phase: The proportion of trace-free examples (Input: Schema + original description; Output: improved description) increases stepwise. The model is forced to internalize the patterns learned in the first phase and apply them using only the tool schema, simulating deployment conditions.
3. Result: The model learns to derive constraints (e.g., valid ranges, required formats, scope exclusions) directly from the schema without needing an execution history.

C. Data Synthesis Pipeline

To support this learning, the authors created a large-scale dataset from real APIs (ToolBench) via a three-stage pipeline:

1. Seed Annotation: An agent annotator validates API health and collects initial call examples.
2. Dependency-Aware Query Synthesis: The system generates multi-step queries that expose interface deficits by chaining APIs based on real call histories.
3. Two-Stage Description Optimization:
   • D1: Applies general documentation guidelines to the original description.
   • D2: Refines D1 using rules extracted from error traces (via RIMRULE), encoding specific constraints such as value formats and prerequisites.
   • Note: D2 serves as the "gold standard" target for the model, but the model is trained to generate descriptions of D2 quality without seeing the traces during inference.

3. Main Contributions

1. Trace-Free+ Framework: A curriculum learning approach that transfers supervision from trace-rich training to trace-free deployment, enabling zero-shot improvement of tool descriptions for unknown APIs.
2. Large-Scale Dataset: A high-quality dataset of tool interfaces derived from real APIs, containing synthesized multi-step queries and improved descriptions (D2) that encode generalizable patterns.
3. State-of-the-Art Performance: The method achieves SOTA results on multiple benchmarks (StableToolBench, RestBench, BFCLv2) without retraining on the test domains.

4. Experimental Results

The paper evaluates Trace-Free+ across three dimensions:

• Trace-Free Generalization:

  • In-Domain (StableToolBench): Trace-Free+ significantly outperforms baselines (D0, D1, EasyTool) on multi-step queries (G2+G3), improving query-level success by 11.1 points over original descriptions (D0).
  • Cross-Domain: It generalizes to unknown domains (RestBench: TMDB/Spotify; BFCLv2) without retraining, showing relative improvements of up to +51.3% over D0.
  • Model-Agnostic: Improvements transfer across various agent models (GPT-4.1, Claude Sonnet 4.5, Gemini-3-pro-preview), raising the SOTA on BFCLv2 by 1.43 points purely through better interfaces.

• Scaling Robustness:

  • In experiments where tool catalogs were scaled to 150+ candidates, Trace-Free+ reduced accuracy degradation by 29.23% compared to D0.
  • It improved average query-level success by 60.89% in large catalogs, demonstrating that clear scope boundaries and parameter constraints are crucial for filtering noise in large search spaces.

• Reinforcement of Agent Fine-Tuning:

  • Trace-Free+ acts as a "force multiplier." Combined with agent fine-tuning, it yields complementary gains.
  • In cross-domain scenarios where fine-tuning alone showed limited transfer (only +1.0% gain), combining it with Trace-Free+ resulted in a gain of +16.3%, proving that interface optimization addresses error modes that model training cannot fix.

5. Significance and Impact

• Paradigm Shift: The paper argues that interface quality is an underutilized axis for improving agents. Instead of solely making agents "smarter," making tools "clearer" leads to massive efficiency gains.
• Scalability: By eliminating the need for per-tool trace collection and execution, Trace-Free+ makes tool integration feasible for enterprise environments with frequent API changes, cold-start scenarios, or strict privacy constraints.
• Internalization of Patterns: The work demonstrates that LLMs can learn abstract, reusable patterns of interface design (e.g., "parameters must be paired," "ranges must be explicit") and apply them to entirely new tools, going beyond simple prompt engineering or isolated tool optimization.

In summary, Trace-Free+ offers a scalable, ready-to-use solution for improving the reliability of LLM agents by transforming how tool descriptions are generated, shifting from reactive, per-tool fixes to proactive, learned generalization.