TL;DR
An LLM remembers the first thing better than the last — the opposite of human memory. When the same fact gets updated several times in a conversation, the model is very likely to recall the original version, not the latest one. Early information in the context literally crowds out fresh updates.
The main pain point is tracking changes in a long chat. You changed the task requirements three times — and the LLM still answers based on the first version. Not because it “didn't read it,” but because of how the attention architecture works: early tokens accumulate more “votes” at every subsequent generation step. Late updates are physically weaker in the selection mechanism.
That means: model size matters more than context window size. A 100B model with 32K of context holds history better than a 10B model with 1M tokens. But when it comes to holding on to the latest information, neither scale nor window length helps — it's an architectural limitation of all transformers.
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.
How the Effect Works
LONG CHAT
[Fact A v1] → [update A v2] → [update A v3] → ... [update A vN]
↓
QUESTION: "What's current for A?"
LLM returns → A v1 (the first version!) ← this is Proactive Interference (PI)
QUESTION: "Remind me what A was originally?"
LLM returns → A v1 correctly ← this is RI resistance (LLMs handle this fine)
TWO DIFFERENT MEMORY MODES
"What came first?" → answers well (RI — retroactive interference resistance)
"What's current now?" → fails (PI — proactive interference failure)
WORKING AROUND PRIMACY BIAS
STEP 1: Before asking about the current state
→ explicitly restate the latest version in the prompt
STEP 2: Ask your question based on what you just stated
→ the model answers from the fresh data, not the first
Example in Action
Task: You're negotiating a contract with a counterparty through a marketplace. For an hour in a single chat you discussed terms, and the commission rate changed three times: first 12%, then 9%, then 7%. Now you ask Claude to help draft the final paragraph on the terms.
Prompt without knowing about primacy bias:
Help me write the final section of the contract on the commission
based on our discussion above.
❌ The model will most likely return 12% — the first version from the start of the chat.
Prompt that accounts for primacy bias:
Final agreed terms — ignore all previous
versions in our chat:
CURRENT COMMISSION RATE: 7%
TERM: 12 months with automatic renewal
REVIEW CONDITION: at either party's request with 30 days' notice
Based on this current data (this data specifically,
not the earlier discussion), write the final paragraph
for the "Compensation" section of the contract.
Result: The model got an “anchor” right before the question — the fresh information became the last context before generation. The answer will rely on 7%, not on the first rate from the start of the negotiation. The paragraph will come out accurate.
Why It Works
The transformer architecture creates inequality between tokens. When the model generates the next word, it “looks” at all the previous text through the attention mechanism. But early tokens have had time to accumulate attention from every later position — they're literally “stronger” in the mathematical sense. Late tokens have accumulated much less. This isn't a bug in one particular model — it follows from how self-attention works in every transformer.
Human memory works the other way around. For us, new beats old — fresh information pushes out what came before. For LLMs it's reversed: the old is protected, the new is vulnerable. That's why the intuitive “but I posted the update above” doesn't work the way you expect.
Restating what's current is the most direct workaround. When you explicitly write the current version right before the question, you make it the “last anchor” — it sits as close as possible to the point of generation. The model will very likely take exactly that one. It's not a hack; it's using the same mechanics to your advantage.
Control knobs: - 📌 “Current version: [data]” before the question → reduces primacy bias for a specific fact - 🔄 A new chat with a summary instead of a long one → removes the accumulated primacy effect completely - 🤖 Model choice: Claude if you need to track the latest changes; o1/o3 if you need to remember the original context
Prompt Template
Template 1: Current-state anchor
Below is the current data on {subject}. Use exactly this data,
ignore any previous versions from our conversation:
CURRENT STATE OF {subject}:
{current data — everything that matters right now}
Question: {your question about the current state}
Placeholders:
- {subject} — what you're tracking: contract terms, writing requirements, task parameters
- {current data} — the latest version, in full, with no “see above” references
- {your question} — what needs to be done with this data
Template 2: Asking for the original state (use primacy bias to your advantage)
Remind me of {subject} in its original form — the way
it was at the very start of our conversation,
before any changes or edits.
{what specifically you need to recall}
Placeholders:
- {subject} — what you need to recall: the original assignment, the first draft, the initial terms
- {what specifically} — e.g. “Specifically: who was the target audience?”
Template 3: Context reset via summary
Let's reset the context of our conversation.
Here is the full current state of the task:
TASK: {what we're doing}
CURRENT PARAMETERS: {all current conditions as a list}
DONE: {what's already finished}
REMAINING: {what still needs to be done}
Continue working based only on this summary.
🚀 Quick start — paste into the chat:
Here are templates for dealing with primacy bias in LLMs.
Adapt them to my task: {your task}.
Ask me questions to fill in the fields.
[paste the template above]
The LLM will ask what data is current right now and what exactly needs to be done — because without a concrete “current state,” the anchor doesn't work. It will take the template's pattern and adapt it to your conditions.
Why It Matters: Breakdown by Task Type
| Task | What happens if you don't know this | How to use it |
|---|---|---|
| Editing a document in chat | The LLM reverts to the first version | Restate the current version as an anchor |
| Tracking deal terms | Remembers the opening terms of the negotiation | New chat or an explicit summary |
| Long brief with clarifications | Ignores later clarifications | Final brief as one block at the end |
| Recalling the original assignment | Works great — primacy on your side | Just ask directly |
Limitations
⚠️ The study used synthetic data: The task — 46 categories with value updates — isn't the same as a real business conversation. The PI > RI pattern is solid, but how strongly it shows up in your particular case depends on the structure of the context.
⚠️ Reasoning models and recency: o1 and o3 are the best at remembering the original context but the worst at tracking recent changes. If you use o1 for tasks where you need to follow updates, it actively hurts. Claude is more accurate on these tasks.
⚠️ The context window doesn't fix it: A bigger context doesn't help with primacy bias. 1M tokens on a small model will lose to 32K on a large one.
⚠️ The pattern is universal, but its strength varies: All 39 tested models showed PI > RI. But Claude's gap is just 1.05× (almost symmetric), while o1's is 8.5×. The hard rule: pick Claude when accuracy on the latest update is critical.
How They Tested It
The idea was elegant: take a classic psychology experiment on memory interference and run it on 39 LLMs. The models got 46 “category → value” pairs (e.g., “visual art: impressionism”), and then the same entries were overwritten with new values again and again — from 3 to 300 times per category. Then came the question: what came first? (the RI task) or what's current now? (the PI task).
Critically, both tasks used identical sequences — only the question changed. That isolated interference itself rather than differences in retrieval difficulty. The result was brutal: accuracy on the PI task crashed from 85% to 2% at 300 updates. On the RI task under the same conditions, 27% remained — 13 times better.
The researchers expected to find that bigger context windows help. They didn't — the correlation was practically zero. Parameter count, however, explains 49% of the variance in RI resistance. That's a strong result: architecture matters more than buffer size. Another discovery came from error analysis: models almost never hallucinate (< 1%) — they mix up positions within the real context. That's a valuable insight in itself: an LLM's memory problem isn't fabrication, it's picking the wrong item among real data.
Original Prompt from the Paper
Stimulus example (RI task):
Initial: "visual art: impressionism"
Updates: "visual art: baroque", "visual art: realism", ..., "visual art: cubism" (N=300)
Query: "What was the original value for visual art?" → Expected: impressionism
Stimulus example (PI task):
Same sequence.
Query: "What is the current value for visual art?" → Expected: cubism (last update)
Result:
RI accuracy at N=300: 27.4% (models can still recall early info)
PI accuracy at N=300: 2% (models completely fail to recall recent info)
Error distribution:
RI failures: 50.8% retrieval failure (passive — nothing retrieved)
PI failures: 56.1% same-key intrusion (active — early value intrudes)
Hallucination: <1% in both cases
Context: The researchers tested 39 models — from 1B to 2.5T parameters, including GPT-4o, Claude-3.5-sonnet, o1, o3, Llama, Qwen and Mistral — on identical data sequences at different levels of interference.
Adaptations and Extrapolations
💡 Adaptation: picking the model for the task
Instead of a one-size-fits-all “best model” — a deliberate choice based on the type of memory task:
You need to track the latest state (current terms, the last edit, up-to-date requirements): → Use Claude. Minimal perplexity bias (1.05×), the best balance between recency and history.
You need to remember the original context (the original assignment, the original text, the initial terms): → Use o1/o3. Primacy bias works in your favor — they hold on to the first version like a vise.
🔧 Technique: forced context reset every N messages
If you have a long working session with frequent updates — drop in a “checkpoint” prompt every 10-15 messages:
CHECKPOINT — current state of the task:
WHAT WE'RE DOING: {current task statement}
PARAMETERS: {all conditions in their final version}
RESULT OF THE LAST STEP: {what we got}
NEXT STEP: {what needs to be done}
Continue based only on this. The earlier context is history,
not instructions.
This wipes out the accumulated primacy bias and re-anchors the model on the current state. It's especially effective when editing documents, iterating on text, or working through a complex task step by step.
🔧 Extrapolation: primacy as a system prompt tool
You can use what you know about primacy bias proactively when writing a system prompt:
If you're writing a detailed system prompt, put critical instructions and constraints at the very beginning, not at the end. The model will hold on to them more firmly throughout a long conversation.
[CRITICAL — AT THE START]
You are an assistant for legal questions.
Never give specific legal advice.
Always recommend consulting a lawyer.
[then — detailed instructions, examples, formatting]
Constraints at the start → primacy protects them better than if you put them at the end of the system prompt.
Resources
Paper title: Transformers Remember First, Forget Last: Dual-Process Interference in LLMs
Authors: Sourav Chattaraj, Kanak Raj — Thomson Reuters
Key concepts from the paper: - Lost in the Middle — Liu et al., 2024 (models handle the middle of the context poorly) - Attention Sinks — Xiao et al., 2024 (initial tokens receive disproportionately high attention) - AB-AC interference paradigm — a classic psychology experiment adapted for LLMs