wikillm

Paper · 2026-10-14 · cs.AI, cs.CL

τ-Emotion-Bench: Exposing the Interaction Fragility of LLM Agents through Real-World User Emotions

A ten-domain benchmark (580 tasks) for tool-calling agents facing simulated users whose emotions can end the chat, plus Tracer, which generates grounded tasks and keeps only trajectories where the user did not give up. Qwen3 1.7B-8B fine-tuned on 1,958 Tracer trajectories gain 13.8-19.7 points in average Avg@3 (author-reported); frontier agents stay unreliable (best average Pass^3 32.2%).

Tool useLLM agentUser simulationSynthetic training dataagentstool-usebenchmarkuser-simulationsynthetic-data

arXivPDFCodeMarkdown15 min read

AI-compiled by claude-haiku-5-5 on 2026-11-21, not yet reviewed by a human. Every claim cites its source; check it when a detail matters.

In plain words

Tool-using AI assistants are usually tested against a patient, cooperative simulated user who always answers the question asked. Real people are often frustrated, rushed or distrustful, and an assistant that keeps asking questions or wanders off can lose them even when the job could still be done. This paper builds a benchmark, called τ-Emotion-Bench, in which the simulated user has an emotional state such as frustration or sadness, a way of speaking (polite or cold, hurried or relaxed, trusting or doubtful), and the option to give up and end the conversation. The tasks cover ten everyday domains such as airlines, retail and banking. Even strong models often fail when they must succeed on repeated attempts.

The authors also describe Tracer, a pipeline that makes these tasks and the conversations used to train smaller models. Conversations where the simulated user gives up are thrown out, so the examples that remain lean toward agents that use their tools rather than keep asking the user. Small Qwen3 models trained on these examples do better on the benchmark. All numbers come from the authors' own runs with simulated users, so read them as a guide, not as a ranking.

TL;DR

  • Benchmark: 580 executable tool-calling tasks in ten domains, each run with an emotion-conditioned user simulator that can say "unsatisfied" and end the episode §3.1 §4.1.
  • Tracer builds grounded tasks from tool graphs and generates trajectories with the same harness; the user's give-up signal removes trajectories that depend too much on the user §1 §7.3.
  • Frontier models stay unreliable: with Qwen3-235B-A22B-Instruct-2507 as user, the best average Pass^3 is 32.2% §4.2 tab. 2.
  • Qwen3-1.7B, 4B and 8B fine-tuned (SFT) on Tracer data gain 13.8 to 19.7 points in average Avg@3 over their base models (author-reported) §4.2.
  • Code is Apache-2.0 and public. The Tracer training code is not in the repository, so the fine-tuning settings cannot be checked against code.

Problem

Agent benchmarks usually treat the user as a fixed persona that follows a script, and they score only whether the task ended in the right state. A trajectory that finishes the task after many unnecessary questions or heavy reliance on the user still scores as a success §1. The authors argue that real users vary in emotion and cooperation, so agents tested only against cooperative users look more robust than they are §1. The task is cast as a partially observable decision process with states, agent actions (tool calls and messages), observations (tool outputs and user messages), transitions and a user instruction space; the user's reply depends on the instruction, the emotion condition and the history §3.1.

Method

Benchmark and task construction

For each domain, a directed tool graph is built. Each node is a task-relevant tool and an edge says that one tool may validly follow another under the interfaces and the domain policy. Edges are inferred from tool definitions, execution behaviour and policy, and the graph is checked by hand before use §3.2. Valid paths give workflows; the workflows are composed into multi-intent traces. The appendix states the sampling: one to three independent random walks of two to six tool calls each per trace, and deduplication §7.

A grounding agent fills workflow entities and arguments using the executable database, which yields a reference trajectory. A preference agent rewrites the grounded goal as a natural user request with feasible preferences that do not change the outcome. A separate feeling generator writes an affective description from the user context and the requested actions; it does not see the database, so the feeling cannot leak information the user would not have §3.2. Figure 2 shows the five stages (graph, traces, instructions, emotion conditions, verification) fig. 2.

