What SAGE does with a contradiction, and what happens the next time someone asks

SAGE resolves a contradiction automatically only when lineage, supersession or authority settle it outright, logged either way. Once a human rules on a genuinely ambiguous case, every other tool inherits that ruling the next time it asks, not the instant it's made.

Most explanations of "contradiction detection" stop at the demo: two documents disagree, a flag appears, everyone nods. The real engineering questions sit underneath that flag. What makes SAGE confident enough to resolve a conflict without a person, and what makes it escalate instead? And once someone has ruled, what actually changes, not in that conversation, but the next time an unrelated tool asks a related question? The answers aren't philosophical. They're mechanical, and every step of them is checkable.

The provable cases

A contradiction, to SAGE, is two facts about the same real thing that can't both be current: two accrual rates for one leave category, two documents both claiming to be the active procedure for one task. When memory holds a pair like that, it checks the lineage of each fact for one of two relationships.

The first is supersession: one fact traces to a version, approval, or effective date that explicitly replaces the other. A revision with a documented sign-off, a procedure marked "supersedes v2", a policy whose effective date has already passed. The second is authority: an organisation-set ranking of sources for that topic, fixed in advance. Head office outranks a site variation, the compliance system outranks a document exported from someone's inbox. Where either relationship holds, closing the conflict is arithmetic, not judgment. SAGE marks the higher-ranked fact current, marks the other superseded (retired, not deleted, because an auditor may later need to know what a tool would have answered before the ruling), and logs which relationship closed it and what evidence supported that.

The ambiguous cases

Escalation isn't a fallback for when SAGE is "unsure". It's the outcome of a specific, checkable absence: neither fact supersedes the other, neither source outranks the other for that topic, and both are still marked current. Picture two facilities each publishing an updated procedure after the same regulation changed, neither one referencing the other's revision. Nothing connects them and no rule decides between them, because the organisation itself hasn't decided yet. That isn't a gap in SAGE's reasoning. It's an accurate report of a real, unresolved disagreement.

When that happens, the person who rules sees both sources side by side, the lineage each traces to, and the history of how the conflict surfaced: the documents themselves, not a summary. Their ruling is written back as its own record, with its own lineage, explicitly superseding both prior versions. It doesn't overwrite history. It extends it, which matters for what comes next.

The next tool that asks

Here's the part worth being precise about, because it's easy to overstate. Say a rostering assistant asks about casual leave accrual, surfaces the contradiction above, and a quality lead rules on it Tuesday. The ruling updates memory: one record, superseding two. Nothing is broadcast. No other tool is notified. No agent finds out.

On Thursday, an unrelated onboarding chatbot, different team, quite possibly a different model, no prior contact with the rostering assistant, is asked whether a new casual employee accrues personal leave. It queries memory the way it always does. What comes back is whatever is current as of Thursday: the quality lead's ruling, sourced to their decision. SAGE doesn't intercept the chatbot's request or block anything. There's simply nothing else to hand over, because the superseded fact stopped being current on Tuesday. The chatbot has no idea a conflict ever existed. It just receives the current fact, because that's what current now means.

That's the entire mechanism behind "decide once, the whole fleet inherits it": not agents talking to each other, but every tool reading the same memory, so a decision made once is simply what every later question finds. Not the instant the ruling is made. The next time it asks.

It's also the concrete difference from retrieval. A search-based pipeline can fetch the superseded procedure and its replacement with equal confidence. It has no lineage telling it which one a person already ruled on, so it cites whichever passage scores closest to the question. SAGE answers a prior question first, is this fact still current, and who decided that, so a tool assembling its context only ever draws from what's currently authoritative. The contradiction doesn't vanish. It gets a lineage, a resolution, and, where it mattered, a name attached to the decision.

Loriq builds SAGE, the governed memory engine. Talk to us.