Continuous Ripple & Contradiction Detection

Knowledge does not exist in isolation. A new fact about a customer changes the relevance of older notes about that customer. A new architectural decision invalidates an older decision. A KMS that stores facts but does not propagate them is a database, not knowledge.

The principle

Every ingest triggers two things:

1. Ripple — propagate the new information to all entities, summaries, and views it touches. If a meeting note mentions three people and a project, all four entity pages reflect the meeting; if a decision supersedes an earlier one, the older decision is marked superseded.
2. Contradiction detection — actively look for places where the new information conflicts with existing knowledge. Surface the tension; do not silently overwrite.

Both run on every ingest. Both are automatic.

Why it matters

A KMS without ripple is a write-once log. Knowledge enters but never updates anything else. Searches return lists of historical events rather than current state.

A KMS without contradiction detection is a slowly-corrupting database. New information overwrites older information silently — or worse, lives alongside it without acknowledgement, leaving the user to discover the conflict at the worst possible moment (in a meeting, in a doc, in front of a customer).

Surfacing contradictions is the move that turns a KMS from a passive store into an active partner in maintaining the integrity of what you know.

How it works

On every ingest:

1. The agent identifies the entities and concepts mentioned.
2. For each, it looks up the current state and compares the new claim against existing claims.
3. If the new claim adds — append it.
4. If the new claim refines — update with a trace of what changed.
5. If the new claim contradicts — surface a contradiction record with both versions, and flag for human resolution. Never silently overwrite.

The contradiction queue is one of the few things the system asks the user to look at — but only because human judgment is irreplaceable for "which version is right."

In Claude primitives

• Subagents do the ripple pass in parallel — one per entity touched — without polluting the main conversation.
• Skills like find-related, compare-claims, record-contradiction keep the methodology callable and testable.
• Hooks (Stop, PostToolUse) trigger the ripple sweep after each ingest.
• Long-context windows let the agent re-read entire entity pages plus their backlinks when checking for contradiction.

Where I've seen it

In a team KMS for client work, contradiction detection is the highest-value behaviour the system has — surfacing "this customer's stated need contradicts the contract we drafted" weeks before it would have been caught manually. In a personal KMS, ripple keeps personal entity pages current without the user ever editing them directly.

The contrarian read

Contradiction detection is expensive and noisy at first. The first month produces too many flagged tensions, half of which are false positives. The right response is to tune the rules, not to turn the feature off — the cost of a missed contradiction is the cost of a wrong decision made in confidence.