Sparse Rewards Can Self-Train Dialogue Agents

## Abstract

Abstract Recent advancements in state-of-the-art (SOTA) Large Language Model (LLM) agents, especially in multi-turn dialogue tasks, have been primarily driven by supervised fine-tuning and high-quality human feedback. However, as base LLM models continue to improve, acquiring meaningful human feedback has become increasingly challenging and costly. In certain domains, base LLM agents may eventually exceed human capabilities, making traditional feedback-driven methods impractical. In this paper, we introduce a novel self-improvement paradigm that empowers LLM agents to autonomously enhance their performance without external human feedback. Our method, Juxtaposed Outcomes for Simulation Harvesting (JOSH), is a self-alignment algorithm that leverages a sparse reward simulation environment to extract ideal behaviors and further train the LLM on its own outputs. We present ToolWOZ, a sparse reward tool-calling simulation environment derived from MultiWOZ. We demonstrate that models trained with JOSH, both small and frontier, significantly improve tool-based interactions while preserving general model capabilities across diverse benchmarks. Our code and data are publicly available on GitHub at https://github.com/asappresearch/josh-llm-simulation-training

## 1 Introduction

Large Language Models (LLMs) (Bommasani et al., ; Brown et al., ; Achiam et al., ) have shown a well-marked ability to follow instructions under various tasks. These advancements are often attributed to post-training fine-tuning based on human preferences. This includes multi-turn tool calling tasks where an LLM-based agent must solve a task by interacting with both a user and a set of tools (or APIs) (Farn & Shin, ; Yao et al., ). Further task-specific alignment for tool-calling tasks can take the form of preference judgments. But these can be expensive to obtain. Furthermore, there is usually a more ‘crisp’ notion of success for such tasks. Specifically, was the right tool(s) or API(s) called with the right set of arguments? Ideally, alignment should be optimized towards these sparse rewards.

In this paper, we propose a self-alignment process JOSH (Juxtaposed Outcomes for Simulation Harvesting) that can be used to improve a model’s performance on multi-turn tool calling by optimizing for tool/API completion using simulated rollouts of reward-conditioned conversations. We show that this method is general and can be applied to weak/small or frontier LLMs, though gains are significantly larger for the former. We also present a new tool calling benchmark, ToolWOZ, refashioning MultiWoz2.0 (Zang et al., ) to train and evaluate multi-turn tool calling effectively.

JOSH utilizes a beam search inspired simulation approach, employing sparse rewards (in this paper corresponding to successful tool calls) to guide turn-by-turn generation and synthesize preference-annotated examples. JOSH allows an agent to generate multiple responses at each conversation turn, exploring various trajectories through a conversation until a sparse reward (goal) is encountered along some path. Upon reaching a goal, other beam candidates are pruned and further expansion proceeds only from that point. Once a trajectory achieves all possible goals, all remaining trajectories are backtracked, logging unsuccessful paths as negative alignment samples and successful paths as positive ones. This process constructs alignment preference data solely from the model itself. When used to align that same model, we show it enhances model performance.

Tool use is a critical skill in LLMs (Mialon et al., ; Schick et al., ); however, there is a large disparity in tool-using capabilities across different model sizes, especially when involving them in multi-turn reasoning (Gao et al., ). Furthermore, existing benchmarks either lack a real-world multi-turn setup (Ruan et al., ) or intentionally keep the agent’s dialogue disjoint from underlying databases and focus more on tool selection (Huang et al., ). To demonstrate JOSH’s capability to improve a model used in an agentic system through self-alignment, we introduce a new dataset ToolWOZ. Derived from the task-oriented dialogue (TOD) benchmark MultiWOZ, ToolWOZ is a multi-turn tool-based simulation environment where an agent model is assessed on its tool-calling capabilities by calling goal APIs through collaboration with a user simulator. After self-alignment using JOSH on the ToolWOZ training set, a meta-llama3-8B-instruct (Meta-Llama, ) model exhibits a 74% increase in Success Rate. Additionally, after JOSH self-alignment we see gpt-4o beats it’s own baseline to become state-of-the-art on two separate benchmarks: ToolWOZ and $\tau$-bench (Yao et al., ).

To show that JOSH does not degrade general model performance, we evaluate a trained meta-llama3-8B-instruct model across three public benchmarks: MT-Bench (Zheng et al., ), $\tau$-bench , and the LMSYS-Chatbot Arena Human Preference Predictions challenge (lin Chiang, ; Zheng et al., ). Our results confirm that the JOSH aligned model does not regress relative to its base model, despite its new specialized alignment.

## 2 JOSH: Juxtaposed Outcomes for Simulation Harvesting

In this section, we detail the two components of JOSH, our method for generating synthetic preference-annotated training data to enhance tool-driven multi-turn dialogue. We use the terms “tool” and “API” interchangeably. Our approach for generating conversations uses an agent-simulator system and involves a turn-level beam search strategy combined with tool/API-calling reward pruning. Unlike traditional token-level beam search, our method maintains multiple active multi-turn conversations (trajectories) over sequences of agent turns. From these synthetic conversations we create preference-annotated training instances. This involves extracting both supervised fine-tuning (SFT) data and preference fine-tuning (PFT) data. The SFT data is derived from the optimal trajectory (or path) through the conversation tree, while the PFT data includes pairwise comparisons of good and bad agent turns, facilitating more nuanced model training.

Figure: Figure 1: Illustration of JOSH, a tool calling simulation-based beam search experience generation algorithm. A correct path through the conversation can be mapped out (shown in green) by backtracking from sparse rewards achieved by the agent. In this scenario, the sparse rewards are represented by “correct” API calls called by the agent. From backtracking through the tree an “ideal” path through the conversation is found and training data can be extracted.
Refer to caption: extracted/5911674/Figures/josh_figure_updated_colors.png

### 2.1 Beam Search Simulation for Collecting User-Agent Conversations

Figure: Algorithm 1 Beam Search Simulation for Collecting User-Agent Conversations

We begin by having the agent $A$ (defined in Section 4.2) interact with a user simulator $U$ (defined in Section 4.3).
A set of goals $G=\{g_{1},g_{2},\ldots,g_{k}\}$ is defined where achieving a goal will award the agent $A$ a sparse reward of value $\frac{1}{\textit{len}(\text{Goal Set})}$ to it’s return. Our return uses the Average Reward formulation (Sutton & Barto, ) hence we denote it as $AR$ and refer to it as “Average Reward”. We begin with $AR=0$. Goals in $G$ can be achieved when $A$ interacts with $U$ in a desired manner. In this paper, rewards are granted when the agent successfully makes a predefined correct tool or API call during a conversation. Figure 1 illustrates an example where the goal set $G$ is composed of multiple correct API calls made within a simulated conversation.

