🤖 AI

GOAT: A Training Framework for Goal-Oriented Agent with Tools

The paper introduces GOAT, a novel training framework that enables fine-tuning of open-source LLM agents for complex tool use without human annotation by automatically synthesizing goal-oriented API execution data from documentation, achieving state-of-the-art performance on existing benchmarks and a newly proposed GOATBench.

Original authors: Hyunji Min, Sangwon Jung, Junyoung Sung, Dosung Lee, Leekyeung Han, Paul Hongsuck Seo

Published 2026-05-06

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Hyunji Min, Sangwon Jung, Junyoung Sung, Dosung Lee, Leekyeung Han, Paul Hongsuck Seo

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you have a very smart, well-read librarian (the AI) who knows how to read books and write stories. However, if you ask this librarian to go to the library's back room, find a specific box of old maps, pull out a specific page, and then use that page to find a specific recipe in a cookbook, the librarian often gets lost. They might guess the wrong box, open the wrong book, or forget to bring the map page to the kitchen.

This is the problem with current AI agents when they try to use "tools" (like APIs, which are digital connections to databases, weather services, or movie lists). They are great at chatting, but terrible at planning a multi-step mission where one step depends entirely on the result of the previous one.

The paper introduces GOAT (Goal-Oriented Agent with Tools), a new training method designed to turn that confused librarian into a master detective. Here is how it works, using simple analogies:

The Problem: The "Guessing Game"

Usually, to teach an AI to use tools, researchers have to hire humans to write out thousands of examples like: "First, ask the weather API for rain. Then, take that 'rain' answer and ask the clothing API for a raincoat."
This is expensive and slow. Without these human-written examples, AI models just guess. They often fail at complex tasks that require chaining multiple steps together.

The Solution: The "Reverse Engineering" Kitchen

The authors of GOAT realized they didn't need humans to write the instructions. They had the "cookbook" (the API documentation) already. Instead of asking the AI to guess the recipe from a finished dish, they decided to build the dish first, then describe the recipe.

They use a "Call-First" strategy:

Map the Kitchen: First, the system reads all the API manuals and draws a map of how the tools connect. (e.g., "The output of the 'Weather' tool fits perfectly into the input of the 'Umbrella' tool").
Cook the Meal (The Call-First Step): The system picks a path on this map and actually runs the tools. It asks the weather tool for data, gets the result, and then immediately uses that result to ask the umbrella tool. It doesn't guess; it executes real steps and gets real answers.
Write the Recipe (The Abstraction Step): After the tools have done the work, the AI looks at the finished chain of events and writes a user query that matches it. It essentially says, "Oh, I just did all these steps to find a raincoat. So, a user asking 'What should I wear if it's raining?' is what I just solved."

By doing this in reverse (Action $\rightarrow$ Question), the AI learns the correct logic of how tools connect without needing a human to write the instructions. It learns by doing the work first, then explaining what it did.

The Result: A Super-Helper

The paper tested this new "GOAT" trained agents on several challenges:

RestBench & API-Bank: These are like exams where the AI has to find movie reviews or music recommendations using a chain of tools.
GOAT-Bench: The authors created a brand new, larger exam specifically for these types of complex, multi-step tasks.

The findings were clear:

Open-Source Models: Before GOAT, smaller, open-source AI models (which are free and available to everyone) were almost useless at these complex tasks. They failed nearly 100% of the time.
After GOAT: Once trained with this new method, these same open-source models became incredibly good at the tasks. In some cases, they performed better than expensive, closed-source models (like GPT-4) that usually dominate these tests.
No Human Needed: The entire training dataset was built automatically by the system using the API manuals. No humans had to sit down and write out the step-by-step instructions.

The Bottom Line

GOAT is a way to teach AI agents how to plan and use tools by letting them practice the actual work first, then teaching them to describe the goal. It turns open-source AI models from "clueless guessers" into "reliable planners" without requiring expensive human teachers. The authors have made their code and their new test suite (GOAT-Bench) available for others to use.

Technical Summary: GOAT: A Training Framework for Goal-Oriented Agent with Tools

Problem Statement

Large Language Models (LLMs) have evolved into interactive agents capable of invoking external tools (APIs). However, a significant gap remains in handling goal-oriented queries. Unlike simpler tasks involving single-step queries or explicitly specified instructions, goal-oriented tasks require an agent to decompose a high-level objective into a sequence of interdependent API calls. This demands complex reasoning for task decomposition, long-horizon planning, and the ability to infer appropriate arguments for API functions based on the outputs of previous calls.

Current approaches to training agents for these tasks are limited by the absence of high-quality training data. Constructing datasets that capture inter-API dependencies typically requires costly human annotation, which is not scalable. Consequently, most existing methods rely on zero-shot evaluation, where models are expected to perform complex reasoning without task-specific supervision. While proprietary models (e.g., GPT-4) show some capability, smaller open-source models often fail to execute these complex tool-use scenarios effectively.

