SEAD: Self-Evolving Agent for Multi-Turn Service Dialogue

🎯 Pitch

A self-play trained 14B agent beats GPT‑4o and a 560B dialogue model on service calls—without any human conversation transcripts—by splitting user simulation into a separate state selector and a neutral role‑player, preventing simulators from unfairly controlling outcomes. This decomposition lifts task completion by 17.6% and cuts call length to just 9.6 turns.

1. Executive Summary

The paper proposes SEAD (Self-Evolving Agent for Service Dialogue), a self-evolving framework for multi-turn service dialogues that requires no large-scale annotated dialogue data—only user profiles and standard operating procedures. SEAD decouples user modeling into a Profile Controller (a generator that samples diverse initial user states and participates in adversarial training by selecting "golden" scenarios where the agent succeeds roughly 50% of the time) and a User Role-play Model (which enacts realistic user behaviors without controlling dialogue outcomes), avoiding the unfair adversarial game where a unified user simulator can arbitrarily determine success. Evaluated in outbound restaurant-service promotion calls using Qwen2.5-14B-Instruct for all components, SEAD outperforms both GPT-4o and a 560B dialogue-specialized model by 17.6% in task completion rate (52.0% vs. 44.2%) while reducing dialogue length to 9.6 average turns, establishing that service agents trained via co-evolutionary self-play can exceed the performance of much larger models and commercial APIs only when the user side is decomposed so that initial-state selection—not mid-dialogue manipulation—controls training difficulty.

2. Context and Motivation

The Core Problem: LLM Dialogue Agents Cannot Learn From Human Conversation Data Alone

This paper addresses a fundamental bottleneck in deploying LLM-based dialogue agents for real-world service scenarios: the training data that exists is both scarce and of unacceptably low quality, and the processes that could produce better data are fundamentally broken. The problem is not merely that annotating multi-turn service dialogues is expensive—it is that the available human-generated data actively teaches agents the wrong behaviors, because the humans who produced those conversations were themselves suboptimal.

The paper opens by observing that training robust goal-oriented dialogue agents is "bottlenecked by scarce, expensive, and low-quality conversational data" (Section 1). The root cause, however, is more specific and more insidious than simple scarcity. Human logs from real sales calls—the paper's motivating domain—exhibit three compounding failures:

Lack of standardization across human agents. Different human operators follow different strategies, use inconsistent language, and achieve different outcomes. A model trained on this heterogeneous mixture inherits this variance rather than learning a coherent policy.
Costly filtering requirements. Because many human calls fail or contain errors (the paper notes the data is "heavily lopsided towards failed attempts"), usable training examples must be manually identified and cleaned, adding expense and introducing selection bias.
Fundamentally capped quality. Most critically, "data quality is fundamentally capped by the capabilities of the original human agents who produced these conversations." An agent trained via supervised learning on human call logs can, at best, learn to imitate the average human operator—including their mistakes, their missed persuasion opportunities, and their suboptimal turn-level decisions. It cannot exceed human performance through this channel.

This creates a paradox: the very domain where LLMs could add the most value—service dialogues where strategic persuasion, emotional intelligence, and adaptive behavior matter—is the domain where the training data is most contaminated by human failure patterns.

Why This Problem Matters: Economic Scale and Deployment Realities

The motivation is not purely academic. Service dialogue systems—outbound sales calls, customer support, appointment scheduling, and similar task-oriented conversations—represent an enormous real-world deployment surface for LLM agents. The paper's specific testbed is restaurant service promotion, where agents must convince business owners to participate in marketing activities. This is a representative instance of a broad class of economically valuable interactions where success depends on multi-turn persuasion, trust-building, objection handling, and adaptive strategy selection.

The practical stakes are high for several reasons:

Data scarcity is the norm, not the exception, in specialized business domains. Unlike open-domain chat or general-purpose reasoning, service dialogues in specific verticals (insurance, real estate, B2B sales, healthcare scheduling) rarely have publicly available large-scale annotated datasets. Each company must build its own, often from scratch. The paper argues that this makes approaches requiring curated human annotations—supervised fine-tuning, retrieval-augmented generation over conversation corpora, or even few-shot prompting with high-quality examples—prohibitively expensive and slow to deploy. A method that requires "zero dialogue data" (only task descriptions and user profiles) fundamentally changes the economics of deploying dialogue agents in new domains.

Smaller, cheaper models that exceed large-model performance create immediate cost advantages. The paper demonstrates that a 14B-parameter model trained via SEAD outperforms GPT-4o by 17.6% on task completion while costing essentially nothing per inference (open-source, self-hosted) versus commercial API pricing. In high-volume deployment scenarios (tens of thousands of calls daily), this difference translates to substantial operational savings. The finding that a 14B model can match or exceed a 560B dialogue-specialized model (LongCat-Flash) on key metrics while requiring no annotated data further strengthens the economic case.

The problem structure (subjective outcomes, adversarial dynamics) generalizes beyond service dialogue. While the paper focuses on outbound calls, the core challenge—how to train an agent when "success" is determined by a subjective, strategic counterparty whose behavior depends on the agent's actions—appears in negotiation, persuasion, debate, and collaborative problem-solving. Solutions that work in service dialogue may transfer to these adjacent domains, amplifying the paper's significance beyond its immediate application.

Prior Approaches and Their Structural Failures

The paper identifies three families of prior approaches, each with a distinct failure mode that prevents them from solving the core problem.

Static Data Methods: Bounded by Human Performance

The first family—static synthesis and supervised fine-tuning—generates a fixed dataset of dialogues from predefined scenarios or curated human logs, then trains an agent on these examples (Li et al., 2025; Ou et al., 2024; Zhu et al., 2025; Bernard and Balog, 2023). These approaches suffer from two well-understood but often underappreciated limitations:

They cannot capture dynamic interactions where user behavior depends on agent behavior. A static dataset, by definition, records a single trajectory through the interaction space. During training, the agent never experiences the consequences of making a different choice at a given turn—it only sees what the original data-producer said and how the user responded to that specific action. This means the agent cannot learn counterfactual reasoning ("if I had addressed the cost concern first instead of the trust issue, would the outcome have been different?") or develop strategies that diverge from the training distribution.

They are upper-bounded by the quality of the human data-producers. The paper emphasizes that human sales agents frequently make suboptimal decisions—pushing too hard and triggering rejection, or being too passive and failing to close. A supervised model trained on these logs learns to reproduce these failure patterns. The paper notes this distinction explicitly when it states that SEAD-trained agents "discover effective strategies beyond existing data distributions," whereas static methods are limited to imitating what humans already did.

Interactive Simulation: The Unfair Adversarial Game

The second family uses LLMs as dynamic user simulators, generating responses on-the-fly during agent training (Sekulić et al., 2024; Zhu et al., 2025). This solves the static-data problem—the simulator can react to arbitrary agent actions—but introduces a new and arguably more severe problem: the simulator can unilaterally determine the outcome of any dialogue, breaking the causal link between agent quality and task success.

The paper illustrates this with two failure modes:

The simulator is too strong. An LLM-based user role-play model has the full power of the underlying language model. It can refuse cooperation on arbitrary grounds, invent objections that no real user would raise, or hang up regardless of agent performance. When the simulator dominates, the agent learns that its actions do not matter—success is random or scripted—and training provides no meaningful signal.
The simulator is too weak. Conversely, if the simulator is insufficiently adversarial, it accepts mediocre agent responses too easily. The agent learns to coast on shallow strategies and never develops robust persuasion skills.

The deeper issue is that the user side naturally dominates the interaction in goal-oriented dialogue. A user can always say "no" and end the conversation; the agent cannot force agreement. This power asymmetry means that in any self-play setup where both sides are trained adversarially, the user side will inevitably learn to exploit its structural advantage—producing an "unfair game" where the agent's learning stalls. The paper terms this "catastrophic reward hacking" in the ablation study (Section 4.7), where the jointly trained user model "collapses into extreme responses (arbitrary acceptance or hang-ups)" and degrades to a humanness score of 3.3/5 (compared to 4.7/5 for SEAD's fixed user model).

Critically, existing simulators also exhibit what the paper calls "overly perfect styles"—they lack the hesitation, attention lapses, linguistic noise, and irrationality that characterize real user behavior (Lin and Tomlin, 2025; Takanobu et al., 2020). An agent trained against an unrealistically clean simulator will fail when deployed against real users who exhibit these natural imperfections.

Self-Evolution Methods: Domain Mismatch

The third family—self-evolution and self-play frameworks (Chen et al., 2024; Zhao et al., 2025; Silver et al., 2017)—has produced impressive results in domains with objective verifiability, such as game-playing (chess, Go, StarCraft), mathematical reasoning, and code generation. In these settings, a "Coder-Tester" or "Solver-Verifier" framework works because correctness is a verifiable, objective property: code either passes tests or it doesn't; a proof either follows or it doesn't.

Service dialogue lacks this property. The paper states the problem directly:

"unlike objective tasks where correctness is verifiable, service dialogue outcomes are entirely subjective—users can arbitrarily control results regardless of agent quality, creating an unfair adversarial game."

This is not a minor implementation detail—it is a structural difference that breaks the core assumption of self-play. In self-play for game-playing, a win is a win regardless of the opponent's subjective state. In service dialogue, "success" means the user agreed, which requires the user model to make a realistic decision based on the agent's performance. If the user model can be trained adversarially, it will learn to make that decision based on factors other than agent quality (e.g., always accepting to maximize a reward signal, or always rejecting to be "difficult"), and the training signal collapses.

How This Paper Positions Itself: A Structural Solution to a Structural Problem

SEAD's core conceptual move is to recognize that the "unfair adversarial game" is not a bug in specific implementations but a structural consequence of allowing the user model to both simulate behavior and determine outcomes while being subject to adversarial training pressure. The solution is equally structural: decompose the user side so that adversarial training pressure is applied only to the component that cannot manipulate mid-dialogue outcomes.

The paper positions this as a transformation of the training game from a "participation game" (where the user's power to accept or reject at any turn makes them an unfair adversary) to a "betting game" (where the user side—specifically, the Profile Controller—must place its "bet" by selecting initial conditions that will yield a ~50% success rate, and then let the dialogue play out without further manipulation). The User Role-play Model is deliberately kept fixed (not trained), which ensures that outcomes are determined by agent quality rather than the simulator's adversarial optimization.

This positioning draws on a well-established principle from curriculum learning and game design: training is most effective when difficulty is calibrated so that the learner succeeds approximately half the time. The Profile Controller's role is precisely to find and maintain this sweet spot—sampling initial user states (combinations of cooperation, emotion, and trust levels) where the current agent's completion rate is near 50%. As the agent improves, the difficulty escalates naturally because previously "hard" scenarios become "moderate," and the Controller shifts its sampling distribution accordingly.

The paper explicitly frames this as a departure from the "Coder-Tester" paradigm that dominates self-evolution work in verifiable domains. Rather than having one component generate challenges and another verify solutions, SEAD has one component set initial conditions and another role-play the consequences—with success determined by the role-player's internal, non-adversarial logic. This framing is novel for dialogue systems, though it echoes concepts from multi-agent reinforcement learning where decomposing roles to prevent exploitation is standard practice.

In the broader landscape of dialogue systems research, SEAD positions itself as the first self-evolving framework specifically designed for the structural properties of multi-turn service dialogue—combining the data-efficiency benefits of self-play (no annotated training data) with the realism of fixed user simulation, while using curriculum-based difficulty adaptation to avoid both the over-strong and over-weak simulator failure modes.

3. Technical Approach

3.1 Reader Orientation

SEAD is a training framework—not a single model—that orchestrates three LLM-based components (a profile generator, a user role-play model, and a service agent) in a co-evolutionary loop so that the agent learns effective multi-turn persuasion strategies purely through interaction, without ever seeing a human-annotated dialogue. The system solves the core structural problem described in Section 2: how to make self-play training work when the "opponent" (a simulated user) could arbitrarily decide conversation outcomes, breaking the causal link between agent quality and reinforcement signal. SEAD's solution is to decouple user modeling into a trainable initial-state selector and a fixed behavior simulator, so that adversarial training pressure applies only to which scenarios the agent faces, not to how users decide to accept or reject within a dialogue. This transforms the training dynamic from an unfair game (where a powerful user model can always say "no" regardless of agent actions) into a fair betting game (where the user side must place its bet by selecting an initial difficulty level, then let the agent's actual performance determine outcomes).

3.2 Big-Picture Architecture (Diagram in Words)

SEAD has three core components operating in a four-phase training loop:

Profile Controller (trainable) : A component that samples initial user states—combinations of cooperation, emotion, and trust levels—from a predefined 120-state space. It maintains statistics on which state combinations yield ~50% completion rates and samples preferentially from those ("golden training scenarios"), implementing automatic curriculum learning. This is the only user-side component that receives adversarial training pressure, and it operates before any dialogue begins.
User Role-play Model (fixed) : An LLM (Qwen2.5-14B-Instruct) that enacts the sampled user profile through multi-turn dialogue. It generates realistic user responses, tracks and updates its own internal state (cooperation, emotion, trust) based on agent behavior, and determines the final dialogue outcome (success or failure). Crucially, this model is never trained—its parameters are frozen—so its decision to accept or reject depends only on the agent's demonstrated persuasion quality, not on adversarial optimization. This ensures that outcomes reflect agent capability rather than simulator exploitation.
Service Agent (trainable) : An LLM (also Qwen2.5-14B-Instruct) that participates in dialogues with the User Role-play Model, generates agent responses turn by turn, and is optimized via Group Relative Policy Optimization (GRPO) to maximize task completion rewards. It also maintains an explicit estimate of the current user state ( $\hat{s}_t$ ) to guide its action selection.

These components interact in a four-phase loop illustrated in Figure 3: (Phase 1) the Profile Controller samples initial user states, (Phase 2) the User Role-play Model and Service Agent conduct multi-turn dialogues producing trajectories, (Phase 3) the service agent is trained on these trajectories using GRPO with task completion rewards, and (Phase 4) Mistake Analysis computes completion rates per state combination and feeds statistics back to the Profile Controller to update its sampling distribution for the next iteration.

3.3 Roadmap for the Deep Dive

The technical breakdown proceeds through the following sequence, each building on the previous:

First, the problem formulation and formalization—what the training objective is, how the state space, action space, trajectory, and reward are defined, and why the agent is the only trained component. This establishes the mathematical scaffolding that the rest of the framework relies on.
Second, the user modeling decomposition—how the Profile Controller and User Role-play Model differ in their responsibilities, their training status, and their interface (the initial state $p_0$ ). This is the central design innovation of the paper and must be understood before the training loop makes sense.
Third, the four-phase self-evolving training loop—Phase 1 (profile sampling with difficulty-adaptive probabilities), Phase 2 (multi-turn dialogue execution), Phase 3 (GRPO-based agent optimization), and Phase 4 (Mistake Analysis and feedback). This is where the co-evolutionary dynamic emerges.
Fourth, the user state space design—the 120 initial states, the dynamic state evolution logic, and the behavior library derived from real enterprise data. This grounds the abstract framework in the concrete outbound call service domain.
Fifth, the training optimization details (GRPO)—the advantage computation, the policy gradient update, and why GRPO is chosen over alternatives requiring a separate value network.

3.4 Detailed, Sentence-Based Technical Breakdown