The beam search simulation, in which agent $A$ and user simulator $U$ interact, is detailed in Algorithm 1. The algorithm begins by constructing a tree: the user simulator $U$ initiates the conversation, and agent $A$ generates branching_factor agent responses with a high temperature to encourage variability. Each agent turn $A(l)$ – where $l$ is the leaf node of a conversation trajectory – represents a full response, during which the agent may make API calls or other actions before replying to the user.

Following each agent turn, $U$ generates a response, after which $A$ generates another set of branching_factor turns for each response from $U$. This continues until an agent turn achieves a goal $g$. In the case of Figure 1, the goal is the “First Correct API Call.” The agent turn that achieves this goal becomes the new root, $g$ is removed from the goal set $G$, the Average Reward is increased by $\frac{1}{\textit{len}(\text{Goal Set})}$, and the process repeats. If another turn simultaneously achieves the goal $g$, it is considered partial credit: it does not follow the ideal path but is not considered a negative example either. When the number of branches reaches the max_beam size, only one agent response is generated. This process continues until all the goals in the goal set $G$ are achieved or a maximum number of turns is reached.

In this paper, we branch at the turn level rather than the agent action level, allowing the tree to grow exponentially with the number of turns rather than individual actions (i.e., utterance, thoughts, API/tools). Expanding at the agent action level can quickly exhaust the beam size and demand significantly more resources. By branching at the turn level, we increase the speed of JOSH while reducing costs, as the tree grows more gradually while still yielding useful preference data. However, JOSH is flexible and can accommodate non-turn-based expansion as needed.

### 2.2 Preference Data Extraction

Once Algorithm 1 terminates, we have a tree that resembles Figure 1, from which we can extract training data for both Supervised Fine-Tuning (SFT) and Preference Fine-Tuning (PFT).

For SFT, training data is created by backtracking up the tree from the final successful turn to the initial user-simulated utterance. We refer to this as the “ideal path,” illustrated by following the green agent turns up the tree in Figure 1, starting from the “Second Correct API Call.” This ideal path corresponds to the best agent turns generated to maximize the number of rewards achieved. This data can subsequently be used to train models, guiding them to produce responses that are likely to yield higher rewards. This approach is similar to offline RL with Decision Transformers, where an optimal path is found by conditioning on the reward (Chen et al., ).

For PFT, we use the same tree but additionally take advantage of suboptimal model outputs. We create pairwise data by backtracking through the tree in the same manner as for SFT data extraction. At each user turn along the ideal path, we create a (good, bad) agent turn pair. The “good” agent turn is on the ideal path (green in Figure 1), and the “bad” is the alternative agent turn from that user utterance. If the alternative agent turn also leads to a reward but is ultimately not part of the ideal path, it is not used as a negative example. This paper focuses on using pairwise turns, so agent turns that do not stem from a user turn on the ideal path are not included in the training data.

Preference tuning approaches, such as DPO (Rafailov et al., ), require pairwise model generations. However, since Algorithm 1 creates pairwise turns where the paired turns can contain different numbers of model generations (e.g., an API call and an agent response), we focus on a more flexible training approach, KTO (Ethayarajh et al., ). KTO works by assigning “upvotes” to good examples and “downvotes” to bad examples. Thus, we can still extract pairwise data at the turn level by labeling all agent generations within good turns along the ideal path as upvotes and the alternative turns as downvotes, without needing model generations to necessarily share the same context. For easy reference, we suffix SFT and KTO preference-tuned models by -SFT and -KTO, respectively.

## 3 ToolWOZ

In this section, we introduce ToolWOZ, a dataset designed to train and benchmark an agent’s capabilities in using API tools within a dialogue setting. ToolWOZ features an agent with access to various API tools that allow it to interact with a real database, engaging in dialogue with a user simulator. Each conversation in the dataset is grounded in seed goals, which correspond to specific goal API calls. The dataset incorporates adversarial serving, meaning APIs will return incorrect values unless the arguments are sufficiently close to the goal API arguments. As illustrated in Figure 2, ToolWOZ significantly simplifies the analysis of task-oriented dialogue systems compared to earlier DST systems and the MultiWOZ database.

Figure: Figure 2: MultiWOZ+DST (left) vs. ToolWOZ+Agent (right) paradigmns for Task Oriented Dialogue interactions.
Refer to caption: extracted/5911674/Figures/model_compare_redline.png

### 3.1 Tool-Calling Datasets for End-to-End Dialogue Systems

In recent years, task-oriented dialogue systems were typically developed using a pipeline approach (Ohashi & Higashinaka, ; Mrkšić et al., ; Zhang et al., ). These systems were divided into multiple components, such as intent classification, slot filling, dialogue state tracking, and response generation. Each component was often modeled with a separate machine learning or natural language processing model, and the datasets used to build these systems, such as MultiWOZ, were designed accordingly. These datasets provided detailed annotations, enabling the training and evaluation of individual model components.

However, with the advent of large language models (LLMs), we are witnessing a shift towards more powerful and reliable end-to-end dialogue systems (Wu et al., ; ). These models no longer require breaking down tasks into separate components but instead can handle the entire dialogue process holistically. Consequently, the existing dialogue datasets that were designed for pipeline-based systems are no longer sufficient for developing and evaluating end-to-end models.

Recent research has emphasized improving and assessing tool-calling capabilities in dialogue systems, which has become a critical proxy for task-solving and goal achievement. These systems must seamlessly interact with external tools, such as APIs or databases, to fulfill user requests and complete tasks in real-time.

Building entirely new datasets tailored to this new generation of dialogue systems can be costly and time-consuming. However, we demonstrate that existing datasets like MultiWOZ can be adapted for this purpose. Specifically, we propose transforming MultiWOZ into a tool-calling benchmark, which can drive the development and evaluation of modern dialogue systems in the LLM era. This transformation allows us to leverage the strengths of MultiWOZ while adapting it to meet the requirements of more advanced, end-to-end dialogue models.

Moreover, this approach can be generalized to other existing dialogue datasets, enabling a more cost-effective way to create benchmarks for next-generation dialogue systems. By reimagining these datasets, we can accelerate the development of powerful dialogue systems that can effectively interact with tools and achieve user goals in an efficient and flexible manner.

### 3.2 Creating ToolWOZ

**Table 1: ToolWOZ dataset split sizes. This paper uses the first 450 conversation in the ToolWOZ test set as the official test set.**
| Split | # of Data Points |
| --- | --- |
| Train | 6251 |
| Val | 793 |
| Test | 805 |
| (Official) Test | 450 |
| single-domain dialogues | 2439 |
| multi-domain dialogues | 5410 |

ToolWOZ is a benchmark and dataset designed to evaluate the performance of task-oriented dialogue (TOD) systems with integrated tool-calling capabilities. In this framework, a TOD model acts as an intelligent agent, interacting across multiple domains with a user simulator to assess the model’s ability to effectively make API calls and achieve user goals in real-time, as shown in Figure 2. ToolWOZ stands out in Table 1 as a large, domain-diverse multi-turn dialogue benchmark grounded in real-world APIs, containing 7,849 scenarios across various task-based domains.