Verification keeps a task only if it has a concrete objective, enough information to execute, an executable reference trajectory and no conflict with the domain policy. Reference trajectories are checked by deterministic replay, and a model judges only when the replay result is inconclusive §3.4. All 580 evaluation tasks were then reviewed by hand. Of the 884 tasks that reached this stage, 101 needed ground-truth edits (corrected parameters, added or removed actions), 23 had internal identifiers replaced by user-visible information (such as the last four card digits instead of a payment identifier), and 23 were rewritten to add policy challenges §7.2. A human tool-calling agent also solved some tasks that every evaluated model failed in all trials §3.4.

Emotion conditions and the user simulator

The feeling is mapped to a structured emotion space derived from the Atlas of Emotions §3.3. It has five families (anger, fear, disgust, sadness and enjoyment) holding 22 fine-grained emotions, four or five per family §3.3 §7.1; the appendix lists each family's members §7.1. Three behavioural dimensions are combined with each emotion: politeness, urgency and trust, each with three levels. The politeness scale runs from warm to cold, urgency from low to high, and trust from trusting to skeptical. Together these give 22 × 27 = 594 conditions §3.3 §7.1.

Each condition has ten natural-language anchor instructions written by GPT-4.1 (5,940 anchors in total) §7.1. A multi-head classifier is trained on the anchors. A task feeling is projected into the embedding space, and similarity to the nearest anchors selects the condition; the paper does not state the number of neighbours §7.1. The simulator receives one anchor instruction for the chosen condition, picked at random, and never the discrete labels §7.1.

The user may end an episode with a normal stop token or with an unsatisfied token. The normal stop follows τ-Bench. The unsatisfied token means that the accumulated interaction has become unacceptable to the user §3.1. Each turn, the simulator sees the task, its emotion instruction and the history, so one condition can produce different replies as the conversation goes on, and the condition itself stays fixed within an episode §3.1 §3.3.

Evaluation protocol

The evaluation uses the τ-Bench agent harness with tool calling through OpenAI-style function calls §4.1 §8.2. Two user simulators are used: Qwen3-235B-A22B-Instruct-2507 (default in the main tables) and GLM-5.2. The user runs at temperature 0.0 with at most 200 interaction turns, and each task is run three times §4.1. Avg@3 is the mean of single-run success over tasks. Pass^k is defined in the text as the fraction of tasks completed in at least k trials, but the code computes the all-k form; see Paper vs code and Pitfalls §4.1.

Tracer training data

Training tasks come from the same pipeline. Each rollout pairs a thinking-mode Qwen3.8-27B agent with a Qwen3-235B-A22B-Instruct simulated user, capped at 50 interaction steps §7.3. Of 7,767 generated training tasks, 7,048 rollouts were kept after endpoint-error discards §7.3. A rollout counts as a success only if its end database equals the reference and the simulated user never sent the unsatisfied token. That gives 2,723 successful trajectories (38.6% of rollouts) §7.3. Tracer-High uses 1,958 trajectories: all successes from Airline, Telecom, School, Restaurant, Travel, Movie and Bank, plus 250 randomly sampled successes each from Retail, Telehealth and Basketball §7.3. Tracer-Low uses all 1,498 successes from Airline, Retail, Telecom and Telehealth only §7.3 §4.1.

Tracer models are trained by supervised fine-tuning with the TRL library on four H100 GPUs, using the Tracer data together with the publicly available AReaL tau2 dataset §8.1. The authors say reinforcement learning on this data is untested (Limitations section).

Pseudocode

Task construction, from the tool graph to candidate tasks §3.2 §7:

Pseudocode
# Tracer: grounded candidate tasks  [§3.2] [§7]
# Input:  domain tools, policy and database
# Output: candidate tasks with a reference trajectory and a feeling

def build_candidate_tasks(domain):
    # Directed graph: an edge means one tool may validly follow another [§3.2]
    tool_graph = build_tool_graph(domain.tools, domain.policy)
    # Compose 1-3 random walks of 2-6 tool calls each into one trace  [§7]
    traces = sample_traces(tool_graph, intents=(1, 3), length=(2, 6))
    tasks = []
    for trace in traces:
        # Fill entities and arguments against the executable database  [§3.2]
        reference = grounding_agent(trace, domain.database)
        # Rewrite the goal as a user request with feasible preferences  [§3.2]
        instruction = preference_agent(reference)
        # Describe the feeling; this step never reads the database  [§3.2]
        feeling = feeling_agent(instruction, reference.actions)
        tasks.append(Task(instruction, feeling, reference))
    return tasks

