LLMs get lost
in conversation.

Every rung below assumes the model reliably carries a task across turns — that information given at step three is still governing behaviour at step twelve. The loop, the reflections, the skill library and the paged memory all depend on it. This rung measures that assumption, and finds it does not hold.

The experiment is clean, which is what makes the result hard to dismiss. Take a task with a complete set of instructions. In one condition, deliver all of it in a single turn. In the other, shard the same information across several turns, adding a piece at a time. Everything else — the content, the model, the task — is held fixed, so the only variable is delivery. Across a large set of current models, reliability drops substantially in the sharded condition.

The proposed mechanism is the useful part and it matches what anyone who has built an agent has seen. The model commits prematurely: given partial information, it produces a full answer built on an assumption it has filled in, and then — because its own earlier turn is now in the context as an apparently settled fact — stays anchored to that assumption as later information arrives, elaborating rather than revising. Errors do not average out over a conversation; they compound, which is why reliability drops once the task is split across turns rather than just fluctuating.

The experiment is beautifully controlled. Take one fully-specified task — say, "write a SQL query" with all its constraints. Deliver it two ways. Concat: everything in a single prompt, the model sees the whole spec at once. Sharded: split the identical requirements into pieces and reveal one per turn, the way a real user drips out details as they think.

The information content is exactly the same. The only difference is timing. So any gap between concat and sharded isolates one thing: the cost of finding out as you go — which is how every real conversation and every agent session works.

Across 15 top LLMs and six task families, sharded delivery cost an average of ~39% in performance. But the headline isn't the average — it's which part moved. The paper decomposes a score into two pieces:

Aptitude barely fell — the ceiling is intact, the model still can do it. What exploded was unreliability: the gap between a model's best and worst attempts on the same sharded task roughly doubled. The same prompt, run twice, now lands in wildly different places. A capable model became an unpredictable one.

Why does drip-feeding break things? Because a model handed partial information tends to answer anyway. It fills the under-specified gaps with a guess and states a full solution — confident, complete, and possibly wrong on the parts it hadn't been told yet. That guess is now in the conversation history as its own words.

When a later turn adds a constraint that contradicts the guess, the model clings. It anchors on its earlier answer, patches around the edges instead of re-deriving, and builds the rest of the conversation on a cracked foundation. The paper's own summary is blunt: models make assumptions too early, and once wrong, "they get lost and do not recover."

You can capture the intuition with one small, illustrative model (the paper itself does not fit a per-turn decay; it finds the loss appears as soon as the task is split into two or more shards). Let p be the model's success rate when it sees the full spec at once (concat). In sharded mode, each turn where it commits on partial info is a chance to lock in a wrong assumption; call that per-turn trap probability q. Surviving a conversation means dodging the trap on every early turn:

One turn (turns=1) has no early-commitment trap, so sharded equals concat. Every extra turn multiplies in another (1−q) — geometric decay. In this toy model, that is why longer conversations get less reliable; the paper's measured drop already shows up at two shards.

It also explains the "aptitude intact, reliability gone" split: p (the ceiling) never changes; the whole loss lives in the compounding (1−q) factor, which is exactly a reliability term. The runnable model below plots the two curves and the widening gap.

The decay model points straight at the cures. Kill the early-commitment traps and the (1−q) factors disappear.

None of these make the model smarter. They change the delivery so its ceiling ability actually shows up — the same lever the experiment pulled to create the effect in the first place.

This is one of the most practically important negative results of the era, because every deployed chat and agent is multi-turn by default. Benchmarks that score single fully-specified prompts systematically overstate how models behave in the wild. The paper reframes a huge swath of "the model is unreliable" complaints as, more precisely, "the model is unreliable when we drip-feed it."

It also gives context engineering a crisp mandate: the highest-leverage thing you can do is keep the model's working context looking like a fresh, complete spec, not a long trail of half-formed turns. It pairs naturally with self-correction work like Reflexion — the difference being that recovery is hard once a model is lost, so the real win is preventing the early commitment rather than repairing it after.

The experiment turns existing single-turn benchmarks into conversations in which the user reveals the task one piece at a time, then simulates many of those conversations for every model.

1. Collect fully specified instructions. Six tasks, each drawn from established benchmarks: Code (HumanEval and LiveCodeBench), Database (text-to-SQL from Spider), Actions (API calls from the Berkeley Function Calling Leaderboard), Math (GSM8K), Data-to-text (table captions from ToTTo) and Summary (query-focused summaries with citations over about twenty documents, from Summary of a Haystack). The first four are scored pass or fail; data-to-text uses BLEU and Summary an LLM-judged coverage and citation score, all on a 0 to 100 scale.
2. Shard each instruction. A semi-automatic process, LLM proposals reviewed and edited by the authors, splits each instruction into shards. The first shard states the high-level intent and each later shard adds one clarification; together they carry exactly the original information. Each task got 90 to 120 sharded instructions, 600 in all.
3. Simulate a user. GPT-4o-mini plays the user. It sees every shard and the conversation so far, picks the shard that fits most naturally next, often the one that answers a question the assistant just asked, and rephrases it without changing its content. It reveals at most one shard per turn.
4. Let the assistant answer freely. The evaluated model gets only a minimal system message with what the task needs, such as a database schema or a list of tools, and is never told that the conversation is underspecified.
5. Classify and score every reply. A classifier labels each response as clarification, refusal, hedging, interrogation, discussion, missing or answer attempt. Answer attempts go to an extractor and then to the task's evaluator. The conversation ends when an attempt is correct or the user runs out of shards.
6. Compare five delivery settings. FULL gives the original instruction in one turn. CONCAT gives all the shards in one turn as a bulleted list, which keeps the sharding's rephrasing but removes the underspecification. SHARDED reveals one shard per turn. RECAP adds a final turn restating every shard, and SNOWBALL restates all earlier shards in every turn.
7. Repeat, and measure the spread. Every model runs 10 simulations per instruction and setting at temperature 1: 15 models and more than 200,000 conversations, for about 5,000 dollars. A manual audit found simulator, classifier or extraction errors in under 5 percent of conversations, and errors that hurt the assistant in under 2 percent.

