WRIT: Write-Read Intensive Trajectory Synthesis for Multi-Turn User-Facing Agents

arXiv:2606.02908 · cs.CL, cs.AI · Submitted 2026-06-01 · Read on arXiv

Listen

Radio episode about this paper

Transcript

Introduction to the show: ident: AI Radio. Generated commentary on the latest Artificial Intelligence papers.

Tom: Today's paper: "WRIT: Write-Read Intensive Trajectory Synthesis for Multi-Turn User-Facing Agents".

Jane: Multi-turn user-facing agents require synthesizing complex training trajectories that capture both long-horizon execution and evidence-grounded decision making.

Tom: First, who's behind it and why it matters.

Paper summary: Tom: So we're diving into this paper today titled "WRIT: Write-Read Intensive Trajectory Synthesis for Multi-Turn User-Facing Agents," which sounds like it tackles a really tricky part of training these agents, right? It focuses on creating training trajectories that are complex in two specific ways.

Jane: Exactly, Tom. The core idea here is that we need to train agents not just on long sequences of actions, but also on making decisions when they have to sift through a lot of information before they can even decide what to write next. This paper argues that just focusing on how many steps an agent takes isn't enough for truly robust multi-turn agents.

Lu: From my perspective, the most interesting part is how they split complexity along these two axes: the number of write decisions and the evidence burden for each decision. They show that balancing these two factors creates a training experience that prepares agents for both long-horizon execution stability and heavy evidence grounding under high information load.

Meng: That makes sense conceptually, Lu, but what does this actually mean in practice for an engineer building something? Are we talking about more complex prompts or just different types of data we feed the agent during training?

Lalam: I think the most impactful vision here is how this synthesis helps us build agents with superior reasoning capabilities. If we can train them to handle situations where a single write action requires comparing multiple read tool outputs, that directly translates into an agent that's much better at making grounded decisions in real-world scenarios.

Tom: That’s what I mean, Lalam; it moves us beyond just training sequential execution paths and into training the actual decision-making quality itself. Jane, can you explain the two axes they are using to make these trajectories harder?

Jane: Absolutely. The first axis is about the number of write decisions in a task, which creates what they call "write-heavy trajectories" that train agents on long-horizon sequential decision making. Then there's the second axis, which is about the evidence burden of a single decision, producing "read-heavy trajectories" where one write action needs the agent to collect and compare multiple read tool outputs before its arguments become identifiable.

Lu: They use this framework to synthesize tasks that teach agents both long-horizon execution stability and evidence-intensive grounding under high information load. It’s a way of ensuring the training data isn't biased toward just one type of difficulty; it covers both aspects simultaneously.

Paper summary: Meng: When you look at the methodology described, they are generating these intensive tasks by creating branches for write-intensive tasks, like basic business logic involving steps such as "Write prototype discovery" and "Valid argument instantiation." Then there’s the read-heavy branch where they generate perturbed variants of a gold read call to form an evidence pool.

Lalam: I see how that works; they're explicitly constructing these scenarios. For example, in the read-heavy branch, they make sure the user request requires consulting that entire evidence pool to uniquely identify the correct argument for a single write action. That’s where the real pressure is applied to grounding.

Tom: It sounds like they are systematically designing scenarios where a single output depends on extensive prior reading, which is something existing methods couldn't capture effectively on their own. So, how do they actually ensure these synthesized tasks are useful? What happens after they build these complex scenarios?

Jane: The WRIT pipeline goes through three stages. First, it synthesizes write-read intensive tasks with known correct outcomes that span both the write-intensive and read-intensive branches. Second, it designs user behavior instructions to diversify how the user expresses the same underlying task across different trajectories.

Lu: That second step of diversifying user behavior is crucial for robustness; it ensures that agents aren't just memorizing one specific way to respond but are learning general principles of interaction style through things like "Progressive disclosure" or "Policy-robustness primitives."

Meng: From an engineering standpoint, I’m curious about the simulation part. How do they actually run these tasks? Is it just feeding them inputs and checking if the final state matches the gold final database state, or is there more to that execution process?

Lalam: The simulation happens in an executable environment where the user simulator follows those instructions, and then we filter for successful interactions to keep only the complete training trajectories. This ensures we are only using data where the agent actually achieved what was intended in those complex settings.

Tom: That filtering step is key because it curates a corpus of demonstrations that systematically covers both axes of complexity they defined earlier. It’s not just generating hard examples; it’s making sure the resulting training set is balanced for both long-horizon and evidence-intensive reasoning.

Jane: And the evaluation showed that WRIT consistently outperforms prior trajectory synthesis methods across all three tested models on the tau squared-bench using a 2K-trajectory training budget against strong synthetic-data baselines <ref:2606.02908#pg0>. Specifically, it shows large gains on read-heavy task subsets.