Keeping a candidate task §3.4:

Pseudocode
# Verification of one candidate task  [§3.4]
# Output: True if the task enters the benchmark

def keep_task(task, domain):
    # Replay the reference trajectory deterministically  [§3.4]
    outcome = replay(task.reference, domain)
    # A model judges only when the replay result is inconclusive  [§3.4]
    if outcome.inconclusive:
        outcome = model_adjudicate(task, domain)
    # Also needs a concrete objective and policy consistency  [§3.4]
    return (outcome.executable and task.objective_is_concrete
            and outcome.policy_ok)

Mapping a feeling to a user instruction §3.3 §7.1:

Pseudocode
# Feeling -> emotion condition -> one anchor instruction  [§3.3] [§7.1]
# Input:  free-text feeling for one task
# Output: natural-language instruction for the user simulator

def emotion_instruction(feeling):
    # Project the feeling into the classifier's embedding space  [§7.1]
    vector = embed(feeling)
    # Similarity to nearby anchors selects the condition  [§7.1]
    neighbours = nearest_anchors(vector)
    condition = similarity_weighted_vote(neighbours)
    # Pass one of the condition's 10 anchors, chosen at random  [§7.1]
    return random_choice(condition.anchors)

One evaluation episode §3.1 §4.1:

Pseudocode
# One episode of the agent-user-environment harness  [§3.1] [§4.1]
# Ends on STOP, on UNSATISFIED, or after 200 turns

def run_episode(agent, user, env, max_turns=200):
    # The user speaks from its instruction and emotion  [§3.1] [§3.3]
    message = user.first_message()
    for turn in range(max_turns):
        # The agent replies with tool calls and/or text  [§3.1]
        reply = agent.respond(message, env)
        message = user.respond(reply, env.history)
        # The user gave up: an early, penalised end  [§3.1]
        if user.said_unsatisfied(message):
            return Outcome(reason="user_unsatisfied")
        # Normal end, as in tau-Bench  [§3.1]
        if user.said_stop(message):
            return Outcome(reason="user_stop")
    return Outcome(reason="max_turns")

Reward and pass^k §3.1 §4.1 §7.3:

Pseudocode
# Reward for one run  [§3.1] [§7.3]
def reward(outcome, final_db, reference_db):
    # Abandoned by the user: penalised, ground truth not checked  [§3.1]
    if outcome.reason == "user_unsatisfied":
        return -1
    # Otherwise 1 if the final database matches the reference  [§7.3]
    return 1 if final_db == reference_db else 0

# Chance that k trials drawn from n runs all succeed  [§4.1]
# Code form  [code: src/tau_emotion/metrics/agent_metrics.py#L110-L123]
# (the text says "at least k"; the code is all-k)
def pass_hat_k(num_trials, success_count, k):
    # C(successes, k) / C(trials, k)
    return comb(success_count, k) / comb(num_trials, k)

Training-set selection §7.3:

Pseudocode
# Tracer-Low and Tracer-High training sets  [§7.3]
# Input:  all rollouts for the ten domains

def select_training_set(rollouts, high):
    # Keep only successful rollouts: reward 1  [§7.3]
    kept = [r for r in rollouts if r.reward == 1]
    if not high:
        # Tracer-Low: four domains only, all successes kept  [§7.3]
        return [r for r in kept if r.domain in LOW_DOMAINS]
    # Tracer-High: 250 random successes from each of three domains  [§7.3]
    return cap_per_domain(kept, cap=250, domains=CAPPED_DOMAINS)

Hyperparameters

Training settings §8.1 and evaluation settings §4.1 §8.2. The paper gives one fine-tuning setting for all three Qwen3 scales.

