Your Bot Aces One Turn and Fails the Conversation

The benchmark you trust tests the wrong thing

Here is the uncomfortable mismatch at the heart of conversational AI quality. Your evals, and the public benchmarks vendors cite, overwhelmingly use single-turn, fully-specified prompts: one complete instruction in, one answer out, graded against a reference. Your users do the opposite. They dribble out their intent over several messages, change their mind, add a constraint they forgot, refer back to something three turns ago, and expect the bot to keep up. The competency you measure (handle a perfect prompt) and the competency you ship (handle a messy conversation) are different things, and the gap between them is enormous.

The landmark evidence is the 2025 paper “LLMs Get Lost in Multi-Turn Conversation” from Microsoft Research and Salesforce. The researchers took fully-specified benchmark tasks and “sharded” them, breaking each complete instruction into atomic pieces revealed one turn at a time, simulating how underspecified real conversations actually are. Across six task types (coding, SQL, API calls, math, data-to-text, summarization), 15 models from eight families, and over 200,000 simulated conversations, every model performed dramatically worse in the multi-turn setting, an average 39% drop. The sharded-simulation framework was released publicly, so the methodology is directly reproducible against your own tasks rather than a result you have to take on faith.

How conversations break that single turns never reveal

Multi-turn failures have their own taxonomy, and none of these show up in a single-turn eval:

• Premature commitment. The model guesses at underspecified intent, generates a full solution, and then anchors on that wrong guess even as the user clarifies. This is the dominant failure the “lost” study identified.
• Context loss. A constraint stated in turn 2 is forgotten by turn 6. The model answers the latest message correctly but violates something established earlier.
• Inconsistency / contradiction. The bot says X in turn 3 and not-X in turn 7, eroding trust even when each statement is locally plausible.
• Reference resolution failure. “Do that again but for the other account”, the model loses track of what “that” and “the other” point to.
• Instruction decay. A system instruction honored early (“always confirm before acting”) gets dropped deeper into a long conversation.

Each of these is a churn driver. Users do not file a bug report; they conclude the bot is dumb and stop using it. The failure is invisible to your dashboards and devastating to retention.

Why this is structurally hard to catch

Multi-turn failures evade detection for reasons baked into how teams build and test conversational systems. The first is that demos and QA are almost always single-exchange: a tester types a question, reads the answer, judges it good. Nobody sits through twelve-turn conversations a hundred times looking for the third-turn anchoring failure, because it is tedious and the failure is intermittent. The second is that each individual turn often looks fine in isolation, the model gives a fluent, on-topic reply to the latest message while quietly having dropped a constraint from four turns ago. A reviewer grading turn-by-turn sees nothing wrong; only an evaluation of the whole conversation against the full set of requirements catches it.

The third reason is the most insidious: the failure is non-deterministic. The same conversation can succeed on one run and collapse on the next, because whether the model takes a wrong early turn depends on sampling. This is exactly why the “lost in conversation” research framed the problem as unreliability rather than incapability, and why a single passing manual test is worthless as evidence. If your QA process is “a human tried it once and it worked, ” you have measured nothing about how the conversation behaves at scale.

Build a conversation-shaped eval

The fix is to make your eval look like a conversation, not a prompt. The sharding technique from the research is directly adaptable: take your existing single-turn golden cases and split each fully-specified instruction into a sequence of partial messages, then evaluate whether the model arrives at the correct final result across the turns.

# Sharded multi-turn eval: reveal the task piece by piece, grade the end state
def multi_turn_eval(model, sharded_cases):
    results = []
    for case in sharded_cases:
        # case.shards: ["build a report", "...for Q3", "...only EMEA", "...as JSON"]
        convo = []
        for shard in case.shards:
            convo.append({'role': 'user', 'content': shard})
            reply = model(convo)                  # full history each turn
            convo.append({'role': 'assistant', 'content': reply})
        final = convo[-1]['content']
        results.append({
            'case': case.id,
            # Does the FINAL answer satisfy ALL constraints revealed across turns?
            'all_constraints_met': all(c.check(final) for c in case.constraints),
            # Did an early wrong assumption persist? (the "lost" failure mode)
            'recovered': case.had_correction and case.final_correct(final),
        })
    return results

Grade the end state against the union of all constraints revealed during the conversation, not each turn in isolation. A model that nailed turns 1-3 but dropped the turn-2 constraint by the end has failed, even though every individual reply looked fine.

The metrics single-turn eval cannot produce

A conversation-aware eval lets you measure things a per-turn grader is blind to:

• Constraint retention. What fraction of constraints introduced in early turns are still honored in the final answer?
• Recovery rate. When the user corrects a wrong assumption, how often does the model actually course-correct rather than stay lost?
• Consistency. Does the model contradict its own earlier statements across the conversation?
• Reliability spread. Run the same sharded conversation multiple times, the “lost” study’s key insight is that variance, not average, is what explodes in multi-turn. Measure the spread, not just the mean.

# Reliability: variance across repeated runs is the multi-turn killer
def reliability_check(model, case, runs=10):
    outcomes = []
    for _ in range(runs):
        convo = replay_sharded(model, case)        # same shards, fresh run
        outcomes.append(all(c.check(convo[-1]) for c in case.constraints))
    success_rate = sum(outcomes) / runs
    # High variance = unreliable in conversation even if it "can" do the task
    return {'success_rate': success_rate,
            'reliable': success_rate >= 0.9}        # consistency, not one lucky pass

Mitigations the eval will validate

Once you can measure multi-turn quality, several fixes become testable rather than hopeful. Prompting the model to ask clarifying questions instead of guessing directly attacks the premature-commitment failure. Summarizing and re-injecting established constraints each turn fights context loss in long conversations. Explicit state tracking, maintaining a structured record of confirmed facts and constraints outside the model and feeding it back, turns “remember everything in the transcript” into “read this checklist.” Each is an empirical bet, and the sharded eval is what tells you whether it actually moved constraint retention and recovery rate or just felt better.

Why bigger context windows do not fix it

A tempting assumption is that multi-turn degradation is just a context-length problem, that a model with a million-token window will simply remember everything and the issue disappears. The research says otherwise. The “lost in conversation” failures occur in conversations far shorter than any modern context limit, so the bottleneck is not capacity, it is that the model commits to an early interpretation and weights its own prior (wrong) outputs too heavily. A bigger window holds more text; it does not stop the model from anchoring on a bad assumption made three turns ago. Separately, performance can degrade within a long context (the “lost in the middle” effect), which compounds the problem rather than solving it.

This matters for how you evaluate. If you assume context length is the cure, you will test long single-turn prompts and conclude the model is fine. The correct test holds the conversation short but underspecified and incremental, exactly the regime where users live and where the 39% drop appears. The classic single-turn conversational benchmark, MT-Bench and its LLM-as-judge methodology, was a real step forward for scoring multi-turn quality, but even it uses pre-scripted, fully-specified turns rather than the underspecified, self-revealing intent of real users, which is precisely the gap the sharded approach exposes. Length and conversational structure are different stressors, and a serious eval suite exercises both.

The bottom line

Single-turn evals certify a competency your users never use, and the data is stark: top models lose an average of 39% of their performance in multi-turn conversation, driven by a doubling of unreliability, because they commit to early wrong assumptions and cannot recover. Build a conversation-shaped eval by sharding fully-specified cases into turn-by-turn messages, grade the final state against all constraints revealed, and measure constraint retention, recovery rate, consistency, and, above all, reliability across repeated runs. Then validate clarifying-question and state-tracking mitigations against those metrics. Your bot acing one turn means nothing if it fails the conversation.