Short answer: When sources disagree about the same moment, preserve both claims instead of silently picking one.
Ordinary reconciliation assumes an older fact was superseded. A genuine contradiction has no clean timeline fix. Silently choosing a side erases disagreement that may matter for fairness or investigation. Distinguish updates from same-moment conflicts, and note that one hedged source can be uncertain alone. Engram can keep contradictions explicit rather than force a false resolution.
Reconciliation, covered elsewhere in this knowledge base, handles the common case where a fact simply changes over time, an old address gets replaced by a new one, an outdated title gets updated to a current one. Not every conflict a memory system encounters is this tidy. Sometimes two sources genuinely disagree about the same point at the same moment, and neither one is obviously the outdated version waiting to be superseded. This chapter looks at what a system should actually do when a contradiction isn’t a simple update at all.
Why Doesn’t Every Conflicting Pair of Facts Actually Fit the Reconciliation Pattern?
Reconciliation assumes a timeline: an older fact was once true, a newer fact has since replaced it, and the system’s job is recognizing that supersession and updating accordingly. A genuine contradiction breaks that assumption, two sources describing the same moment in two incompatible ways, with no clear sense that one simply came later and corrected the other. Forcing this kind of disagreement through the reconciliation pattern, silently picking one side as though it were simply the more recent, more correct version, discards a genuine unresolved conflict as though it had already been settled when it hadn’t been.
What Actually Goes Wrong When a System Silently Picks One Side of a Genuine Contradiction?
Silently resolving a contradiction in favor of whichever source happened to be processed first, or whichever one a confidence heuristic slightly favored, presents an unsettled disagreement to anyone relying on that memory as though it were a confirmed, uncontested fact. This is exactly the kind of failure this knowledge base’s earlier discussion of context engineering described as context clash, contradictory information sitting in a system’s working context that misleads it into confidently building on an assumption that was never actually settled. A memory system that quietly erases the existence of a genuine disagreement doesn’t resolve that disagreement, it just hides it from view until it resurfaces as an unexplained inconsistency later.
What Does It Actually Mean to Represent a Contradiction Rather Than Resolve It?
Representing a contradiction means storing both conflicting claims, along with enough context to show that they genuinely disagree, rather than collapsing them into a single, falsely confident statement. This might mean keeping both versions as separate memories linked to the same underlying question, each carrying its own source and confidence, or it might mean capturing the contradiction directly within a single memory that explicitly states two sources disagree rather than asserting one side as settled fact. Either approach preserves the honest reality that a question remains genuinely open, rather than pretending it’s already been answered.
How Should a System Decide Whether a Given Pair of Facts Is Actually a Genuine Contradiction Rather Than an Ordinary Update?
The key distinguishing signal is whether there’s a credible timeline explanation for the difference, one fact plausibly having simply become outdated and replaced by the other, versus both facts genuinely claiming to describe the same moment in incompatible ways. A preference stated differently across two conversations months apart usually fits the ordinary update pattern reasonably well. Two independent witnesses describing the same specific event differently, with no plausible timeline separating them, is a genuine contradiction that deserves to be preserved as such rather than quietly resolved one way or the other.
Does Representing Uncertainty Always Mean Two Sources Actively Disagree, or Can a Single Source Alone Be Uncertain?
A single source can carry its own honest uncertainty even without a second, conflicting source in the picture at all, a fact stated tentatively, hedged, or explicitly flagged by the person or system reporting it as something they aren’t fully sure of. This connects directly back to the confidence modeling covered earlier in this Part: uncertainty isn’t only a property of disagreement between sources, it’s also a property a single memory can and should carry honestly on its own, reflecting exactly how sure the original source actually was, rather than flattening that hedge into unwarranted, false certainty.
How Does Weaviate Engram Let a System Preserve a Genuine Contradiction Rather Than Silently Resolving It?
Weaviate Engram’s transform step can be configured to keep conflicting memories side by side, rather than automatically collapsing them into a single rewritten fact whenever a new, disagreeing claim arrives. Consider a product-safety investigation team’s incident-report assistant, gathering accounts from multiple independent parties about the same reported malfunction:
from engram import EngramClient
client = EngramClient(api_key=os.environ["ENGRAM_API_KEY"])
client.memories.add(
"The consumer reports the device's battery compartment overheated during normal charging, unrelated to any third-party accessory.",
properties={"case_id": "case-device-incident-2291", "reporting_party": "consumer"},
)
client.memories.add(
"The manufacturer's technician inspection found evidence of a non-authorized third-party charging cable, suggesting the overheating was not caused by a device defect.",
properties={"case_id": "case-device-incident-2291", "reporting_party": "manufacturer"},
)
Both accounts remain stored side by side rather than one silently overwriting the other, letting an investigator searching this case see the genuine disagreement clearly:
results = client.memories.search(
query="What do we know about the cause of the overheating in this incident?",
properties={"case_id": "case-device-incident-2291"},
)
An investigator reviewing this case needs to see both accounts and recognize that they genuinely conflict, rather than having the system quietly favor one party’s version and present it as though the matter were already settled. This is exactly the value representing contradiction honestly delivers for a use case like incident investigation, where prematurely resolving a genuine disagreement in either direction could seriously compromise a fair, accurate assessment of what actually happened.
Representing uncertainty and contradiction honestly closes out this Part’s exploration of how memory gets structured and organized as data, from objects and schemas through confidence, provenance, and now genuine disagreement between sources. Everything covered in this Part has assumed memory content already exists, ready to be structured. The next Part turns to the pipeline that actually produces it, the steps raw data passes through on its way to becoming durable, structured memory in the first place. Our next chapter, What is the memory pipeline: extract, transform, commit?, opens that next Part.