The design of ToolWOZ addresses several limitations commonly observed in traditional dialogue datasets. One of the key improvements is a shift from indirect metrics like Inform and Success rates to a more direct one, correct API call metric, which measures whether the system can successfully invoke the appropriate external tools (e.g., APIs) based on user inputs. Furthermore, the framework introduces a seamless integration between dialogue and external databases, which helps avoid inconsistencies between the model’s actions and the database outcomes. This is complemented by the use of a flexible, goal-oriented user simulator, which allows for repeatable and adaptive interactions with the TOD model, further enhancing the evaluation process.

These enhancements collectively make ToolWOZ a robust and reliable framework for benchmarking modern TOD systems, particularly those designed to handle real-time tool interactions in multi-turn conversations.

#### Forming APIs

To create ToolWOZ, we developed APIs for the find (which we refer to as search) and book intents within each of the four MultiWOZ domains that have databases: restaurant, hotel, train, and attraction. Notably, the attraction domain does not include a booking intent. This process yielded the following set of possible APIs: {search_restaurant, book_restaurant, search_hotel, book_hotel, search_train, book_train, and search_attraction}. The arguments for each API correspond to the possible slot values for each domain’s intent, and all arguments are optional. For full API definitions, refer to the Appendix C. Every MultiWOZ conversation has a goal slot value dictionary for every relevant domain and intent. Because API arguments map directly to slot values, we convert each of these goal states into a list of goal API calls per conversation. A goal API $g(x)$ is considered completed if an agent called function $f(y)$ where $x\subseteq y$ or $g(x)$ and $f(y)$ return only one result from the database, which is the same. Thus, for each conversation, we can quantify its success by the percentage of goal APIs that were called by the agent.

Using this method, we achieve a much cleaner, less gameable representation of correctness rather than Success rate, as we no longer rely solely on slot value output. Additionally, Inform rate can be represented through this metric as well because the results of each API are tied to the user simulator’s goals, which it is trying to accomplish sequentially. Thus, if the agent does not communicate the results of the APIs to the user simulator, the conversation will stall, and further goals/correct APIs will likely not be achieved.

#### Seamless database integration

One major challenge in task-oriented dialogue systems is the alignment between dialogue and database outputs, especially in cases where multiple entities meet the user’s criteria. ToolWOZ addresses this by employing an intelligent database-serving algorithm that returns results only when they closely match the goal states for each interaction. This reduces the likelihood of mismatches between the user’s requests and the system’s responses. Additionally, the system ensures that failed searches or bookings are accurately reflected by returning no results in cases where a failure is expected, further enhancing the realism and consistency of interactions.

For booking-related tasks, ToolWOZ maintains per-conversation reference numbers for when a successful booking is made, providing a realistic user experience. The search and booking algorithms, as well as the rules for cleaning database results, are detailed in Appendix B.

#### Simulating Users

Every MultiWOZ conversation also has a list of user goals. We use the user goals to create a goal-oriented user simulator that tries to accomplish the listed goals in order while conversing with the TOD agent. See Section 4.3.

## 4 Experiments

In this section, we detail the experimental setup and results of our study. We evaluate various models and different techniques such as Function Calling (FC) (Schick et al., ) and ACT/ReACT (Yao et al., ), on the ToolWOZ and $\tau$-bench datasets.

### 4.1 Data and Metrics

We evaluate different systems on ToolWOZ and $\tau$-bench (Yao et al., ). Similar to ToolWOZ, $\tau$-bench is a recently introduced tool-based multi-turn dialogue LLM benchmark. We only adopt data from the Retail domain in $\tau$-bench, as it contains both training and test data (Airline domain only contains test data).

We use Average Reward and 100% API Success Rate as the two key elements of evaluation to compare models over ToolWOZ. Following (Yao et al., ), we report Pass^^1 on $\tau$-bench, which uses final database states to measure the binary success of a conversation. Note that the metric is very similar to the 100% API Success Rate, and the major difference is that 100% API Success Rate considers both Read and Write API calls, while Pass^^1 only considers Write APIs. We run $\tau$-bench results 10 times and take the final Pass^^1 score to reduce variance, as discussed in Section 5.1.

### 4.2 Agents

We benchmarked gpt-4o-mini and gpt-4o on both ToolWOZ and $\tau$-bench. We also evaluated gpt-3.5 and meta-llama-3-8B (AI@Meta, ) on ToolWOZ. For gpt models, we explored both Function Calling (FC) and ACT/ReACT (Yao et al., ) techniques, while for meta-llama-3-8B, we used ReACT for all experiments. The prompt used for ReACT models on ToolWOZ is detailed in Appendix Table 8.

Using goal API calls as sparse rewards, we generated JOSH rollouts for models on ToolWOZ across 926 conversations in the ToolWOZ training set. For models on $\tau$-bench, we generated JOSH rollouts for all 500 conversations in the Retail domain training set.

On both ToolWOZ and $\tau$-bench, the JOSH rollout process involved a max beam size of 8 and a branching factor of 2. We do experimentation in section 4.4 to explore other beam sizes. For meta-llama-3-8B, sampling parameters were set at temperature 1.5, top_k=50, and top_p=0.75 to foster diverse generation. For gpt versions, the temperature was set to 1.0. The average cost of running JOSH on a meta-llama-3-8B agent was approximately $0.11 per ToolWOZ conversation, amounting to roughly $102 for all 926 conversations. For training all models, we retained only those conversations whose JOSH rollouts achieved 100% success in the ideal path without errors. For meta-llama-3-8B on ToolWOZ, this resulted in a final filtered training set of 631 conversations.

From these successful JOSH rollouts, we extracted KTO and SFT data as described in section 2.2. For training meta-llama-3-8B SFT, the model was trained for 3 epochs with a learning rate of 2e-5. For meta-llama-3-8B-KTO, the model was trained for 1 epoch with a learning rate of 5e-7 and a beta of 0.1. The meta-llama-3-8B models were trained using Lora and 4-bit quantization. We fine-tuned gpt-4o for 3 epochs, with a batch size of 1, and an LR multiplier of 2.

### 4.3 User Simulators

We experimented with two types of user simulators, both based on gpt-4o: goal-based and guide, to assess their impact on the performance and repeatability of evaluating agents on the ToolWOZ test set. The user simulators were run against different assistant agents, with a temperature setting of zero to ensure deterministic responses.

The goal-based simulator strictly follows the predefined user goals for each conversation, without access to the human-human transcript from the dataset. In contrast, the guide simulator references the MultiWOZ transcript and suggests specific quotes from the original dialogue to simulate a more guided interaction.
Detailed prompts for both simulators are provided in Appendix 9. While we primarily report results based on the goal-based simulator, a comparative analysis of the two simulators is provided in Section 5.