NameValueWhereNotes
base modelsQwen3-1.7B, Qwen3-4B, Qwen3-8B§4.1 §8.1Evaluated with thinking on §8.2
training methodsupervised fine-tuning (TRL)§8.1RL not tried
training dataTracer-High 1,958; Tracer-Low 1,498§4.1 §7.3Trajectories with reward 1
learning rate5 × 10⁻⁵§8.1
schedulercosine§8.1
warm-up ratio0.03§8.1
epochs3§8.1
optimizerpaged AdamW, 8-bit§8.1
weight decay0.0§8.1
max gradient norm1.0§8.1
effective batch size32§8.1
precisionBF16 with TF32§8.1
gradient checkpointingenabled§8.1
attentionFlashAttention-3§8.1
loss kernelLiger fused cross-entropy§8.1
packing / padding-freedisabled§8.1
max sequence length32,768§8.1Qwen3 models
hardwarefour NVIDIA H100 GPUs§8.1
training rolloutsagent Qwen3.8-27B (thinking); user Qwen3-235B-A22B-Instruct; 50 steps§7.3Used to create the data
eval user simulatorQwen3-235B-A22B-Instruct-2507, temperature 0.0§4.1 config.pyGLM-5.2 is the second simulator
eval turn limit200§4.1 config.pySee Pitfalls on what counts as a turn
eval trials3 per task§4.1Avg@3 and Pass^k
eval decoding, Tracerthinking: temperature 0.6, top-p 0.95, top-k 20, min-p 0§8.2Per-model table; Qwen3-4B and 8B use temperature 0.0 in the table
emotion anchors10 per condition; 5,940 in total§7.1 config.jsonGenerated with GPT-4.1
emotion kNNnot stated in paper§7.1 config.jsonCode: k = 9, see Paper vs code

Results

Author-reported. Setup: 580 evaluation tasks in ten domains; main tables use Qwen3-235B-A22B-Instruct-2507 as user simulator, three trials per task §4.1. The baseline set is open-weight and proprietary agents; the Tracer models are the authors' fine-tunes of Qwen3 base models §4.1.

Pass^3 averaged over the ten domains, all models in the main table (Qwen3-235B-A22B-Instruct-2507 user) tab. 2. Per-domain values are in the table; this card shows the average column only:

ModelThinkingPass^3 avg (%)
Qwen3-32Bno9.4
Qwen3-235B-A22B-Instruct-2507no13.8
DeepSeek-V4.1-Flashno32.2
Qwen3-32Byes8.6
Qwen3-1.7Byes1.2
Qwen3-4Byes3.9
Qwen3-8Byes8.4
Qwen3-235B-A22B-Thinking-2507yes16.5
Qwen3.8-27Byes27.3
MiniMax-M3yes17.6
Muse-Glimmer-30Byes20.5
MiniMax-M2.7yes16.8
Gemma-4-31B-ityes24.7
GLM-5.3yes31.7
Kimi-K2.7-Codeyes26.1
Tracer-High-1.7B (ours)yes10.4
Tracer-High-4B (ours)yes17.2
Tracer-High-8B (ours)yes19.8

Average Avg@3 values quoted in the text (Qwen3-235B user): DeepSeek-V4.1-Flash 55.9%, GLM-5.3 51.9%, Kimi-K2.7-Code 49.3%, Tracer-High-8B 38.1%, MiniMax-M3 37.0%, Qwen3-235B-A22B-Thinking 36.0% §4.2. Per-domain gaps are large: DeepSeek-V4.1-Flash reaches 44.3% Pass^3 on Retail but 17.1% on Telecom; GLM-5.3 reaches 62.0% on Basketball but 2.9% on Telecom §4.2 tab. 2.

Tracer gains over the base model, Avg@3 (Qwen3-235B user), 1.7B / 4B / 8B: +13.8 to +19.7 points (text range) §4.2. Pass^3 average rises from 1.2 to 10.4 at 1.7B, 3.9 to 17.2 at 4B, and 8.4 to 19.8 at 8B §4.2 tab. 2.

With GLM-5.2 as user, Avg@3 goes from 11.1 to 36.3 at 1.7B, 31.2 to 51.4 at 4B and 37.6 to 54.7 at 8B; the authors report GLM-5.3 at 78.6% Avg@3 and 66.5% average Pass^3 as the strongest model under this user §4.2.

