A document, a dataset, a release, or a full AI-agent run: hash it, sign it, anchor it, and hand out one portable evidence package that shows it existed, unchanged, at that time. Anyone can check it with the open verifier. Store the bytes onchain if you want to; by default only the hash leaves your machine.
AUTO· AI3
SOL· SOLAUTO· AI3SOL· SOLAUTO· AI3SOL· SOLAUTO· AI3SOL· SOLAUTO· AI3SOL· SOLAUTO· AI3SOL· SOLAUTO· AI3SOL· SOLAUTO· AI3SOL· SOLAUTO· AI3SOL· SOLAUTO· AI3SOL· SOLAUTO· AI3SOL· SOLAUTO· AI3SOL· SOLTry it
Drop any file — a document, a photo, a dataset, an agent output. It's hashed in your browser and sealed into an evidence package; storing the bytes onchain is an optional choice — by default nothing but the hash leaves your machine.
Who is this for
Seal a run's outputs, tool calls, and approvals under the Agent Evidence Profile. Hand the envelope to whoever needs independent evidence that those records existed, unchanged, when the run finished, and which keys signed them.
Agent EvidenceHash a release tarball and its SBOM into one manifest and seal it, from the SDK or the starter GitHub Action. Anyone holding the bytes recomputes the hashes and confirms they match, without trusting the registry that served them.
SDK and Action docsTimestamp a document or dataset on public settlement systems and keep the file wherever you hold it. Store the bytes onchain only if you choose to; by default only the hash leaves your machine.
Upload a fileIn every scenario the envelope shows existence, integrity, signing keys, and timing. Signed claims are assertions by the signer; an envelope never proves truth, legal validity, or authorship.
For developers
Seal with the reference SDK, verify with the CLI, or hand the tools to the agent you already use. Every path produces and checks the same portable envelope.
import { readFile, writeFile } from "node:fs/promises";
import { sealAgentRun } from "@fileonchain/sdk/evidence";
// Hash-only by default: the bytes are digested here and never leave your machine.
const envelope = await sealAgentRun({
subjectBytes: await readFile("report.md"), // the agent's output artifact
run: { runId: "run_01J9X4T7", agentId: "agent://acme/analyst", status: "completed" },
signers: [agentSigner], // an EIP-191 wallet or an ed25519 agent key
});
// One portable evidence envelope. Anchor it, then hand it to anyone to verify.
await writeFile("evidence.json", JSON.stringify(envelope, null, 2));createEvidence seals any file the same way, without the agent claims. Only digests enter the envelope; storing bytes onchain is an explicit opt-in. Reference SDK on the docs page.
The pipeline
The same pipeline the SDK, the hosted API, and the MCP server run through — whether the artifact is a single file, one agent output, or a whole session batched behind a signed manifest.
Any file — a document, a dataset, an agent output — is hashed client-side, SHA-256. Provenance claims ride alongside when you want them: run id, agent id, model metadata, approvals. Manifests batch many artifacts into one root.
Your wallet, an agent key, or an organization key signs the canonical descriptor — including delegated signing, where an agent signs on behalf of an organization. Signatures answer who; the next step answers when.
The hash (or Merkle root) is settled on the public systems you choose, for each system's ordinary transaction fee. Opt into permanent on-chain storage to keep the bytes too — hash-only stays the default; raw bytes are never required.
Out comes one portable evidence package: subject digests, claims, signatures, receipts. Anyone can validate it locally — fileonchain verify evidence.json — without trusting us or opening an account.
What you get
Every subject is bound to a SHA-256 digest. Anyone holding the bytes can recompute the hash and know, bit-for-bit, that nothing changed — wherever the bytes came from, whoever produced them.
Artifact signatures say who made or approved the thing — agent keys, wallets, organization keys, including delegated signing. Envelope signatures say who assembled the evidence. The verifier reports both, separately.
Multi-system settlement receipts — each one an independent, system-native attestation anyone can check. The envelope is a file; the open local verifier validates it without calling FileOnChain.
Supported chains
Each network settles anchors its own way, and the registry itself charges nothing beyond that network's transaction fee. Anchoring the same file on several networks is optional, and each one charges its own fee, so redundancy has a real cost.
Same Ethereum tooling, different network.
Uses Substrate's `system.remark` as the on-chain storage primitive.
Programs instead of contracts. Use a Solana wallet.
Move modules. Use an Aptos wallet.
IBC app-chains; anchors ride the transaction memo. Use Keplr or Leap.
Move objects and PTBs — separate from Aptos. Use a Sui wallet.
Cairo contracts on a ZK rollup. Use Argent or Braavos.
Human-readable accounts and WASM contracts. Use a NEAR wallet.
TVM contracts with TRON addressing. Use TronLink.
Anchors ride transaction metadata. Use a CIP-30 wallet like Lace.
Anchors ride transfer comments. Use a TON Connect wallet.
Anchors are Consensus Service messages — a small fixed topic fee instead of gas. Use HashPack.
Paid private cache
Onchain anchors are permanent but slow to retrieve. For files that need low-latency reads — site assets, datasets, game assets — pay a cache node to pin the CID encrypted for the duration you need.
See the cache plansAES-GCM with a key derived from your wallet signature. Only you (and whoever you share with) can read the bytes.
Subscribe by the day or month in the chain's native token. The contract holds the escrow; cache nodes watch the events.
Cache nodes pin your CID for the duration you paid. Retrieval is instant — no RPC lag, no synchronous chain reads.
Frequently asked
A portable JSON envelope bundling a subject's SHA-256 digest, provenance claims (run id, agent id, tool calls, approvals), the signatures of whoever — or whatever — produced and assembled it, and storage and settlement receipts from public systems. It travels as a file: paste it into the /verify page or run the open-source CLI (fileonchain verify evidence.json) and it validates locally, without calling FileOnChain.
Open infrastructure
Anchoring writes one transaction per chunk on the network you pick. That receipt alone shows the hash existed at that block. If you opted into on-chain storage, that network alone is also enough to retrieve the file, provided its storage history is available. Anchor-only evidence, the default, keeps the bytes wherever you hold them. If you want redundancy you can anchor the same file on more networks. Each one charges its own gas, so the price stacks. Use the explorer to see what's already public before paying for an extra anchor.