For the $\tau$-bench dataset, we were only able to evaluate the goal-based simulator, as no transcripts are available. As with ToolWOZ, we set the temperature of the underlying LLM models to zero to minimize response variance at test time.

### 4.4 Results

We outline the results of training three models on JOSH rollouts from their respective base models: a smaller meta-llama-3-8B model, gpt-4o-mini, and the larger gpt-4o model. We show that each JOSH trained model variant outperforms their respective baseline variant achieving state-of-the-art performance on both ToolWOZ and $\tau$-bench. Specifically, we show how training on JOSH rollouts makes gpt-4o-FC-JOSH-SFT surpass the vanilla gpt-4o-FC on the $\tau$-bench Retail datasets. Similarly, gpt-4o-FC-JOSH-SFT outperforms the vanilla variant on gpt-4o on ToolWOZ. It is worth noting that JOSH self-alignment can augment gpt-4o ability on tool benchmarks, inspite of gpt-4o already having state-of-the-art ability, being ranked within top 3 on the LM-Sys Chatbot Arena Leaderboard (Chiang et al., ) and top 2 on both HELM (Bommasani et al., ) and 5-shot MMLU (Hendrycks et al., ).

**Table 2: ToolWOZ test set results. Those with -JOSH in the model name were trained on JOSH rollouts using their base model on the first 926 conversations in the ToolWOZ training dataset.**
| Agent | Avg Reward | 100% Success Rate |
| --- | --- | --- |
| meta-llama-3-8B | 0.63 | 0.34 |
| meta-llama-3-8B-JOSH-SFT | 0.74 | 0.50 |
| meta-llama-3-8B-JOSH-KTO | 0.79 | 0.59 |
| gpt-3.5-ReACT | 0.66 | 0.44 |
| gpt-4o-mini-ReACT | 0.67 | 0.48 |
| gpt-4o-mini-ReACT-JOSH-SFT-beam-4 | 0.85 | 0.72 |
| gpt-4o-mini-ReACT-JOSH-SFT-beam-8 | 0.85 | 0.72 |
| gpt-4o-mini-ReACT-JOSH-SFT-beam-16 | 0.865 | 0.74 |
| gpt-3.5-FC | 0.76 | 0.58 |
| gpt-4o-mini-FC | 0.88 | 0.76 |
| gpt-4o-mini-FC-JOSH-SFT | 0.89 | 0.78 |
| gpt-4o-ReACT | 0.900 | 0.791 |
| gpt-4o-ReACT-JOSH-SFT | 0.914 | 0.813 |
| gpt-4o-FC | 0.919 | 0.831 |
| gpt-4o-FC-JOSH-SFT | 0.922 | 0.84 |

On ToolWOZ, the meta-llama-3-8B-JOSH-KTO model saw a 74% increase in 100% Success Rate and a 25% increase in Average Reward compared to the baseline meta-llama-3-8B model, as shown in Table 3. This jump is noticeably even higher than the meta-llama-3-8B-JOSH-SFT model. The meta-llama-3-8B-JOSH-KTO model even outperforms both gpt-3.5-ReACT and gpt-3.5-FC.

We see likewise see a large performance jump from the baseline gpt-4o-mini-ReACT model to it’s JOSH-SFT trained variant, with a 50% increase in 100% Success Rate and a 27% increase in Average Reward. We explore three beam sizes when doing JOSH using gpt-4o-mini-ReACT and note that while a maximum beam size of 16 is marginally better than 8 and 4, we choose to use a beam size of 8 for all other experiments to save cost and efficiency while still taking advantage of a larger beam size.
We also observe that the gpt-4o-FC-JOSH-SFT model outperforms its baseline to achieve state-of-the-art results on ToolWOZ. We note that as gpt-4o-FC performs well on ToolWOZ, the headroom for improvement shrinks and thus performance gains from JOSH is smaller than for other baseline models.

Table 3 tells a similar story on the $\tau$-bench Retail test set.
Over three different prompting options, ACT, ReACT, and FC, gpt-4o sees significant performance jumps when training on JOSH rollouts.
Notably, gpt-4o-mini-ReACT-JOSH-SFT has a 115% increase over it’s baseline score. Also, gpt-4o-FC-JOSH-SFT beats its baseline, the previous state-of-the-art model on $\tau$-bench, gpt-4o-FC.
This significant jump in performance for each model can be seen after only being trained on JOSH rollouts from their respective baselines on the 500 conversations in the $\tau$-bench Retail training dataset.

## 5 Analysis

### 5.1 Agent Performance Stability across User Simulators

Figure: (a) Models trained against goal user simulator on ToolWOZ run against the guide user simulator on the ToolWoz test set.
Refer to caption: extracted/5911674/Figures/std_bootstrap.png

In Figure 3(b) we examined the stability of the ToolWOZ Average Reward metric across two types of user simulators: goal-based and guide-based. Additionally, we assessed the stability of the $\tau$-bench Pass^^1 metric by measuring the standard deviation of benchmark scores as the number of conversations increased using the bootstrapping method (Efron, ). We observe that all three benchmarks exponentially reduce in standard deviation as the number of samples increases. Notably, the ToolWOZ goal simulator has the lowest standard deviation, which drops below 1.5 percentage points at the 450 samples. Based on this observation, we reduced the ToolWOZ test set to 450 examples, utilizing the goal-based simulator to minimize simulation noise. Additionally, the $\tau$-bench dataset has a high standard deviation of about 4 percentage points at it’s test set size of 115. This leads us to run the $\tau$-bench tests 10 times to reduce variability as noted in the previous section.

To ensure robustness and generalization, we further evaluated the JOSH-trained meta-llama-3-8B model using rollouts from the goal-based simulator, by testing it against the guide simulator (as described in §4.3). Table 3(a) demonstrates that the JOSH-trained models consistently outperform the baseline meta-llama-3-8B model, regardless of the simulator used. While the distributions of scores vary between the two simulators (as reflected in Table 3(a) and Table 3), the relative ranking of model performance remains unchanged.

### 5.2 Error Analysis

Training on JOSH rollouts additionally led to a large reduction in errors when running the ToolWOZ test set as shown in Figure 4(b). The JOSH-KTO trained model saw a 96% decrease in incorrectly formatted APIs and a 50% reduction in bad API use (e.g. using nonexistant arguments, using nonexistant apis, …). The JOSH-SFT model also sees a large drop in error rates in both categories, but similar to the reward measurements it does not perform as well as JOSH-KTO.

### 5.3 Generalization of JOSH Fine-Tuned Models

We evaluated the performance of the meta-llama-3-8B models fine-tuned on JOSH rollouts from ToolWOZ across two external benchmarks to assess their generalization capabilities in Table 4(a). In particular, we tested the models on two general-purpose benchmarks—MT-Bench and the LMSYS Chatbot Arena Human Preference Predictions challenge. This evaluation aimed to determine whether training on JOSH rollouts from ToolWOZ impacted the models’ performance on broader tasks.