Out-of-domain (six domains that Tracer-Low never trains on: School, Basketball, Restaurant, Travel, Movie, Bank) tab. 3:

ScaleMethodAvg Pass^1 (%)Avg Pass^3 (%)
1.7BBase3.30.0
1.7BAReaL1.90.3
1.7BEnvScaler6.50.7
1.7BTracer-Low (ours)8.42.7
4BBase11.72.0
4BAReaL7.61.7
4BEnvScaler16.93.3
4BArctic-AWM10.91.7
4BSPADE1.00.0
4BTracer-Low (ours)18.67.7
8BBase16.55.0
8BAReaL7.51.0
8BEnvScaler20.87.0
8BArctic-AWM14.22.3
8BSimia-Tau-SFT14.54.3
8BSimia-Tau-SFT-RL14.02.7
8BSPADE0.80.0
8BTracer-Low (ours)20.78.3

In-domain (Airline, Retail, Telecom; same database as Tracer-Low/High training) tab. 4:

ScaleMethodAvg Pass^1 (%)Avg Pass^3 (%)
1.7BBase8.42.9
1.7BAReaL11.41.9
1.7BTracer-Low (ours)34.312.9
1.7BTracer-High (ours)36.215.2
4BBase24.34.3
4BAReaL23.66.2
4BTracer-Low (ours)45.720.5
4BTracer-High (ours)45.720.5
8BBase32.810.5
8BAReaL24.38.1
8BSimia-Tau-SFT33.511.4
8BSimia-Tau-SFT-RL34.812.9
8BTracer-Low (ours)47.824.3
8BTracer-High (ours)46.424.7

Behavioural results (author analysis, correlational):

  • Policy violations stay high even for stronger models: for some emotion conditions the rate is around two-thirds in Telehealth and about 91% in Telecom §5.
  • Successful runs have a moderate balance of tool calls and follow-up questions. Tool calls exceed follow-ups in 76.2% of Tracer-Low and 78.9% of Tracer-High trajectories, against 55.6% for AReaL and 22.0% for Simia §5 fig. 8.
  • Of 6,961 failed trajectories, 449 user turns were flagged as possible simulator hallucinations and 124 were confirmed as user errors, which the authors report as 1.1% of failed trials §5 §9.1.
  • Empathetic replies are associated with more follow-up questions in every model group; the effect on success depends on the emotion §5 fig. 6.

Figure 1 is a bar chart of average accuracy over three runs fig. 1. Figures 3 to 5 show Pass^k rows, violation rates and a tool-to-follow-up scatter fig. 3 fig. 4 fig. 5. Figure 7 shows hallucination rates fig. 7. Figure 8 shows the tool-versus-follow-up distribution in training trajectories fig. 8.

Paper vs code

Official code: github.com/sahsaeedi/tau-emotion-bench, linked on the paper's first page; Apache-2.0; commit ecd0bc1. Checked against the paper's evaluation settings and the Tracer emotion and generation code.

Matches:

  • Default user simulator is qwen3-235b-a22b-instruct-2507 at temperature 0.0 config.py and the README says the same README.md.
  • Step cap DEFAULT_MAX_STEPS = 200 config.py.
  • Ten anchors per emotion condition config.json.

Differs or is unclear:

  • Pass^k. The text says "completed successfully in at least k trials" §4.1. The code uses the all-k form: the probability that k trials drawn from the n runs all succeed, C(s,k)/C(n,k) agent_metrics.py. Implement the code form if you want the published numbers.
  • Unsatisfied termination. The text says the -1 applies when the user is unsatisfied "before successful task completion" §3.1. The code gives -1 to every run that ends with the unsatisfied token and skips ground-truth scoring evaluator.py. Detection is by a token in the simulator's message user_simulator.py and the orchestrator sets the reason on a stop message that carries it orchestrator.py orchestrator.py.
  • Runs that hit the turn cap score 0 without ground-truth scoring evaluator.py. The paper does not say this.
  • Emotion mapping neighbours. The paper does not give k §7.1. The emotion config sets knn_k to 9 config.json; the training script falls back to 7 when it is absent train_encoder.py. The kNN uses cosine distance with distance weights train_encoder.py.
  • Fine-tuning. The repository has no SFT or training script (searches for TRL, SFT trainer, epochs and learning rate found none), so the Tracer-High and Tracer-Low settings in §8.1 cannot be checked against code. The 250-per-domain subsampling and the reward-1 filter in §7.3 are also not in the repository.
  • Generation. The Tracer generator, feeling and grounding agents and per-domain prompts are in tracer/tracer/. This card did not compare their prompts with §3.2; the claim that the feeling generator never sees the database is not verified.

