AppWorld-UL: Benchmarking the Missing Link in Tool-Use Agents – User Interaction

TL;DR

Current tool-use agents are evaluated on fully specified tasks, but real-world deployment requires handling ambiguous, infeasible, or high-stakes goals that demand user interaction. AppWorld-UL introduces a systematic perturbation method to transform 516 autonomous tasks into interactive ones, covering three essential interaction types: clarification, infeasibility communication, and confirmation-seeking. The best agent (Claude Opus 4.7) achieves only 48.6% success, and ablation reveals that interaction requirements account for the majority of the difficulty. This benchmark is a critical stress test for any agent claiming to be deployable in the real world.

Problem & Motivation

Most existing benchmarks (e.g., SWE-bench, WebArena) assume tasks are fully specified at the outset. However, real users rarely provide perfect instructions. They may say "return the shirt I bought last week" when multiple shirts were purchased, or "order a coffee maker under $170" when the available options have different prices. The agent must proactively identify ambiguity, detect infeasibility, and seek approval when actions have high consequences.

The prior work on interactive benchmarks falls into two camps:

• Rigid simulators (e.g., BFCLv3): Use fixed, pre-defined user messages at predetermined turns. These are reproducible but unrealistic – the user cannot adapt to agent-initiated questions.
• Unconstrained LLM simulators (e.g., τ-bench): Allow the LLM to freely respond and even decide when the task is complete. This introduces instability and makes it hard to attribute failures to the agent versus the simulator.

The key insight of AppWorld-UL is to create a middle ground: a constrained LLM-based user that is flexible enough to answer questions naturally, but bounded by a well-defined knowledge set that only contains the information the agent needs to elicit. This is achieved through a perturbation-based transformation that systematically introduces known gaps into autonomous tasks.

Methodology

Perturbation-Based Transformation

The authors start with well-defined autonomous tasks from AppWorld (a rich environment with 9 apps and 475 APIs). Each task is represented as a 4-tuple: (I, S0, E, K), where K is the user knowledge set. For autonomous tasks, K = ∅. To create interactive tasks, they apply three types of perturbations:

1. Underspecified Goals: Remove critical information from the instruction or introduce ambiguity in the initial state so that multiple valid solution paths exist. The agent must ask the user to clarify which path to take.
2. Infeasible Goals: Modify the initial state or evaluation criteria so that the original instruction cannot be satisfied. The agent must detect the impossibility and request an alternative goal.
3. Confirmation-Requiring Goals: Introduce high-cost consequences (e.g., price increase) for actions that were low-risk in the original task. The agent must seek explicit approval before proceeding.

These perturbations can be composed to create tasks requiring multiple types of interaction.

Figure 2: The perturbation process creates three interaction types. The right side shows an example agent trajectory.

Simulated User Design

The user is simulated by an LLM (e.g., GPT-5.5) prompted with:

• The task instruction
• The user knowledge set K (as question-answer pairs)
• Instructions to only answer questions that map to entries in K, and to deflect others

The key innovation is that the LLM explicitly checks whether the agent's question matches a QA pair before responding. This ensures that the user does not provide information beyond what is in K, making the interaction reproducible. The system also enables programmatic evaluation of interaction quality: a unit test verifies that the agent asked all required questions (i.e., covered all K entries), independent of task success.

Experiments & Results

Main Results

The authors evaluate 6 LLMs with two agent scaffolds (Code Agent and Function Calling) on the 516 tasks.

Even the best agent achieves only 48.6% I-TGC, and on the harder compositional tasks, performance drops to 35.7% (Claude Opus 4.7 Code). The interactive scenario-level metric (I-SGC) is even lower, indicating that agents are inconsistent across task variations.

Ablation: Isolating Interaction Difficulty

To understand how much of the difficulty comes from interaction requirements versus environment complexity, the authors conduct an ablation with GPT-5.5 Code Agent:

• Default: 41.8% I-TGC
• Hidden Knowledge: 12.8% TGC (user refuses to answer)
• Oracle Knowledge: 78.1% TGC (all K given upfront)

The massive gap between Default and Oracle (78.1% vs 41.8%) shows that interaction requirements account for most of the difficulty. The gap between Oracle and original AppWorld (85.3%) shows that perturbations also introduce additional environment complexity.

Figure 5: Ablation showing that interaction requirements are the primary source of difficulty.

Interaction Quality Analysis

The paper shows a strong correlation between interaction quality and task success. On successful tasks, agents achieve 100% recall (asked all required questions) and 80-91% precision. On failed tasks, recall drops to 37-40% and precision to 40-47%. This confirms that good interaction is a prerequisite for success.

Critical Analysis & Conclusion

Takeaways

• Perturbation-based transformation is a principled way to create interactive benchmarks from existing autonomous ones, enabling precise control over interaction types and programmatic evaluation.
• Constrained user simulation strikes a good balance between realism and reproducibility, with only 1.3% error rate in user responses.
• Current agents are far from ready for user-in-the-loop deployment. The best system achieves only 48.6% success, and the gap to oracle knowledge (78.1%) shows that the primary bottleneck is interaction capability, not environment reasoning.

Limitations

• The benchmark simulates a single user; real-world scenarios may involve multiple users (e.g., a manager and a colleague) with conflicting instructions.
• The knowledge set K is determined by the perturbation designer; in practice, the set of possible missing information is open-ended.
• The simulated user is cooperative; a real user might be unresponsive, busy, or provide wrong information.

Future Work

• Extend the perturbation framework to support more interaction types, such as error recovery or iterative refinement.
• Use the benchmark to train agents that are explicitly optimized for interaction quality (e.g., via reinforcement learning).
• Apply the same methodology to other domains (e.g., code generation, data analysis) to create general-purpose interactive benchmarks.

AppWorld-UL is a timely and rigorous benchmark that exposes a critical gap in current LLM agents. It will likely become a standard evaluation for any deployable tool-use agent.