👉 New here? Start with QUICKSTART.md — understand and run Decifact in 5 minutes.
Two systems can both pass audit.
That doesn't mean their decisions can be reconciled.
Decifact verifies whether two independently governed decisions share a comparable reference — before anyone assumes they do.
(Cross-system decision equivalence based on invariant boundaries. Built on Guardian v0.2 — Decision Equivalence Specification.)
Decifact answers one question:
Can two independently governed decisions be meaningfully compared?
Not whether they are correct. Not whether they are compliant. Not whether they should be executed.
Only whether a shared comparison basis exists.
Decifact determines:
EQUIVALENTNON_EQUIVALENTFORMALLY_INCOMPARABLE
and returns the classification-driving fracture boundary currently preserved by the implementation.
Additional evaluated diagnostics may not yet be retained in all
classification paths; see docs/implementation-items.md.
Two ministries each deploy the same kind of AI system. Each one passes its own audit. Each has its own approved policy framework. Each has signed off internally.
Then they need to coordinate — and discover their decisions don't line up.
Neither one is wrong. Neither audit was incomplete. But something that was assumed to be comparable... wasn't ever checked.
That's the gap this addresses. (Full worked example below.)
Most AI governance work focuses on a single system:
- Does this agent behave correctly?
- Is this decision auditable?
- Does this output comply with policy?
These are necessary questions. But they leave a deeper problem unaddressed.
When independently governed systems begin coordinating — sharing decisions, delegating authority, producing joint consequences — a prior question must be answered first:
Before these systems started depending on each other's outputs, was anyone checking whether their decisions could even be placed side by side in the first place?
This is not a runtime enforcement problem. It is a precondition problem.
Without comparability verification at this layer, coordination proceeds on assumptions that may never have been valid. Operational success can be mistaken for structural resilience. The gap widens unnoticed until the cost of closure is prohibitive.
Decifact is the minimal inspectable surface for this layer.
That's the situation in miniature. More generally:
When two independently governed AI systems process the same input and reach different decisions, most setups can't answer:
- Are these decisions actually different — or just expressed differently?
- If they diverge, where exactly does that happen?
- Does the divergence matter — or is it just noise in how each system represents things?
- Was anyone checking, before now, whether these two systems' decisions could even be placed side by side?
Without a standard for decision equivalence, cross-system coordination is undefined.
"Without decision equivalence, economic correctness is undefined." — Guardian v0.2 Specification
"The canonical boundary must exist before layer instantiation." — Guardian Constitutional Invariant
Interoperability tells you data was exchanged. Comparability tells you whether the governance conditions behind that exchange were ever established on a canonically comparable basis.
Most interoperability protocols establish transport. Decifact evaluates whether independently governed systems were ever established on a canonically comparable basis before coordination begins.
These are different questions. Answering the first does not answer the second.
Two systems may successfully exchange governance records. That does not imply:
- shared authority assumptions
- shared policy foundations
- shared admissibility conditions
- shared comparison basis
Operational interoperability can exist without governance comparability.
Decifact exists to inspect that distinction.
Decifact evaluates comparability.
It does not establish whether governance claims are transferable across independent governance layers.
Before two governance decisions can be meaningfully compared, a prior condition must already hold:
The governance conditions carried by each decision must be admissible for transfer into the comparison itself.
Layer validity does not automatically imply layer transferability.
Transfer occurred does not imply transfer was validated.
A governance framework may be internally valid within its own authority, policy, and execution context while remaining non-transferable outside that context.
Comparability therefore begins only after transferability has already been established.
Decifact evaluates comparability after that prerequisite has been satisfied.
Comparability does not create transferability. Where a judgment has been carried across a governance boundary, Decifact requires the relevant transfer and governing context to be represented as part of the comparison basis. It does not independently authorize that transfer or determine whether the receiving party may rely on it.
Transferability itself remains outside the scope of Decifact. A technically available judgment is not automatically admissible as comparison evidence.
The governance decision artifact is the unit of comparison.
Decifact evaluates governance decisions, not model outputs.
The object under comparison consists of:
- The governance decision artifact
- Its authority context
- Its policy foundation
- Its execution boundary
Decifact does not compare:
- Systems
- Institutions
- Model responses
- Agent outputs
- Runtime execution results
- Business outcomes
Decifact evaluates whether two governance decisions were established against a canonically comparable reference before coordination occurs.
The purpose is not to determine which system is correct.
The purpose is to determine whether the decisions were ever established on a comparison basis that makes equivalence evaluation meaningful.
Determines whether two decisions match under the implementation's current invariant-boundary and field-exclusion rules.
The current canonicalization logic produces a deterministic
representation under implementation-defined exclusions. Those
exclusion boundaries have not yet been formalized as a complete
constitutional definition of the minimal semantic set; see
docs/implementation-items.md.
- Deterministic: same input always produces same output
- Transparent: differences are explicit, not opaque
- Minimal: no LLM calls, and no external network service is required for the core comparison logic
- Composable: works alongside any agent framework
- Independent by design: intended for deployment outside the systems being compared. Actual independence, custody separation, and write-domain separation must be established by the deployment environment; they are not created by this codebase alone.
Cross-system coordination involves several distinct governance questions, not one:
- Referent continuity — do the judgments still concern the same governed object?
- Governing-basis currency — are the relevant definitions, authority conditions, evidence thresholds, and time states still current?
- Comparison determination — do the judgments share a valid comparison basis, and if so, are they equivalent or non-equivalent?
- Reliance authority — may a receiving party rely on the comparison result for a particular purpose?
- Execution admissibility — may the resulting action proceed under current conditions?
- Runtime continuity — do the governing conditions remain valid as execution continues?
- Evidence reconciliation — were all required evaluations completed and preserved as reviewable evidence?
Decifact is scoped primarily to the comparison determination in Layer 3.
It requires the relevant comparison inputs from Layers 1 and 2 to be represented. It does not independently establish ongoing authority, authorize reliance, determine execution admissibility, govern runtime continuation, or discharge downstream evidentiary obligations — those remain separate governance layers, each with its own responsible party.
A Decifact result describes the relationship between two judgments. It does not authorize what any system should do with that result.
┌─────────────────────────────────────────────────────────┐
│ Independently Governed System A │
│ (its own policy, authority, execution environment) │
└──────────────────────┬──────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────┐
│ DECIFACT — Comparability Boundary Layer │
│ │
│ "Were these decisions produced under governance │
│ conditions that were ever canonically comparable?" │
│ │
│ /verify-equivalence /canonicalize /compare │
└──────────────────────┬──────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────┐
│ Independently Governed System B │
│ (its own policy, authority, execution environment) │
└─────────────────────────────────────────────────────────┘
Decifact does not govern either system. It does not transfer authority between them. It exposes whether their decisions match the comparison conditions represented under the implementation's current invariant-boundary and field-exclusion rules.
This question must be answered before coordination begins — not after consequences have already formed.
| Endpoint | Function |
|---|---|
POST /verify-equivalence |
Decision equivalence verification |
POST /canonicalize |
Canonical boundary engine |
POST /compare |
Cross-runtime fracture inspection with comparability classification |
Decifact treats comparability as a condition that must be established before equivalence can be evaluated.
/compare returns one of three classifications:
EQUIVALENT
A shared comparison basis exists and governance conditions are identical.
NON_EQUIVALENT
A shared comparison basis exists, but governance conditions differ.
The comparison is valid; the result is disagreement.
FORMALLY_INCOMPARABLE
The current implementation did not detect a shared comparison basis
under its Phase 1 policy_reference equality proxy.
This is a valid result within the implemented evaluation model. It
does not prove that no translation or comparison basis could be
established by a broader mechanism.
This is a first-class result, not an error condition.
Two systems can each have valid governance records and still be operating on incommensurable decision logic. That is not a deployment problem. It is a proof problem.
The current Phase 1 implementation uses policy_reference
equality as a proxy for shared canonical reference detection. This
proxy is intentionally conservative and may classify some
translatable governance frameworks as formally incomparable under
this proxy.
Guardian V0.3 examines constitutional conditions and prohibitions surrounding cross-domain acceptance. Decifact does not implement acceptance, authority translation, or reliance authorization. Any future work in those areas would require a separate specification and evidence threshold — it is not a committed roadmap item of this implementation.
A comparison result should preserve more than a terminal classification.
Where applicable, a future determination record should distinguish:
- which comparison prerequisite was evaluated;
- which boundary failed or remained unresolved;
- which downstream checks were not evaluated because a prerequisite was not established;
- the governing reference and rule version used;
- the evidence considered; and
- whether the result is reconstructable from the preserved inputs.
For example, failing to establish that two judgments concern the
same governed object is not the same outcome as establishing a
shared object and then finding different governing conditions. A
downstream check may be NOT_EVALUATED rather than
NON_EQUIVALENT when its required referent was never established.
The Phase 1 implementation currently returns a flat
fracture_boundary list of reason codes.
Its current evaluation flow computes all implemented fracture checks, but some evaluated, non-classification-driving diagnostics may be discarded when the terminal classification is returned.
The current flow does not yet produce genuinely skipped
NOT_EVALUATED checks. That state would become necessary only if a
future staged evaluation model introduces prerequisite-dependent
short-circuiting.
Staged, per-prerequisite result tracking remains a design direction, not a current API guarantee.
See docs/implementation-items.md for the corresponding bounded implementation item.
Comparability answers a specific question: can two decisions be placed on the same comparison basis?
Many important governance questions remain outside that determination — not because they are unimportant, but because they are different questions.
Comparability does not determine whether either decision is correct.
Two decisions may be comparable and both wrong.
Comparability does not determine whether a system's behavior conforms to its own declarations.
That is a question about the relationship between a claim and conduct, not between two claims.
Comparability describes a relationship at the time it is evaluated.
Whether that relationship remains stable as either system evolves — new policies, new authority structures, new operating contexts — is a separate question.
Comparability does not determine whether a decision, or the governance conditions surrounding it, can be independently reconstructed at a later time.
That is a different question from comparability itself.
Comparability does not determine whether a decision should be executed.
A decision may be comparable and still be inadmissible.
A comparability result does not determine whether a receiving party is authorized to rely on that result for a particular purpose, context, or consequence.
A judgment may be comparable yet not authorized for use.
A comparison result is valid only for the governing objects, references, evidence, and time states represented in that determination.
A prior comparison result does not automatically remain current after a relevant governing condition changes. A later comparison may establish a new current state. It does not retroactively validate reliance that occurred during an earlier, unconfirmed interval.
The following example illustrates a governance comparison between two independently governed ministries evaluating deployment of the same AI capability under different policy foundations.
{
"runtime_a": {
"decision": {
"intent": "deploy_ai_system",
"target": "patient_triage_module",
"mandate_scope": "acute_care",
"policy_context": "UK-AI-Framework-v1"
},
"authority_context": {
"authority_domain": "UK-Health-Ministry",
"policy_reference": "UK-AI-Framework-v1",
"execution_context": "acute-care-deployment",
"admissibility_scope": "clinical-decision-support"
}
}
}{
"runtime_b": {
"decision": {
"intent": "deploy_ai_system",
"target": "patient_triage_module",
"mandate_scope": "acute_care",
"policy_context": "UAE-AI-Framework-v2026"
},
"authority_context": {
"authority_domain": "UAE-Interior-Ministry",
"policy_reference": "UAE-AI-Framework-v2026",
"execution_context": "acute-care-deployment",
"admissibility_scope": "clinical-oversight"
}
}
}Both ministries may possess valid governance records.
Both may have independently approved deployment.
Both may have completed internal audit and compliance review.
The question Decifact evaluates is not:
Which ministry is correct?
The question is:
Was anyone checking whether these two "valid" decisions could ever be placed on the same basis to begin with?
When the current policy_reference-equality proxy does not establish
a shared canonical reference, Decifact returns:
{
"comparability_classification": "FORMALLY_INCOMPARABLE",
"fracture_boundary": [
"no_shared_canonical_reference"
]
}This is a first-class governance finding.
The result does not indicate failure, disagreement, or policy violation.
It indicates that the current policy_reference-equality proxy did
not find these systems on the same comparison basis, without one
jurisdiction inheriting the authority assumptions of the other. It
does not rule out a translation mechanism a broader implementation
could establish.
pip install -r requirements.txt
uvicorn app.main:app --reloadcurl -X POST https://<your-endpoint>/verify-equivalence \
-H "Content-Type: application/json" \
-d '{
"decision_a": {
"intent": "execute_trade",
"target": "AAPL",
"parameters": {
"direction": "buy",
"size": 100,
"threshold": 0.8
},
"policy_context": "risk_conservative"
},
"decision_b": {
"intent": "execute_trade",
"target": "AAPL",
"parameters": {
"direction": "buy",
"size": 100,
"threshold": 0.7
},
"policy_context": "risk_conservative"
}
}'{
"equivalent": false,
"invariant_identity_match": false,
"canonical_hash_a": "a3f9c2...",
"canonical_hash_b": "b7d1e4...",
"invariant_boundary": {
"a": {
"intent": "execute_trade",
"target": "AAPL",
"parameters": { "direction": "buy", "size": 100, "threshold": 0.8 },
"policy_context": "risk_conservative"
},
"b": {
"intent": "execute_trade",
"target": "AAPL",
"parameters": { "direction": "buy", "size": 100, "threshold": 0.7 },
"policy_context": "risk_conservative"
}
},
"invariant_boundary_diff": [
{
"path": "parameters.threshold",
"a": 0.8,
"b": 0.7
}
],
"call_count": 1
}{
"equivalent": true,
"invariant_identity_match": true,
"invariant_boundary_diff": [],
"call_count": 2
}Two independently governed ministries, each with valid governance records but operating under different policy foundations:
{
"comparability_classification": "FORMALLY_INCOMPARABLE",
"canonical_equivalent": false,
"governance_equivalent": false,
"fracture_boundary": [
"no_shared_canonical_reference"
],
"canonical_hash_a": "e2a9f1...",
"canonical_hash_b": "c4b7d3...",
"boundary_context_hash_a": "f1e3a2...",
"boundary_context_hash_b": "d9c1b4...",
"replayable": true,
"sovereignty_principle": "canonical boundary must exist before layer instantiation"
}FORMALLY_INCOMPARABLE means: under the current
policy_reference-equality proxy, these systems were not placed on
the same comparison reference without one jurisdiction inheriting
the other's authority assumptions. The finding is structural,
not a disagreement about outcomes.
The replayable field is a static implementation marker. It does
not report that an actual replay was performed, or that all
materials required for independent reconstruction are available.
See docs/implementation-items.md for tracked follow-up work.
The following MUST NOT be used to determine equivalence:
| Method | Why It Fails |
|---|---|
outcome_a == outcome_b |
Same outcome can come from different decisions |
hash(serialized_a) == hash(serialized_b) |
Structural equality ≠ semantic equivalence |
identity_a == identity_b |
Same actor can produce non-equivalent decisions |
both_passed_audit == true |
Independent audit results ≠ cross-system comparability |
import requests
def check_equivalence(decision_a, decision_b):
response = requests.post(
"https://<your-endpoint>/verify-equivalence",
json={"decision_a": decision_a, "decision_b": decision_b}
)
result = response.json()
if not result["equivalent"]:
print(f"Decisions diverge at: {result['invariant_boundary_diff']}")
return result["equivalent"]Decifact evaluates comparability and equivalence (Guardian v0.2).
| Concern | Scope |
|---|---|
| Comparability classification | ✅ This engine |
| Decision equivalence | ✅ This engine |
| Reliance authority / acceptance | ❌ Separate governance responsibility |
| Execution correctness | ❌ Out of scope |
| Identity validation | ❌ Out of scope |
| Runtime policy enforcement | ❌ Out of scope — a different layer |
| Governance of either system | ❌ Out of scope — Decifact sits between systems, not inside them |
It does not determine correctness, acceptance, authority, execution admissibility, runtime enforcement, or governance ownership.
Those questions may remain important. They are simply different questions.
Comparability precedes equivalence. Equivalence precedes acceptance. These concerns remain strictly separated.
Decifact does not tell systems what to do. It exposes whether they were ever comparable enough for coordination to be meaningful.
Decifact is the reference implementation of Guardian v0.2 Decision Equivalence Specification.
Guardian defines the constitutional conditions under which independently governed systems can determine whether their decisions remain canonically comparable without inheriting each other's jurisdiction.
Guardian V0.3 examines the constitutional conditions and prohibitions surrounding cross-domain acceptance. It is a separate research question from decision equivalence, not a planned extension of this codebase.
Specification: xsa520/guardian
Active research reference implementation.
Decifact has been exercised through controlled internal experiments and reference-environment evaluations. These exercises inform the implementation but do not constitute external production certification or proof that all seven governance layers are operationalized.
The current /compare classification uses a Phase 1
policy_reference equality proxy for shared-reference detection.
Known implementation limitations are recorded in
docs/implementation-items.md.
Internal research use began in 2026 (Alpha System, RFC3161 evidence chain). This describes the origin of the implementation, not external production validation.
It is not a production authorization, execution, or runtime-governance service.
See: docs/decifact-explainer.pdf
Run the minimal comparability demo:
python3 examples/verify_demo.py examples/example-decisions.json
The theoretical development of Decifact is governed independently from the implementation.
Research methodology, constitutional principles, topology observation, objection analysis, and hypothesis validation are maintained separately from this implementation repository.
This repository intentionally remains scoped to the comparability layer.
Decifact evaluates comparability. It does not determine layer transferability, governance acceptance, runtime admissibility, execution authority, or coordination policy.