Pitfalls

  • Pass^k definition. Use the all-k form from the code, not the "at least k" wording in the text (see Paper vs code). The two differ a lot at k = 3.
  • Give-up reward. The paper's "before successful task completion" is narrower than the code, which penalises every unsatisfied ending. Check which one you implement, because the training filter depends on it.
  • Turn limit. The paper says 200 interaction turns §4.1. The code calls it max_steps and its docstring says the default is 100, while the constant is 200 orchestrator.py config.py. A config comment says the value "bounds the tool calls". What a turn counts as is not settled.
  • Same family for data and evaluation. Qwen3-235B-A22B-Instruct generated the evaluation tasks and was also the evaluation user simulator §7.2. The paper does not test whether this favours the Qwen family.
  • Shared database for in-domain results. One database backs both the training and the test tasks in four domains (Airline, Retail, Telecom, Telehealth) §7.3. The in-domain table tab. 4 is therefore not a test of unseen data. Only the six out-of-domain tables test unseen databases tab. 3.
  • Small per-domain samples. Domains have 50 or 70 tasks, so one task is 2.0 or 1.4 percentage points, and each run is 1/3 of a task's score. Domain differences of a few points are noise-level.
  • Simulator reliability. The authors checked user hallucinations only on failed trials, with an LLM judge §5. The 124 confirmed errors are 1.8% of the 6,961 flagged trajectories (124 / 6,961), not 1.1%. The 1.1% figure implies a denominator near 11,300 failed trials; the paper does not state it.
  • Robustness arithmetic. The Tracer-High-8B gain with GLM-5.2 is 37.6 to 54.7, which is 17.1 points; the appendix states 17.5 §4.2 §9.1.
  • EnvScaler at 8B. Tracer-Low's average Pass^1 at 8B (20.7%) is 0.1 below EnvScaler's (20.8%) tab. 3. Its advantage is in Pass^3 (8.3% vs 7.0%).
  • Decoding. The decoding table gives one setting per model for the largest number of domains only §8.2. It lists Qwen3-4B and Qwen3-8B at temperature 0.0 while Qwen3-1.7B uses 0.6. Use the per-model setting and mark the rest as not stated.
  • Mixed training data. The text says Tracer data is used "together with the publicly available AReaL data" §8.1. It is not clear whether AReaL rows are in the Tracer training mix; the authors also fine-tuned AReaL themselves as a baseline §8.2.
  • Float numbers. Figure and table numbers in this card are counted from the TeX source order, which was not checked against the printed PDF. Appendix tables are cited by section.

Lineage

  • Builds on: τ-Bench and τ-Trait (environments, tools, policies and the user-simulator termination token); ToolOrchestra (environments); VULCAN (tool-dependency graph); the Atlas of Emotions taxonomy §1 §3.2 §3.3.
  • Compared against: AReaL, EnvScaler, Arctic-AWM, SPADE and Simia-Tau-SFT / Simia-Tau-SFT-RL, all fine-tuned or reported at the same Qwen3 scales §4.1 tab. 3.
  • Superseded by: not known.

Source and license

Adapted from “τ-Emotion-Bench: Exposing the Interaction Fragility of LLM Agents through Real-World User Emotions” by Rishitosh Kumar Singh, Amir Saeidi, Shamanthak Hegde, Shrinidhi Kumbhar, Chitta Baral (arXiv:2610.19560), used under CC BY 4.0. Changes: condensed and restructured for implementation, with tables, equations and algorithms taken from the paper and its code, each cited to its source. Not affiliated with or endorsed by the authors. Code citations refer to https://github.com/sahsaeedi/tau-emotion-bench at commit ecd0bc1b26b6 (Apache-2.0). Any quoted code is shown under that license.