OPENPROOF.NET — RPO v0.1
Try the live demo
Mechanism, not opinion. Same input → same output.

How RPO works, in plain, enforceable steps.

RPO v0.1 is a minimal proof bundle format. It turns a narrative into a deterministic artifact that can be audited later, without rewriting history. It does not decide truth. It makes integrity measurable and transformations explainable.

Try the live demo Read the spec Browse examples

No AI. No inference. No hidden ranking. RPO makes integrity verifiable. Humans remain accountable.

1) The pipeline (deterministic)
Integrity • Readability • Verifiability
1
Input
A short narrative (1–3 paragraphs). Optionally: evidence references and a PDF path. The point is not volume. The point is clarity.
2
Structure
The narrative is mapped into a minimal JSON bundle with canonical fields (issuer, subject, created_at, narrative block, evidence list). Nothing “smart”. Just enforceable structure.
3
Integrity anchor
A SHA-256 public hash is computed from a deterministic payload. If anything changes, the hash changes. That’s the whole point: tampering becomes detectable.
4
Validate
Any independent implementation can recompute the hash and verify required fields. Match = integrity confirmed. Mismatch = alteration detectable. Trust without central authority.
The artifact is usable by humans (readable) and machines (verifiable). Your org keeps accountability; you gain defensible reconstructability. Minimal contract: JSON + PDF + public_hash
2) What leaders live every day
  • People data in HRIS, approvals in email, rationales in meetings, exceptions in someone’s head.
  • Six months later, the chain is unreproducible — and the narrative starts rewriting itself.
  • When questioned, the org can show documents, but cannot show decision traceability.
  • The risk is not “bad intent”. The risk is non-reconstructability.
You’re not challenged for what you decided.
You’re challenged for what you cannot reconstruct — and therefore cannot defend.
3) The missing layer: reconstructable data

Most organizations don’t lack data. They lack reconstructable data: data that stays aligned across systems, versions, owners, and time.

  • If HRIS fields, approvals, and exceptions are not governed, the chain breaks.
  • Dashboards won’t save you in litigation — they don’t explain how data changed.
  • RPO is the “proof format”, but it presupposes a minimum of data integrity.
This is why large groups recruit HR Data / Governance roles: not to “have more data”, but to make decisions defendable.
4) What you win (concretely)

Legal / Audit

An artifact that preserves what existed at the time, with detectable tampering. This is how you answer: “Show me the chain.”

Governance

Traceability without “trust me”. Decisions become re-evaluable without being rewritten. Same input → same output.

Operations

A repeatable format that survives tool changes, reorganizations, and handovers. The proof object remains stable when org charts don’t.

Translation for executives: you reduce decision liability by making the decision chain reconstructable — not by collecting more documents.
5) The anchor (what exactly is hashed?)
Deterministic payload → SHA-256

RPO v0.1 computes a public hash over a deterministic concatenation of core fields. If any core field changes, the hash changes. That’s how integrity becomes verifiable. 

payload =
  "rpo_version=" + rpo_version +
  "|bundle_id=" + bundle_id +
  "|created_at=" + created_at +
  "|issuer=" + issuer.label +
  "|subject=" + subject.label +
  "|title=" + narrative.title +
  "|narrative=" + narrative.text

public_hash = sha256(payload)
Important: hashing does not “prove truth”. It proves whether the record was altered.

Paste a real internal decision note (sanitized), generate a minimal RPO bundle, and observe how integrity becomes verifiable instead of simply “trusted”. Deterministic by design: no AI, no opinion, no magic.