Every run produces a cryptographically sealed evidence bundle.
Every generation run emits a canonical-JSON evidence record containing the sealed contract, per-step proof packets (inputs, outputs, parameters, hardware, timing), the quality report, the privacy report, and a correction ledger. The whole record is hashed into a single bundle hash that an offline verifier can check in one line.
For the auditor: no platform trust required. Run rady evidence verify against the bundle and get a single green line — tampering, re-ordering, or substitution all break the check. For the CISO: optional Ed25519 signing attaches a sender identity on top of the hash. For the data-science lead: every run replays byte-for-byte under the same seed.
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. Offline verifier recomputes the chain in under a second.
The sealed contract — entities, relations, constraints, seed. The root of the chain.
Per-step proof packet — inputs, outputs, parameters, hardware, timing, tool code version.
Inventory of every data artefact produced (name, size, content hash, MIME).
Per-column distributional drift, adversarial detectability, correlation preservation, constraint-violation counts. Fail-closed gates.
Disclosure risk, membership-inference resistance, attribute-inference resistance, and the method used.
Downstream-task utility score plus task-specific utility metrics.
Entity counts, total rows, warnings surfaced during the run.
Software bill of materials — every library + engine version that produced this bundle.
Cryptographic hash of the canonical concatenation of the prior artefacts. An optional digital signature is attached when the customer's signing key is configured.
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. That is what makes it the product. 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, SBOM, and the seal. No dashboard to screenshot, no platform to log in to, no support ticket to escalate. If the verifier exits zero, the bundle is what it claims to be.
Commercial consequence: procurement unblocks deals in hours instead of quarters. The data-vendor question "can we trust this supplier?" becomes a mechanical check, not a negotiation over trust.
"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. No secret to rotate on the customer side.
Commercial consequence: the supply-chain question you would normally answer with a 40-page SOC 2 Type II excerpt is answered in one grep 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. A / B debugging becomes a one-command exercise, not an "it worked on my machine" argument.
Commercial consequence: the analyst who left last year's job did not take the only reproducible version of the model dataset with them. The archive is the source of truth, and it can be re-verified years later without any RadMah AI dependency alive on the customer side.
"Trace the dataset to the contract that authorised it."
A regulator does not care about platform architecture — they care about whether a specific number on a specific report can be traced to the specific generation run that produced it, and whether that run was authorised by a specific contract, reviewed by a specific person, and executed against a specific code version. The bundle encodes every one of those answers.
Commercial consequence: the audit question "how did this row come to exist" is answered with a hash and a contract reference, not a Slack archaeology dig. GDPR Article 89 research-exemption claims, FDA Part 11 audit trail claims, and ISO 27001 information-asset-inventory claims are all evidence-backed, not paperwork-backed.
Verify any bundle offline.
The SDK ships rady evidence verify <bundle> — no network, no credentials. It recomputes the cryptographic hash chain, validates the optional cryptographic signature signature against your trust root, and reports the Merkle root.
Exit 0 on success, 1 on any mismatch. Script it into CI. An auditor can re-verify any archived bundle on a fresh laptop without any RadMah AI dependency alive.
$ rady evidence verify ./bundle.tar.zst ╭──────────────────────────────────────────────────╮ │ Verify → OK │ │ Integrity OK │ │ Signature cryptographic signature verified │ │ Merkle root b34bb1a5c7d2…e9fa │ │ Bundle hash f7c82e18a4bb…0e2d │ │ Reason integrity + cryptographic signature verified│ ╰──────────────────────────────────────────────────╯ (exit 0)
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.
Makes regulatory replay a one-command exercise. Makes A/B debugging possible without "it worked on my machine" ambiguity.
{
"contract_hash": "a8f3b21c…a7e2",
"seed": 42,
"library_versions": {
"python": "3.13.12",
"torch": "2.5.1",
"cryptographic hash": "1.0.5"
},
"determinism": {
"mode": "strict",
"final_hash": "7e41ba90…c4d8",
"rng_streams": [ /* per-op stream fingerprints */ ],
"cublas_workspace": ":4096:8"
}
}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.
The left button takes you to the CLI install page. One rady evidence verify <bundle.tar.zst> and you have the proof. The right button is the physics-constrained post-processor that rides on the same evidence chain.