When persistent memory says one thing about a fact and a freshly retrieved document says another, what does the model do? The honest answer is: there is **no built-in preference**.
The model reads both blocks as text. It does not know which one came from a vector store and which one came from a long-term memory file. It does not have a hard-coded rule like 'retrieval is more authoritative than memory'. What actually drives the outcome is mechanical: **where each block sits in the prompt** (top, middle, bottom), **how recent each block is** to the user turn, and **whether anyone wrote down a precedence rule** the model can follow.
The three wrong options all describe behaviors people assume the model has but it does not. The model does not prefer retrieval automatically. It does not pick the shorter source. It does not refuse on conflict (unless you tell it to). It just produces text influenced by what it saw, in the order it saw it.
The context-engineering fix is to make precedence explicit. One sentence in the system prompt,'When persistent memory and retrieved documentation conflict, prefer the documentation and note the conflict', removes the ambiguity and stops the outcome from depending on accidental positioning.
**No built-in preference. Outcome depends on position, recency, and explicit precedence rules.**
This is the core context-engineering failure mode behind a class of bugs that look like model hallucinations but are actually composition bugs. The team adds a memory layer, the team adds a retrieval layer, and at some point the two layers contradict each other on a fact (the user's company name changed, a feature was renamed, a policy was updated). The system produces the wrong answer and the blame goes to the model. The real cause is that nobody told the model what to do when the two sources disagree.
Three levers determine the actual outcome. **Position**: blocks near the top and the bottom of the prompt get more attention than blocks in the middle. If the stale memory is near the bottom and the fresh retrieval is in the middle, the stale memory tends to win. **Recency**: in a streaming conversation, the most recently added block carries weight; if memory was just refreshed but retrieval was prepared earlier in the trajectory, the order matters. **Explicit precedence**: a written rule in the system prompt overrides both effects when the model follows instructions reliably, which modern frontier models do.
The right move is to never leave precedence to chance. State the rule explicitly: 'When persistent memory and retrieved documentation conflict on a fact, prefer the documentation, quote the document, and note the conflict to the user.' Now the resolution is deterministic and auditable, not a function of accidental ordering.
Quick reference
TL;DR
The model treats memory and retrieval as plain text; outcome is determined by position, recency, and any explicit precedence rule you write, not by source type.
Imagine a kid doing homework who gets two answers to the same question: one from a sticky note on the fridge (older, but written by a parent) and one from a textbook just opened on the desk. Nobody told the kid which to trust. The kid will probably go with whatever they read last or whichever is louder. That is exactly what the model does when persistent memory says one thing and a fresh retrieved document says another. The model has no built-in rule that 'retrieval beats memory' or the reverse. If you want a specific answer when they disagree, you have to write the rule down at the top of the prompt: 'when these two disagree, do this'.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example.
Your application has only one source of facts (pure RAG with no persistent memory, or pure memory with no retrieval) No two-source conflict to resolve; the precedence problem does not arise
The fact in question is preference-shaped rather than world state shaped (the user prefers Python over JS) Memory should always win for preferences; retrieved 'industry trend' data should not override stated user preference
You are still in the prototype phase before instrumenting traces Set precedence by rule now; defer detection at write time and provenance tagging until you have signal from real usage
Quick scan · 2–4 min
Everything important, quickly.
8 min: the three levers (position, recency, precedence), the no-preference fact, provenance tagging with timestamps, write-policy as upstream fix, conflict detection at write time, eval coverage for conflict resolution.
Real-world examples
Real products, models, and research that use this idea.
1ChatGPT's memory feature explicitly tells the model how to reconcile with web search results when they disagree, surfaced in OpenAI's published system-prompt patterns.
2Cursor's agent mode includes precedence between the user's persistent rules, the project-level context, and freshly read files; conflicts are resolved by stated rule.
3Mem0 and Zep both expose conflict-resolution hooks at the memory layer so contradictions are flagged before reaching the model prompt.
4Anthropic's Claude memory features in 2026 explicitly distinguish 'preferences memory' from 'fact memory' and document precedence with retrieved citations.
Interviewer follow-ups
What an interviewer would ask next. Try answering before peeking at the approach.
QHow would you build an eval set for conflict resolution?
Sign in or go Pro to see the approach for this follow-up.
QWhat signals would tell you a memory write policy is too aggressive?
Sign in or go Pro to see the approach for this follow-up.
Don't say this
Red flags and common mistakes that signal junior thinking. Click to expand.
Most common mistake
Assuming the model has an implicit rule that 'fresh retrieval beats stored memory', then being surprised when it confidently quotes the stale memory because that copy was nearer the user turn.