Source-linked AI summary
User-Oriented Multi-Turn Dialogue Generation with Tool Use at scale
Jungho Cho, Minbyul Jeong, Sungrae Park
TL;DR
Existing agent datasets are limited by static tools and short, task-solving trajectories that poorly capture iterative human–agent collaboration. The paper introduces a modular user-oriented simulation framework with dynamic tools, incremental interaction, and execution grounding. It reports stronger long-horizon agent performance and more reliable tool use, while requiring higher computational cost and facing execution-alignment and state-recovery challenges.
Problem
Existing datasets and generation approaches rely on static toolsets and minimal-turn trajectories, limiting their representation of open-ended, iterative human–agent collaboration.
Method
The framework dynamically synthesizes tools and tasks, decouples objectives from interaction through a user simulator, and supports plug-and-play generation from arbitrary states.
Results
The user-oriented pipeline with tool execution improves long-horizon agent performance, with stronger results on τ2 and its Telecom domain and more reliable tool use on agentic benchmarks.
Takeaways & Limitations
Execution-grounded, user-oriented interaction modeling supports verifiable, high-density trajectories that reflect iterative and multifaceted human–agent communication.
Takeaways & Limitations
The multi-turn execution-grounded pipeline consumes more tokens and processing time, while quality depends on environment consistency and accurate long-horizon state tracking.
Abstract
from arXiv · showhide
The recent paradigm shift toward large reasoning models (LRMs) as autonomous agents has intensified the demand for sophisticated, multi-turn tool-use capabilities. Yet, existing datasets and data-generation approaches are limited by static, predefined toolsets that cannot scale to the complexity of open-ended human-agent collaboration. To address this, we initially developed a framework for automated task-oriented multi-turn dialogue generation at scale, utilizing an LRM-based simulator to dynamically generate high-value, domain-specific tools to solve specified tasks. However, we observe that a purely task-oriented design often results in "solely task-solving" trajectories, where the agent completes the objective with minimal interaction, failing to generate the high turn-count conversations seen in realistic scenarios. To bridge this gap, we shift toward a user-oriented simulation paradigm. By decoupling task generation from a dedicated user simulator that mimics human behavioral rules - such as incremental request-making and turn-by-turn feedback - we facilitate more authentic, extended multi-turn dialogues that reflect the iterative nature of real-world problem solving. Our generation pipeline operates as a versatile, plug-and-play module capable of initiating generation from any state, ensuring high scalability in producing extended tool-use data. Furthermore, by facilitating multiple task completions within a single trajectory, it yields a high-density dataset that reflects the multifaceted demands of real-world human-agent interaction.
1 Introduction
The paper addresses limited, static tool-use data and short, task-solving trajectories by introducing user-oriented simulation for extended, realistic interactions. Its modular pipeline dynamically creates tools, supports arbitrary starting states, and produces high-density trajectories, with stronger multi-turn benchmark performance reported.
- Motivation: Static toolsets and single-shot data-generation pipelines inadequately represent open-ended, iterative human–agent collaboration.Agents trained under fixed schemas may struggle with unfamiliar tool compositions, while minimal-turn trajectories omit clarifications, incremental requests, and feedback.
- Initial framework: A task-oriented LRM simulator dynamically synthesizes domain-specific tools, database schemas, tasks, and evaluation rubrics at scale.The simulator increased data volume but tended to complete objectives in the minimum number of turns.
- User-oriented paradigm: A dedicated user simulator issues incremental requests and turn-by-turn feedback, decoupling the task objective from the interaction.These behavioral rules encourage extended dialogue rather than immediate task completion.
- Scalability: The plug-and-play pipeline can initiate generation from any state and support multiple task completions within one conversation thread.This produces high-density data reflecting multifaceted real-world sessions.
- Results: Models trained on the generated data show stronger multi-turn performance and more reliable tool use on BFCL and τ2, especially in long-horizon and stateful domains.Repeated-execution analysis also reports sustained correct tool-use behavior across trials.
2 Related Works
Related work has progressed from constrained, fixed-tool interaction toward dynamic tool creation and specialized agent training, but existing approaches still inadequately model coherent, iterative dialogue. The paper positions its modular, plug-and-play framework as a response to these limitations.
- Reasoning Models and Tool-use Benchmarks: Early tool-use benchmarks emphasized single-turn invocation or static API selection within constrained domains.
- Evolution of Tool-use Agents: Tool-use agents evolved toward autonomous orchestration, but fixed toolsets limited adaptability to open-ended tasks.
- Evolution of Tool-use Agents: Recent work explores dynamic tool creation and training strategies such as critique-informed planning, selective reasoning, and decoupled format following.
- Synthetic Dialogue Generation for Agents: Synthetic dialogue methods commonly rely on fixed trajectories, predefined toolsets, and rigid schemas that omit ambiguous intents and incremental feedback.
- Synthetic Dialogue Generation for Agents: The proposed pipeline separates generation into independently replaceable stages and supports high-density, extended dialogues from arbitrary states.The design incorporates incremental requests, iterative feedback, dynamically generated tools and schemas, and verifiable interactions.
3 Task-Oriented Multi-turn Generation
The task-oriented pipeline constructs executable tool-use data through dynamic tool preparation, rubric-based task generation, simulated responses, and validation. Although scalable and verifiable, it remains biased toward efficient completion with minimal interaction.
- Pipeline overview: The end-to-end pipeline automates tool creation, task generation, response generation, and validation as a plug-and-play process.Components can be swapped by modifying input-output formats, supporting diverse domain-specific data generation.
- Tool preparation: Tool preparation begins from a minimal seed tool and expands it into diverse, realistic tools grounded in practical user questions.
- Tool preprocessing: Each generated tool receives an explicit JSON return schema through conversational preprocessing to support structural and semantic consistency.The process maintains input-output consistency across previously defined tools and shared entities.
- Task generation: Structured tasks are categorized as easy, medium, or hard and include rubrics specifying success criteria, expected tool-use patterns, and intermediate checkpoints.These elements enable objective step-level verification and encourage multi-step interactions.
- Response generation: An LRM-based simulator generates synthetic tool-execution results conditioned on arguments and evolving conversation context.A randomized reference time is maintained while user-specified temporal information receives priority.
- Validation: Validation filters trajectories against semantic correctness and required tool invocations, retaining successful high-density interactions.The task-oriented pipeline nevertheless tends to produce efficient, minimally interactive task-solving trajectories.
4 User-Oriented Multi-turn Generation
The user-oriented paradigm extends tool-use dialogues by modeling incremental user behavior and grounding interactions in executable database environments. Its modular pipeline supports coherent, high-density trajectories with multiple task completions and generation from arbitrary states.
- Motivation: The task-oriented simulator often completed complex objectives in a single turn, producing efficient trajectories that missed incremental and iterative human–agent interaction.This efficiency trap motivated the shift to user-oriented simulation.
- User-oriented simulation: The proposed paradigm separates descriptive objectives from interaction and uses a dedicated user simulator to issue one or two subtasks per turn.The simulator is governed by behavioral rules that encourage intermediate reasoning, clarification, and verification.
- Task grounding: Tasks are grounded in database schemas and partial data views so generated objectives remain feasible for supported operations such as reading, updating, and combining records.Uncertain information is framed for later retrieval or confirmation through tool use.
- Scalability and density: The modular pipeline can begin from arbitrary intermediate states and supports multiple related task completions within one conversation while preserving state changes across turns.These properties enable high-density trajectories reflecting sequences such as querying information, updating records, and requesting summaries.
- Executable tool use: Executable SQL-backed tools run against controlled relational databases, returning computationally verified outputs that maintain intermediate states across dialogue turns.This replaces reliance on synthetic tool outputs with real execution during generation.
5 Experiments
The experiments evaluate fine-tuned models on τ2 and BFCL using a high-density dataset built from expanded tools, executable schemas, and multi-task trajectories. Across benchmarks and model scales, user-oriented data improves multi-turn performance, with execution-grounded supervision providing the strongest results.
- Experimental Setups: The evaluation uses τ2 and BFCL to test robustness to incremental requests, coherent multi-turn interaction, and function calling.The models include two Qwen-family reasoning models at different scales.
- Experimental Setups: The dataset expands NEMOTRON seed tools and τ2 tasks into diverse domain-specific toolsets, executable database schemas, and multi-task conversations.The generated trajectories frequently contain multiple task completions within a single multi-turn conversation.
- Experimental Results: Models trained on user-oriented synthetic data outperform APIGEN and NEMOTRON baselines across both BFCL and τ2.The comparison covers models fine-tuned with different data-generation pipelines.
- Experimental Results: Gains are most pronounced on τ2, where user-oriented data improves tracking of goals, persistent state, and tool-calling strategies over extended dialogues.This pattern holds for both Qwen3-4B and Qwen3-30B.
- Experimental Results: User-oriented simulation with execution-grounded supervision produces the strongest overall results, particularly in Telecom, while BFCL accuracy remains stable or improves slightly.Executable tool outputs are associated with more faithful tool selection and error recovery in stateful interactions.
6 Analysis
The analysis examines generation efficiency and repeated-execution consistency. User-oriented generation costs more but produces more sustained correct tool use across domains and trials.
- 6.1 Generation Efficiency: User-oriented generation has higher latency and lower throughput than task-oriented generation because it requires longer, more complex multi-turn interactions.Latency is average wall-clock seconds per sample; throughput is aggregate generated tokens per second across GPUs.
- 6.2 Consistency of Tool Usage: Pass^k measures how often a model correctly completes the same task across repeated attempts under identical conditions.The metric is used to assess consistency rather than one-off success.
- 6.2 Consistency of Tool Usage: Models trained with the proposed pipeline achieve consistently higher Pass^k values across Retail, Airline, and Telecom.The results indicate that correct tool usage is sustained across multiple trials rather than isolated executions.
- 6.2 Consistency of Tool Usage: Consistency gains are especially pronounced in stateful, interaction-heavy domains such as Telecom, where repeated execution requires tracking intermediate states and user intent.The analysis connects repeated correctness with stable tool-use behavior across turns.
- 6.2 Consistency of Tool Usage: Pass^k analysis indicates that the training data encourages tool-use strategies that generalize across repeated attempts.The evaluation targets reliability under repeated real-world usage rather than isolated successes.
7 Conclusion and Discussion
The paper presents a scalable user-oriented simulation framework that generates verifiable, high-density trajectories for realistic multi-turn tool use. Results associate user-oriented simulation and executable tools with stronger long-horizon performance, especially in Telecom, while identifying important deployment trade-offs.
- Conclusion: The plug-and-play framework generates high-fidelity, high-density trajectories from realistic, iterative user-agent communication.Its modular design supports verifiable interactions and multiple task completions within trajectories.
- Discussion: User-oriented generation with tool execution is associated with substantial gains on τ2 and its Telecom domain.The conclusion highlights these results as evidence for improved long-horizon agent performance.
- Discussion: Execution-grounded supervision appears to encourage faithful tool selection, state tracking, and recovery behavior when actions modify persistent state.This discussion point is framed particularly for environments with persistent state.
- Discussion: The SQL-based executable pipeline extends realistic stateful tool use beyond handcrafted benchmarks, but its effect on cross-domain generalization remains open.The paper explicitly leaves cross-domain generalization as an unresolved question.
Limitations
The user-oriented and executable pipeline improves realism but introduces computational, environmental, and robustness constraints. Its scalability and generalization therefore remain bounded by generation cost, environment consistency, and partial database visibility.
- Computational Cost: User-oriented generation requires multiple simulator-environment interaction rounds, increasing computational cost and latency relative to task-oriented generation.The added interaction is intended to capture incremental human collaboration.
- Environment Dependence: Execution-grounded generation couples dataset quality to precise alignment between synthesized database schemas and agent tool-calling logic.State-tracking discrepancies during long-horizon interactions can propagate errors.
- Robustness: The executable pipeline becomes more brittle under partial database visibility.This brittleness is listed as a challenge introduced by increased realism.
C Domain Visualization of SQL-based Tool-execution Data
The pipeline grounds dynamically generated tools in executable relational databases and SQL queries, enabling verified interactions across diverse practical domains. Persistent state changes support coherent, adaptive multi-turn trajectories.
- The framework maps generated domain-specific functions to complex SQL queries over executable relational databases.It uses diverse schemata from open-source datasets such as Spider.
- Real-time interaction with a functional database engine computationally verifies tool outputs and supports factual accuracy.
- The generated data spans a wide array of practical domains, visualized through a SQL-backed word cloud.
- Persistent state changes from updates and queries help maintain coherence across multifaceted, multi-turn scenarios.
D Qualitative Examples of Generated SQL Tool-use Data
Qualitative SQL-based examples demonstrate that the pipeline generates diverse, high-fidelity multi-turn dialogues involving complex schemas, valid queries, intent interpretation, and conversational context.
- The examples target SQL tasks requiring interpretation of user intent, complex database schemas, and conversational context across multiple turns.
- The generated SQL queries follow valid syntax in a financial or sales database scenario.
- The qualitative samples confirm diverse, high-fidelity data that mimics complex human-agent collaboration in data-intensive domains.
F Evaluation Details
Evaluation uses realistic dual-control interaction and function-calling benchmarks, with Pass@1 reported for the costly API-based evaluation.
- The τ2 benchmark evaluates agent-user interaction under dual control across five realistic domains, excluding the unstable Mock domain.Reported domains include Airline, Retail, and Telecom.
- Pass@1 is reported because API-based evaluation is costly.
- BFCL evaluates function-calling performance on 5,088 samples with diverse tool schemas and interaction patterns.
G Preliminary Experiments
Preliminary analysis finds that existing tool-use datasets vary in scale but remain concentrated or sparse across categories and domains. The framework addresses these patterns by generating diverse, high-density, multi-turn data and non-trivial tools.
- Category Counts: BFCL has concentrated high-quality tool schemas, while Nemotron scales in volume but spikes sharply in specific categories.
- Domain Sparsity: Embedding projections show sparse or isolated domains in static datasets, motivating high-density trajectories that bridge domains within one session.
- Domain Visualization: Nemotron’s semantic visualization contains a substantial generic Others cluster, while filtering it reveals the specialized-domain distribution.
- Question Generation: The framework generates domain questions spanning capabilities, user types, workflows, complexity levels, edge cases, and realistic constraints.
- Tool Expansion: Generated questions guide detailed tool specifications with names, descriptions, and parameters, while functional-gap analysis proposes up to ten complementary tools.
- Usefulness & Non-Triviality: Tool proposals exclude simple helpers, basic formatters, redundant wrappers, and functions lacking substantive domain logic.
- Initial Understanding: The interaction policy begins with the first essential request and handles subtasks step by step rather than combining them prematurely.