This is primarily a systems and training methodology paper whose core idea is that decomposing user simulation into a trainable initial-state selector and a fixed behavior simulator transforms self-play from an unfair adversarial game into a fair co-evolutionary process, enabling effective zero-data training of service dialogue agents.

Problem Formalization and the Sequential Decision Process

The paper models multi-turn service dialogue as a sequential decision process where the agent and user alternate turns until one of three terminal conditions is met: the user agrees to the service (success), the user refuses or hangs up (failure), or the conversation reaches the maximum turn limit $T_{\max} = 15$ (failure). The agent's goal is to maximize a cumulative reward $R$ that measures task completion.

State and action spaces. At each turn $t$ , the dialogue history $h_t = \{u_1, a_1, \ldots, u_t\}$ represents the sequence of user utterances $u_i$ and agent responses $a_i$ up to that point. The agent observes $h_t$ and must produce its next response $a_t$ . The agent also maintains an explicit state estimate $\hat{s}_t$ —its prediction of the user's current cooperation, emotion, and trust levels—to guide its action selection. This explicit state tracking is motivated by the nature of service dialogue: effective persuasion requires the agent to know whether the user is currently open, frustrated, skeptical, or trusting, since different states demand different strategies (empathy for emotional users, evidence for skeptical users, urgency for cooperative users).

The user's true state (hidden from the agent) is $p_t = (c_t, e_t, tr_t)$ , where $c_t \in [0, 4]$ is the cooperation level (5 discrete levels), $e_t \in [0, 3]$ is the emotion level (4 discrete levels), and $tr_t \in [0, 5]$ is the trust level (6 discrete levels). These three dimensions capture the axes along which user willingness evolves during a persuasion attempt: a user might start out cooperative ( $c_0$ high) but lose trust ( $tr_t$ decreasing) if the agent makes implausible claims, or start out skeptical ( $tr_0$ low, $c_0$ low) and gradually warm up if the agent demonstrates competence.

Initial state and profile. Before a dialogue begins, the system samples an initial user profile $p_0 = (c_0, e_0, tr_0, \mathcal{B})$ , where the initial cooperation, emotion, and trust levels are drawn from the 120 possible combinations of the three state dimensions, and $\mathcal{B}$ is a behavior set sampled from a library $\mathcal{L}$ of behavior patterns (described in detail in the state space design subsection below). The behavior set $\mathcal{B}$ determines what conversational tendencies the user exhibits—for example, questioning the AI's identity, expressing cost concerns, showing attention lapses—and is randomly selected to ensure diversity.

Trajectory. A complete dialogue trajectory is:

$\mathcal{H} = (p_0, u_1, a_1, p_1, \ldots, u_T, a_T, p_T, \text{outcome})$

where $T$ is the total number of turns (agent utterances) before termination, and $\text{outcome} \in \{\text{success}, \text{failure}\}$ is determined by the User Role-play Model at turn $T$ based on its final internal state $p_T$ . The inclusion of $p_0$ at the start and $p_T$ at the end makes explicit that the trajectory records both the initial conditions (which the Profile Controller chose) and the final state (which determines success), enabling the Mistake Analysis in Phase 4 to compute completion rates per initial state combination.

Reward. The reward is a sparse, binary, outcome-based signal:

$R_{\text{task}}^{(i)} = \mathbb{I}[\text{outcome}^{(i)} = \text{success}]$

where $\mathbb{I}[\cdot]$ is the indicator function (1 if the condition is true, 0 otherwise), and $\text{outcome}^{(i)}$ is the dialogue outcome for trajectory $\mathcal{H}^{(i)}$ .

What it computes: the reward for a single dialogue trajectory is 1 if the User Role-play Model determined that the user accepted the service offer at the end of the conversation, and 0 otherwise (user refused, hung up, or the conversation timed out at $T = 15$ turns without resolution). This is a terminal reward—no intermediate rewards are given for turn-level progress, state improvements, or partial agreements.