Paper summary: Lu: The ablation studies confirm that both the read-heavy task synthesis and the user behavior diversification contribute independently to this improved performance, which suggests that mixing these complexity types systematically yields more capable agents than focusing on just one aspect alone.

Meng: That result is significant because it validates the idea that a carefully structured set of trajectories balancing write-intensive and read-intensive complexity can produce better agents, not just harder ones. It gives us a concrete path forward for designing training data.

Lalam: And on the practical side, they pointed out that WRIT approaches strong API agents with substantially lower inference cost compared to models like GPT-five point one no-think, suggesting it transfers the required behavior into SFT for efficient agent behavior at inference time <ref:2606.02908#pg1>. That efficiency is a huge win for deployment.

Tom: So we've talked about how they synthesize these complex training trajectories and what those initial results tell us about their effectiveness against other methods. Now we need to think bigger about where this work goes next, particularly concerning the implications of WRIT: Write-Read Intensive Trajectory Synthesis for Multi-Turn User-Facing Agents.

Jane: I agree, Tom; it’s important to unpack what this title and the authors actually mean for the future of building multi-turn AI agents that interact with users. It moves us beyond just making agents follow instructions sequentially in a simple manner.

Lu: The implication is that we can now create training data that explicitly models the kind of heavy information processing agents need to handle real user interactions effectively, specifically when those interactions require deep evidence comparison before any action is taken.

Meng: For me, the impact lies in making our deployed AI agents more resilient when faced with ambiguous requests or requests requiring external information gathering. If an agent can be trained to reliably sift through a pool of retrieved data to make a sound decision, that’s where the real operational value comes from.

Lalam: From my view, this work impacts the culture of AI development by showing that we don't just need bigger models; we need smarter training strategies that deliberately build in complexity around how those models use tools and information during conversation.

Tom: That’s a big picture thought, Lalam; it shifts the focus toward designing the learning process itself rather than just optimizing the model weights in isolation. Jane, can you give us a simple way to frame this for our listeners?

Paper summary: Jane: Certainly. Think of it like training a chef. Instead of just showing them one recipe at a time—a write-intensive task—WRIT shows them many recipes where every single step requires them to check multiple ingredient lists and compare quality reports before they can start cooking the main dish, which is the read-heavy element.

Lu: That analogy captures the essence well; it’s about training for complex decision points where information gathering is as critical as generating a final output. The authors are showing that this two-axis complexity approach creates a richer learning environment for these agents than just long sequences of simple actions.

Meng: I wonder if this synthesis method could be adapted to other domains beyond booking flights, like complex technical troubleshooting or detailed legal document analysis, where the evidence required is massive and the sequence of necessary steps is long.

Lalam: If we can apply this to those areas, it could dramatically improve how AI assists in highly specialized fields because it teaches the agent to manage that high information load gracefully during a multi-step interaction.

Tom: It sounds like the future of trajectory synthesis isn't just about making paths longer; it’s about making those necessary decision points inherently more demanding in terms of evidence processing. So, we see WRIT as a method that systematically structures training to build agents that can handle real-world information complexity.

Jane: Exactly, Tom; the WRIT framework provides a systematic way to generate training data that forces agents to develop both long-horizon execution stability and the ability to perform deep grounding when facing substantial amounts of external evidence.

Lu: And looking ahead, the authors themselves acknowledge that they haven't fully explored how different types of complexity might mix, like creating multi-write tasks where each decision point is also read-heavy. That opens up a whole new avenue for future research into even more intricate synthesis strategies.

Meng: That limitation is important; understanding how those combinations interact would help us engineer training data that mimics the most chaotic or complex real-world agent interactions we might encounter.

Lalam: And ultimately, this paper contributes to a cultural shift where we recognize that the structure of our training environment profoundly dictates the capability of the final AI agent in complex, multi-turn scenarios.

Tom: That’s a solid way to wrap up our discussion on WRIT; it seems like they’ve laid some very clear groundwork for how we design more capable agents for these intricate user-facing roles.

Conclusion: Tom: So we’ve seen how WRIT tackles training agents by designing trajectories that force them to handle both long sequences of actions and deep evidence gathering, but now let's talk about what that title actually means for the industry.

Jane: Exactly, Tom; the name WRIT tells us it's all about synthesizing those complex training paths where writing and reading are both heavy parts of the job. The authors are showing how you can engineer training data to specifically prepare agents for multi-turn conversations that demand a lot from their reasoning skills simultaneously.

Lu: From my perspective, this is wild because they’re not just making tasks longer; they’re deliberately making the decision points themselves much harder by layering in evidence requirements on top of the sequential steps. It suggests a new way to think about how we structure agent learning environments.

Meng: I'm thinking practically about that difficulty; it means we can train agents to be much more reliable when they have to sift through mountains of user input or retrieved information before committing to an output. That kind of grounded reasoning is exactly what we need in production systems.

