Mechanism, not opinion

By Gersende Ryard de Parcey — decision governance & probative infrastructure.

How RPO works, in enforceable steps.

RPO v0.1 is a minimal proof bundle format. It turns decision context into a deterministic artifact: a sealed JSON core, a human-readable preview/PDF, and a public hash. The objective is not persuasion; it’s reconstructability under pressure.

The uncomfortable truth: organizations are rarely challenged for what they decided, they’re challenged for what they cannot reconstruct. RPO exists to make that reconstruction verifiable, not rhetorical.
Property Deterministic Output Sealed bundle Hash Public integrity anchor AI None

RPO = sealed JSON core + human-readable preview/PDF + public hash. The hash proves integrity over time, not “truth”. Accountability remains human.

The deterministic pipeline

Same input → same output
Step 01
Declare context
A short narrative and declared sources. Not volume; clarity. Your perimeter becomes explicit instead of implicit.
Step 02
Canonicalize
Map content into a minimal schema: issuer, subject, timestamps, narrative block, evidence list. No hidden interpretation, just enforceable structure.
Step 03
Seal
Compute a public SHA-256 integrity anchor over a deterministic payload. If anything changes, the hash changes. Tampering becomes detectable.
Step 04
Verify
Any independent tool can recompute the hash and validate required fields. Match = integrity confirmed. Mismatch = alteration detectable.
The “win” is not a prettier report. The win is a shared object: a sealed bundle that Legal, HR, IT/Sec and executives can verify independently.
Open the simulator

Why this exists

Because memory is not a system

Reconstructability beats narrative

When a decision is contested later, the question is rarely “what was your intent?” It’s “show me what existed, when, and who owned it.”

You don’t lose because you were wrong.
You lose because your chain is non-reproducible.

Documents are not traceability

A folder of PDFs is not an audit trail. Dashboards are not a chain of custody. RPO is a minimal contract that makes transformations and scope explicit.

Determinism is the governance property

If the output changes with each run, you can’t defend it. Determinism makes the bundle reproducible, comparable, and independently verifiable.

What is hashed (and what is not)

Integrity anchor, not “truth engine”

RPO v0.1 computes a public hash over a deterministic concatenation of core fields. If any core field changes, the hash changes. That’s integrity: alterations become detectable. 

// Deterministic payload (illustrative)
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)

Hashed

The core perimeter: identity, timestamps, narrative block, and canonical fields. That’s what gives you a stable integrity anchor.

Not hashed

“Truth” as opinion. RPO does not judge reality. It exposes what was sealed, with what scope, at what time.

Why it matters

A public hash lets third parties verify integrity without accessing sensitive content. Verification is independent; accountability stays human.

Hashing doesn’t make you right.
It makes alteration detectable — which is exactly what governance needs.

FAQ (the hard questions)

No euphemisms
Q1 “Is this blockchain?” NO

No. RPO uses a cryptographic hash as an integrity anchor. It does not require a chain, network, or token. Keep it boring. Boring scales.

Q2 “Is this an AI that decides truth?” NO AI

No AI in the standard. RPO does not decide. It captures perimeter, sources, timestamps, and an integrity anchor so the decision remains explainable under scrutiny.

Q3 “What does this change for executives?” LIABILITY

It reduces decision liability by making decision chains reconstructable. Not by collecting “more documents”, but by producing a verifiable object that survives time and reorgs.

Q4 “Where does the Simulator fit?” RAMP

The Simulator is the shortest path to understanding. One run, one bundle, one hash. It demonstrates the mechanism without requiring integration.

If you only do one thing: run the Simulator once and generate one bundle. You’ll understand RPO in one run, not in ten pages.
Run the simulator

Get started

One run · one bundle · one hash
Use the Simulator to generate a deterministic bundle and preview the report structure. When ready, move to the Pilot Cockpit to evaluate integration scenarios and decision governance at scale.
Pilot cockpit

Created by Gersende Ryard de Parcey. OpenProof RPO v0.1 is an open, verifiable format for decision-proof bundles.