Why this form: the binary outcome reward directly encodes the business objective (did the call result in a conversion?). The paper deliberately avoids dense, shaped rewards (e.g., per-turn improvements in cooperation or trust) because, in service dialogue, intermediate proxy metrics do not reliably predict final outcomes—a user can seem cooperative throughout and still refuse at the end, or seem hostile throughout and suddenly agree. Teaching the agent to optimize for genuine task completion, rather than gaming intermediate metrics, forces it to learn the full persuasion arc rather than short-term manipulation of state variables. Additionally, the binary reward is naturally objective (the user model's internal logic determines success deterministically given the final state), eliminating the need for learned reward models or human preference judgments during training.

Why only the agent is trained. The paper makes an explicit, motivated decision to train only the Service Agent ( $\pi_a$ ), not the User Role-play Model ( $\pi_u$ ). The reasoning (Section 3.3) is twofold:

Training the User Role-play Model degrades role-play quality. When the user model is optimized adversarially (rewarded for making the agent fail), it discovers that it can achieve its reward by simply rejecting regardless of agent performance—collapsing into extreme, unrealistic behavior. The ablation study (Table 3) confirms this: training the User Role-play Model (Config 1) yields a humanness score of only 3.3/5 (compared to 4.7/5 for SEAD's fixed model) and a completion rate of only 35.2% (compared to 52.0%), precisely because the simulator learns to exploit its structural advantage rather than simulate realistic users.
Keeping the User Role-play Model fixed reduces memory and compute by 50%. Since only the agent undergoes gradient-based optimization, the optimizer states (Adam moments, etc.) are needed only for the agent's parameters. The paper uses a decoupled architecture where the Profile Controller, User Role-play Model, and Service Agent never occupy GPU memory simultaneously, further reducing peak memory requirements. This is a practical engineering consideration that enables training on 8×A100 80GB GPUs without model parallelism.

This asymmetric training design—where one side is frozen and the other adapts—is the paper's structural solution to the unfair adversarial game. The only trainable user-side component is the Profile Controller (which selects $p_0$ ), and its training signal is indirect: it is rewarded for sampling initial states where the agent's completion rate is near 50%, not for any per-dialogue outcome manipulation.

User Modeling Decomposition: Profile Controller vs. User Role-play Model

The paper's central technical innovation is decomposing the user side into two components with distinct responsibilities, distinct training status, and a clean interface between them.

Profile Controller (trainable, operates before dialogue). The Profile Controller $\pi_g$ is parameterized by a sampling distribution $p_\theta(p_0 \mid \mathcal{H})$ that conditions on dialogue trajectory history $\mathcal{H}$ to select an initial user state $p_0$ . Its responsibility is to manage the training curriculum—it decides which of the 120 possible user state combinations the agent should practice against in the next batch of dialogues. Its design is intentionally restricted: it can only set initial conditions ( $c_0, e_0, tr_0, \mathcal{B}$ ), not intervene once the dialogue begins. This restriction is what transforms the unfair adversarial game into a fair betting game.

User Role-play Model (fixed, operates during dialogue). The User Role-play Model $\pi_u$ is a frozen Qwen2.5-14B-Instruct model that takes the initial profile $p_0$ and the dialogue history $h_t$ as input and generates a user utterance $u_t$ that is consistent with the profile's cooperation, emotion, trust, and behavior patterns. It also autonomously updates its internal state $p_t$ based on the agent's responses—moving cooperation up or down, shifting emotion toward positive or negative valence, building or eroding trust. Its responsibility is to simulate realistic user behavior without any adversarial optimization pressure. The critical property is that its state updates and outcome decisions are determined by its internal, non-adversarial logic—it was never trained to optimize any reward signal, so its rejection or acceptance decisions genuinely depend on the agent's persuasion quality.

Interface: the initial state $p_0$ . The clean separation between the two user-side components creates a well-defined interface: the Profile Controller outputs a $p_0$ , the User Role-play Model consumes it and produces a dialogue trajectory, and the completion rate for that trajectory's initial state combination is recorded in $\mathcal{H}$ . This means the Profile Controller receives feedback about which initial states produce ~50% completion rates, but it never receives per-turn feedback or outcome-level rewards—it only learns through the aggregated statistics of many dialogues, not through a direct reinforcement signal tied to individual outcomes.

Why this decomposition matters operationally. In a unified user model (the standard approach in prior work), the same LLM both selects initial behavior and determines moment-by-moment responses and outcomes. Training this unified model creates a conflict: the model can satisfy the training objective (adversarial reward) by manipulating outcomes at any turn—accepting when it should reject, or rejecting when it should accept—completely decoupling the agent's reward from its actual performance. By decomposing and freezing the interactive component, SEAD ensures that the only degree of freedom available to adversarial optimization is the choice of initial difficulty, which is a legitimate curriculum design decision rather than outcome manipulation.

The "betting game" analogy (not in the paper's formal notation but permeates the methodology). The Profile Controller "bets" that a particular initial state combination will be at the right difficulty level for the current agent—where the agent succeeds roughly 50% of the time. If the bet is correct (completion rate near 0.5), the Profile Controller receives high sampling probability for similar states in the next iteration, because Equation 1 assigns probability proportional to $1 - |CR - 0.5|$ . If the bet is wrong—either too easy (CR > 0.6, the agent steamrolls) or too hard (CR < 0.4, the agent never wins)—those state combinations receive lower sampling probability. This mechanism does not require explicit reward signals to the Profile Controller; it is purely a statistical feedback loop based on the Mistake Analysis phase's computations.

The Four-Phase Self-Evolving Training Loop

Figure 3 depicts the complete training loop, which alternates between agent optimization (Phases 2–3) and curriculum adaptation (Phases 1 and 4). The loop operates continuously across training iterations, with each iteration processing a batch of $B = 60$ initial profiles.

Phase 1: Diverse User Profile Sampling

The Profile Controller samples a batch of $B$ initial user profiles $\{p_0^{(i)}\}_{i=1}^B$ from the 120-state space. The sampling strategy differs between the first iteration and all subsequent iterations:

First iteration (cold start). The Profile Controller performs uniform random sampling across all 120 state combinations. For each sampled $(c_0, e_0, tr_0)$ combination, the behavior set $\mathcal{B}$ is also randomly sampled from the behavior library $\mathcal{L}$ , which contains behavior patterns extracted from real enterprise dialogues (described in Section 3.4, "User State Space Design"). This ensures the initial batch covers the full diversity of possible user states without any prior about which states are informative for training.

Subsequent iterations (statistics-driven sampling). After the first iteration, Phase 4 has computed completion rates $CR(c, e, tr)$ for each state combination—the fraction of dialogues starting from that combination that ended in success. The Profile Controller then samples state combinations with probability proportional to:

$p_\theta(p_0 \mid \mathcal{H}) \propto 1 - |CR - 0.5|$

where $CR$ is the completion rate for that state combination computed from dialogue trajectory history $\mathcal{H}$ , and $|\cdot|$ denotes absolute value.

What it computes: for each of the 120 state combinations, this expression yields a weight between 0 and 1. When $CR = 0.5$ (the agent succeeds exactly half the time), the weight is $1 - |0.5 - 0.5| = 1.0$ —maximum probability mass. When $CR = 0$ (the agent never succeeds) or $CR = 1$ (the agent always succeeds), the weight is $1 - |0 - 0.5| = 1 - |1 - 0.5| = 0.5$ —half the maximum. States with extreme completion rates (close to 0 or 1) receive lower but non-zero probability, ensuring the Profile Controller does not completely abandon any region of the state space (which would risk forgetting or overfitting to a narrow difficulty band).

Why this form: the expression $1 - |CR - 0.5|$ is a triangular kernel centered at 0.5, which is the simplest function that (1) peaks at the desired difficulty level (50% success), (2) decays symmetrically as difficulty deviates in either direction (too easy or too hard are equally undesirable), and (3) produces non-negative weights everywhere (no state is assigned zero probability). The linear decay, as opposed to a Gaussian or quadratic decay, provides a relatively flat incentive near the optimum—states with CR between 0.4 and 0.6 all receive weights between 0.9 and 1.0—which avoids overfitting to a single state combination and maintains curriculum diversity.

Profile validation and deduplication. After sampling, the Profile Controller performs two quality checks: (1) consistency validation ensures that the sampled cooperation, emotion, trust, and behavior set form a semantically coherent profile (e.g., a user with $c_0 = 4$ (highly cooperative) and $e_0 = 0$ (highly negative emotion) might be flagged as inconsistent, since highly cooperative users are typically not simultaneously furious), and (2) deduplication prevents the same exact profile from appearing multiple times in the same batch, which would waste training diversity on redundant scenarios. The paper does not specify the exact consistency rules—they are presumably derived from the behavior patterns extracted from real dialogues—but notes that these checks ensure "diverse and high-quality profiles."

Phase 2: Multi-Turn Dialogue Generation

For each initial profile $p_0^{(i)}$ sampled in Phase 1, the system initiates a new conversation between the Service Agent and the User Role-play Model.

Dialogue flow. The agent begins with an opening utterance (typically a greeting and service introduction). The User Role-play Model observes this utterance, updates its internal state $p_t$ based on what the agent said, and generates a user response $u_t$ . The agent observes $u_t$ , updates its state estimate $\hat{s}_t$ , and generates $a_t$ . This back-and-forth continues until one of the terminal conditions is met.

Terminal conditions. The dialogue terminates when any of the following occurs:

Success: The User Role-play Model's internal logic determines that the user agrees to the service. This occurs when the user's state reaches a threshold of cooperation, trust, and positive emotion such that acceptance is the natural behavior for a user in that state. The exact threshold logic is internal to the User Role-play Model (it is an LLM, not a rule-based system) and is not explicitly parameterized in the paper. The outcome is recorded as $\text{outcome} = \text{success}$ .
Failure: The User Role-play Model determines that the user refuses cooperation, hangs up, or otherwise ends the interaction negatively. This occurs when state variables deteriorate below thresholds, or when the user's behavior patterns (e.g., skepticism about AI identity) trigger a rejection. The outcome is recorded as $\text{outcome} = \text{failure}$ .
Timeout: The conversation reaches $T_{\max} = 15$ turns without either success or explicit failure. This is treated as a failure ( $R_{\text{task}} = 0$ ), since the agent failed to close the deal within the allotted interaction budget.

State evolution during dialogue. The User Role-play Model autonomously updates $p_t$ at each turn. Effective agent responses (addressing concerns empathetically, providing credible information, building rapport) shift state variables in positive directions (higher cooperation, better emotion, increased trust). Poor agent responses (ignoring user concerns, being pushy, making implausible claims) shift state variables negatively. This evolution is not governed by explicit rules but emerges from the LLM's learned understanding of how real users react to different conversational strategies—the model was trained (during its base pretraining) on vast corpora that include realistic human conversational dynamics. The paper validates this emergent realism in Section 4.6, where GPT-5.1 evaluations rate the simulator's humanness above 4.5/5 across multiple dimensions.

Trajectory collection. For each profile in the batch, the complete trajectory $\mathcal{H}^{(i)}$ —including all turns, state updates, and the final outcome—is recorded and passed to Phase 3 for training and Phase 4 for analysis.

Why this dynamic interaction matters. Unlike approaches that generate static datasets where user responses are predetermined, Phase 2 produces trajectories where the user's behavior genuinely depends on the agent's actions. If the agent makes a persuasive argument, the user's state improves and future responses become more cooperative; if the agent makes a mistake (e.g., misreading the user's emotional state and pushing too aggressively), the user's state degrades and the conversation may spiral toward rejection. This dependency is essential for the agent to learn causal relationships between its strategies and outcomes—it can observe that strategy A (addressing cost concerns upfront) leads to trust increases in skeptical profiles, while strategy B (ignoring concerns and pushing benefits) leads to trust decreases. A static dataset, by contrast, only shows correlations (users who were convinced vs. not convinced) without revealing the counterfactual.

Phase 3: Task Strategy Optimization via GRPO

After collecting a batch of trajectories from Phase 2, the Service Agent is updated using Group Relative Policy Optimization (GRPO; Shao et al., 2024).

Why GRPO and not PPO. Standard Proximal Policy Optimization (PPO) requires a separate value network (critic) to estimate the expected return from each state, which approximately doubles the memory and compute requirements. For dialogue tasks where the agent is an LLM already occupying substantial GPU memory, this additional model is a significant engineering burden. GRPO eliminates the critic by computing advantages relative to the batch mean: instead of learning a value function $V(s)$ , it estimates the baseline as the average reward across trajectories in the current batch. This is valid when the batch contains a diverse set of trajectories from the same policy, which Phase 2 guarantees by sampling diverse initial profiles. The paper does not explicitly state the memory savings, but the ablation study notes that training only the agent (not the user model) reduces GPU memory by 50%—using GRPO further reduces memory compared to actor-critic methods.

Advantage computation. For a batch of $N$ trajectories (where $N = B = 60$ ), the advantage for trajectory $i$ is:

$A^{(i)} = R^{(i)} - \frac{1}{N} \sum_{j=1}^N R^{(j)}$

where $R^{(i)} \in \{0, 1\}$ is the task completion reward (Equation 2) for trajectory $i$ , and $\frac{1}{N}\sum_{j=1}^N R^{(j)}$ is the empirical mean reward across the batch.

What it computes: for each trajectory, subtract the batch's average success rate from the trajectory's binary outcome. If the batch has a 40% average completion rate (mean reward = 0.4), then a successful trajectory receives advantage $1.0 - 0.4 = +0.6$ , and a failed trajectory receives $0.0 - 0.4 = -0.4$ . Successful trajectories get positive advantages (the policy should become more likely to produce the actions that led to success), and failed trajectories get negative advantages (the policy should become less likely to produce those actions).

Why this form: the batch-relative advantage is a variance-reduction technique. The raw reward $R^{(i)}$ is always 0 or 1, but subtracting the batch mean centers these values so that the average advantage is zero. This removes the effect of overall difficulty: if the batch happened to contain mostly hard profiles and the average reward is only 0.2, a successful trajectory still gets a substantial positive advantage (+0.8), so the agent learns from rare successes. If the batch contained mostly easy profiles with average reward 0.8, a failed trajectory gets a substantial negative advantage (−0.8), so the agent learns from rare failures. Without this centering, the gradient magnitude would be dominated by whichever outcome (success or failure) is more common, which would distort learning.

Policy gradient update. The agent parameters $\theta_a$ are updated using the gradient:

$\nabla_{\theta_a} \mathcal{L} = \mathbb{E}_{\mathcal{H} \sim \pi_a} \left[ \sum_{t=1}^T A^{(i)} \nabla_{\theta_a} \log \pi_a(a_t \mid h_t) \right]$

where $\pi_a(a_t \mid h_t)$ is the policy distribution—the probability the agent assigns to generating response $a_t$ given dialogue history $h_t$ —and the expectation is over trajectories $\mathcal{H}$ sampled from the agent's current policy.

What it computes: for each turn $t$ in trajectory $i$ , compute the gradient of the log-probability of the action the agent actually took, weighted by the trajectory-level advantage $A^{(i)}$ . Sum these weighted gradients across all turns, then average over the batch of trajectories. The result is a gradient direction that increases the probability of actions taken in successful trajectories (positive advantage) and decreases the probability of actions taken in failed trajectories (negative advantage).

Why this form (and why the advantage is trajectory-level, not per-turn): the advantage $A^{(i)}$ is constant across all turns within a trajectory—it does not vary with $t$ . This means that every action in a successful dialogue receives the same positive update signal, and every action in a failed dialogue receives the same negative update signal. This is a deliberate choice driven by the sparse reward structure: since the only reward signal comes at the end of the dialogue, there is no way to assign per-turn credit—we cannot know whether turn 3 was brilliant and turn 7 was the one that ruined the deal, or vice versa. The trajectory-level advantage treats the entire sequence as jointly responsible for the outcome, which is appropriate for tasks where success depends on cumulative persuasion rather than individual moves. The standard policy gradient theorem (the REINFORCE estimator) naturally handles this: the sum over turns with a constant weight is exactly the gradient of the log-probability of the full trajectory, weighted by its total return.

Phase 4: Mistake Analysis and Self-Evolving Curriculum Feedback

The fourth phase closes the co-evolutionary loop by feeding completion statistics back to the Profile Controller.

Mistake Analysis procedure. For each of the 120 initial state combinations $(c, e, tr)$ , the system computes the completion rate $CR(c, e, tr)$ —the fraction of dialogues starting from that combination that ended in success—using the trajectories collected in Phase 2. These statistics are accumulated across iterations, so the CR estimates become more reliable over time as more dialogues are sampled from each state combination.

Categorization. Each state combination is categorized into one of three groups based on its current CR estimate:

Too easy: $CR > 0.6$ . The agent reliably succeeds on these profiles. Continued training on them provides diminishing returns—the agent is not learning anything new from easy wins. The Profile Controller will downsample these states in the next iteration.
Too difficult: $CR < 0.4$ . The agent rarely or never succeeds on these profiles. Continued training on them is demoralizing and wasteful—the agent cannot learn from constant failure because no positive examples exist to imitate. The Profile Controller will also downsample these states.
Ideal (golden training scenarios): $CR \in [0.4, 0.6]$ . The agent succeeds approximately half the time. These are the scenarios where training is most informative: the agent experiences both successes and failures from similar starting conditions, so it can learn what distinguishes the two cases. The Profile Controller will upsample these states in the next iteration.

Why these thresholds (0.4 and 0.6): the paper's choice of the "ideal" band as $[0.4, 0.6]$ represents a ±10% tolerance around the theoretical optimum of 0.5. This tolerance serves two purposes: (1) it accounts for statistical noise in CR estimates (with finite samples per state combination, the measured CR may fluctuate around the true value), and (2) it maintains a sufficiently broad training distribution—if the band were narrower (e.g., $[0.48, 0.52]$ ), very few states would qualify and the agent would train on a tiny fraction of the user population, potentially overfitting to those specific profiles. The ±10% band ensures that roughly 20–30% of the state space is active for training at any given time, which the paper's results suggest is sufficient for effective curriculum learning.

Feedback to Phase 1. The CR statistics and categorizations are stored in the dialogue trajectory history $\mathcal{H}$ , which the Profile Controller consults in Phase 1 of the next iteration. States in the ideal band receive high sampling probability (via Equation 1's $1 - |CR - 0.5|$ weighting), while states in the too-easy or too-difficult bands receive lower probability.

Automatic curriculum escalation. As the agent improves through training (Phase 3), state combinations that were previously too difficult (CR < 0.4) gradually become more tractable as the agent learns strategies that work on harder profiles. When their CR crosses above 0.4, they enter the ideal band and begin receiving higher sampling probability—the curriculum naturally escalates. Similarly, states that were previously ideal may become too easy (CR > 0.6) as the agent masters them, and they exit the training distribution. This creates a self-adjusting difficulty curve without any manual scheduling of training phases or hand-designed progressions. The paper reports that this mechanism "enables our 14B model to surpass 72B models and commercial APIs," attributing the performance gains to the adaptive curriculum rather than any single architectural innovation.

User State Space Design

The state space definition is critical because it determines the granularity at which the Profile Controller can set difficulty and the diversity of training scenarios.

Static initial states. The initial user state $p_0$ is defined over three dimensions: cooperation $c \in [0, 4]$ (5 levels), emotion $e \in [0, 3]$ (4 levels), and trust $tr \in [0, 5]$ (6 levels). The Cartesian product yields:

$N = 5 \times 4 \times 6 = 120 \text{ initial state combinations}$

These 120 combinations span the full spectrum from highly resistant users (low cooperation, negative emotion, low trust) to fully receptive users (high cooperation, positive emotion, high trust), with all intermediate combinations. The paper states these levels were identified from "common behavior patterns" in real enterprise dialogues—they are not arbitrary discretizations but reflect distinct, qualitatively different user attitudes observable in actual outbound sales calls.

What these dimensions mean operationally for the User Role-play Model:

Cooperation ( $c$ ): The user's willingness to engage with the service offer. At $c = 0$ , the user is hostile and actively trying to end the call. At $c = 4$ , the user is receptive and interested. Intermediate levels correspond to gradations of openness: $c = 1$ might mean "willing to hear the agent out but skeptical," $c = 2$ might mean "neutral, neither pushing back nor leaning in," $c = 3$ might mean "leaning toward interest but with reservations."
Emotion ( $e$ ): The user's affective state, independent of their cooperation level—a user can be uncooperative and calm ( $c = 0, e = 3$ ) or cooperative and frustrated ( $c = 4, e = 0$ ). At $e = 0$ , the user is angry, frustrated, or upset. At $e = 3$ , the user is calm, positive, or engaged. Emotion affects the tone of responses and the agent's strategy: a frustrated user requires empathy and de-escalation before persuasion can begin, while a calm user can engage with the substance of the offer directly.
Trust ( $tr$ ): The user's belief in the agent's credibility and the service's value. At $tr = 0$ , the user believes the agent is a scam or the service is worthless. At $tr = 5$ , the user fully trusts the agent and the offer. Trust is the most learnable dimension: specific agent behaviors (providing concrete information, acknowledging limitations, being transparent about costs) build trust, while evasiveness or pushiness destroys it.

Behavior library $\mathcal{L}$ and behavior sets $\mathcal{B}$ . The behavior library $\mathcal{L}$ contains behavior patterns extracted from over 100,000 real enterprise dialogues. The paper identifies several patterns explicitly: questioning the AI's identity ("Are you a real person or a robot?"), expressing cost concerns ("This sounds too expensive, I can't afford it"), attention lapses ("Sorry, what did you say? I wasn't paying attention"), and others not enumerated in the text. These patterns are anonymized—they capture the structure of common user behaviors without reproducing any specific individual's conversations.

Each initial user profile $p_0$ includes a behavior set $\mathcal{B}$ randomly sampled from $\mathcal{L}$ . The behavior set determines which conversational tendencies the user will exhibit during the dialogue. For example, a profile might be $(c_0=2, e_0=2, tr_0=1, \mathcal{B}=\{\text{AI skepticism, cost sensitivity}\})$ , meaning the user starts neutral but with low trust, and will periodically question whether the agent is human and express concerns about cost. The behavior set injects the "linguistic noise and irrationality" that the paper identifies as missing from prior simulators—real users do not rationally assess offers like idealized economic agents; they get distracted, ask off-topic questions, and exhibit inconsistent preferences.

Dynamic state evolution. During Phase 2 dialogues, the User Role-play Model autonomously updates $p_t = (c_t, e_t, tr_t)$ at each turn. The updates are not deterministic functions of agent actions but emerge from the LLM's simulation of how a person with the given profile would realistically react. The paper emphasizes that "effective responses improve user states, while poor interactions degrade them," but does not specify the exact mechanism—it is encapsulated in the LLM's prompt and base capabilities. This is both a strength (natural, flexible state evolution without hand-coded rules) and a limitation (the state evolution logic is opaque and may contain biases or unrealistic patterns that the LLM learned during pretraining).

Maximum dialogue length $T_{\max} = 15$ . The choice of 15 turns as the maximum dialogue length is a practical compromise between realism and training efficiency. Real outbound sales calls can last much longer (especially successful ones, where the agent needs time to build rapport, address objections, and close), but allowing arbitrarily long dialogues would (1) increase the computational cost per trajectory, (2) create extremely long context windows that challenge the LLM's attention mechanism, and (3) increase gradient variance because very long trajectories accumulate more stochasticity per update. The 15-turn cap forces the agent to be efficient—it must persuade the user within a bounded interaction budget, which aligns with the paper's ATT (Average Turns to Target) metric that rewards concise, effective dialogues.

Training Optimization Details

Base model for all components. All three components—Profile Controller, User Role-play Model, and Service Agent—use Qwen2.5-14B-Instruct as their base model. The Profile Controller and Service Agent undergo fine-tuning/training, while the User Role-play Model remains frozen at its initial Instruct checkpoint. Using the same architecture for all components simplifies implementation but has a subtle consequence: the Service Agent cannot exploit model-specific weaknesses in the User Role-play Model (since they share the same base capabilities and limitations), which forces the agent to learn genuinely transferable persuasion strategies rather than adversarial exploits. The paper does not explore using different model families for different components, which could potentially create a more challenging and diverse training environment.

Implementation framework. The system is built on the VeRL (Volcano Engine Reinforcement Learning) framework, an open-source RL training infrastructure for LLMs. Key hyperparameters specified in the paper:

Batch size $B = 60$ : the number of initial profiles sampled per iteration (Phase 1), which equals the number of trajectories collected per iteration (Phase 2) and the group size for GRPO advantage computation (Phase 3). A batch size of 60 means each GRPO update uses 60 trajectories to estimate the baseline reward—large enough to provide a stable mean estimate but small enough to fit in GPU memory.
Learning rate $\alpha = 1 \times 10^{-6}$ : a relatively low learning rate appropriate for fine-tuning a pretrained LLM, where large updates risk catastrophic forgetting of the model's general language capabilities. The paper does not specify a learning rate schedule, suggesting a constant rate throughout training.
Maximum dialogues per state combination $N_{\max} = 200$ : each of the 120 initial state combinations can be sampled at most 200 times across the entire training run. This cap prevents the curriculum from overfitting to a small set of states where the agent happens to have near-50% completion rates, ensuring the Profile Controller must eventually explore other states as the cap is reached.

Hardware and decoupled architecture. All experiments use 8 NVIDIA A100 80GB GPUs. The components operate in a "decoupled architecture" where "profile controller, User Role-play Model, and service agent never occupy memory simultaneously." This means phases are executed sequentially on the GPU cluster: Phase 1 runs the Profile Controller to generate 60 profiles, then offloads it from GPU memory; Phase 2 loads the User Role-play Model and Service Agent, runs all 60 dialogues, then offloads them; Phase 3 loads only the Service Agent for gradient computation and parameter updates; Phase 4 is a lightweight statistical analysis that does not require GPU. This sequential execution trades wall-clock time for memory efficiency, enabling a 14B model to train on 8 GPUs without model parallelism or gradient accumulation tricks.

Training data requirements (zero-shot). The paper emphasizes that SEAD requires no dialogue data for training. The only inputs are:

Standard Operating Procedures (SOP): a textual description of the desired dialogue flow, service details, and agent guidelines, provided as part of the agent's system prompt.
Task objective description: a natural language specification of what the agent should achieve (convince restaurant owners to participate in promotional activities).
User profile specifications: the behavior library $\mathcal{L}$ derived from anonymized patterns in real enterprise dialogues (but not the dialogues themselves). The library defines what kinds of behaviors exist, not how to respond to specific utterances.

This "zero dialogue data" property is what enables rapid deployment in new domains—an organization with a new service offering can deploy SEAD by writing an SOP, defining the task, and providing a behavior library (which can often be bootstrapped from similar domains or constructed via expert brainstorming), without collecting or annotating a single training dialogue.

Why GRPO is appropriate for this setting. The paper's choice of GRPO over alternatives is motivated by three considerations:

Memory efficiency: GRPO requires no critic network, substantially reducing GPU memory compared to PPO or other actor-critic methods. For LLM-based agents where the policy network itself consumes tens of gigabytes, this saving enables larger batch sizes or longer training on the same hardware.
Simplicity in sparse-reward settings: When rewards are sparse and binary (as in service dialogue), the critic's value estimates are highly noisy and slow to converge. GRPO's batch-relative baseline avoids this learning problem entirely by using the empirical mean, which is an unbiased estimator of the expected reward under the current policy (though it has higher variance than a well-trained critic).
Compatibility with language model fine-tuning: GRPO has been successfully applied in prior work on mathematical reasoning (DeepSeekMath; Shao et al., 2024), demonstrating that it works for LLM policy optimization on tasks with verifiable outcomes—a property that service dialogue shares (the outcome is verifiable post-hoc, even if it is subjective at the moment of decision).

4. Key Insights and Innovations

Innovation 1: Decomposing User Simulation into a Curriculum Controller and a Fixed Role-player Transforms Self-Play from an Unfair Adversarial Game into a Fair Co-evolutionary Process

The paper's most fundamental conceptual contribution is not a new training algorithm or architecture, but a diagnosis of why self-play fails for service dialogue and a structural solution to that diagnosis. The diagnosis is sharp: the failure is not a matter of insufficient data, poor simulator quality, or suboptimal hyperparameters—it is a structural consequence of giving a single user-side model both the power to simulate realistic behavior and the power to determine dialogue outcomes while subjecting it to adversarial training pressure. This creates an "unfair adversarial game" where the user side inevitably discovers that it can satisfy the training objective by manipulating outcomes (accepting or rejecting arbitrarily) rather than by simulating realistic users, completely decoupling the agent's reward from its actual performance.

Prior work on self-play dialogue (e.g., negotiation and goal-oriented settings; Lewis et al., 2017; Wei et al., 2018) treated the user simulator as a monolithic opponent to be trained symmetrically with the agent. More recent LLM-based self-evolution frameworks (Chen et al., 2024; Zhao et al., 2025; Huang et al., 2025) extended this paradigm to reasoning and code, but operate in domains where correctness is objectively verifiable—a solver either gets the right answer or doesn't, independent of any adversary's subjective judgment. Service dialogue lacks this property entirely: "success" means the user decided to agree, which is a subjective judgment internal to the user model. In a monolithic setup, training the user model to serve as an adversary inherently teaches it to make that judgment adversarially, breaking the training signal.

What makes SEAD's solution distinctive is that it recognizes the problem is not that the user model is adversarial, but when it can exercise that power. By decomposing user modeling into a Profile Controller (which selects initial conditions $p_0$ but cannot intervene during dialogue) and a fixed User Role-play Model (which simulates behavior during dialogue but is never trained), SEAD restricts adversarial optimization to the only degree of freedom that constitutes legitimate curriculum design: which difficulty level the agent faces. The fixed role-play model cannot be corrupted by training because it is never trained; its acceptance/rejection decisions genuinely depend on the agent's persuasion quality, not on optimization pressure. The trainable Profile Controller can only influence outcomes indirectly, by betting on which initial states will produce ~50% success rates—and it wins this bet only when it correctly estimates the agent's current capability.

This is a fundamental reframing of the self-play paradigm for subjective-outcome domains. It shifts the problem from "how do we prevent the adversary from cheating?" (an arms race that prior work has consistently lost) to "how do we redesign the game so cheating is structurally impossible?" (a mathematical constraint enforced by the component decomposition). The ablation study (Table 3) provides the cleanest evidence for this claim: training the unified user model (Config 1) causes catastrophic reward hacking—the simulator collapses to extreme behaviors (arbitrary acceptance or hang-ups), humanness degrades to 3.3/5 (vs. 4.7/5 for SEAD), and task completion drops from 52.0% to 35.2%. The 47.7% relative improvement in completion rate when switching from the adversarial to the decomposed setup is not a hyperparameter tuning gain—it is the difference between a broken training process and a functional one.

The "betting game" framing—though the paper does not use this exact term—is conceptually powerful because it connects to a well-established principle across machine learning: adversarial training works when the adversary's action space is constrained to setting difficulty, but fails when the adversary can directly manipulate rewards. This principle appears in GANs (where the discriminator can only classify, not generate), in curriculum learning (where the teacher selects examples but doesn't modify their labels), and in multi-agent RL (where designing the game structure to prevent exploitation is a central concern). SEAD applies this principle to the novel domain of LLM-based service dialogue, creating a blueprint for how to structure self-play when the "win condition" is a subjective judgment by one of the players.

Innovation 2: Adaptive Curriculum Learning via Completion-Rate Statistics as a Training Signal for the Difficulty Controller

The second distinctive contribution is the mechanism by which the Profile Controller learns to select appropriate difficulty levels without explicit per-dialogue rewards. Prior work on curriculum learning for RL typically requires one of two approaches: (1) hand-designed curricula where a human specifies which scenarios to introduce when (brittle, domain-specific, doesn't scale), or (2) learned curricula where a teacher model receives explicit rewards for student performance and adjusts accordingly (requires designing a teacher reward function that doesn't incentivize gaming). SEAD introduces a third approach that is both simpler and more robust: the Profile Controller samples initial states with probability proportional to $1 - |\text{CR} - 0.5|$ , where CR is the empirically observed completion rate for that state combination, computed from the trajectory history.

What makes this mechanism intellectually distinctive is that it works without any gradient-based optimization of the Profile Controller. The Controller does not have trainable parameters in the neural-network sense—it maintains a sampling distribution over the 120 state combinations, updated purely based on aggregated completion statistics. There is no backpropagation through the Controller, no reward function for the Controller to maximize, and no risk of the Controller learning to exploit a misspecified reward signal. The "learning" is purely statistical: as the agent improves, completion rates shift, the $1 - |\text{CR} - 0.5|$ weights shift, and the sampling distribution automatically tracks the agent's current difficulty frontier.

This is a new diagnostic concept for self-evolving systems: that a non-parametric statistical controller can serve as an effective curriculum designer when the state space is discrete and the optimality criterion (50% success rate) is simple. The paper demonstrates that this approach achieves automatic difficulty escalation—as the 14B agent improves through GRPO training, state combinations that were previously too hard become tractable, their CR crosses 0.4, and they enter the "ideal" sampling band naturally, without any manual phase scheduling or progress tracking. The paper explicitly claims this mechanism "enables our 14B model to surpass 72B models and commercial APIs" (Section 3.2, Phase 4 description), attributing the performance to the curriculum rather than to the base model quality or the RL algorithm.

The ablation study (Table 3) provides the supporting evidence: removing the Mistake Analysis phase (Config 3, "w/o MA")—which means the Profile Controller samples uniformly from all 120 states without difficulty adaptation—reduces completion rate from 52.0% to 45.8%, a 11.9% relative degradation. This is a substantial drop that cannot be attributed to noise, and it isolates the contribution of adaptive curriculum selection from the rest of the framework. The gap between "w/o MA" and "w/o MA + w/o PS" (45.8% vs. 40.5%) further shows that having any structured profile space is better than none, but the adaptive selection within that space is what drives the majority of the gain.

Compared to prior work on learned curricula for dialogue (which typically uses reinforcement learning or bandit algorithms to select scenarios, adding complexity and potential for reward hacking), SEAD's statistical approach is both simpler and more transparent. It makes the curriculum design process fully interpretable—one can inspect which state combinations are currently in the ideal band and track how the active training distribution shifts over iterations—which is valuable for debugging and domain understanding.

Innovation 3: The Simulator Does Not Need to Be Trained—and Training It Actively Damages It

This is the paper's most important negative result, and it has implications that extend beyond service dialogue to any self-play system where one component's role is to simulate realistic behavior rather than to optimize a score. The finding is simple but profound: training the User Role-play Model to be adversarial degrades its ability to simulate realistic users, because the training objective (maximize adversarial success) is fundamentally misaligned with the evaluation objective (realistic role-play). The ablation study (Table 3, Config 1) quantifies this: a trained user model achieves only 3.3/5 humanness (vs. 4.7/5 for the fixed model in SEAD) while simultaneously producing worse agent training outcomes (35.2% CR vs. 52.0%).

This result challenges a widespread assumption in the self-play literature that both sides of an adversarial game should be trained symmetrically. In game-playing (chess, Go, StarCraft), symmetric training works because both sides share the same objective (winning) and improving either side improves the training signal for the other. In dialogue, the objectives are asymmetric: the agent's objective is to persuade, while the simulator's "objective" should be to behave like a real person—an objective that cannot be captured by any simple reward function, because realistic behavior is defined by fit to a distribution (human conversational patterns) rather than by optimization of a scalar signal.

The paper implicitly makes a deeper argument: the quality of a user simulator should be measured by its fidelity, not by how difficult it makes training. Prior work on interactive simulation (Sekulić et al., 2024; Zhu et al., 2025) often conflates simulator quality with adversarial strength—if the simulator makes training harder, it must be better. SEAD demonstrates that this is backwards: an unrealistically strong simulator (one that rejects regardless of agent quality) provides no training signal at all, while an unrealistically weak one (one that accepts regardless) teaches shallow strategies. Optimal training requires that simulator difficulty be separated from simulator realism—the Profile Controller controls difficulty (by selecting initial states), while the fixed User Role-play Model maintains realism (by faithfully simulating how a user with those initial conditions would react).

This distinction has implications for the broader field of LLM-based simulation and evaluation. If training a simulator to be adversarial degrades its realism, then (1) simulator quality should be evaluated on held-out human judgments of realism, not on the agent's training performance; (2) frozen, prompted simulators may be preferable to fine-tuned ones for any application where fidelity matters; and (3) the only components that should receive adversarial training are those whose role is explicitly to manage difficulty, not those whose role is to simulate behavior. This principle could guide the design of self-play systems for negotiation, debate, and other subjective-outcome domains beyond service dialogue.

Innovation 4: A 14B Self-Evolved Agent Outperforms a 560B Dialogue-Specialized Model and GPT-4o with Zero Annotated Data—Establishing a New Pareto Frontier for Cost-Efficient Service Dialogue

While performance numbers alone do not constitute an intellectual contribution, the pattern of results in Table 1 reveals something structurally significant about the relationship between model scale, training data, and dialogue capability. The 14B Qwen2.5-Instruct base model (zero-shot prompted, no training) achieves 38.7% completion rate. Scaling to 72B parameters (same prompt) improves this only marginally to 39.0%—a negligible gain for a 5× increase in parameters. GPT-4o (presumably much larger than 72B, with extensive dialogue training) reaches 44.2%. LongCat-Flash, a 560B model specifically designed and pretrained for dialogue tasks, achieves 42.2%. Then SEAD, using the same 14B base model but trained via co-evolutionary self-play with zero annotated dialogue data, achieves 52.0%.

The key insight is not that SEAD is "better" in absolute terms—it is that the returns to model scale and annotated data are dramatically sublinear in this domain compared to the returns from structured self-play training. Going from 14B to 560B parameters (40× scale-up) buys ~3.5 percentage points of completion rate (38.7% → 42.2%). Going from zero-shot prompting to GPT-4o-quality training buys ~5.5 points (38.7% → 44.2%). But going from zero-shot prompting to SEAD's self-play training buys ~13.3 points (38.7% → 52.0%)—roughly 2.5× the gain of either scaling axis alone, using the smallest model.

This pattern suggests that service dialogue capability is bottlenecked not by model capacity or by the availability of human demonstrations, but by exposure to diverse, adaptively calibrated interactive experiences. This is a significant reframing of where the "scaling bottleneck" lies for dialogue systems. The dominant narrative in the LLM community—that bigger models with more pretraining data will subsume all downstream capabilities—predicts that model scale should dominate training methodology. The SEAD results challenge this narrative for service dialogue specifically: a 14B model that has experienced ~50,000 interactive training dialogues (rough estimate based on batch size 60, 120 state combinations, up to 200 samples each, over multiple iterations) outperforms a 560B model that has been pretrained on trillions of tokens and specialized for dialogue. The interactive experience—not the static pretraining data—is what builds the strategic, adaptive, persuasion-oriented reasoning that service dialogue demands.

This finding connects to a broader literature on the limits of scaling for tasks requiring interactive reasoning (as opposed to knowledge recall or pattern matching). It suggests that for domains where success depends on modeling a counterparty's mental state and adapting strategy turn-by-turn, static pretraining data provides coarse understanding but interactive training provides the fine-grained adaptive skill—and that the latter cannot be substituted by the former, regardless of scale. This is a testable hypothesis that the paper implicitly advances, even though it doesn't state it in these terms.

The practical implication—that a 14B self-trained model running on 8 A100s can replace a commercial API costing hundreds of dollars per thousand calls—is significant for deployment economics, but the intellectual contribution is the evidence that the deployment economics gap exists because of a fundamental mismatch between what static pretraining provides and what interactive service dialogue requires, not because of temporary engineering limitations that larger models will eventually overcome.

5. Experimental Analysis

Evaluation Methodology

Dataset. The paper evaluates on outbound call service dialogues for restaurant service promotion—convincing restaurant owners to participate in promotional activities. There is no pre-existing benchmark dataset; instead, the evaluation environment is constructed from three inputs: (1) Standard Operating Procedures (SOP) defining the desired dialogue flow, (2) a task objective description, and (3) user profiles drawn from a behavior library $\mathcal{L}$ containing anonymized behavior patterns extracted from over 100,000 real enterprise dialogues. The absence of a standardized benchmark means all evaluations are conducted within the paper's own simulated environment—there is no human-evaluated test set of real service dialogues against which completion rates are measured. The evaluation relies entirely on the User Role-play Model's determination of dialogue outcomes as the ground truth for success.
Base model(s). All components—Profile Controller, User Role-play Model, and Service Agent—use Qwen2.5-14B-Instruct as the base architecture. The paper also evaluates three larger Qwen2.5-Instruct variants (32B, 72B) as zero-shot baselines. The choice of Qwen2.5-14B-Instruct for SEAD is motivated by its representation of "a canonical approach" for mid-scale open-source LLMs. The paper does not report experiments with other model families (e.g., LLaMA, Mistral, DeepSeek), meaning all results are conditional on the Qwen architecture and pretraining distribution.
Metrics. The paper reports six metrics for service agent evaluation. Completion Rate (CR): the percentage of dialogues where the User Role-play Model determines the user accepted the service offer (outcome = success). This is the primary metric and directly encodes the business objective. Average Turns to Target (ATT): the mean number of agent turns (utterances) in successful dialogues only—lower values indicate more efficient persuasion that closes deals faster. Standard deviations are reported as superscripts in Table 1. User Portrait Accuracy (UPA): the accuracy of the agent's explicit state estimates $\hat{s}_t$ compared to the User Role-play Model's true internal state, computed as $\text{UPA} = 1 - \frac{1}{3}(\frac{\text{MAE}_c}{4} + \frac{\text{MAE}_e}{3} + \frac{\text{MAE}_{tr}}{5})$ , where $\text{MAE}_c$ , $\text{MAE}_e$ , $\text{MAE}_{tr}$ are mean absolute errors for cooperation (range $[0,4]$ ), emotion (range $[0,3]$ ), and trust (range $[0,5]$ ), respectively, normalized by each dimension's maximum value. A UPA of 1.0 means perfect state tracking. Emotion Improvement (EI), Trust Improvement (TI), Cooperation Improvement (CI): average change in each state dimension from initial state $p_0$ to final state $p_T$ across all dialogues. Positive values indicate the agent, on average, moved users toward better states. Total Cost: cumulative inference cost in CNY for processing 1,000 multi-turn dialogue samples (applicable only to API-based models, calculated at standard commercial rates). For user role-play model evaluation, the paper uses GPT-5.1 with few-shot human annotations to score five dimensions on 0–5 scales: Humanness, Emotion realism, Trust realism, Cooperation realism (higher = more human-like), and Violation (higher = more severe unnatural behavior; optimal is low, reflecting real users' natural hesitation at score ~1).
Baselines. The paper compares against two categories. Foundation Models (zero-shot): Qwen2.5-14B-Instruct, Qwen2.5-32B-Instruct, and Qwen2.5-72B-Instruct, all using "carefully designed prompts that include task descriptions and standard operating procedures" without any task-specific training. Large Model APIs: GPT-4o (Hurst et al., 2024), DeepSeek-Chat (671B parameters; Liu et al., 2024), Qwen3-235B-A22B (Team et al., 2024), and LongCat-Flash-Chat (560B parameters, specifically designed for dialogue tasks; Team et al., 2025). All API models use "carefully engineered prompts optimized for dialogue tasks." The paper explicitly does not compare against Supervised Fine-Tuning (SFT) methods, citing "the lack of available data and the prohibitive cost of manual annotation" as the reason—this is a significant omission since SFT on even a modest amount of annotated dialogue data would be the most natural baseline for a zero-data method. The paper argues SFT methods "are upper-bounded by data quality and exhibit poor generalization," but this claim is not empirically tested.
Generation budget / compute accounting. There is no explicit generation budget constraint—the Service Agent and User Role-play Model engage in dialogues that terminate naturally when the user accepts, refuses, or the conversation reaches $T_{\max} = 15$ turns. Compute cost is instead measured indirectly through model size (parameters) for open-source models and through API inference pricing (CNY per 1,000 samples) for commercial models. The paper emphasizes that SEAD's trained 14B agent incurs zero API inference cost (self-hosted on 8×A100 GPUs), creating a favorable cost comparison against commercial APIs (GPT-4o: 727.28 CNY per 1,000 samples; DeepSeek-Chat: 87.36 CNY; Qwen3-235B: 69.36 CNY; LongCat-Flash: 23.08 CNY). The cost of training SEAD itself (GPU-hours for the full co-evolutionary loop) is not reported, making the total cost of ownership comparison incomplete—the zero inference cost is offset by non-trivial training cost that is never quantified.
Cross-validation / statistical protocol. The paper does not report any cross-validation, statistical significance testing, or confidence intervals beyond standard deviations on ATT and UPA metrics. The 120 state combinations serve as the full evaluation space, and completion rates are computed across all dialogues generated during training and evaluation. The ablation study in Table 3 compares four configurations, but the paper does not specify whether results are averaged over multiple random seeds or training runs, which is a concern for reproducibility given the known sensitivity of RL training to initialization and hyperparameters. The user role-play model evaluation (Table 2) uses GPT-5.1 as an evaluator with few-shot human annotations, but no inter-annotator agreement or evaluator calibration metrics are reported, making it unclear how reliable the 4.5–4.7/5 humanness scores are as absolute measures of simulator quality.

Main Quantitative Results

Service Agent Performance Against Foundation Models and Commercial APIs (Table 1)

The headline result is that SEAD's 14B trained agent achieves a 52.0% completion rate, outperforming all baselines by substantial margins:

Versus zero-shot open-source models: SEAD improves over the untrained Qwen2.5-14B-Instruct base model by 13.3 percentage points (52.0% vs. 38.7%), representing a 34.4% relative improvement. The scaling pattern for untrained models is remarkably flat: 14B achieves 38.7%, 32B achieves 38.3% (worse than 14B), and 72B achieves 39.0%. This near-zero return to model scale (a 5.1× parameter increase yields only 0.3 percentage points of improvement) suggests the base models fundamentally lack the strategic persuasion capabilities needed for service dialogue, regardless of capacity.
Versus GPT-4o: SEAD outperforms GPT-4o by 7.8 percentage points (52.0% vs. 44.2%), a 17.6% relative improvement, while using a model estimated to be at least an order of magnitude smaller (GPT-4o's parameter count is not disclosed but is widely believed to exceed 1T parameters based on inference cost and capability). This is the paper's strongest comparative claim because GPT-4o represents the state-of-the-art in commercial LLM capabilities. However, GPT-4o's evaluation uses only prompt engineering without any task-specific fine-tuning or reinforcement learning—it is not an apples-to-apples comparison against a system that has undergone thousands of training episodes in the exact deployment environment.
Versus DeepSeek-Chat (671B MoE): SEAD achieves 52.0% vs. 31.6%—a 64.6% relative improvement. DeepSeek-Chat's unusually low completion rate (worst among all baselines) is not discussed or explained in the paper. It is possible that DeepSeek-Chat's training distribution or alignment characteristics make it particularly unsuited for persuasive outbound sales dialogue, but without analysis this remains speculation.
Versus Qwen3-235B: SEAD achieves 52.0% vs. 32.3%, a similar massive gap. The consistent underperformance of the two largest open-weight models (DeepSeek-Chat at 671B, Qwen3 at 235B) relative to much smaller models (Qwen2.5-32B at 38.3%) further reinforces the finding that raw model scale does not translate to service dialogue capability in the zero-shot setting.
Versus LongCat-Flash (560B, dialogue-specialized): SEAD achieves 52.0% vs. 42.2%, a 23.2% relative improvement. LongCat-Flash is the most relevant baseline because it is specifically designed and pretrained for dialogue tasks, representing the best available commercial system purpose-built for this domain. The 9.8 percentage point gap favoring SEAD, despite a 40× parameter disadvantage, is the paper's strongest evidence that structured self-play training provides capabilities that even massive dialogue-specific pretraining cannot replicate.

Dialogue efficiency (ATT). SEAD achieves the lowest Average Turns to Target at 9.6 turns, tied with Qwen2.5-72B-Instruct (9.6 ± 2.18). This means SEAD not only succeeds more often but also closes successful deals more efficiently—convincing users in fewer turns than GPT-4o (10.8 turns), DeepSeek-Chat (11.3 turns), or Qwen3-235B (10.4 turns). The standard deviation of ±2.09 for SEAD's ATT indicates relatively consistent performance: most successful dialogues fall within ~7.5–11.7 turns. This efficiency improvement (11.1% reduction in turns compared to GPT-4o's 10.8) matters practically because shorter calls mean higher throughput in production deployment and less user fatigue.

User state tracking (UPA). SEAD achieves a User Portrait Accuracy of 0.912, slightly below LongCat-Flash (0.925) but substantially above GPT-4o (0.867) and all Qwen base models (0.765–0.899). This result is notable because LongCat-Flash's advantage in state tracking is intuitive—its 560B parameters and dialogue-specific pretraining should give it superior user modeling capabilities—yet SEAD nearly matches it while dramatically exceeding it on the task completion metric that ultimately matters. The paper interprets this as evidence that "our self-evolution approach with adaptive curriculum learning enables a compact 14B model to match the user understanding capabilities of a 560B dialogue-specialized model, while requiring zero annotated dialogue data and maintaining superior task completion performance." This interpretation emphasizes a key point: accurate state tracking is necessary but not sufficient for task success—knowing the user's emotional state does not guarantee knowing what to say next.

User state improvement (EI, TI, CI). SEAD achieves the highest Emotion Improvement (0.63) and Trust Improvement (1.57) among all methods, and ties LongCat-Flash on Cooperation Improvement (1.55 vs. 1.56). All three improvement metrics are positive for SEAD, confirming that its dialogues tend to leave users in better states than they started—the agent is genuinely persuasive rather than simply aggressive. The comparison with GPT-4o is instructive: GPT-4o achieves near-zero EI (0.04) and modest TI (0.97), suggesting it maintains user state rather than improving it, perhaps by being overly cautious or generic. DeepSeek-Chat and Qwen3-235B show negative EI (−0.20 and −0.24), meaning their dialogues, on average, leave users more emotionally negative than they started—a clear sign of strategic failure.

Cost efficiency. SEAD's zero inference cost (self-hosted, no API fees) contrasts sharply with commercial APIs: GPT-4o costs 727.28 CNY per 1,000 samples, DeepSeek-Chat 87.36 CNY, Qwen3-235B 69.36 CNY, and LongCat-Flash 23.08 CNY. This comparison understates SEAD's cost advantage somewhat unfairly because the cost of GPUs, electricity, and engineering time to run SEAD is not zero—but the paper's framing is that once trained, the agent can be deployed on existing infrastructure with negligible marginal cost per dialogue. The training cost itself is not amortized into these figures, which represents an incomplete accounting.

User Role-Play Model Quality Validation (Table 2)

The paper validates its fixed User Role-play Model's realism by evaluating its behavior when interacting with three agent quality tiers: perfect human agents (presumably hand-crafted optimal dialogues), SEAD-trained agents, and low-quality agents (presumably weak or untrained models). GPT-5.1 evaluates five dimensions on 0–5 scales:

Humanness: Scores of 4.7–4.8 across all three agent tiers, with standard deviations of 0.2–0.3. The near-identical humanness scores regardless of agent quality demonstrate that the simulator maintains realistic behavior even when facing very different agent strategies—it does not break character or resort to mechanical responses when the agent is poor. The paper claims these scores are "near-perfect" (>4.5/5), though what constitutes a perfect score on a 0–5 GPT-5.1 evaluation scale is not calibrated against any external ground truth.
Emotion, Trust, Cooperation realism: All three dimensions score 4.6–4.8 across agent tiers, with the highest scores appearing for the perfect human agent condition (4.8 on emotion and trust). The consistency across tiers is again the key finding: the simulator's emotional responses, trust dynamics, and cooperation patterns remain realistic whether the agent is competent or incompetent.
Violation: Scores of 1.10–1.15 across agent tiers. The paper explains that "in real scenarios, most users exhibit minimal noise (score 1: hesitation, pauses) rather than severe violations; our simulator achieves 1.15, matching real behavior." This is an important calibration claim—the simulator is not artificially clean (which would make training too easy) but exhibits the natural imperfections of real users (hesitations, minor attention lapses, etc.). The slightly higher violation score for the SEAD-trained agent condition (1.15 vs. 1.10 for perfect human agents) suggests that the simulator becomes marginally less smooth when dealing with a competent but imperfect agent, which is consistent with realistic user behavior (real users display more hesitation when the agent is not perfectly polished).

The paper does not report what happens to these metrics when the User Role-play Model is trained adversarially (the Config 1 ablation), except that humanness drops to 3.3/5 (reported in Table 3's URM-H column). This 1.4-point degradation on a 5-point scale is the quantitative evidence for the paper's claim that training the user model causes it to "collapse into extreme responses."

Ablation Studies and Robustness Checks

Training the User Role-play Model adversarially (Config 1: w/o MA + w/o PS + Train URM): This configuration represents traditional symmetric self-play where both the service agent and the user model are trained adversarially. The results in Table 3 show catastrophic degradation: Completion Rate drops from 52.0% (SEAD full) to 35.2%—a 32.3% relative decrease and worse than the untrained 14B baseline (38.7%). User Portrait Accuracy collapses to 0.294, compared to 0.912 for full SEAD—the agent essentially loses its ability to track user states. State improvement metrics are similarly devastated: EI drops from 0.63 to 0.25, TI from 1.57 to 0.04, and CI from 1.55 to 0.26. The User Role-play Model humanness score (URM-H) falls to 3.3/5 (vs. 4.7 for SEAD). ATT increases to 12.5 turns, indicating that even when the agent does succeed, it takes longer. This ablation provides the strongest evidence for the paper's central claim: decomposing user modeling and keeping the role-play model fixed is not a minor optimization but a necessary condition for the training to work at all. The "catastrophic reward hacking" the paper describes—the simulator "prioritizes adversarial scores over realism, collapsing into extreme responses (arbitrary acceptance or hang-ups)"—is empirically validated.

Removing both Mistake Analysis and Profile Sampling (Config 2: w/o MA + w/o PS): This configuration keeps the User Role-play Model fixed but removes both adaptive mechanisms—there is no structured profile space with 120 combinations and no statistics-driven curriculum. The results show CR dropping from 52.0% to 40.5%, a 22.1% relative decrease. UPA collapses to 0.450 (less than half of full SEAD's 0.912), indicating the agent cannot learn to track user states without structured profile variation. Notably, TI is anomalously high at 1.87 (even higher than SEAD's 1.57), despite the low UPA. The paper interprets this as "revealing a bias toward unrealistically easy scenarios"—without the Profile Controller's structured difficulty management, the training distribution becomes skewed toward easy profiles where trust improves trivially, but the agent never develops robust state-tracking abilities. This result demonstrates that decomposed user modeling alone (fixed URM) is insufficient; structured difficulty management is essential.

Removing Mistake Analysis while keeping Profile Sampling (Config 3: w/o MA): This configuration retains the 120-state profile space but removes the adaptive difficulty feedback loop—the Profile Controller samples uniformly from all states rather than prioritizing those with completion rates near 50%. CR drops from 52.0% to 45.8%, an 11.9% relative decrease. This is a smaller degradation than removing Profile Sampling entirely (Config 2's 40.5%), confirming that having a structured state space matters more than adaptively sampling from it—but the adaptive mechanism still provides a meaningful additional gain. UPA drops modestly from 0.912 to 0.877, and state improvement metrics remain relatively competitive (EI: 0.58 vs. 0.63, TI: 1.52 vs. 1.57, CI: 1.50 vs. 1.55), suggesting that adaptive difficulty primarily affects success rate rather than per-dialogue persuasion quality. The paper claims this ablation "proves that structured Profile Sampling ensures behavioral diversity," but more precisely, it proves that structured sampling is the larger contributor to the gain (the jump from 40.5% to 45.8%) while adaptive difficulty provides incremental improvement (45.8% to 52.0%).

Full SEAD (Config 4): The complete framework achieves the optimal balance: CR 52.0%, ATT 9.6, UPA 0.912, EI 0.63, TI 1.57, CI 1.55, and URM-H 4.7. The paper claims a "47.7% relative CR improvement over adversarial training," which is calculated as (52.0 − 35.2) / 35.2 = 47.7%. This comparison, while technically accurate, somewhat overstates the case by using the worst-performing configuration as the denominator—the improvement over the more relevant Config 2 (neither adaptive mechanism) is 28.4%, and over Config 3 (structured sampling without adaptivity) is 13.5%.

Robustness to user profile generation (implicit ablation). The paper does not conduct an explicit ablation on the user behavior library $\mathcal{L}$ —for example, comparing SEAD trained with the full 100k-dialogue-derived behavior patterns against SEAD trained with a reduced or synthetic behavior set. This is a significant omission because the behavior library is the only component that depends on real-world data, and its size and quality are not characterized. If the 100k real enterprise dialogues are essential for the behavior library's diversity, then SEAD is not truly "zero-data" in the sense implied—it still requires access to a substantial corpus of (anonymized, pattern-extracted) real interactions, even if not annotated dialogues.

Critical Assessment

Do the experiments support the claim that SEAD requires "no large-scale annotated dialogue data"?

Partially, with a significant caveat. SEAD's training loop indeed does not consume annotated dialogues—the only inputs are SOPs, task descriptions, and user profiles. However, the user behavior library $\mathcal{L}$ is extracted from "over 100k real enterprise dialogues" (Section 4.6), which constitutes a substantial corpus of human conversational data even if it is not manually annotated. The paper claims this library contains "anonymized behavior patterns" and frames it as distinct from "annotated dialogue data," but behavior pattern extraction from 100k real calls is itself a non-trivial data processing pipeline that the paper does not describe in detail. A purist interpretation of "zero-data" would require the behavior library to be constructed synthetically or through expert knowledge, without access to real call logs. The paper does not test whether SEAD works with such a synthetic behavior library, making the "zero-data" claim partially dependent on access to a large corpus of real (if unannotated) user interactions.

Do the experiments support the claim that SEAD's 14B agent "significantly outperforms" GPT-4o and LongCat-Flash?

Yes, but the comparison is inherently unfair in one direction and arguably fair in the other. The comparison is unfair to the baselines in that GPT-4o and LongCat-Flash are evaluated zero-shot (prompt only), while SEAD undergoes thousands of training episodes in the exact evaluation environment. No reasonable person would expect a prompted model to match a model that has been specifically trained for the task—the more informative comparison would be against GPT-4o or LongCat-Flash with equivalent task-specific fine-tuning or RL training, which the paper does not conduct (and likely cannot, since fine-tuning GPT-4o is not generally available). The comparison is arguably fair in the opposite direction: SEAD trains on no human demonstrations, while GPT-4o and LongCat-Flash were trained on vast corpora that undoubtedly include service dialogue examples, transcripts, and related materials. A prompted model with encyclopedic pretraining knowledge about persuasion and sales conversations should have an advantage over a model that learns entirely from scratch in simulation—yet SEAD wins. This makes the result more convincing than it first appears: SEAD is not being given more information than the baselines (it has far less), but it is being given the right kind of experience (interactive, adaptive, outcome-driven).

Do the experiments support the claim that decomposed user modeling "enables genuine adversarial learning"?

Strongly supported by the ablation study (Table 3), but with a limited definition of "genuine." The ablation shows that training the user model adversarially (Config 1) produces a catastrophic 32.3% relative drop in completion rate and a 1.4-point degradation in humanness. This is clear evidence that the decomposed design prevents a specific failure mode (adversarial reward hacking). However, "genuine adversarial learning" is a stronger claim that implies the training process produces an agent that is robust against genuinely adversarial users—users who actively try to resist persuasion, not just users with varying initial difficulty levels. The paper's case studies (Figure 4) show the agent handling "Rude & Irrational" and "AI-Skeptical" users, but these are fixed behavior patterns from the library, not active adversaries optimizing against the agent. SEAD's training does not include an adversary that learns to counter the agent's evolving strategies—the Profile Controller only adjusts initial difficulty, not mid-dialogue adversarial tactics. Whether the resulting agent would be robust against a genuinely adversarial human or an adversarially optimized simulator is not tested.

Do the experiments support the claim that the Profile Controller "identifies golden training scenarios where agents can succeed approximately half the time"?

Partially supported by the comparison between Config 3 (w/o MA, uniform sampling) and full SEAD (with MA, adaptive sampling). The 6.2 percentage point improvement in CR (45.8% to 52.0%) demonstrates that adaptive difficulty selection provides a meaningful training benefit. However, the paper does not directly verify that the Profile Controller actually samples states with completion rates near 50%—it only reports the downstream effect on agent performance. A direct verification would show the distribution of completion rates for sampled states over training iterations, demonstrating that the sampling distribution indeed concentrates around 0.5. Without this analysis, the mechanism is inferred from the performance improvement rather than directly observed. Additionally, the paper does not test alternative difficulty-selection strategies (e.g., sampling from states with CR = 0.3–0.7, or using different kernel functions than $1 - |\text{CR} - 0.5|$ ), so it is unclear whether the 50% target is truly optimal or whether other difficulty bands would work equally well.

Weaknesses in experimental design

Single model family (Qwen2.5). All components use Qwen2.5-14B-Instruct as the base architecture. The paper does not test whether SEAD's benefits transfer to other model families (LLaMA, Mistral, DeepSeek). This matters because the Qwen architecture and pretraining distribution may have specific properties that make the decomposition approach work well—for example, the base model's ability to simulate realistic user behavior without fine-tuning might be architecture-dependent. If SEAD requires a base model with strong role-playing capabilities out of the box, then the approach is not universally applicable to any LLM.

Simulated evaluation only. All metrics—completion rate, state tracking accuracy, state improvement—are measured against the User Role-play Model's determinations, not against real human judgments. The paper never validates whether the simulator's notion of "success" (user agreement) or "state change" (cooperation/emotion/trust shifts) correlates with what real restaurant owners would actually do or feel when called by a service agent. The user role-play model quality evaluation (Table 2) shows that the simulator appears realistic to GPT-5.1 when shown examples, but this is a surface-level assessment—it does not establish that the simulator's acceptance/rejection decisions are calibrated to real human behavior. An agent that achieves 52% CR against the simulator might achieve 30% or 70% against real restaurant owners, and the paper provides no evidence either way.

No real-world deployment results. The paper reports only simulated metrics. It does not include a pilot deployment where SEAD-trained agents actually called real restaurant owners and the completion rate was measured against ground-truth outcomes. This is a critical gap for a paper whose primary motivation is real-world service dialogue deployment. Without deployment results, the 52.0% completion rate is best understood as an upper bound on what might be achievable in practice, conditioned on the simulator's fidelity being perfect.

Missing baselines. The most significant absent baseline is an agent trained via supervised fine-tuning on a modest amount of annotated dialogue data (e.g., a few hundred to a few thousand human-labeled conversations). The paper argues that SFT is limited by data quality, but this is a claim that should be tested, not assumed. If 100 annotated calls could achieve comparable performance to SEAD's 52.0% CR, the economic case for SEAD's complex training pipeline would be substantially weaker. An RL-from-human-feedback (RLHF) baseline using a small amount of human preference data would also be informative, since this is the standard approach for aligning LLMs to subjective human preferences.

No training cost accounting. The paper reports inference costs for commercial APIs but does not report the GPU-hours required to train SEAD. Training a 14B model via GRPO across potentially thousands of iterations (each involving 60 multi-turn dialogues) is computationally significant. For a practitioner deciding between using GPT-4o (727 CNY per 1,000 samples, zero training cost) and training SEAD (zero inference cost, unknown training cost), the missing training cost figure makes the economic comparison incomplete.

Small and domain-specific evaluation. The evaluation is limited to a single service domain (restaurant promotion) with a single agent objective. The paper does not test whether SEAD-trained agents generalize to other service domains (e.g., insurance sales, appointment scheduling, customer retention) or whether the training framework transfers without substantial re-engineering of the user state space and behavior library.

Lack of statistical rigor. No confidence intervals, standard errors, or significance tests are reported for completion rates (the primary metric). The paper reports standard deviations for ATT and UPA in Table 1, but does not explain how these were computed (across dialogues? across training runs? across evaluation episodes?). The ablation study (Table 3) compares four configurations, each presumably run once—without multiple random seeds, it is impossible to determine whether the 6.2 percentage point gap between Config 3 and full SEAD is statistically significant or within the noise floor of RL training variance.

Evaluation of user role-play model relies on a single LLM judge. The humanness, realism, and violation scores in Table 2 are all produced by GPT-5.1 with few-shot human annotations. While LLM-as-judge is an increasingly common evaluation methodology, its reliability depends on calibration against human judgments, which the paper does not report. Additionally, using a commercial API (GPT-5.1) as the evaluator while simultaneously comparing against other commercial APIs (GPT-4o) as baselines introduces a potential evaluator bias—the judge and one of the baselines share architectural lineage, which could advantage or disadvantage GPT-4o's scores in unknown ways.

6. Limitations and Trade-offs

1. All Evaluation Is Simulated — Zero Real-World Deployment Validation

The assumption or constraint: SEAD's entire evaluation—completion rates, state tracking accuracy, user state improvements, and even the user role-play model's humanness—is conducted within the paper's own simulated environment. The User Role-play Model serves as both the training opponent and the evaluator: its internal state transitions and outcome decisions determine what counts as "success" in every metric reported in Tables 1–3. The paper never deploys a SEAD-trained agent against real restaurant owners to measure actual task completion rates against ground-truth human behavior.

The paper is transparent that its training requires no human dialogue data, but it does not acknowledge this as an evaluation limitation—it reports the 52.0% completion rate as if it were a performance metric with external validity, without discussing the gap between simulated and real outcomes. This is a foundational concern for a framework whose stated motivation is real-world service dialogue deployment.

The consequence: There is no evidence that the 52.0% completion rate measured against the simulator would translate to anything close to 52.0% against real restaurant owners. The gap could go in either direction and could be large:

The simulator may be easier than real users. Real restaurant owners interrupted during a busy shift may be more resistant, more skeptical, or more impatient than any behavior pattern captured in the 100k-dialogue library. Cultural nuances, regional communication styles, and context-specific objections that were not represented in the enterprise data used to build the behavior library $\mathcal{L}$ would not appear in training or evaluation, making the agent overfit to an incomplete distribution.
The simulator may be harder than real users in arbitrary ways. If the behavior patterns extracted from enterprise data overrepresent adversarial interactions (because failed calls are more memorable or numerous in the corpus), the simulator could be unrealistically aggressive, limiting the agent's true capability.
The simulator's success criteria may not match real success. The User Role-play Model determines "agreement" based on its internal state reaching some threshold. Real restaurant owners might agree verbally and then fail to participate in the promotion (no-shows), or might agree more readily than the simulator predicts because real people are persuadable through mechanisms the LLM simulator does not capture (voice tone, perceived authority, social obligation to be polite).

Absent a real deployment study, the 52.0% CR is best interpreted as the upper bound of what SEAD can achieve within its training distribution, with unknown degradation when that distribution fails to match reality. All comparisons to GPT-4o, LongCat-Flash, and other baselines are similarly confined to the simulator's judgment—GPT-4o's 44.2% CR is the simulator's assessment of GPT-4o's persuasiveness, which may not correlate with how real users would rate those same dialogues.

What evidence exists in the paper: None. The paper contains no pilot deployment, no A/B test against human agents, no comparison between simulator-predicted outcomes and real outcomes on any sample. The user role-play model quality evaluation (Table 2) shows that the simulator appears realistic to GPT-5.1 when shown examples, but this is a surface-level naturalness evaluation—it does not validate that the simulator's acceptance/rejection decisions are calibrated to real human behavior. A simulator could be rated 4.7/5 on humanness by GPT-5.1 and still accept or reject at rates that diverge sharply from real users.

Mitigation status: Not addressed. The paper's Limitations section acknowledges that "real-world applications demand high user satisfaction" and that "future work must better assess the agent's ability to perceive emotion and maintain user comfort," but this concerns satisfaction metrics, not the fundamental gap between simulated and real task completion. The authors do not frame the simulation-only evaluation as a limitation at all.

2. The Behavior Library Requires Access to 100k+ Real Enterprise Dialogues, Undermining the "Zero-Data" Claim

The assumption or constraint: The paper repeatedly frames SEAD as requiring "no large-scale annotated dialogue data" (Abstract, Section 1, contributions, Section 4.1), positioning this as its primary advantage over supervised fine-tuning and static synthesis approaches. The method description states that training "only needs: (1) Standard Operating Procedures (SOP) defining dialogue flow; (2) task objective description; (3) user profile" (Section 4.1).

However, the user behavior library $\mathcal{L}$ is explicitly built from "anonymized behavior patterns extracted from over 100k real enterprise dialogues" (Sections 3.4, 4.6). This corpus is not annotated in the traditional sense (no turn-level labels, no outcome annotations, no strategy tags), but it is still a large collection of real human conversations that required substantial data processing to extract behavior patterns from. The paper does not describe the extraction methodology, the filtering criteria, or the pattern taxonomy that maps raw dialogue to discrete behavior categories like "questioning AI identity" or "expressing cost concerns." It is unclear whether this extraction was automated (e.g., topic modeling or clustering on transcripts) or manual (human analysts reading calls and coding behaviors).

The consequence: The "zero-data" claim is only partially true. SEAD does not require annotated dialogue data for supervised training, but it does require access to a substantial corpus of real user interactions to construct a behavior library that is diverse and realistic enough to drive effective training. This has several practical implications that weaken the paper's primary value proposition:

New domain deployment is not truly zero-data. A company deploying SEAD for insurance sales, healthcare scheduling, or B2B contract negotiation would need an equivalent corpus of 100k+ real calls in that domain—or would need to construct a synthetic behavior library. The paper does not test SEAD with a synthetic or expert-constructed behavior library, so there is no evidence that it works without the real-corpus-derived patterns.
The behavior library quality may drive performance more than the training algorithm. If the specific behavior patterns in $\mathcal{L}$ —the AI skepticism, cost concerns, attention lapses, and other traits—are what make the training environment challenging and diverse, then domains without access to a comparable corpus may get substantially lower performance. The ablation study (Table 3) tests the effect of removing Profile Sampling and Mistake Analysis, but never tests the effect of degrading or reducing the behavior library.
The extraction pipeline is a hidden dependency. Even if 100k dialogues are available, extracting structured behavior patterns from them is a non-trivial NLP pipeline—likely involving transcription, speaker diarization, utterance classification, pattern clustering, and deduplication. The paper treats this as a given input rather than as part of the system, but a practitioner attempting to replicate SEAD would need to build this pipeline from scratch, with no guidance on methodology or quality thresholds.

What evidence exists in the paper: The paper provides no ablation on behavior library size, diversity, or source. There is no experiment showing SEAD performance when $\mathcal{L}$ is reduced to 10% of the real-corpus patterns, or when it is replaced with a synthetic library written by domain experts. The only evidence that the library matters comes indirectly: the case studies in Figure 4 show the agent handling behavior patterns like "Rude & Irrational" and "AI-Skeptical," which are presumably drawn from $\mathcal{L}$ . If these patterns were absent, the agent would face a less challenging and less realistic training distribution, potentially degrading real-world performance in unknown ways.

Mitigation status: Not addressed. The paper frames the behavior library as an input (like the SOP and task description) rather than as a data dependency. The Limitations section mentions "scenario diversity" as a future work direction—"we have not yet extended our method to multi-scenario environments"—but does not discuss the data requirements for the single-scenario behavior library itself.

3. The Approach Is Validated Only on Qwen2.5 Models in a Single Service Domain — No Evidence of Cross-Architecture or Cross-Domain Transfer

The assumption or constraint: Every component of SEAD—the Profile Controller, the User Role-play Model, and the Service Agent—uses Qwen2.5-14B-Instruct as its base model. The evaluation is conducted exclusively on a single task (restaurant service promotion via outbound calls) with a single user state space (120 combinations of 5 cooperation x 4 emotion x 6 trust levels) and a single behavior library derived from one enterprise's call logs.

The paper does not test whether SEAD's benefits persist when:

The base model architecture changes (LLaMA, Mistral, DeepSeek, Gemma)
The user role-play model is a different architecture or scale than the service agent
The service domain changes (insurance sales, appointment scheduling, tech support, retention calls)
The dialogue structure changes (inbound vs. outbound, text-based vs. voice, B2C vs. B2B)
The state space dimensions or granularity change (different numbers of cooperation/emotion/trust levels, or additional dimensions like urgency or product knowledge)

The consequence: The paper's findings may be contingent on properties of Qwen2.5-14B-Instruct that are not documented or understood. Several specific concerns arise:

The user role-play model's quality depends on the base model's role-playing capability. Qwen2.5-14B-Instruct might have unusually strong instruction-following or persona-adherence capabilities compared to other models of similar scale. If a different base model family produces less realistic or less controllable simulated users, the entire training loop could degrade—the fixed role-play model is the foundation on which the co-evolutionary dynamic rests. The paper never measures persona adherence or instruction-following for the User Role-play Model in isolation; it only measures the downstream humanness of the resulting dialogues via GPT-5.1 evaluation (Table 2).
The service agent's learning dynamics may be sensitive to the base model's RL-trainability. GRPO on Qwen2.5-14B might produce stable policy improvements because of architectural or pretraining properties that do not generalize. Different model families exhibit different sensitivities to RL training—some undergo catastrophic forgetting of general language capabilities under policy gradients, while others are more robust. Without testing across architectures, practitioners cannot know whether SEAD requires careful model selection or works out-of-the-box.
Single-domain evaluation provides no evidence of generalizable service dialogue capability. The agent learns to persuade restaurant owners about promotions. Would the same agent (or the same training framework applied to a new domain) perform well on persuading patients to schedule checkups, convincing customers to renew subscriptions, or negotiating payment terms with vendors? Service dialogues across domains differ in their persuasion dynamics, objection patterns, trust-building strategies, and success criteria. An agent trained in one simulated environment may have acquired domain-specific patterns rather than general persuasion skills.

What evidence exists in the paper: None. The paper evaluates only Qwen2.5 models on restaurant promotion. The Limitations section acknowledges this in passing: "we have not yet extended our method to multi-scenario environments. Given its independence from curated data, our framework holds promise as a resource-efficient foundation model for diverse service dialogues, a potential we plan to validate in subsequent studies." This framing treats cross-domain generalization as a future capability to be validated, but the current paper provides zero evidence for it.

Additionally, the flat scaling curve for Qwen2.5 models (14B: 38.7%, 32B: 38.3%, 72B: 39.0%) suggests that Qwen's pretraining distribution may be particularly weak on persuasive dialogue tasks compared to other model families—but without testing other architectures, we cannot distinguish between "persuasion is hard for all LLMs" and "Qwen is bad at persuasion."

Mitigation status: Acknowledged as future work in the Limitations section but not experimentally addressed. The paper positions this as a scope limitation rather than a methodological weakness.

4. Training Cost and Wall-Clock Time Are Not Reported — The Total Cost of Ownership Comparison Is Incomplete

The assumption or constraint: The paper's headline cost comparison (Table 1, "Total Cost" column) reports inference costs for commercial API models (GPT-4o: 727.28 CNY per 1,000 samples; LongCat-Flash: 23.08 CNY per 1,000 samples) and lists SEAD's cost as "0.00." This gives the impression that SEAD is free to operate, since it runs on self-hosted 8×A100 GPUs without per-call API fees.

The paper never reports:

Training GPU-hours required to converge the SEAD co-evolutionary loop to 52.0% CR.
Number of training iterations, total dialogues generated, or total tokens processed during training.
Amortized training cost per deployed dialogue for any reasonable deployment volume.
Wall-clock training time — whether the full training run takes hours, days, or weeks on the reported hardware.

The implementation details (Section 4.2) specify the batch size (60), learning rate (1×10⁻⁶), maximum dialogues per state combination (200), and hardware (8×A100 80GB), but do not report the total number of training steps, the convergence criterion, or any training curve showing CR improvement over iterations.

The consequence: The economic comparison between SEAD and commercial APIs is substantially incomplete. A practitioner evaluating whether to adopt SEAD needs to know:

Total training cost to reach deployment-quality performance. If SEAD requires 5,000 GPU-hours of A100 time to train, that represents a ~ $10,000–15,000 upfront investment (at typical cloud GPU pricing of$ 2–3/A100-hour). This cost must be amortized over the number of calls the agent will handle. At 100,000 calls, the amortized training cost is ~ $0.10–0.15 per call—comparable to LongCat-Flash's API pricing. At 10,000 calls, it is ~$ 1.00–1.50 per call—substantially more expensive than any API baseline. Without knowing the training cost, it is impossible to determine SEAD's breakeven deployment volume.
Retraining cost when the domain or service offering changes. Service promotions, pricing, and product details change over time. If SEAD must be retrained from scratch for each significant update (rather than fine-tuned incrementally), the training cost recurs with each update cycle, further eroding the cost advantage over pay-per-call APIs.
Wall-clock training time as a deployment bottleneck. The paper's decoupled architecture—where components "never occupy memory simultaneously"—trades memory for time: phases run sequentially rather than in parallel. If a full training run takes two weeks, SEAD cannot be deployed rapidly in response to changing business needs, making it unsuitable for agile service environments where dialogues must adapt to weekly promotions or seasonal campaigns.

What evidence exists in the paper: None. The paper provides no training curves, no convergence analysis, and no runtime benchmarks. The abstract's claim that "SEAD significantly outperforms Open-source Foundation Models and Closed-source Commercial Models" is a performance claim, not an economic one, but the inclusion of the "Total Cost" column in Table 1 invites economic interpretation while providing incomplete data.

Mitigation status: Not addressed. The paper does not mention training cost as a limitation, and the Limitations section focuses on evaluation metrics and scenario diversity rather than computational efficiency. This omission is particularly notable because the cost comparison is one of the paper's explicit contributions (Table 1 includes it as a primary metric), yet the comparison systematically favors SEAD by omitting its largest cost component.

5. The Profile Controller's Difficulty Estimation Requires Computing Completion Rates Over Many Dialogues Before Adaptation Begins — Cold-Start and Sample-Efficiency Concerns

The assumption or constraint: The Profile Controller's adaptive difficulty mechanism (Equation 1, Phase 4 Mistake Analysis) requires empirical completion rate estimates $CR(c, e, tr)$ for each of the 120 state combinations. These estimates are computed from the trajectory history $\mathcal{H}$ , which accumulates over iterations. In the first iteration, the Profile Controller performs uniform random sampling because no CR statistics exist. After one iteration with batch size $B = 60$ , each sampled state combination has at most 1–2 completed dialogues—a completion rate estimated from 1–2 samples has extremely high variance (a single success or failure swings the estimate by 50–100 percentage points).

The paper does not specify:

How many iterations must pass before CR estimates become reliable enough to guide meaningful curriculum selection.
Whether the Profile Controller uses raw empirical rates or applies smoothing/regularization (e.g., Bayesian prior, Laplace smoothing) to prevent early overcommitment to noisy estimates.
Whether the 120-state space is tractable with $B = 60$ samples per iteration—at this rate, covering all 120 states once requires 2 iterations, and getting even 5 samples per state requires 10 iterations.

The consequence: The adaptive curriculum may be ineffective or counterproductive in early training iterations, and the paper provides no evidence about how quickly it becomes useful. Several failure modes are possible:

Early noise locks in suboptimal sampling distributions. If a state combination happens to yield 2 successes in 2 trials during early iterations (a 100% CR estimate from 2 samples), it gets downweighted as "too easy" and may never be sampled again—even if its true completion rate is near 50%. The agent loses access to potentially informative training scenarios due to sampling noise rather than genuine difficulty.
The "warm-up" period without effective curriculum may dominate total training. If it takes 20–30 iterations (1,200–1,800 dialogues) before CR estimates stabilize and the Profile Controller begins meaningfully prioritizing the 50% difficulty band, then a substantial fraction of total training dialogues are generated without curriculum guidance. This would make Config 3 (w/o MA, uniform sampling) a strong baseline for the first ~30 iterations, and the gap between Config 3 and full SEAD would only emerge later in training. The paper's ablation (Table 3) reports only final performance, not per-iteration progress, so this dynamic is invisible.
The $N_{\max} = 200$ cap interacts with cold-start noise. The paper limits each state combination to at most 200 sampled dialogues to prevent overfitting. If early noise causes some state combinations to be undersampled (because noisy CR estimates made them appear too easy or too hard), those states may never reach their $N_{\max}$ cap and the agent's training diversity is permanently reduced.

What evidence exists in the paper: None. The paper reports only final performance (Table 3) and does not show training curves, per-iteration completion rates, or the evolution of the Profile Controller's sampling distribution over time. The Mistake Analysis phase is described conceptually (Section 3.2, Phase 4) but its empirical behavior—convergence rate of CR estimates, stability of the ideal band composition, the fraction of states in each category over training—is not analyzed.

Mitigation status: Not addressed. The paper does not discuss cold-start, sample efficiency, or CR estimate reliability. The Profile Controller is presented as a solved component within the framework, but its practical behavior in the critical early-training regime is unexamined. A practitioner implementing SEAD would need to make ad-hoc decisions about minimum samples per state, smoothing parameters, and convergence diagnostics without guidance from the paper.

6. State Space Design and the Fixed Role-Play Model Create a Hard Ceiling on Realism That No Amount of Agent Training Can Exceed

The assumption or constraint: SEAD's training is bounded by two design choices that are fixed before training begins and never improved:

First, the user state space (Section 3.4) is defined as a 120-element discrete grid over three dimensions (cooperation, emotion, trust). Real users do not fall neatly into 120 discrete categories—their attitudes vary continuously, exhibit correlations between dimensions (trust and cooperation are not independent in practice), and involve dimensions the paper does not model (urgency, product knowledge, price sensitivity, decision-making authority, competing priorities). The behavior library $\mathcal{L}$ adds some diversity through behavior patterns, but these are injected as random traits rather than modeled as correlated with the user's underlying state or the dialogue context.

Second, the User Role-play Model is frozen—its ability to simulate users is capped at the quality of Qwen2.5-14B-Instruct's zero-shot role-playing, which the paper validates as "near-perfect" (>4.5/5) using GPT-5.1 evaluation (Table 2). However, a 14B model almost certainly exhibits systematic biases, blind spots, or unrealistic patterns that the 4.5/5 aggregate score does not capture. For example, it may be unrealistically susceptible to certain persuasion tactics (flattery, social proof) that real users resist, or unrealistically resistant to others (logical argument, evidence presentation) that real users find persuasive. These biases are baked into training and cannot be corrected because the model is frozen.

The consequence: The agent's maximum real-world performance is bounded by the fidelity of its training environment. Even if SEAD's training algorithm is perfect—even if the agent learns an optimal strategy for the simulated environment—that strategy may not transfer to real users if the simulator's behavior differs systematically from real behavior.

The paper's own evidence supports this concern indirectly. The User Role-play Model achieves a humanness score of 4.7/5 (Table 2), which is described as "near-perfect." But on a 0–5 scale, a 0.3-point gap from perfection represents a 6% realism deficit—and it is unclear how that 6% deficit maps to task completion rates. A systematic bias affecting only 6% of dialogues could, in principle, account for a 10–20 percentage point gap between simulated and real completion rates (if the bias consistently affects which dialogues succeed or fail). The paper provides no sensitivity analysis: if the simulator were 10% less realistic (e.g., humanness 4.2 instead of 4.7), how much would the trained agent's performance degrade?

Furthermore, the 120-state discretization means that the agent never encounters users whose state falls "between" grid points. A real restaurant owner might have trust = 2.7 and cooperation = 1.3—a combination that the discrete grid approximates as either (2, 1) or (3, 2), both of which may produce meaningfully different behavior in the simulator. The agent optimizes for performance against these 120 discrete user types, which may embed strategies that exploit discretization artifacts rather than generalize to continuous human behavior.

What evidence exists in the paper: The only evidence about simulator realism comes from Table 2 (GPT-5.1 evaluation of humanness, emotion, trust, cooperation, and violation scores) and the qualitative case studies in Figure 4 (which show the simulator producing plausible responses in specific challenging scenarios). There is no:

Comparison of simulator behavior to real human behavior on the same scenarios.
Measurement of simulator calibration (do users with simulated trust=3 accept at the same rate as real users with equivalent trust?).
Analysis of sensitivity to the number of state levels (would 10×10×10 = 1,000 states produce better agents than 5×4×6 = 120?).
Test of whether agents trained in the 120-state simulator transfer to a higher-fidelity simulator (e.g., a GPT-4o-based role-player with continuous state representation).

Mitigation status: Not addressed as a limitation. The paper positions the 120-state space as a design choice derived from real enterprise data and the frozen User Role-play Model as a solution to the adversarial training problem (which it demonstrably is; Table 3). However, it does not discuss the trade-off this creates: solving adversarial fairness by freezing the simulator simultaneously caps the simulator's realism at its base-model quality, creating a ceiling on real-world performance that the agent's training cannot exceed. The Limitations section mentions future work on "emotional perception" and "multi-scenario environments" but does not address the fundamental ceiling imposed by the fixed, discrete, 14B-parameter simulator.

7. Implications and Future Directions

How This Work Changes the Landscape

This paper introduces a new diagnostic for why self-play fails in subjective-outcome domains and demonstrates a structural solution that changes how researchers should think about training dialogue agents. The diagnostic is that self-play with a unified user model creates an "unfair adversarial game" not because of insufficient data, poor simulator quality, or bad hyperparameters, but because the user side's ability to both simulate behavior and determine outcomes while being subject to adversarial training pressure lets it decouple agent performance from reward. This is a structural problem, not an engineering one—and structural problems demand structural solutions.

The solution—decomposing user simulation into a trainable initial-state selector and a frozen behavior simulator—establishes a design pattern for adversarial training in any domain where one component's role is to simulate realistic behavior rather than to optimize a score. The pattern is: identify which component can manipulate outcomes, freeze it so that its decisions depend on genuine agent quality, and apply adversarial pressure only to the component that controls difficulty (initial conditions, scenario selection, curriculum). This pattern has been implicit in some prior work (GAN discriminators only classify; curriculum learning teachers only select examples), but SEAD is the first to articulate it explicitly for LLM-based dialogue and to provide clear ablation evidence that violating it causes catastrophic reward hacking (Table 3: training the user model drops humanness from 4.7 to 3.3 and completion rate from 52.0% to 35.2%).

The paper also provides the strongest evidence to date that service dialogue capability is bottlenecked by interactive training experience, not by model scale or pretraining data volume. The near-zero return to scaling Qwen2.5 models from 14B to 72B on task completion (38.7% → 39.0%; Table 1) while SEAD's 14B trained agent achieves 52.0% is a result that challenges the dominant "bigger models subsume everything" narrative. If the finding replicates across model families and domains, it implies that certain strategic, adaptive, multi-turn interaction capabilities cannot be acquired through next-token prediction on static text—they require the experience of interacting with a counterparty whose behavior depends on your actions, receiving outcome feedback, and adapting. This reframes the "scaling bottleneck" for dialogue systems: the bottleneck may not be model capacity or training data volume, but the absence of interactive training environments that provide adaptive, outcome-driven feedback.

This finding also reconciles a tension in the dialogue systems literature between static-synthesis approaches (which struggle with dynamic interactions) and self-play approaches (which have been largely unsuccessful for dialogue due to adversarial collapse). The paper demonstrates that both failure modes stem from the same root cause—conflating behavior simulation with outcome determination under training pressure—and that the decomposition solves both simultaneously. Static synthesis fails because it cannot capture how user behavior depends on agent actions; self-play with a unified model fails because it gives the user side too much power over outcomes. SEAD's decomposition captures the behavioral dependency (through the fixed role-play model) while preventing outcome manipulation (by freezing the role-play model and restricting adversarial training to initial-state selection).

The demonstration that a 14B self-trained agent outperforms a 560B dialogue-specialized model while requiring zero annotated dialogue data opens a new Pareto frontier for cost-efficient dialogue deployment. Prior to this work, the implicit assumption in the field was that dialogue capability required either (a) massive pretraining with dialogue-specific data (the LongCat-Flash approach) or (b) extensive human annotation for supervised fine-tuning or RLHF (the standard commercial approach). SEAD shows a third path: structure a self-play environment where the agent learns through adaptive, outcome-driven interaction, and the resulting policy can exceed what either scaling or annotation provides. This is not a universal claim—the paper is careful to scope it to service dialogue—but within that scope, it changes the economics of deploying dialogue agents in data-scarce specialized domains.

The paper also implicitly challenges how user simulators should be evaluated. Prior work on dialogue simulation (Sekulić et al., 2024; Zhu et al., 2025; Lin and Tomlin, 2025) has tended to evaluate simulators either in isolation (human-likeness judgments) or through agent training performance (how well the agent does after training against the simulator). SEAD's ablation results suggest these two evaluation criteria are in tension: training a simulator to be a stronger adversary for agent training degrades its human-likeness (Table 3). The paper's solution—evaluating the simulator on fidelity alone and using a separate component for difficulty management—implies that simulator quality and training difficulty should be decoupled evaluation axes, and that conflating them (as prior work often has) leads to suboptimal design choices on both fronts.

Follow-Up Research This Work Enables

Real-world deployment validation to measure the simulation-to-reality gap. The most urgent follow-up is to deploy SEAD-trained agents against real restaurant owners (or another service domain) and measure actual task completion rates. The paper's 52.0% CR is measured against the simulator; the real-world CR could be anywhere from 20% to 60%, and the gap size and direction would fundamentally change how the framework is interpreted. A strong study would: (a) deploy SEAD-trained agents making real outbound calls, (b) measure ground-truth completion rates and compare to the simulator's predictions on the same user profiles, (c) collect real user state annotations (cooperation, emotion, trust ratings from both the users themselves and from human evaluators listening to call recordings) and compare to the simulator's state evolution, and (d) report per-user-profile breakdowns to identify which regions of the state space have the largest simulation-to-reality gap. A negative result—25% real CR vs. 52% simulated—would indicate that the simulator's acceptance logic is substantially easier than real behavior, narrowing SEAD's practical applicability to domains where the simulator can be calibrated against real outcomes. A positive result—45%+ real CR—would validate the framework for production deployment and greatly strengthen the paper's central claims.

Cross-architecture replication to test whether the decomposition approach is model-family-dependent. All of SEAD's results are conditioned on Qwen2.5-14B-Instruct serving as all three components. The fixed User Role-play Model—the foundation on which the entire co-evolutionary dynamic rests—must simulate realistic user behavior out of the box without any fine-tuning. If Qwen2.5 happens to have unusually strong persona-adherence or role-playing capabilities compared to other model families, SEAD's results may not transfer. A systematic replication would: (a) replicate SEAD using LLaMA-3, Mistral, DeepSeek, and Gemma as the base model for all components, (b) measure both agent completion rate and user role-play model humanness scores (as in Table 2) for each architecture, (c) analyze whether model families that produce more realistic simulators (higher humanness) also produce better-trained agents (higher completion rate), establishing whether simulator quality is the binding constraint on agent performance, and (d) test a cross-family setup where the User Role-play Model and Service Agent use different base architectures, which could potentially create a more challenging and diverse training distribution. If SEAD works robustly across families (within, say, ±5 percentage points of completion rate), it would establish the framework as architecture-agnostic and thus broadly applicable. If it fails on certain families, the research question shifts to identifying which base model properties (instruction-following quality? persona consistency? strategic reasoning capability?) are prerequisites for the framework to function.

Behavior library ablation and synthetic construction to determine the true data dependency. The paper's behavior library $\mathcal{L}$ is derived from over 100k real enterprise dialogues, complicating the "zero-data" claim. A clarifying study would systematically vary the behavior library's size, source, and construction method and measure the impact on agent performance and simulator realism. Specifically: (a) train SEAD with reduced behavior libraries (100%, 50%, 25%, 10%, 1% of the original patterns) to establish the marginal value of additional real-world behavior patterns—at what point does the agent's performance degrade substantially? (b) Replace the real-corpus-derived library with a synthetic behavior library constructed entirely by domain experts (e.g., "list 50 common user behaviors in outbound restaurant sales calls, including realistic linguistic patterns for each"), with no access to the real call logs, and measure whether SEAD still outperforms the 14B zero-shot baseline—this would test whether the framework is truly deployable in new domains without any corpus access. (c) Test whether GPT-4o-generated behavior patterns (zero-shot prompted with the task description) can substitute for the real-corpus patterns while maintaining simulator realism and training effectiveness. The ideal outcome for SEAD's practical deployability is that a small, expert-constructed, synthetic behavior library (50–100 patterns) achieves performance within 10% of the full 100k-dialogue-derived library. If it doesn't—if the full corpus is essential—then SEAD's "zero annotated data" claim needs to be qualified as "zero annotated data but requires a large corpus of unannotated real interactions for behavior pattern extraction," which substantially weakens its deployment value proposition.

Combining SEAD-trained agents with a small amount of real human feedback to push past the simulator's realism ceiling. The paper demonstrates that the frozen User Role-play Model caps the agent's maximum real-world performance at whatever fidelity the 14B base model provides. A natural extension would add a lightweight human-in-the-loop component: after SEAD training converges in simulation, deploy the agent in a small-scale real pilot (e.g., 100–200 real calls), collect outcome labels and, optionally, per-turn human preference judgments, and fine-tune the agent using this real data via RLHF or DPO. This tests whether SEAD provides a strong initialization that reduces the amount of real human data needed compared to training from scratch—the hypothesis being that SEAD learns broadly correct persuasion strategies in simulation, and only a small amount of real feedback is needed to correct simulator-specific biases and calibrate to real user behavior. The key measurement would be: how many real labeled dialogues are needed to surpass the simulator-alone performance, and how does this compare to the number needed if starting from the zero-shot base model? If SEAD reduces the required real data by 5–10× (e.g., needing 100 calls instead of 500–1000), it would establish a new efficient frontier for dialogue agent deployment: cheap simulated pretraining followed by cheap real fine-tuning.

Extending the decomposition principle to other subjective-outcome domains to test generality. The paper's core structural insight—that adversarial training with a unified opponent fails when the opponent's decisions determine outcomes subjectively, and that decomposing into a difficulty-setting component and a fixed behavior-simulating component solves this—should apply beyond service dialogue to any domain where success is a subjective judgment by a counterparty. Obvious candidate domains include: (a) negotiation (where the counterparty decides whether to accept a deal), (b) debate (where a judge or audience decides the winner), (c) persuasion for charitable donations or political engagement (where the persuadee decides whether to act), (d) collaborative problem-solving (where a partner decides whether the solution is satisfactory). A systematic study would: for each domain, implement both a unified self-play baseline (both sides trained adversarially) and a decomposed SEAD-style variant (fixed counterparty model, trainable scenario selector), and measure both task success and counterparty realism. The prediction from SEAD's framework is that the decomposed variant should consistently outperform the unified variant, and the performance gap should widen as the counterparty's decision power increases (e.g., the gap should be largest for negotiation, where the counterparty's "no" is final, and smallest for collaborative problem-solving, where objective criteria partially constrain the counterparty). A failure to replicate across domains would refine our understanding of which structural properties make decomposition necessary vs. optional.

Analyzing the Profile Controller's difficulty convergence dynamics to understand when adaptive curricula fail. The paper's Profile Controller operates on empirical completion-rate statistics estimated from dialogue history, but the paper provides no analysis of how quickly these estimates converge, how sensitive they are to sampling noise, or whether the $1 - |\text{CR} - 0.5|$ weighting is optimal. A thorough empirical study would: (a) generate training curves showing per-iteration completion rate, the Profile Controller's sampling distribution entropy (how concentrated it is on the ideal band vs. uniform), and the fraction of state combinations in the too-easy/ideal/too-hard categories, (b) sweep alternative difficulty-selection strategies—different target CRs (0.3, 0.4, 0.5, 0.6, 0.7), different kernel functions (Gaussian vs. triangular vs. uniform-within-band), and different band widths (±0.05, ±0.10, ±0.15, ±0.20 around the target)—to determine how sensitive agent performance is to these design choices, (c) implement Bayesian smoothing of CR estimates (e.g., Beta-binomial with prior centered at 0.5) and compare to the raw empirical estimator to see whether early-training noise causes the raw estimator to lock into suboptimal sampling patterns, and (d) test an oracle curriculum baseline where a human expert manually sequences difficulty levels and compare to the automatic Profile Controller, to establish how much of the adaptive gain is due to adaptivity vs. simply having a curriculum. This study would transform the Profile Controller from a demonstrated-but-unexamined component into a well-characterized mechanism with known convergence properties and design guidelines.

Practical Applications and Downstream Use Cases

Rapid deployment of dialogue agents in data-scarce business verticals. The most direct application is for companies that need to deploy service dialogue agents in domains where no annotated training data exists. SEAD requires only: a written SOP describing the desired dialogue flow, a task objective, and a behavior library of common user patterns (which can be bootstrapped from expert knowledge or a small corpus of anonymized call transcripts). The paper demonstrates this in restaurant promotion, but the pattern applies to insurance sales, real estate inquiry handling, B2B appointment setting, healthcare scheduling, and any other vertical where multi-turn persuasion matters and annotated dialogue data is expensive to collect. A company could go from "we have an SOP and domain experts" to a trained deployment-ready agent in days (subject to the unknown training time), avoiding the months and tens of thousands of dollars typically required for dialogue data collection and annotation. The 52.0% simulated completion rate and 9.6 average turns provide concrete performance targets to benchmark against, though the simulation-to-reality gap discussed in the limitations means real deployment should begin with a controlled pilot to calibrate expectations.

Cost-efficient self-hosted dialogue agents as an alternative to commercial LLM APIs. For organizations that handle high call volumes (thousands to tens of thousands of calls daily), the cost comparison in Table 1 is compelling: GPT-4o costs 727.28 CNY per 1,000 samples, while SEAD's self-hosted agent has zero per-call API cost. Even accounting for GPU hosting and the amortized training cost (which the paper does not report, but which likely pays for itself at high enough volume), self-hosting a 14B model is dramatically cheaper than calling a 560B+ commercial API. Organizations with existing GPU infrastructure (8×A100 or equivalent) can deploy SEAD-trained agents without any vendor dependency, data leaving their infrastructure, or per-call pricing. The primary deployment risk is the unknown real-world completion rate—an organization would need to run an A/B test comparing the SEAD agent against their current human or API-based solution on real calls to validate that the simulated 52.0% CR translates to acceptable real-world performance.

Training data generation for supervised fine-tuning of larger production models. Even if an organization ultimately deploys a larger model (for latency, reliability, or capability reasons), SEAD can serve as a training data generator. The co-evolutionary loop produces thousands of diverse, outcome-labeled dialogue trajectories across the full spectrum of user difficulty levels (120 state combinations × up to 200 samples each = up to 24,000 trajectories). These trajectories capture strategic agent behaviors that succeeded (or failed) against adaptive, realistic user simulations—a far richer training signal than static human call logs dominated by suboptimal strategies. A production pipeline could: (1) run SEAD to generate a large corpus of high-quality, diverse training dialogues, (2) use these dialogues to supervised-fine-tune a larger model (e.g., 72B or commercial-scale), (3) optionally add a small amount of real human preference data via DPO to calibrate the model to real user behavior, and (4) deploy the fine-tuned larger model. This pipeline combines SEAD's data-generation efficiency with the robustness of a larger deployed model, potentially achieving better performance than either approach alone. The key unknown is whether dialogue strategies learned by a 14B agent in simulation transfer effectively as training data for a different model architecture—a question the paper does not address but that is testable with moderate engineering effort.

When to Prefer This Method

The paper explicitly positions SEAD as a solution for data-scarce service dialogue domains where annotated dialogue data is unavailable and commercial LLM APIs are either too expensive at scale or insufficiently capable in the zero-shot setting. Based on the experimental results (Table 1) and the structural properties of the framework, the decision conditions are:

Prefer SEAD when: (1) the deployment domain is a specialized service dialogue vertical with no existing annotated training corpus—the framework eliminates the data collection bottleneck; (2) the organization has access to a corpus of (possibly unannotated) real user interactions from which behavior patterns can be extracted, or can construct a synthetic behavior library from domain expertise—the framework requires behavior patterns as input but not annotated dialogues; (3) the organization can self-host a 14B-parameter model on 8×A100-class GPUs for both training and inference—the framework's cost advantage depends on avoiding per-call API fees; (4) call volumes are high enough to amortize the training cost (which the paper does not quantify, but which likely breaks even at thousands to tens of thousands of calls); (5) deployment latency is not extremely tight, since multi-turn dialogues average ~9.6 turns and the decoupled architecture adds per-phase overhead; and (6) a small-scale real-world pilot can be conducted to calibrate the simulator's completion rate against real user behavior before full deployment, since the framework's evaluation is entirely simulated.
Prefer zero-shot commercial APIs (GPT-4o, LongCat-Flash) when: (1) the deployment volume is low (hundreds of calls, not thousands), making training cost amortization unfavorable; (2) the domain changes frequently (weekly promotions, seasonal campaigns) and retraining from scratch would be needed each time; (3) the organization lacks GPU infrastructure and values the simplicity of API integration over cost optimization; (4) the service dialogue task requires capabilities (multilingual, multimodal, extremely long context) that exceed what a 14B self-hosted model can provide; or (5) a rapid prototype is needed immediately and the weeks (or days) of SEAD training are not feasible.
Prefer collecting and annotating real dialogue data for supervised fine-tuning when: (1) the organization already has a pipeline for collecting and annotating service dialogues at scale; (2) the annotated data captures strategies that exceed what the frozen Qwen2.5-14B-Instruct User Role-play Model can simulate—for example, if real top-performing human agents use sophisticated multi-step persuasion techniques that the 14B simulator does not naturally produce; (3) the deployment model is substantially larger than 14B and the organization wants to maximize its performance with real rather than simulated training data; or (4) the real-world completion rate is the only metric that matters and the organization cannot accept the risk of simulation-to-reality performance degradation (which the paper does not quantify).

The critical unresolved factor in all of these tradeoffs is the unknown real-world performance of SEAD-trained agents. If the 52.0% simulated CR translates to, say, 35–40% real CR (a 25–35% degradation), SEAD remains competitive with GPT-4o's 44.2% simulated CR but with much lower inference cost. If it translates to 20–25% real CR, the framework's practical value is limited to niches where even modest automation is economically attractive. A deployment pilot—which the paper does not conduct—would resolve this uncertainty and sharpen all of the above decision rules.