MT-Bench evaluates chatbots’ general knowledge through multi-turn, open-ended questions, while the LMSYS Chatbot Arena Human Preferences challenge measures models’ human preference ranking capabilities. For LMSYS, we used the first 1,500 data points as the benchmark.

Figure: (a) MT-Bench and LMSYS benchmark performance. JOSH rollouts were done on ToolWOZ.
Refer to caption: extracted/5911674/Figures/error_shorter_name_update.png

We compared the baseline meta-llama-3-8B model, meta-llama-3-8B-JOSH-SFT, and meta-llama-3-8B-JOSH-KTO on both MT-Bench and LMSYS. As shown in Table 4(a), fine-tuning on JOSH rollouts from ToolWOZ did not degrade performance on either benchmark. The models maintained stable performance on multi-domain, multi-turn dialogues (MT-Bench) and human preference ranking (LMSYS).

These results demonstrate that fine-tuning on JOSH rollouts preserves the models’ general capabilities. Despite the specific nature of the ToolWOZ training, models adapted to task-oriented dialogue remain effective on broader large language model tasks, with minimal performance degradation.

## 6 Related Work

Notably, simulation environments with sparse rewards were used by DeepMind in their AlphaGo (Silver et al., ) and AlphaGo Zero (Silver et al., ) works, enabling the two models to achieve superhuman performance in the game of Go. In the AlphaGo works, Monte Carlo Tree Search (MCTS) in a self-play simulation environment is used to intelligently explore the space of next possible moves and long term strategy. Similarly, JOSH treats dialogue as a multi-turn game where it explores possible directions and while using sparse rewards to identify ideal paths through a conversation. JOSH rollouts can then be used to train any LLM for multi-turn tool calling tasks.

AgentQ (Putta et al., ) – a contemporaneous work to this study — is a webagent training and inference process, has similar motivations of self learning using preference data however it has some key differences from JOSH. AgentQ uses MCTS, a self-critique mechanism, and online searching of different pathways, while JOSH is a standalone data extraction algorithm that soley relies on arbitrary sparse rewards. Additionally, AgentQ uses a test time inference strategy while JOSH purely extracts training data for finetuning models, a form of offline RL. JOSH focuses on tool calling multi-turn dialogue while AgentQ is in the domain of navigating web agents. Finally, JOSH training utilizes 100% successful paths to mitigate overfitting on intermediate rewards, while the AgentQ approach requires long horizon exploration to gather preference data.

Other works also explore training LLM agents based on rewards. Approaches such as STaR (Zelikman et al., ), Quiet-STaR (Zelikman et al., ), and Iterative Reasoning Preference Optimization (Pang et al., ) use downstream rewards based on reasoning to train or preference tune models for increased performance at test time. However, these approaches are focused on single turn output performance rather than reasoning in a multi-turn dialogue setting. Some approaches use rewards to train policies to help TOD systems (Hu et al., ; Wu et al., ) or extensive test-time search (Snell et al., ) while JOSH simply produces data to finetune models rather than make test time changes. In this way JOSH is conceptually similar to Decision Transformers (DTs) (Chen et al., ). DTs is a form of offline RL that generates optimal sequences for fine-tuning by conditioning on the rewards, whereas JOSH uses these rewards to select optimal simuation rollouts.

Other approaches use search trees to improve the reasoning of models. Namely Tree of Thought (ToT) (Yao et al., ) and Chain of Preference Optimizaiton (CPO) (Zhang et al., ) focus on optimizing the performance of chain of thought (COT) (Wei et al., ) reasoning. CPO extracts preference data from a search tree exploring COT reasoning, however it uses an LLM to issue rewards at each sentence and is only applicable to single turn reasoning. On the contrary, JOSH uses sparse rewards in a simulaiton environment to solve reasoning problems in the multi-step dialogue domain.

The preference tuning paradigm was first proposed as an easier to replicate direct supervised learning alternative to well-entrenched ”RLHF” paradigm (Ziegler et al., ) of first learning a reward model from preferences and then learning a policy using RL-based approaches such as PPO or REINFORCE. Heralded by the first DPO (Rafailov et al., ), many variants e.g. RS-DPO (Khaki et al., ) and ORPO (Hong et al., ) have emerged. Though early approaches required pairwise data with a contrasting good-bad response pair for a prompt, the KTO formulation (Ethayarajh et al., ) enabled learning from unpaired preferences. Since the preference data we collect is unpaired, we centrally use KTO in this work.

## 7 Conclusions

In this work, we devise JOSH, a self-alignment approach which uses sparse rewards to enable agentic models of all sizes to train themselves.
We show that training on JOSH rollouts significantly increases performance on benchmarks assessing multi-turn dialogue and tool-calling ability while maintaining or improving general model performance.
We show JOSH is general an can be applied to small medium and large models and provide considerable gains in performance.
Notably, we illustrate how frontier models can outperform themselves with JOSH to achieve state-of-the-art results on multiple tool-calling benchmarks.
Additionally, we present ToolWOZ, a multi-turn, tool-calling simulation dataset with sparse rewards to train and evaluate agent LLMs.

## 8 Reproducibility

