TL;DR
Contextual Drag is the effect where a model sees a wrong solution in its context and its next answer drifts toward structurally similar mistakes. Even if the model recognizes the error itself or is told outright "this is wrong", it still copies the reasoning pattern from the failed draft. It works like an anchor — the model tries to produce a new solution but subconsciously hangs on to the logic in the context.
The researchers tested 11 models (from GPT-5 to small open ones) on 8 task types. When a model sees 1-2 wrong solutions in its context, performance drops by 10-20% for large models and by up to 50% for small ones. The biggest surprise: explicitly stating "the draft is wrong" barely helps. The model acknowledges the error in words but repeats the same structural patterns in its new solution — like a person who knows an anchor is bogus but still uses it as a reference point.
On Game of 24 (build an expression from 4 numbers that equals 24), they measured the tree edit distance between solutions. It turned out that the model's new attempts were 2-3x closer to the faulty draft than to a "from scratch" solution. The model doesn't copy the words, but it inherits the structure of the computation. Worse still: run several rounds of "try again" and weak models fall into self-degradation — accuracy drops with every iteration instead of improving.
Want this for your own case? Apply this study to your task: AI adapts its method to what you are working on and writes the prompt.
Why It Matters
This effect breaks the basic idea behind many workflows: "show the model its mistake → it'll fix it". In practice:
Doesn't work:
You: Solve problem X
LLM: [wrong solution A]
You: That's wrong, try again
LLM: [solution B — structurally similar to A, wrong again]
Why: The context already contains reasoning pattern A. The model sees it and acknowledges it as wrong, but when generating a new answer the attention mechanism still latches onto that structure — slotting in similar steps, similar intermediate conclusions. It's not deliberate copying; it's a technical effect of the architecture.
Works:
You: Solve problem X
LLM: [wrong solution A]
[You open a new chat]
You: Solve problem X
LLM: [solution C — independent of A, better odds of being right]
Why: Empty context = no anchor. The model generates "from scratch" without building on the failed structure.
Working Principles
This isn't a ready-made prompting technique — it's a set of context hygiene rules. What to do:
1. New chat when the model makes a mistake
Rule: If the model got a task wrong 1-2 times, don't write "try again" — open a new chat.
When: - Math, logic, code — where there's an exact answer - The model produced clearly wrong reasoning (not just "I don't like the tone" but "the conclusion is logically flawed")
When it's NOT critical: - Creative tasks without a clear right answer - Style iterations ("make the text shorter", "add more examples") - Refinements ("now do it for a different audience")
2. Separate chats for parallel attempts
Instead of:
Chat 1:
- Solution option 1
- Solution option 2
- Solution option 3
Do:
Chat 1: Option 1
Chat 2: Option 2
Chat 3: Option 3
Then compare them in a separate 4th chat or by hand. That way each attempt is independent and doesn't drag along the structure of failed options.
3. Don't pile up failed reasoning
If you're doing a multi-step task: - Step 1 failed → don't fix step 1 in the same chat - Better: a new chat, rephrase the task or the approach
Analogy: You write some code, run it — error. You don't patch things right in the console with the error on screen; you go to the editor and rewrite with fresh eyes. Same with an LLM.
Example
Task: You're analyzing the payback of launching an online school in the "Python for analysts" niche. You asked the model to work out the course's unit economics.
The situation:
First attempt in the chat:
You: Calculate the course payback: average order value $299,
marketing $150 per student, production 200 hours...
LLM: [Produces a calculation that forgets taxes and computes the margin incorrectly]
You: There's a mistake, you didn't account for taxes, recalculate
LLM: [A new calculation — structurally similar, again confuses
margin with profit, adds taxes but in the wrong place]
Why: The model latched onto the structure of the first calculation — the sequence of steps, the formula. Even after acknowledging the error, it keeps reasoning within the same logic.
The right way:
[You see the model made a mistake]
[You open a NEW chat]
You: Calculate the course payback: average order value $299...
Be sure to account for: 15.3% self-employment tax, contribution margin vs. net profit
LLM: [A from-scratch calculation — better odds of the right structure]
Result:
The model builds the calculation from zero without leaning on the failed pattern. You get an independent second attempt instead of "fixing the error within the same logic".
How They Tested It
A Princeton team took 11 models — from GPT-5 and Gemini down to small open-source ones (7B parameters) — and ran them through 8 task types: competition math (AIME, HMMT), science questions (GPQA), code (CRUXEval), logic puzzles (Game of 24).
The design is simple and clever: First the models solved the tasks "from scratch" (DIRECT) to establish a baseline. Then the same tasks, but with 1-2 wrong solutions from other models already sitting in the context (1F/2F). On top of that, the model was explicitly asked to check the draft first and then give its own answer.
What they measured: The drop in accuracy. If DIRECT = 70% and with a draft in context = 55%, contextual drag costs 15 percentage points.
The most interesting part — Game of 24: Each solution can be represented as a tree (numbers in the leaves, operations in the nodes). They computed the tree edit distance between the draft and the new answers. Result: the model's answers under drag were 2-3x closer to the faulty draft than to a clean solution. That's direct evidence: the model doesn't just solve poorly, it copies the computational structure from the context.
The logic of the conclusions: If the issue were only "the model didn't recognize the error", explicitly saying "the draft is wrong" would help. They checked — it barely did. So the problem runs deeper: even after recognizing the error, the model clings to the pattern in the context while generating. The attention mechanism gravitates toward existing tokens and structures.
The surprise: Proprietary models (GPT-5, Gemini) suffer from drag too, if less so (a 5-10% drop vs. 30-50% for small models). The assumption was that extended thinking would protect them — no, it doesn't fully. A model can reason for 15 steps, declare the draft wrong, and still repeat a similar mistake.
Practical insight: The authors tried two mitigations: 1. Context denoising (the model rewrites the draft itself before using it) — helps partially, but not fully 2. Fine-tuning with fallback (training the model to "reset and solve from scratch if the draft is wrong") — better, but also not a 100% recovery
The researchers' conclusion is honest: there's no complete fix yet. Contextual drag is a fundamental property of the architecture, not a bug you can easily patch with a prompt.
Limitations
⚠️ Not about creative work: The effect was measured on tasks with a clear right answer (math, code, logic). For creative writing or brainstorming, showing different options (even weak ones) in the context may actually help — it widens the space of ideas.
⚠️ Large models are more resilient: GPT-5 and Gemini 3 Pro drop by 5-10%, but they still drop. Not even frontier models are fully immune.
⚠️ No ready-made fix: The study exposes the problem but doesn't offer a "do this and it works" technique. The only reliable approach is resetting the context, but that requires a manual action (a new chat).
Adaptations and Extrapolations
💡 Adaptation for multi-step projects
If a task has several stages and you're stuck on one:
Don't:
Chat:
- Stage 1: Audience analysis [ok]
- Stage 2: Positioning [failed, redone 3 times]
- Stage 3: Content plan [built on the botched stage 2]
Do:
Chat 1: Stage 1 [ok, result saved]
Chat 2: Stage 2, approach A [failed]
Chat 3: Stage 2, approach B [ok!]
Chat 4: Stage 3 [use the output from Chat 3, not Chat 2]
Principle: Isolate every failed attempt in its own chat. Don't carry it into the next stages.
🔧 Technique: An explicit reset when the prompt has grown complicated
If you're iteratively bolting things onto a prompt:
Typically:
You: Write an outline for an article about {topic}
LLM: [an outline — not quite it]
You: Add more examples
LLM: [added them, but the structure is still from the first version]
You: And make the intro shorter
LLM: [everything's tangled]
Alternative:
[After the first failed attempt]
You: Stop. Start from scratch. Here's the final brief:
- An outline for an article about {topic}
- 3-5 examples in every section, no exceptions
- Intro under 100 words
[Or just a new chat with the final prompt]
Effect: You cut off the "tail" of failed iterations. The model works from a clean brief and doesn't drag in the structure from the first attempts.
Resources
Contextual Drag: How Errors in the Context Affect LLM Reasoning
Yun Cheng, Xingyu Zhu, Haoyu Zhao, Sanjeev Arora
Princeton Language and Intelligence, Princeton University
Preprint, February 2026
Code: github.com/princeton-pli/contextual-drag