Home › How it works › Contradiction Handling
Conflict resolution

AI memory shouldn't just pick a winner and move on.

When beliefs conflict, Tenure flags it, keeps both sides on record, checks it against your org's standards, and gives you a way to resolve it.

Get Started → Belief Merging
Detect

Conflicts are identified explicitly.

Contradictions can come from extraction signals, confidence comparisons, compaction scans, or organization standards.

Preserve

Nothing gets deleted.

Tenure keeps provenance and lineage so teams can see where conflicting memory came from.

Resolve

Policy can override preference.

Org standards can act as absolute constraints while user and team preferences remain reviewable.

The conflict path

A contradiction is something Tenure manages, not something it hides.

Most memory systems just grab whichever item scores highest and move on. Tenure detects the conflict, records it, keeps the evidence, and resolves it out in the open.

01

Compare beliefs

Tenure checks whether two beliefs assert incompatible things about the same subject.

02

Apply confidence

If content differs within the confidence margin, the conflict is flagged instead of overwritten.

03

Respect policy

Organization standards can mark a belief as conflicting with policy even without another belief.

04

Keep it reviewable

Contradictions remain pending until resolved, with belief ids, reason, scope, and timestamps.

Conflict states

A contradiction isn't a mistake. It's evidence something changed.

When a team changes its mind, when a user preference conflicts with a team norm, or when a policy disagrees with a local convention, Tenure makes that visible.

Contradiction record
active Use REST for public API integrations. team:platform
pending conflict Use GraphQL for public API integrations. same subject · incompatible approach
resolved later Use REST for public API integrations unless the partner already requires GraphQL. supersedes prior versions
Belief conflicts

Same subject. Incompatible claims.

Tenure flags clear conflicts even when the beliefs do not share the same canonical name.

  • Preference conflicts stay pending instead of being collapsed.
  • Fact and decision conflicts include a one-sentence reason.
  • Existing pending pairs are deduplicated.
  • Resolution can supersede one or both earlier beliefs.
Org violations

Policy can be an absolute constraint.

When org standards are supplied, a belief can be flagged against the organization standard itself.

  • Contradictions can use the organization as the opposing side.
  • Merged content is not allowed to contradict org standards.
  • Non-user-edited violations can be auto-superseded.
  • Teams keep a traceable record of the policy conflict.

Tenure doesn't assume memory is always consistent. It's trying to make sure that when it's not, you can see it, review it, and fix it.

Resolution model

A contradiction should end in a decision, not disappear into the prompt.

A resolved contradiction can produce a more precise belief while keeping older assertions available for audit and lineage.

// detected conflict
{ belief_ids: ["use_rest_public_api", "use_graphql_public_api"], status: "pending" }

// resolved state
{ canonical_name: "public_api_integration_style", content: "Use REST for public integrations unless a partner contract requires GraphQL.", supersedes: ["use_rest_public_api", "use_graphql_public_api"] }
Why teams need this

The more people share memory, the more they disagree.

A single developer's memory can get away with rough edges. A team's can't. Once multiple developers, repos, tools, and policies are all feeding in context, you need something handling contradictions for you.

Without contradiction handling

The model receives whichever memory wins retrieval.

  • Old decisions can appear beside new decisions.
  • User preferences can override team conventions accidentally.
  • Policy conflicts become invisible prompt noise.
With Tenure

You know when memory disagrees, and why.

  • Conflicts are recorded as first-class objects.
  • Org standards can constrain what gets merged and injected.
  • Resolved beliefs preserve a change history.
The point

You can't trust memory you can't see disagree.

Tenure helps your team keep AI memory useful even as facts, preferences, standards, and decisions keep changing.

Install Free → Back to Belief Merging