Lalam: For me, the most impactful vision here is how this work improves the culture around building AI; it shows us that we can deliberately structure the learning process to instill a deeper level of careful, evidence-based interaction into the AI from the start. It shifts our focus toward designing smarter training environments for better agent behavior.

Tom: That’s a big picture way to put it, Lalam; moving away from just training simple sequences and towards training agents for real-world complexity in user interactions. Jane, can you simplify what this whole concept boils down to for our listeners?

Jane: Absolutely, Tom; WRIT is essentially about creating training scenarios that force the AI to master two types of hard skills at once: executing a long plan while also being able to thoroughly check and compare all the necessary supporting information before writing anything down. It’s about building agents that are not just fast, but also exceptionally careful and well-grounded.

Lu: And what’s really exciting is the way they achieved this by separating the complexity into write decisions and evidence burden; it proves that balancing these two factors is a key to getting more capable models across the board.

Meng: I see how that separation helps; if you only focus on one axis, you might get a fast agent that can't actually handle complex information loads when they happen in practice. The authors are showing us a balanced approach works better for real-world deployment scenarios.

Lalam: And this has huge implications because it suggests we can move toward AI systems that exhibit much more thoughtful and rigorous interaction styles, which really elevates the standard of what we expect from these tools in daily life.

Tom: It sounds like the main point is that WRIT gives us a systematic blueprint for creating training data that builds agents capable of both sustained effort and deep factual grounding in complex, multi-turn settings. That sets a new bar for how we approach agent development.

North Carolina State University · Case Western Reserve University

cs.CL, cs.AI

Submitted: 2026-06-01

Updated: 2026-10-07

Project page: https://hengrui-gu.github.io/WRIT

Importance score: 83/100

The gist: Multi-turn user-facing agents require synthesizing complex training trajectories that capture both long-horizon execution and evidence-grounded decision making.

Key concepts

Write-Heavy Trajectories
These are training sequences designed to make the agent perform many sequential writing decisions in a task. They focus on teaching the agent how to handle long-horizon, step-by-step execution, similar to completing a complex multi-step plan without getting lost.
Read-Heavy Trajectories
These trajectories force the agent to collect and compare multiple pieces of evidence before making a single write decision. This simulates real-world scenarios where an action requires gathering information from various tools or sources, testing the agent's ability to ground its arguments thoroughly.
Two-Axis Complexity
WRIT synthesizes tasks along two independent axes: task length (number of writes) and evidence load (how much reading is needed for one write). Balancing these two factors ensures the agent learns both stable long-horizon planning and robust, evidence-intensive decision-making.
User Behavior Diversification
To ensure training robustness, WRIT uses reusable instructions (like 'Progressive Disclosure') to change how a user expresses the same goal across different tasks. This makes the resulting training data more diverse and less dependent on a single, specific conversational style.

Terminology

Summary

Multi-turn user-facing agents require synthesizing complex training trajectories that capture both long-horizon execution and evidence-grounded decision making. The proposed WRIT pipeline addresses this by synthesizing trajectories along two complexity axes: the number of write decisions in a task and the evidence burden of each individual decision, demonstrating that balancing these factors produces more capable and reliable agents than existing methods.

The gist

WRIT is a pipeline for synthesizing multi-turn agent training trajectories along two complexity axes: the number of write decisions in a task and the evidence burden of each individual decision.

Two-Axis Trajectory Complexities

The paper introduces two independent ways to make agent training harder and more comprehensive. The first axis is the number of write decisions in a task, which produces write-heavy trajectories that train the agent on long-horizon sequential decision making. The second axis is the evidence burden of a single decision, which produces read-heavy trajectories, where one write action requires the agent to collect and compare multiple read-tool outputs before grounding its arguments. The synthesis objective is therefore to generate training trajectories along both axes, teaching agents both long-horizon execution stability and evidence-intensive grounding under high information load.

WRIT Pipeline Stages

The WRIT pipeline consists of three stages. First, WRIT "synthesizes write-read intensive tasks with known correct outcomes, spanning tasks with multiple sequential actions (i.e., write-intensive) and tasks where one action requires extensive reading and comparison (i.e., read-intensive). Second, it designs user behavior instructions that diversify how the user expresses and reveals the same underlying task across trajectories. Third, it runs the agent and user through each task in an executable environment and retains successful interactions as complete training trajectories."

Write-Read Intensive Task Synthesis