The 15 models span eight families, from Llama 3.1 8B and OLMo-2 13B to GPT-4.1, Gemini 2.5 Pro and Claude 3.7 Sonnet, and include two reasoning models, o3 and DeepSeek-R1, chosen to test whether extra thinking helps.

What the transcripts show

Reading the simulation logs, the authors name four behaviors behind the drop. Models propose a complete answer before the specification is complete, filling the gaps with assumptions. They lean on their own earlier, wrong attempts, so answers grow longer with each try. They weight the first and the latest turns over the ones in between, a loss of the middle turns. And their verbose replies add assumptions that pull attention away from what the user actually said.

• Si — the score of simulation i on one instruction, 0 to 100; pass-or-fail tasks score 0 or 100.
• N — simulations per instruction and setting, 10 in the main experiment.
• A — aptitude: a best-case score, roughly what the top tenth of runs achieves.
• U — unreliability: the gap between the best-case and worst-case runs of the same instruction; R is its complement.

All three are computed per instruction and then averaged over the corpus, which is what lets the paper tell apart two models with the same average. A model that is perfect on six of ten instructions and fails the rest every time has P = 60, A = 60 and U = 0: its problem is aptitude. A model that solves every instruction in six of ten runs also has P = 60, but A = 100 and U = 100: its problem is reliability. Going from single-turn to sharded delivery, the models moved like the second case, not the first.

Every one of the 15 models did worse in SHARDED than in FULL on every task, with an average drop of 39 percent. CONCAT, the same shards delivered at once, kept 95.1 percent of FULL on average (86 to 92 percent for the smallest models), so the loss is not explained by information lost in sharding. Decomposed, aptitude fell by an average of 16 percent while unreliability rose by 112 percent, to a typical gap of about 50 points between a model's best and worst runs on the same instruction. Better models had slightly higher multi-turn aptitude but about the same unreliability as weaker ones, and the two reasoning models degraded like the rest; their responses ran about 33 percent longer, which the authors link to more unstated assumptions.

Repeating the information helps only partly. On four tasks (Code, Database, Math and Actions) with two models:

RECAP assumes you know which turn is the last, which a real conversation does not, so the authors treat SNOWBALL as the realistic fix: it recovers about 15 to 20 percent of the lost ground.

Two other knobs failed. Lowering temperature cut unreliability by 50 to 80 percent in single-turn settings, but in SHARDED GPT-4o-mini saw no improvement and GPT-4o only 15 to 20 percent; with both user and assistant at temperature 0, unreliability stayed around 30 points. Splitting more finely did not matter much either: in a gradual-sharding test with GPT-4o and GPT-4o-mini, both were already lost with two shards, and giving everything at once was the only setting that restored reliability.

Timing explains part of it. On Math and Code, conversations whose first answer attempt came in the first 20 percent of turns averaged 30.9, against 64.4 when the first attempt came in the last 20 percent.

Very recent work, and as a measurement paper its limits are about construct validity: synthetic sharding of a complete specification is a controlled proxy for real conversation, and real conversation also contains clarification, correction and emphasis that this setup does not model. The effect's size in production is therefore not what the controlled numbers say. The effect's direction is well established, and it matches the failure every agent builder already recognises.

What it implies is concrete and is the reason this rung closes the ladder. Do not rely on accumulated context to carry the task. Restate the full current specification rather than trusting that turn three is still in force; treat a long agent trajectory as a liability rather than as a growing store of understanding; and make the agent's early commitments cheap to abandon — which is an argument for structures that can backtrack over ones that only append.

Read against rung 1, the ladder makes an uncomfortable and honest point. The agent loop is a genuinely good idea, and all six rungs of machinery above it are built on a substrate whose reliability degrades exactly as the loop gets longer. That tension is the current state of the field, not a gap someone forgot to close, and a page that ends on it is more useful than one that ends on the newest framework.

Work each one out before you open it — a number, a prediction or a reason, not a definition. Producing the answer is what makes it stick. Your progress is kept on this device.

Give the model a tool, then a loop, then a memory, then a world. Ends on the 2026 paper measuring how badly the whole stack degrades over many turns.

1. 1ReAct2023
2. 2Toolformer2023
3. 3Reflexion2023
4. 4Voyager2023
5. 5Generative Agents2023
6. 6MemGPT2023
7. 7LLMs Get Lost in Multi-Turn Conversation2026

All 110 papers, in 19 ladders →