kevindong-intuit's picture
add arxiv
c986295
---
license: apache-2.0
language:
- en
datasets:
- intuit/tool-optimizer-dataset
base_model:
- Qwen/Qwen3-4B-Instruct-2507
pipeline_tag: text-generation
library_name: transformers
tags:
- agents
- tool-use
- sft
- documentation
- text-generation
---
# Agent Tool Optimizer (`intuit/agent-tool-optimizer`)
`intuit/agent-tool-optimizer` is a **supervised fine-tuned (SFT)** model that rewrites **tool / API descriptions** to be more usable by **LLM agents**. Given a tool name, a parameter schema, and a baseline (often human-written) description, the model produces an improved description that helps an agent:
- decide **when to use vs. not use** the tool
- generate **valid parameters** (required vs optional, constraints, defaults)
- avoid common mistakes and likely validation failures
This model is trained to work in a **trace-free** setting at inference time (i.e., **no tool execution traces required**).
For the accompanying codebase (inference + training), see: [Agent Tool Interface Optimizer](https://github.com/intuit-ai-research/tool-optimizer).
---
## What problem does this solve?
Tool interfaces (descriptions + parameter schemas) are the “contract” between agents and tools, but are typically written for humans. When descriptions under-specify **required parameters**, omit **constraints**, or fail to explain **tool boundaries**, agent performance can plateau and can degrade as the number of available tools increases.
We study tool interface improvement as a scalable complement to agent fine-tuning, and propose **Trace-Free+**: a curriculum-learning approach that transfers knowledge learned from trace-rich training to trace-free inference for unseen tools.
---
## Paper (arXiv)
This model is released alongside the preprint:
- **Learning to Rewrite Tool Descriptions for Reliable LLM-Agent Tool Use**
Ruocheng Guo, Kaiwen Dong, Xiang Gao, Kamalika Das
arXiv:2602.20426 (2026) — [paper](https://arxiv.org/abs/2602.20426)
### Citation
```bibtex
@misc{guo2026learningrewritetooldescriptions,
title={Learning to Rewrite Tool Descriptions for Reliable LLM-Agent Tool Use},
author={Ruocheng Guo and Kaiwen Dong and Xiang Gao and Kamalika Das},
year={2026},
eprint={2602.20426},
archivePrefix={arXiv},
primaryClass={cs.AI},
url={https://arxiv.org/abs/2602.20426},
}
```
---
## Recommended prompt (trace-free)
This is the **canonical inference prompt** used for trace-free tool description generation (also available as `tool_prompt.txt` in the `tool-optimizer` repo).
```
You are an API documentation specialist.
Rewrite the API description so an AI agent can:
1) Decide when to use this API
2) Generate valid parameters
Inputs:
- API name: {tool_name}
- Parameter schema: {parameter_json}
- Baseline description: {original_description}
Infer (do not output):
- When to use vs not use this API
- Required vs optional parameters
- Parameter meanings and constraints
- Cross-parameter dependencies or exclusions
- Common parameter mistakes
- no examples are provided, infer from the schema and baseline description only
Write a clear API description that:
- States when to use and NOT use the API
- Does not invent or reference non-provided APIs
- Explains each parameter's meaning, type, required/optional status, constraints, and defaults
- Describes likely validation failures and how to avoid them
- Abstracts patterns into general rules
- Does not restate the full schema verbatim
- Does not mention whether examples were provided
You may replace the baseline description entirely.
Output ONLY valid JSON (no markdown, no code blocks):
{{"description": "<your improved API description here>"}}
```
### Inputs
- **`tool_name`**: the tool/API name
- **`parameter_json`**: a JSON string describing the parameter schema (treat this as authoritative)
- **`original_description`**: the baseline description you want to improve
### Output
The model is trained to output **only valid JSON** with a single field:
- **`description`**: the improved tool description (string)
---
## Prompt variation guidance (SFT-sensitive)
Because this model is SFT to follow a specific prompt and output contract, it can be sensitive to prompt changes. The safest strategy is to treat the prompt as a template and apply only **minimal, well-scoped edits**.
### Prompt invariants (do not change)
- Keep the three input slots exactly: `{tool_name}`, `{parameter_json}`, `{original_description}`
- Keep: **“Output ONLY valid JSON (no markdown, no code blocks)”**
- Keep the output schema exactly: `{"description": "..."}` (same key name; no extra keys)
### Safe, minimal edits (usually OK)
- Add 1–3 bullets under **“Infer (do not output)”** to clarify what to pay attention to
- Add constraints under **“Write a clear API description that:”** as additional bullets
- Add brief reminders about schema authority, parameter-name exactness, or concision
### Risky edits (often break JSON / behavior)
- Reordering or removing the output-format lines
- Asking for examples, multi-part outputs, markdown, or extra keys
- Changing placeholder names or introducing new “inputs” not present during training
### Concrete example: minimal diff that still tends to work
The prompt below is a conservative variation. It adds clarifications without changing the core structure or output contract:
```diff
Infer (do not output):
- Preserve key lexical tokens from the baseline description that may match user queries
- Clarify boundaries if this API could be confused with similar tools
Write a clear API description that:
- Treats the parameter schema as authoritative and does not introduce fields, types, or requirements not defined in it
- Explains each parameter's meaning ... while keeping parameter names exactly as defined in the schema
- Lists REQUIRED parameters before optional ones
- Uses enumerated or candidate values exactly as defined in the schema when applicable
- Describes likely validation failures strictly based on schema-defined constraints ...
- Keeps the description concise and avoids unnecessary verbosity
```
---
## Inference
### Option A: Use the `tool-optimizer` library (recommended)
The open-source repo includes a working CLI that runs this model with either **vLLM** or **Hugging Face Transformers**:
```bash
git clone https://github.com/intuit-ai-research/tool-optimizer
cd tool-optimizer
# Install (one option)
python -m pip install -e .
# Run inference (vLLM default)
python src/agent_tool_optimizer/inference_main.py \
--model_name intuit/agent-tool-optimizer \
--dataset_id intuit/tool-optimizer-dataset
```
Notes:
- `--inference_engine vllm` (default) or `--inference_engine hf`
- The dataset is expected to have a `test` split with a `prompt` field.
### Option B: Transformers (direct)
```python
import json
from transformers import pipeline
import torch
model_id = "intuit/agent-tool-optimizer"
gen = pipeline(
"text-generation",
model=model_id,
torch_dtype=torch.bfloat16,
device_map="auto",
trust_remote_code=True,
)
prompt = """<prompt above>"""
out = gen(
[{\"role\": \"user\", \"content\": prompt}],
max_new_tokens=512,
do_sample=True,
temperature=0.6,
top_p=0.95,
top_k=40,
return_full_text=False,
)
result = out[0][\"generated_text\"]
print(result)
# Optional: validate JSON
json.loads(result)
```
---
## Example (Before vs After)
![Screenshot 2026-02-20 at 5.23.36 PM](https://cdn-uploads.huggingface.co/production/uploads/65dcb410bda21d181b38321b/dFj0XgXancXD51iyGxC83.png)