This stage generates tasks along two branches. The write-intensive branch covers basic business logic, involving steps like Write prototype discovery, Valid argument instantiation, and User-request construction. For instance, it involves generating a natural user request that expresses intent through preferences rather than direct identifiers, such as describing the desired flight by preference instead of providing a literal flight number. The read-heavy branch focuses on inducing evidence gathering. This involves Read-call set construction, where perturbed variants of a gold read call are generated to form an evidence pool. Subsequently, it generates a user request that requires consulting the full evidence pool, ensuring the stated user preference leads the agent to consult all specified read-tool outputs and uniquely identify the correct gold argument.

User Behavior Diversification

To ensure robustness, WRIT diversifies user behavior across trajectories. This is achieved by maintaining a library of reusable behavior instruction primitives, such as Progressive disclosure (where the user reveals task details gradually) and Policy-robustness primitives, which cover behaviors like False-premise assertion or Complaint pressure. For each synthesized task, an LLM instantiates compatible primitives as concrete user-simulator instructions tailored to that specific task. These instructions govern only interaction style, ensuring that the underlying goal and correct write action remain fixed while the conversational path changes.

Trajectory Simulation and Filtering

The final stage involves running the agent and user simulator simultaneously in an executable environment. The user simulator is guided by the task request and behavior instructions, while the agent follows domain policy. The output is a complete trajectory, which is then filtered to retain only correct and complete demonstrations where the agent successfully completes the intended task. This results in a training corpus that systematically covers both axes of complexity defined in Section 2.

Evaluation and Findings

WRIT was evaluated on the τ2-bench using a controlled 2K-trajectory training budget against strong synthetic-data baselines. Results show that WRIT consistently outperforms prior trajectory synthesis methods across all three tested models, with especially large gains on read-heavy task subsets. Specifically, WRIT improves performance on difficult tasks requiring substantial read/search behavior before the final decision. Ablation studies confirm that both read-heavy task synthesis and user-behavior diversification contribute independently, showing that a small, carefully structured set of trajectories balancing write-intensive and read-intensive complexity can produce more capable agents. Furthermore, WRIT approaches strong API agents with substantially lower inference cost compared to GPT-5.1 no-think, suggesting it transfers required behavior into SFT for efficient agent behavior at inference time.

Limitations

The paper notes limitations in its current scope: they have not fully explored the composition of complexity types, such as constructing multi-write tasks where each decision point is also read-heavy. Additionally, they do not exhaustively study the optimal mixture ratio between different complexity types for various model families or base capabilities. The authors recommend a "more systematic mixture study could clarify how each type of synthetic trajectory shapes agent behavior during supervised fine-tuning.

Improvements for AI systems

Here are the specific improvements for AI systems based on the WRIT (Write-Read Intensive Trajectory Synthesis) paper, and what those improved systems can achieve:

The core improvement offered by WRIT is shifting training data synthesis from simple sequential execution to a model that masters complex, evidence-intensive decision-making.

Here are the specific improvements:

An agent trained on WRIT trajectories will exhibit superior performance in environments where user requests are ambiguous or underspecified. It learns to anticipate the need for broad information retrieval rather than committing to a write action based on incomplete data.

The system will develop robust argument grounding capabilities, specifically improving its ability to compare and synthesize evidence from multiple read-tool outputs (e.g., searching across different dates or locations) before finalizing a state-changing action (like booking a flight). This directly addresses the weakness of agents that only perform shallow lookups.

The improved agent will demonstrate significantly better reliability (higher Passk scores) when faced with read-heavy tasks—scenarios where one write decision requires collecting and comparing substantial read evidence (up to six or more search calls). This means the agent will be less likely to make costly errors due to insufficient information.

The system will achieve higher stability across repeated trials (higher Pass4 scores), indicating that its reasoning process is consistent even when faced with stochastic or varied user inputs, as modeled by the user simulator.

The model will become more robust near policy boundaries. By incorporating script primitives into the training data, the agent will be better at handling adversarial user behaviors like false premise assertions or pressure tactics (e.g., complaint pressure), leading to graceful refusals and correct adherence to domain policies without breaking context or executing unintended actions.

The system will be trained to handle complex state changes efficiently by mastering multi-write tasks, allowing it to compose multiple sequential write actions into a single, coherent request structure, improving long-horizon task execution stability.

The improved AI system can do the following:

  1. Book or perform complex transactions (like airline reservations) with significantly fewer errors because it correctly interprets vague user requests and performs comprehensive searches across all relevant search criteria before booking.

  2. Navigate real-world, multi-step workflows (e.g., changing an address and modifying pending order items simultaneously) with high accuracy, as it can correctly sequence multiple state-changing actions into a single instruction.

  3. Act as a highly reliable customer service representative that can gracefully handle difficult or aggressive users by refusing requests appropriately while maintaining politeness and adhering strictly to complex domain rules.

  4. Function effectively in low-inference-cost deployment scenarios, as the learned reasoning is encoded into the model weights via SFT, allowing smaller, non-thinking agents to perform sophisticated tasks efficiently at test time.

Sources

Related papers