LLMs Get Lost in Evolving User Intent: A Scalable Framework for Evaluating Dynamic Multi-Turn Agents

TL;DR

This paper reveals a fundamental gap in current LLM agents: despite excelling on single-turn benchmarks, they consistently fail to track and act on user intent as it evolves across multiple turns. The authors introduce a scalable framework that transforms any verifiable single-turn dataset into a dynamic multi-turn environment with three types of intent transitions (reveal, revise, switch), preserving automatic evaluation. Across frontier models, performance drops by up to 100% on some tasks after only 6 intent changes, exposing a critical capability invisible to static evaluation.

Position in the field: This work is a systematic benchmark and analysis contribution, not a new model or training method. It identifies and quantifies a previously under-explored failure mode, providing a scalable testbed for future research on intent-tracking in collaborative agents.

Problem & Motivation

The Static Evaluation Mirage

Current LLM evaluation is dominated by single-turn, fully-specified queries. Benchmarks like GSM8K, BIRD-SQL, and SWE-Bench measure a model's ability to solve a problem when all constraints are given upfront. However, real users rarely interact this way. In practice, users:

• Disclose information incrementally (“Find me a restaurant in New York... I’m vegan”).
• Revise previously stated details (“Actually, make it Brooklyn, not Manhattan”).
• Switch to a related task after completing the current one (“Now book a table for 7 PM”).

These dynamics are fundamental to collaborative interaction, yet they are absent from standard evaluations. The central question of this paper is: Do today's LLMs, which excel on static benchmarks, actually track and act on intent as it evolves?

Why Existing Multi-Turn Benchmarks Fall Short

While multi-turn benchmarks exist, they suffer from three limitations:

1. Verifiability: Many rely on LLM-as-judge, whose reliability is contested.
2. Scalability: Hand-authoring multi-turn conversations is expensive and domain-specific.
3. Controllability: Existing simulators often only support incremental information disclosure, missing revision and task-switching dynamics.

The authors propose a radical alternative: instead of constructing new multi-turn environments from scratch, reuse existing single-turn benchmarks by turning them into dynamic multi-turn conversations while preserving their built-in verifiers.

Methodology: The Core Framework

Formalizing Evolving User Intent

The authors define user intent at turn (t) as a structured tuple:

[ \mathcal{I}_t = (f_t, \mathcal{C}_t, \mathcal{C}_t^{ ext{rev}}, y_t) ]

• (f_t): the function (task) the user wants to accomplish (e.g., find_restaurant)
• (\mathcal{C}t = {c{1,t}, ..., c_{N,t}}): set of arguments (e.g., {city, cuisine})
• (\mathcal{C}_t^{ ext{rev}} \subseteq \mathcal{C}_t): arguments already revealed to the agent
• (y_t): the ground-truth answer

Three types of intent state transitions are defined:

1. Argument Reveal: The user discloses a previously unrevealed argument. The function and argument set remain unchanged.
2. Argument Revision: The user changes the value of a revealed argument (e.g., New York → Brooklyn). The function and number of revealed slots stay the same.
3. Function Switch: The user pivots to a different function (e.g., find_restaurant → book_table), with shared arguments carried over.

Retrospective Expansion: Building Conversations Backwards

The key insight is to anchor the final turn to the source single-turn intent and then synthesize a plausible history that leads to it. This is done in three steps:

1. Intent Extraction: For each single-turn problem-answer pair ((q, y^)), an LLM extracts the function (f^) and argument set (\mathcal{C}^*). This forms the anchor intent (\mathcal{I}_T).

2. Counterfactual Argument Generation: For each source argument (c_i^*), a counterfactual value (c_i^{ ext{cf}}) is generated (e.g., if the source is Brooklyn, the counterfactual might be New York). This enables revision: the user first states the counterfactual, then later revises to the source.

3. Predecessor Function Generation: For function switches, a predecessor function (f^{ ext{pre}}) is synthesized that shares overlapping arguments with (f^*) (e.g., find_restaurant as predecessor for book_restaurant). Longer chains are built recursively.

Situated Simulation

The scheduler distributes the intent transitions across (T) turns, respecting rules such as:

