Semantic Integrity Platform

Knowledge has always
degraded silently.
Until now, nobody measured it.

Congruence is a semantic integrity system for organisational knowledge. It tracks not what your documents say, but what they mean, and enforces that meaning survives as AI, teams, and time transform every artifact from client interaction to production code.

Read the thesis Subscribe via RSS
Listen to the explanation
0:00
0:00
01
The problem
Why organisational intent degrades silently through document chains

Every organisation runs the same invisible failure. Intent is established at the top. It travels through a chain of documents written by different people, tools, and increasingly AI agents. By the time it reaches implementation, the original meaning has quietly eroded -- and nobody noticed.

A typical product development chain -- you know this story
Product Research
Establishes: "Primary user has low digital literacy. Simplicity is non-negotiable."
↓ handed to product
Product Spec
Carries forward: "UX should be clean and approachable." Simplified. The specificity is already gone.
↓ handed to design
UX Brief
Interprets as: "Modern, minimal interface." No mention of literacy. No mention of the original constraint.
↓ handed to engineering
Developer Spec
Nothing. The constraint never made it here. The developer builds a feature-rich interface. Nobody violated a documented rule. The original truth simply evaporated.
02
The core insight
Why existing tools cannot solve this -- and what the correct model looks like
Insight
Truths are not text. They are objects.
When a PM writes "phase one audience requires simplified UI" -- that is not a sentence in a document. It is a constraint with identity, authority, confidence, and dependents. It should outlive the document that contains it.
Implication
Documents are containers. Truths are the durable thing.
A document can be completely rewritten -- different structure, length, even language. The truths it carries survive that transformation and propagate their constraints forward through the dependency graph.
Result
Drift becomes visible, measurable, and resolvable.
When a downstream artifact drifts from an upstream truth, the system surfaces it -- not as a version diff, but as a semantic gap: this fragment no longer satisfies this constraint, established by this person, at this stage, for this reason.
03
The knowledge loop
Every artifact has a position -- position governs authority, challenge rules, and gate conditions

Every artifact in Congruence has a position in the knowledge loop -- the lifecycle through which understanding moves from raw ground truth through ideation, crystallisation, execution, and back again with richer foundations.

01 Ground Truth
What is known, what exists, what the constraints are. Truths declared here carry the highest authority.
02 Ideation & Exploration
Probe broadly. Stay divergent — resist narrowing too early. Truths here are soft. Challenges encouraged.
03 Context Building
Condense understanding into artefacts — specs, briefs, requirements. Congruence anchors begin to form here.
04 Decomposition
Break into bounded units. Cross-document dependencies become explicit and the graph becomes checkable.
05 Execution
AI does the heavy lifting. Human steers direction, not keystrokes. Drift detection runs continuously.
06 Human Gate
Review, judgment, peer validation. The irreplaceable step. Conflicts must be resolved — no silent overrides.
07 Output
The deliverable — code, document, decision, design. Truths are frozen and archived at this point.
08 Draw the Line
Explicit decision: this unit is done, scope is closed. All drift scores checked. All anchors resolved.
09 Feedback & Update
The output changes the ground truth. Resolutions become new truths. Loop restarts with richer foundations.
04
The conceptual model
Containment hierarchy, truth taxonomy, and drift scoring
Containment hierarchy
Organisation corporate intent
Programme initiative scope
Project ground truth
Stage loop position
Artefact working document
Fragment atomic unit
Implementation linked · not owned
API documentation
README & runbooks
Code & tests

Organisation and Programme truths cascade down as inherited constraints. Implementation artefacts are linked, not owned -- the system monitors congruence but does not replace your engineering tooling.

Three truth types
Declaration

"This will run on AWS. Non-negotiable."

Assertion · confidence level · blocks contradictions

Congruence Anchor

"MySQL version must match the infra spec."

Synchronisation · binds to another truth · propagates changes

Scope Truth

"Phase 1 includes external customers who need simplified UI."

Context · derivable implications · cascades downstream

Drift scoring
Origin Drift

How far did it travel from the source truth?

Inform
Semantic Drift

Does the downstream fragment still satisfy the constraint?

Warn
Resolution Status

Has a human reviewed and resolved? Gate condition.

Block
05
Competitive positioning
Why existing tools do not solve the semantic integrity problem
Capability Confluence / Notion Contract AI (Juro / Ironclad) Congruence
Tracks document versions ✓ Yes ✓ Yes ✓ Yes
Truths are first-class objects ✗ No ~ Clauses only ✓ Yes
Truths survive document restructuring ✗ No ✗ No ✓ Yes
Cross-document dependency graph ✗ No ✗ No ✓ Yes
Semantic drift detection ✗ No ~ Clause deviation only ✓ Yes
Knowledge lifecycle stage awareness ✗ No ✗ No ✓ Yes
Constraint archaeology ✗ No ✗ No ✓ Yes
Works across all domains ✓ Yes ✗ No ✓ Yes
06
Roadmap & entry point
Sequenced from highest pain, lowest complexity to broadest reach
v0.1 · In Development
Product ↔ Technology Interface
In Development
The boundary where product thinking becomes engineering specification -- where semantic loss is most expensive and most common. Single user. Local-first. Rust + SQLite + Svelte 5. Building now.
v2 · Next
Programme Governance
Planned
A CEO sets a constraint. Every sprint plan and architecture decision is evaluated against it automatically. "Here are the twelve decisions in Q2 that violated the constraint you set in January. None were flagged." That is a conversation that gets a meeting.

Follow the build.
Watch it take shape.

Development updates published to the urd.dev RSS feed as Congruence is built.

Subscribe via RSS

urd.dev/rss.xml · No email required