Methodology: The GOAT Framework

To address the data scarcity issue, the authors propose GOAT (Goal-Oriented Agent with Tools), a fully automatic training framework that synthesizes goal-oriented API execution data from existing API documentation without human annotation. The framework operates on the premise that API documentation is typically available for target domains and can be leveraged to construct training data.

1. Automatic Dataset Construction

The core innovation of GOAT is a call-first generation paradigm, which contrasts with the "instruction-first" strategies used in prior works (where an LLM generates a query first and then attempts to map it to API calls). GOAT reverses this flow to avoid self-reinforcing biases toward "easy" instances.

The data construction process involves three main stages:

API Dependency Graph Construction:
- Parsing: API documents are parsed to extract input/output specifications.
- Graph Initialization: A fully connected multidigraph is initialized where edges represent potential dependencies (output of API $A$ as input to API $B$ ).
- Progressive Filtering: To ensure reliability, the graph is refined through three filtering stages:
  1. Embedding Similarity: Coarse filtering using SBERT embeddings to discard semantically incompatible edges.
  2. LLM Verification: An LLM evaluates semantic plausibility based on descriptions alone.
  3. Execution Validation: The most rigorous step, where the LLM generates arguments, executes the source API, and verifies if the output can validly populate the destination API's parameters. This ensures only executable workflows are retained.
Goal-Oriented Data Synthesis:
- Sampling: Connected subgraphs (representing valid API sequences) are extracted from the dependency graph.
- Call-First Instantiation: The framework instantiates and executes the API sequence, generating concrete outputs.
- Query & Response Generation: Based on the executed sequence and outputs, the LLM generates a natural language user query that encapsulates the high-level goal and a final response that interprets the results. This creates a dataset where the supervision signal (the API call sequence) is grounded in reality, and the query is an abstraction of that reality.

2. Agent Training

The framework fine-tunes two components on the synthesized dataset:

LLM Agent: Instruction-tuned to plan the correct sequence of calls, fill arguments (with argument values masked during training to prevent overfitting to specific values), and generate the final natural language response.
Retriever: A dense retrieval model (based on SBERT) trained on ground-truth query-API document pairs to map user queries to relevant API specifications.

Key Contributions

GOAT Framework: A novel, fully automatic training framework that constructs goal-oriented API execution datasets from API documentation without human annotation. It introduces a call-first generation strategy that provides reliable supervision for learning complex reasoning by grounding data in executable API workflows.
State-of-the-Art Performance: Extensive experiments demonstrate that agents trained with GOAT achieve state-of-the-art performance on multiple existing goal-oriented benchmarks using open-source models, in some cases surpassing closed-source models with strong reasoning capabilities.
GOATBench: The introduction of a new, large-scale evaluation benchmark for goal-oriented tasks. Built using the GOAT pipeline with lightweight human verification, it covers diverse domains (Entertainment, Financial, Food, Travel) and includes both "seen" and "unseen" API compositions to test generalization.

Experimental Results

The authors evaluated GOAT on RestBench, API-Bank, and the new GOATBench.

RestBench: Open-source models (Llama-2-13B, Vicuna-13B) fine-tuned with GOAT showed substantial improvements over zero-shot baselines and prior open-source methods (RestGPT). In some cases, they outperformed closed-source models like GPT-4.
API-Bank: GOAT-trained models significantly outperformed zero-shot baselines and other synthetic data approaches, achieving higher success rates and correct path percentages.
GOATBench: GOAT-trained agents demonstrated consistent gains over non-fine-tuned models and models trained with instruction-first data (e.g., from ToolLLM). The framework proved effective in both single-tool and inter-tool (multi-API) scenarios.
Ablation Studies:
- Call-First vs. Instruction-First: Models trained with call-first data consistently achieved higher success rates than those trained with instruction-first data, validating the strategy's ability to provide better supervision for complex reasoning.
- Generalization: Models trained on GOATBench showed improved performance on unseen APIs and cross-benchmark generalization (e.g., training on GOATBench and testing on RestBench), though gains were more pronounced in-domain.

Significance and Claims

The paper claims that GOAT provides a practical and scalable path toward building robust open-source LLM agents capable of complex reasoning and tool use. By eliminating the reliance on costly human annotation and leveraging the "call-first" paradigm, GOAT enables efficient domain-specific adaptation of LLMs. The results suggest that open-source models, when properly fine-tuned with this synthetic data, can rival or exceed the performance of proprietary models in goal-oriented tool use, addressing a critical bottleneck in the deployment of agentic AI systems.

The authors acknowledge limitations, noting that while the framework improves in-domain performance, generalization to entirely unseen scenarios remains limited, and the quality of generated data is dependent on the quality of the source API documentation. Nevertheless, the work establishes a new baseline for training agents on interdependent tool use without human intervention.