How can an AI runtime keep private data and heavy compute off-chain and still let anyone review what actually ran? This note lays out the split the architecture is designed around: material stays in permanent off-chain storage, while the chain anchors a compact, reviewable proof of each job.
Raw datasets and model weights belong in permanent off-chain storage. The chain needs only the minimum receipt required to verify that a job ran as claimed.
A hashed reference is not a dataset record.
AI pipelines handle licensed corpora, medical data and proprietary weights. Publishing that material directly on a public ledger would create confidentiality, licensing and correction problems without improving the verification decision.
The safer architecture keeps data and weights in permanent decentralized storage - the layer Ztakora Drive is designed for - while the Ztakora Grid anchors a content hash, a model version and an access policy so the run can be reproduced and audited without exposing the material itself.
The split - data and compute stay private; only the deterministic statement anchors on-chain.
A receipt should carry scope, inputs and determinism bounds.
A simple transaction hash is rarely enough. A job can vary by model version, dataset slice, hardware, seed and library build. The receipt should therefore identify what ran, on which inputs, under which runtime version and with which reproducibility limits.
The contract does not need to understand the underlying computation. It needs a deterministic statement that can be reviewed later: this model version ran on this dataset slice and produced this certified output under these bounds.
- Input and model hashes
- Runtime and hardware version
- Cost and expiry records
- Minimal public data
The interface must explain a blocked job before asking for a signature.
The demo's runtime and registry surfaces are useful places to test this communication. A connected version should resolve access and cost early, show whether a receipt is current and explain the next permissible step without exposing restricted data.
If a job fails at the runtime layer, the product should reconcile the outcome and display an actionable state. Generic errors are not an acceptable compute interface.
Every run needs a replayable audit path.
The off-chain runtime should retain the input references, model version, evaluation result and operator or system authority permitted by the retention policy. On-chain receipts provide the durable certification record; the two sides are connected by stable identifiers rather than personal data.
This hybrid model supports confidentiality and verifiability together, but only if reconciliation and revocation are designed as first-class flows rather than operational afterthoughts.
Continue with the product and architecture.
- Product walkthrough: Inside the ErisAI demo: from dataset upload to certified inference
- Evidence boundary: What the compute slice proves - and what it deliberately does not
- See it in context: the live demo and the ErisAI product dossier
Product-direction content only. No model, accuracy, cost or availability claim.