• The last turn must be the anchor intent.
• Reveals must precede revisions of the same argument.
• Switches are only allowed when the current task is fully specified.

Each turn's user utterance is rendered by describing only the change (\Delta\mathcal{I}_t), using domain-appropriate discourse prefixes (e.g., "Wait, I need to correct that" for revisions).

Experiments & Results

Main Results: A Consistent and Severe Degradation

The authors evaluate 9 models (frontier and open-source) across 4 domains: math (GSM8K), text-to-SQL (BIRD-SQL), agentic search (BrowseComp+), and software engineering (SWE-Bench Verified). Each conversation includes 6 intent transitions: 2 reveals, 2 revisions, and 2 switches.

Key observations:

• No model is immune: Every model shows degradation, with relative drops of 5-100%.
• SWE-Bench is particularly brutal: GPT 5.1 and Grok 4.20 drop to 0% because they exhaust the tool-call budget on exploration rather than execution, getting lost in the accumulated context.
• Function switches are the hardest: Ablation studies show that function switches cause the steepest decline, and combining multiple transition types compounds the problem.

Deeper Analysis: Why Models Fail

Scaling transitions monotonically degrades accuracy. Figure 4 shows that increasing any transition type hurts, with function switches having the steepest slope.

Memory mechanisms help but don't close the gap. The authors test two simple interventions:

• Prompt recap: A fixed reminder to reconsider the conversation history.
• Oracle recap: Providing the exact current intent (function + revealed arguments) at each turn.

Oracle recap recovers some performance (e.g., from 65% to 75% under function switch on BIRD-SQL), but still falls short of single-turn accuracy (80%). This indicates two sources of error: (1) failure to correctly infer the current intent from history, and (2) failure to act on even the correct intent when it conflicts with prior context.

Difficulty compounds in multi-turn. Using BIRD-SQL's optional hints to control problem difficulty, the authors show that harder problems suffer a larger relative drop under evolving intent (9.0% vs 3.6% for easy problems), suggesting that the multi-turn setting amplifies existing weaknesses.

Critical Analysis & Conclusion

Key Takeaways

1. Static evaluation is insufficient: Strong single-turn performance does not transfer to dynamic, multi-turn interactions. This is a fundamental blind spot in current LLM evaluation pipelines.
2. Intent tracking is the bottleneck: The turn-wise analysis shows that models can nearly perfectly track reveals and revisions, but fail dramatically on function switches. This suggests that the core challenge is not information accumulation, but belief update—the ability to detect when the user's intent has changed and selectively disregard outdated context.
3. The framework is a powerful tool: By repurposing existing benchmarks, the authors provide a scalable, verifiable, and controllable testbed for studying evolving-intent capabilities. This is valuable for both evaluation and training (as demonstrated by the preliminary RL experiment).

Limitations

• Single intent per turn: The framework assumes each user turn contains exactly one intent transition, which simplifies controllability but may not capture real-world multi-intent utterances.
• Stylistic uniformity: The rule-based and LLM-based renderers may not capture the full diversity of user communication styles, including typos, grammatical errors, and persona variations.
• Final-turn verification only: Only the final turn is directly verifiable against the source benchmark. Intermediate turns are controlled but not individually verified, which could allow for plausibility gaps.

Future Directions

The authors identify several promising avenues:

• Persona-conditioned pipelines to generate user utterances reflecting diverse backgrounds and communication patterns.
• Multi-intent turns where a single user utterance contains both a revision and a switch, requiring more complex scheduling and verification.
• Intermediate verifiers that preserve scalability while allowing more flexible intent updates throughout the conversation.
• Training on evolving-intent data: The preliminary RL experiment (Qwen3-4B: 64% → 76% on evolving GSM8K) suggests that targeted training can substantially improve this capability, opening the door to agent training pipelines that explicitly handle dynamic user intent.

Bottom line: This paper is a wake-up call for the LLM agent community. The ability to track and act on evolving user intent is not a luxury—it is a core requirement for any collaborative agent. Current models fail at it, and the proposed framework provides both the diagnostic tool and a path toward improvement.