ARSS is a governance evidence protocol. Every governance decision is recorded as a recomputable, cryptographically verifiable hash chain — so auditors, regulators, and counterparties can verify structural integrity without trusting any intermediary.
"Governance frameworks produce policies.
ARSS produces evidence.
Policies describe governance.
Evidence proves it happened."
This is not a demo. The hashes below are the actual production chain records (RPU-0004 ~ RPU-0008). Your browser recomputes each chain_hash from the embedded payloads and compares against the pre-committed values.
The expected hash for each RPU below is a pre-committed constant — derived from the original, unmodified payloads and hardcoded into this page before it was published. When you press Run Verify, your browser recomputes each chain hash from scratch using SHA-256 and compares against that fixed value.
If the payloads are intact, computed matches expected: PASS. Edit any payload — even one character — and the recomputed hash diverges from the pre-committed value: FAIL.
The global AI governance landscape has grown rapidly. Major frameworks now define standards, requirements, and obligations at every level — yet all of them share the same structural gap.
EU AI Act, NIST AI RMF, ISO/IEC 42001 — and dozens of enterprise governance programs — have established a dense policy layer for AI systems. Each framework defines what organizations must declare and commit to.
Yet no major governance framework today provides a native protocol layer for independently recomputable cryptographic decision-chain evidence. Organizations can declare compliance. They cannot yet prove it structurally — in sequence, by a specific actor, at a specific time — to any party, without a trusted intermediary.
Existing AI governance frameworks operate at the policy and management layers. ARSS occupies the protocol layer — the structural foundation that makes framework commitments verifiable.
Policy frameworks define what must be governed. Management programs define how organizations respond. But neither layer provides structural proof that the response actually occurred — in the right sequence, by the right actor, at the right time.
ARSS fills this gap. It is not a competitor to existing frameworks — it is the protocol layer that makes their requirements provable. Organizations implementing EU AI Act obligations or ISO/IEC 42001 certification can use ARSS to produce chain evidence that satisfies auditors without requiring trust in any single intermediary.
ARSS is to governance what PKI is to identity:
a structural layer that makes declarations verifiable.
Every governance decision is captured as a Record Proof Unit (RPU). Required fields: rpu_id, actor_id, payload_hash, governance_context. Serialized via JCS (RFC 8785) — keys sorted in ascending alphabetical order, recursively — producing an identical byte sequence across all verifiers regardless of language or platform.
Each RPU is linked to its predecessor via the chain hash formula:
chain_hash = SHA256(prev_hash + ":" + payload_hash) [UTF-8]
Tampering with any record — payload, prev_hash, or chain_hash — is detectable immediately by any verifier, without access to the original system or its operators.
Any party runs the reference verifier against the chain. No trusted intermediary required. Pass means structural integrity confirmed. Fail surfaces the break point: chain position, RPU ID, and hash delta — enabling precise forensic reconstruction.
Clone the repository and inspect the live production chain records in samples/. The reference generator (Canonical Schema v1.0) and verifier are both available. Any party can independently recompute and confirm chain integrity.
# Clone the repository git clone https://github.com/choizinsa-coder/arss-protocol cd arss-protocol # Inspect the live production chain cat samples/ledger.json cat samples/rpu-0008.json # Recompute chain_hash manually (Python 3) python3 -c " import hashlib, json def canonical_json(obj): if isinstance(obj, dict): return '{' + ','.join( f'{canonical_json(k)}:{canonical_json(v)}' for k, v in sorted(obj.items()) ) + '}' if isinstance(obj, list): return '[' + ','.join(canonical_json(i) for i in obj) + ']' if isinstance(obj, bool): return 'true' if obj else 'false' if isinstance(obj, (int, float)): return str(obj) return json.dumps(obj, ensure_ascii=False) with open('samples/rpu-0008.json') as f: rpu = json.load(f) ph = hashlib.sha256(canonical_json(rpu['payload']).encode()).hexdigest() ch = hashlib.sha256((rpu['chain']['prev_hash']+':'+ph).encode()).hexdigest() print('chain_tip:', ch) " # Expected: # chain_tip: 3fa890300b41871f9e3aa0ed0d6b8463231bb75efba9dd250bccdf3e3e572c52
The reference verifier performs three sequential checks: (1) JCS normalization and single-RPU payload hash integrity, (2) chain_hash continuity across all records using SHA256(prev + ":" + payload_hash), (3) HACS cryptographic signature verification v0.2 planned.
The production chain (RPU-0004 ~ RPU-0008) is publicly available in samples/. The Chain Tip is independently recomputable from the raw JSON records — no AIBA infrastructure access required.
Requirements: Python 3, standard library only. SHA-256 + JSON. No external dependencies.
ARSS provides the structural foundation for any entity that needs to prove governance decisions were made — and made consistently over time.
Provide regulators with independently verifiable records of AI governance decisions. Structural evidence that survives third-party scrutiny under EU AI Act, NIST AI RMF, and ISO/IEC 42001 obligations.
Maintain a tamper-evident log of every governance decision, policy change, and override event across AI systems — auditable at any point without rebuilding the original context.
Issue certifications backed by recomputable chain evidence. Any party can verify the certification basis independently — no trusted intermediary, no snapshot dependency, no expiry ambiguity.
When an AI failure occurs, investigators can recompute the governance chain to determine whether required decisions were recorded — and where the chain breaks. ARSS enables forensic reconstruction for insurance claims, litigation, and regulatory probes.
samples/.