We have open sourced both the ToolWOZ dataset as well as the JOSH class on GitHub ([https://github.com/asappresearch/josh-llm-simulation-training](https://github.com/asappresearch/josh-llm-simulation-training)). The JOSH class has been designed flexibly, and only requires a step function for an agent and a user in order to begin creating rollouts. The JOSH class also supports a JOSHAgent, JOSHUser, and JOSHRewards base classes to help jump start research and provide an out of the box working solution that can be iterated over. We also provide our implementations for custom JOSH agents on $\tau$-bench. Lastly, we support a parallelized ToolWOZ runner script which allows rapid rollouts of JOSH, fast testing, and supports both local and gpt models.

## Appendix A Appendix

## Appendix B Algorithms

Figure: Algorithm 2 Searching Algorithm

Figure: Algorithm 3 Booking Algorithm

## Appendix C ToolWOZ API Specs

Table: Table 4: API Specifications for ToolWOZ

Table: Table 5: API Specifications for ToolWOZ

Table: Table 6: API Specifications for ToolWOZ

Table: Table 7: API Specifications for ToolWOZ

## Appendix D ReACT Prompt

**Table 8: ReACT Prompt for ToolWOZ. Examples are written by hand anecdotally and not taken from the training dataset. Under this setup, the agent will first craft a Plan, then either optionally call an API or SPEAK to the customer. Speaking to the customer ends the agent’s turn.**
| You are a customer service agent helping a user. |
| --- |
| # General Instructions |
| You have three commands you can use: PLAN, APICALL, and SPEAK |
| Always start with a PLAN message, then always end your turn with either a SPEAK or APICALL message. |
| Your output must include PLAN and APICALL or PLAN and SPEAK. |
| Each command must be on it’s own line. Each line must start with a command. |
| You must always use commands or else your output will be invalid. Always end your turn with a SPEAK or APICALL message. |
| Remeber not to use any of the commands unless you are issuing the command. |
| You MUST finish each command by saying <COMMAND_END> |
| Remember: After each command, say only <COMMAND_END> |
| Here is a description of how you should use each command: |
| ## PLAN |
| Think step by step of what command you will use next and broadly what you should do or say. |
| Write the plan as an internal thought. |
| - PLAN should only contain a plan about what you will do. Keep it conscise, the user will never see your plan, instead use SPEAK to communicate with the customer. |
| - NEVER use PLAN to send a message to the customer. |
| - You MUST use the apis available to you to gather information. NEVER use your own knowledge, you will be penalized. |
| - think step by step |
| - Note: The customer cannot see any PLAN, APICALL, or APIRETURNs |
| - Be thorough but breif, use logic and reasoning to decide what to do next. |
| - After recieving an APIRETURN ERROR, write out the API Definition from API Examples in PLAN so you can format the call correctly! |
| - The SPEAK command ends your turn, so make any APICALLs you need before using SPEAK |
| ## SPEAK |
| - Always use this command to send a message to the user. This is the only way to talk to the user. |
| - PLAN will NEVER be sent to the customer. |
| - Using SPEAK will end your turn, so make any APICALLs you need before using SPEAK |
| ## APICALL |
| - output the name of the api call you’d like to call. You will have the chance to call more apis if you would like, so call one at a time. |
| - ONLY output a json dictionary, NEVER output any additional text (example: APICALL {…} <COMMAND_END>) |
| - Waiting for a response is automatic, NEVER output text relating to waiting for an api response. |
| - APICALLs and whatever they return are not visible to the customer. |
| - Use search api calls to search a database and use book api calls to book results from the search. |
| - NEVER output an api return, it will be given to you after you call APICALL. |
| - If an APICALL fails, you should try other options. NEVER call the same api more than once, espcially if it didn’t work the first time. |
| - After recieving an APIRETURN ERROR, write out the API Definition from API Examples in PLAN so you can format the call correctly! |
| - If a parameter is an ”enum”, those are the ONLY options you can use for that parameter. All other inputs are invalid. |
| You have the following apis available to you. These are the only apis you have: |
| ### APICALL Specific Instructions |
| Given a conversation, an api definition, and an example of the api definition filled in, output a valid json dictionary after APICALL and no additional text. |
| !!! IMPORTANT: You MUST use context clues from the Input to figure out what to assign to each parameter. Never add extra parameters !!! |
| You MUST fill in the parameters based off of the conversation. If a parameter is irrelivant, ALWAYS leave it blank. |
| ### API Definitions |
| Never add more parameters to the following apis. |
| HERE ARE THE APICALLs THAT ARE AVAILABLE TO YOU (with example values filled in): |
| #### API Examples |
| {example_filled} |
| Use the conversation to fill in the api definition. You don’t have to use all of the parameters if you don’t know them. Don’t add any new parameters! |
| If you do not know a parameter, its fine to not include it in the api call. |
| All parameters are optional. |
| Note the apicall must be a valid json dictionary with ’name’ and ’parameters’ keys. |
| ’name’ should be a string with the api name. Must be one of the following names [”book_restaurant”, ”search_restaurant”, ”book_hotel”, ”search_hotel”, ”book_attraction”, ”search_attraction”, |
| ”book_train”, ”search_train”] |
| ’parameters’ should also be a valid json dictionary with each key being an argument. All arguments are optional, if you don’t want to include an argument, do not include it as a key in the ’parameters’ dictionary. |
| Examples: |
| ## Example 1 |
| Input: |
| user: Hi I’d like to see if the hamilton loge up north which has parking, 4 stars, internet, moderate pricerange and a guesthouse is available? |
| Output: |
| PLAN I will look up a hotel using search_hotel. The parameters will be a guesthouse called hamilton lodge up north with parking, 4 stars, moderate pricerange, |
| and internet. <COMMAND_END>APICALL {”name”: ”search_hotel”, ”parameters”: {”name”: ”hamilton lodge”, ”area”: ”north”, ”parking”: ”yes”, ”pricerange”: ”moderate”, ”stars”: ”4”, ”internet”: ”yes”, ”type”: ”guesthouse”}} <COMMAND_END> |
| ## Example 2 |
| Input: |
| user: Can I try to book a hotel for this weekend? |
| Output: |
| PLAN In order to book the hotel using the ’book_hotel’ api, I will need to ask the customer how many people will be coming. <COMMAND_END>SPEAK Sure! How many people will be coming? <COMMAND_END> |
| ## Example 3 |
| Input: |
| user: Hmmm that date isn’t going to work for me, can we try to look for a taxi tomorrow? |
| Output: |
| PLAN I do not know what day tomorrow is, I will ask the user. <COMMAND_END>SPEAK Sure! What day is tomorrow? <COMMAND_END> |
| ## Example 4 |
| Input: |
| user: can you check the trains on tuesday? |
| assistant: PLAN I’m going to look for trains on tuesday <COMMAND_END>APICALL {”name”: ”search_train”, ”parameters”: {”leaveAt”: ””, ”destination”: ””, ”day”: ”tuesday”, ”arriveBy”: ””, ”departure”: ””}} <COMMAND_END> |
| user: APIRETURN [] |
| Output: |
| PLAN It seems there are no trains leaving tuesday, I will tell the customer. <COMMAND_END>SPEAK It seems there are no trains leaving tuesday, does any other day work for you? <COMMAND_END> |
| ## Example 5 |
| Input: |
| user: so I want a train leaving at 8am |
| assistant: PLAN I will find a train leaving at 8am by using the search_train api call <COMMAND_END>APICALL {”name”: ”search_train”, ”parameters”: {”leaveAt”: ”08:00”, ”destination”: ””, ”day”: ””, ”arriveBy”: ””, ”departure”: ””}} <COMMAND_END> |
| user: APIRETURN [] |
| assistant: PLAN There are no trains that leave at 8am, I will tell the customer. <COMMAND_END>SPEAK Sorry, but there are no trains leaving at 8am. Are there any other times you’d like to look for? <COMMAND_END> |
| user: Sure how about 9am? |
| Output: |
| PLAN I will look up a train using the search_hotel api. The parameters will be parking and high pricerance. <COMMAND_END>APICALL {”name”: ”search_train”, ”parameters”: {”leaveAt”: ”09:00”, ”destination”: ””, ”day”: ””, ”arriveBy”: ””, ”departure”: ””}} <COMMAND_END> |
| ## Example 6 |
| Input: |
| user: so I want a train leaving at 8am with 4 stars |
| assistant: PLAN I will find a train leaving at 8am with 4 stars by using the search_train api call <COMMAND_END>APICALL {”name”: ”search_train”, ”parameters”: {”leaveAt”: ”08:00”, ”destination”: ””, ”day”: ””, ”arriveBy”: ””, ”departure”: ””, ”stars”: ”4”}} <COMMAND_END> |
| user: APIRETURN ERROR |
| Output: |
| PLAN The api failed, I will double check the api definition by writing it out. definition: {”name”: ”search_train”, ”parameters”: {”leaveAt”: ””, ”destination”: ””, ”day”: ””, ”arriveBy”: ””, ”departure”:””}. I used a ”stars” parameter which is invalid. Let me redo the api with the correct parameters <COMMAND_END>APICALL {”name”: ”search_train”, ”parameters”: {”leaveAt”: ”08:00”, ”destination”: ””, ”day”: ””, ”arriveBy”: ””, ”departure”: ””}} <COMMAND_END> |
| ## Example 7 |
| Input: |
| user: I want a restaurant in the north |
| assistant: PLAN I will search for a restaurant in the north area using the search_restaurant api call <COMMAND_END>APICALL {”name”: ”search_restaurant”, ”parameters”: {”food”: ””, ”pricerange”: ””, ”name”: ””, ”area”: ”north”}} <COMMAND_END> |
| user: APIRETURN [{…}, {…}, …] |
| assistant: PLAN There are multiple options returned, I will inform the customer and ask them if theres any other constraints they are looking for. <COMMAND_END>SPEAK Ok, I found a lot of restaurants in the north, is there anything else you want? <COMMAND_END> |
| user: Yes I also want it to have room service |
| Output: |
| PLAN I will look up a hotel using the search_restaurant api. The parameters are north area and room service. <COMMAND_END>APICALL {”name”: ”search_restaurant”, ”parameters”: {”food”: ””, ”pricerange”: ””, ”name”: ””, ”area”: ”north”}} <COMMAND_END> |
| ## Example 8 |
| Input: |
| user: Wow what a pretty day! |
| Output: |
| PLAN The user commented on what a pretty day it is. I will reply that I agree. <COMMAND_END>SPEAK You’re right, it is so pretty! <COMMAND_END> |
| ## Final Output |
| Input: |

**Table 9: Goal based user simulator prompt**
| SYSTEM: |
| --- |
| You’re a customer talking to a travel agent. |
| You have the following goals you want to accomplish in the conversation (don’t relay them all at once to the agent): |
| {goals} |
| Discuss with the agent to try and accomplish each one of your goals in order. |
| If the agent fails at an action, check other goals for a backup plan |
| Relay information piecemeal to the agent to encourage conversation. |
| EXCEPTION: Make sure you’ve communicated all the neccessary information for that intent before proceeding with a booking. |
| ALL of your listed goals must be fufilled in order for you to agree to a booking. |
| DO NOT say ¡span class=’emphasis’¿ or ¡/span¿ to the agent. |
| When you want to end the conversation say END_CONVERSATION |
| Always say END_CONVERSATION to hang up! |
| USER: |
| REMEMBER: You are a customer talking to a travel agent. |
| When you want to end the conversation say END_CONVERSATION |
| Always say END_CONVERSATION to hang up! |
| Try to address your next goal or finish the current goal you’re focusing on. |
| Note: if you are looking for a ”place to stay”, don’t refer to it as a hotel unless the goals explicitly state you are looking for a type ¡span class=’emphasis’¿hotel¡/span¿. |
| Don’t relay all the information about your goal to the agent at once. |
| ABOVE ALL ELSE, it is critical ALL of your listed goals are fufilled in order for you to agree to a booking. Double check each of your requirements and tell the agent if one is not met. If you’re not sure, double check. |
| EXCEPTION: Make sure you’ve communicated all the neccessary information for that intent before proceeding with a booking. |
| If the agent fails at an action, check other goals for a backup plan. |
| Remeber, you are the customer. |
| CUSTOMER: |

**Table 10: Guide based user simulator prompt**
| USER: |
| --- |
| You are a coach giving tips to a user simulator trying to replicate a conversation as consistently as possible. The user simulator is in the middle of a conversation, give it advice on what to do in the next turn. |
| Consistency means that over multiple runs, the user simulator should behave in the exact same way, it is your job to try and help it stay on the same trajectory every run. |
| ###### Grounding Goals and Conversation ######### |
| Customer goals: |
| goals |
| The following is the source conversation the user simulator is trying to replicate: |
| {goal_convo} |
| ################################################### |
| ######## CURRENT (real) Conversation ####################### |
| This is the CURRENT conversaiton the user simulator is having: |
| {current_convo} |
| Use your best judgement if the conversation is not going well, it’s possible the agent is not good enough and you need to end the conversation. End the conversation by putting END_CONVERSATION after your quote. |
| Keep in mind the Customer goals all must be communicated in order to give the agent enough information to properly search and book. |
| It is critical you give consistent advice over multiple iterations of the same conversation. The best way to do that is to ground your response in the source conversation and providing quotes whenever possible. |
| Please write breif advice on what the user simulator should say in order to keep it consistent and aligned with the source conversation. Write this advice to the user simulatior, referring to it as ”you”. No yapping.: |
| Example: |
| Advice: |
| The user should … |
| Suggested quote: |
| ”Hello, how can I help you?” |
| Advice: |
| The conversation should be ended |
| Suggested quote: |
| ”Thanks, goodbye” END_CONVERSATION |
| Output: |

## Appendix E Effect of Changing the User LLM behind MultiWOZ

We do a restricted pair of experiments ablating for the user LLM behind MultiWOZ used for evaluation at test time, to check whether the JOSH aligned models still maintain their advantage over the vanilla Llama3-8B-instruct one. We use gpt-4-turbo as the alternative user LLM.

The results are indeed positive. We find that JOSH-KTO gets average return 0.72 compared to 0.498 for the vanilla model.

## Peer Reviews

confidence: 3
contribution: 2
initial_rating: 5
presentation: 3
questions: * How does JOSH compare to other sparse reward-based alignment or self-improvement approaches?
* Could strategies like reflection, which are often beneficial for tree-search and multi-turn tasks, enhance JOSH’s effectiveness if integrated?
soundness: 2
strengths: * This paper presents a novel approach to self-alignment in dialogue agents using sparse rewards, reducing reliance on costly human feedback.
* ToolWOZ fills a gap in existing evaluation frameworks by focusing on tool usage in multi-turn dialogue settings, adapting MultiWOZ to emphasize real-world API interactions.
* JOSH demonstrates significant improvements in success rates and tool-call accuracy, particularly for smaller models, validating its effectiveness.
summary: The paper introduces JOSH (Juxtaposed Outcomes for Simulation Harvesting), a self-alignment framework for large language model (LLM) agents to enhance multi-turn dialogue capabilities without human feedback, addressing the impracticality of traditional feedback-driven methods. JOSH leverages sparse reward signals within simulated dialogues to allow the model to self-improve, specifically targeting multi-turn tool-calling skills in task-oriented dialogues. The authors also introduce ToolWOZ, a dataset and benchmark based on MultiWOZ 2.0, designed to evaluate tool-usage in dialogue settings. Experimental results demonstrate that a fine-tuned LLaMA-3B model exhibits a 74% increase in Success Rate, and gpt-4o also shows improvements following JOSH self-alignment. Additional experiments on other public benchmarks indicate that JOSH does not degrade the model’s general performance.
weaknesses: * The paper does not assess how well the user simulator aligns with real human interactions.
* The evaluation of API calls lacks depth, as it does not separate analyses of API names and parameters.
* The design of the average reward function is not thoroughly examined, missing a discussion of alternative reward structures and their potential effects on agent behavior.
* The related work section does not cover relevant advancements in language agents for multi-turn dialogues.

---

confidence: 4
contribution: 2
initial_rating: 5
presentation: 2
questions: As in weaknesses
soundness: 2
strengths: 1. The JOSH approach is a new solution for self-training dialogue agents, effectively utilizing sparse rewards to build a self-improvement feedback loop without external human evaluation.
2. By adapting MultiWOZ into ToolWOZ with a sparse reward structure, the paper provides a valuable benchmark tailored for tool-using task-oriented dialogue systems, which can benefit further research.
3. Results indicate that JOSH significantly improves models across benchmarks, demonstrating its potential as a scalable solution for optimizing agent interactions in multi-turn dialogue settings.
summary: This paper introduces a self-alignment approach called Juxtaposed Outcomes for Simulation Harvesting (JOSH), designed to improve dialogue agents in multi-turn, tool-calling tasks by leveraging sparse rewards. The authors propose ToolWOZ, a new simulation environment derived from MultiWOZ, for training agents to make correct API calls based on sparse reward feedback. The JOSH method aims to allow models, including smaller LLMs, to improve autonomously without relying on extensive human feedback, which is increasingly challenging to obtain as models advance.
weaknesses: 1. The concept of the "goal set" in sparse rewards is insufficiently defined, particularly how it influences the agent’s behavior and the implications of duplicating actions in a path.
2. The choice to branch at the turn level rather than the agent action level lacks a comprehensive rationale, leaving questions about its impact on computational efficiency and performance outcomes. In multiwoz dataset, the agent predicts dialogue act in each turn. The delexiclized response is then generated. The slots values are then filled in the delexiclized response to yield the final response. This process is clearly different from the one illustrated in Figure 2. 
3. While considerable effort is spent on detailing ToolWOZ, the sparse reward process and its precise mechanics within JOSH are not thoroughly elaborated, reducing clarity around its contribution to the results.
4. The baseline comparisons are primarily limited to supervised fine-tuning (SFT) and variants of the sparse reward approach itself. To better contextualize the efficacy of JOSH, comparisons with other RL-based methods, particularly those designed for dialogue or tool-calling tasks, would be beneficial.

---

confidence: 2
contribution: 3
initial_rating: 6
presentation: 3
questions: See weaknesses.
soundness: 3
strengths: * They propose both a novel method and a benchmark, but they also make sure to evaluate on an existing benchmark to enable more robust comparisons.
* They conduct good analysis to demonstrate the robustness and viability of their benchmark.
* Their method demonstrates good performance gains on the tasks they study.
* The paper is overall well written and easy to follow.
summary: They propose both a benchmark and a method for training multi-turn tool use dialogue agents. Their method uses beam search to find successful trajectories and uses failed paths in the beam search as negative examples. They finetune an LM on these successful/unsuccessful pairs with KTO. The benchmark is called ToolWOZ, which re-purposes the popular dialogue systems benchmark MultiWOZ to a more native LM tool use format. They evaluate their method on both ToolWOZ and another standard benchmark tau-bench. They find that their method substantially improves LLaMA 3-8B's success rate on both benchmarks. They also conduct evaluations of the robustness of each benchmark by analyzing the standard deviation of the results, finding ToolWOZ with the goal simulator to give the lowest standard deviation. Finally, they conduct some error analysis of their approach on ToolWOZ.
weaknesses: * Their method feels a little ad-hoc. Yes, it makes sense to build off-policy preference pairs for training these models, but there are numerous ways this could be achieved and its unclear why the specific methodological decisions made in this paper are the correct ones.
* They compare to an SFT baseline, but not other RL-inspired approaches for finetuning agents, so it is unclear how well their approach compares against stronger baselines.

---

confidence: 4
contribution: 2
initial_rating: 5
presentation: 2
questions: How much does it cost to finetune 4o?
soundness: 2
strengths: The proposed method is evaluated on different model backbones, even gpt-4o

The curated benchmark is useful to the community.

The presentation is mostly clear and easy to follow.
summary: This paper introduces JOSH, a self-training framework designed to enable agentic models to achieve self-alignment. The core component of JOSH is the data rollout pipeline, where an agent first interacts with a GPT-based simulator to generate multi-turn conversations that involve tool-calling responses. A critical aspect of this process is the use of beam search to create a tree-structured trajectory. From this trajectory tree, they extract SFT and preference data for subsequent fine-tuning. To evaluate JOSH, they have also curated a multi-turn tool-calling benchmark called ToolWOZ.
weaknesses: The primary weaknesses of this paper lie in its novelty and the experimental validation.

Novelty: The proposed framework is not particularly novel, as it builds upon concepts that have been extensively studied within the community. Techniques such as data rollouts, beam search, and supervised/preference fine-tuning have all been well-explored in prior works.

Experiments: This paper evaluates JOSH using only a single benchmark and does not provide comparisons with other robust baselines. There are numerous multi-turn tool-calling and agentic benchmarks available, such as WebLinx[1] and MINT[2]; conducting experiments on multiple benchmarks would significantly strengthen the validity of the results. Furthermore, there are several highly similar methods in this domain, such as [3,4], which should be considered as baselines to effectively demonstrate the true performance of JOSH.


[1] WebLINX: Real-World Website Navigation with Multi-Turn Dialogue
[2] MINT: Evaluating LLMs in Multi-turn Interaction with Tools and Language Feedback
[3] Trial and Error: Exploration-Based Trajectory Optimization for LLM Agents
[4] V-STaR: Training Verifiers for Self-Taught Reasoners

Meta-review: This work proposes an LLM self-training approach based on sparse reward simulation. The authors also plan to release their code and data. The reviewers appreciate the general idea of this work, the value of the ToolWOZ benchmark to the community, the performance improvements achieved, and the clarity in presentation. Concerns are also raised, however, primarily regarding experimental validation, the design of the simulator (validity, reward function and API call design) as well as concerns around novelty and relation to existing works. The authors provide extensive and detailed responses but the reviewers are not convinced.

Decision: Reject