Every run produces a cryptographically sealed evidence bundle.
Every generation run emits a canonical-JSON evidence record: the sealed contract, per-step proof packets, the quality and privacy reports, a BLAKE3 determinism proof, and a correction ledger — all hashed into a single bundle an offline verifier checks in one line.
No platform trust required. Run rady evidence verify and get a single green line — tampering, re-ordering, or substitution all break the check. Optional Ed25519 signing attaches a sender identity on top of the hash.
- Evidence artefacts
- 9
- Verify
- Offline
- Premium tier
- None
Multi-part evidence, one chain.
Every run emits all nine. The final evidence_seal.json chains cryptographic hashes of the prior eight, making the bundle uniquely identifiable and tamper-evident. The offline verifier recomputes the chain in under a second.
Contract K — entities, relations, constraints, seed. The root of the chain.
Run manifest + timing telemetry — job, tenant, engine, timestamps, stage-level durations.
Per-column pass/fail for every declared constraint, including referential integrity. Fail-closed gates.
BLAKE3 hash of the output — the bit-for-bit reproducibility proof.
Disclosure risk, k-anonymity, singling-out risk, and the method used.
Statistical fidelity vs. reference data plus an ML utility score.
Engine + version identity that produced this bundle.
Index + content hashes of every artifact in the bundle (name, size, hash).
The seal binding all prior artefacts — the final tamper-evidence anchor. Generated data artifacts (CSV/JSON tables) ship alongside these evidence files.
Four readers. One artefact. Zero trust in the runtime.
Procurement, security, the data-science team, and the regulator all read the same sealed bundle from different angles. Before synthetic data becomes enterprise data, someone has to be willing to sign for it — and signing without a provenance chain is the bit that blocks every enterprise deal.
“Show me the evidence this dataset is safe to use.”
One command, one green line. The bundle is a self-contained record: contract, quality, privacy, physics, determinism, transcript, manifest, and the seal. No dashboard to screenshot, no platform to log in to. If the verifier exits zero, the bundle is what it claims to be.
Procurement unblocks deals in hours instead of quarters — trusting a data supplier becomes a mechanical check, not a negotiation.
“Prove nothing was tampered with between generation and delivery.”
Every artefact is hashed into a canonical-JSON evidence record, the record is hashed into a single bundle hash, and the bundle hash is optionally signed under an Ed25519 identity. Re-ordering a file, substituting a byte, or replaying an old bundle under a new contract all break the check — deterministically.
The supply-chain question you would normally answer with a 40-page audit excerpt is answered in one check against your own build pipeline.
“Reproduce the run I shipped three quarters ago.”
The sealed contract plus the seed together pin every stochastic source — RNG streams, cuBLAS workspace, library versions, thread counts. Re-run on a different cluster, a different OS, a different year — the dataset hash matches. Regression tests stay stable.
The archive is the source of truth, re-verifiable years later without any RadMah AI dependency alive on your side.
“Trace the dataset to the contract that authorised it.”
A regulator cares whether a specific number on a specific report traces to the specific run that produced it, whether that run was authorised by a specific contract, and executed against a specific code version. The bundle encodes every one of those answers.
GDPR Article 89, FDA Part 11 audit-trail, and ISO 27001 asset-inventory claims become evidence-backed, not paperwork-backed.
Verify any bundle offline.
The SDK ships rady evidence verify <bundle> — no network, no credentials. It recomputes the BLAKE3 hash chain, validates the optional Ed25519 signature against your trust root, and reports the Merkle root.
- Exit 0 on success, 1 on any mismatch — script it straight into CI.
- An auditor can re-verify any archived bundle on a fresh laptop with no RadMah AI dependency alive.
- Tampering, re-ordering and substitution are all caught deterministically.
$ rady evidence verify ./bundle.tar.zst
╭────────────────────────────────────────────────╮
│ Verify → OK │
│ Integrity OK │
│ Signature Ed25519 verified │
│ Merkle root b34bb1a5c7d2…e9fa │
│ Bundle hash f7c82e18a4bb…0e2d │
│ Reason integrity + signature ok │
╰────────────────────────────────────────────────╯
(exit 0){
"contract_hash": "a8f3b21c…a7e2",
"seed": 42,
"library_versions": {
"python": "3.13.12",
"torch": "2.5.1",
"blake3": "1.0.5"
},
"determinism": {
"mode": "strict",
"final_hash": "7e41ba90…c4d8",
"rng_streams": [ /* per-op stream fingerprints */ ],
"cublas_workspace": ":4096:8"
}
}Same contract, same seed. Byte-identical output.
The contract hash + seed together pin every stochastic source: RNG streams, cuDNN algorithm selection, cuBLAS workspace, thread counts, library versions. Re-run the same sealed job on a different cluster and the dataset hash matches byte-for-byte.
Evidence is how the platform works, not a feature.
Every run emits a multi-artefact bundle. Every customer gets the offline verifier. No premium tier.