The operator runs your AI — and it's governed like any other agent. It can't take an action without writing a hash-chained receipt and anchoring it on a public chain, so every move it makes is checkable. You — or your auditor — recompute the proof yourself, without trusting a single thing we say.
Instead of an autopilot you take on faith, the operator runs every model and agent your company uses through one neutral lane — in any cloud or your own VPC — enforces your rules before each call, and writes an independently-verifiable receipt after. The result is not a claim to trust, but evidence you check. Six things the operator does on that one ledger — five shipping today, one on the roadmap and honestly flagged.
A row in a database the vendor controls. You're asked to trust that an autonomous system did the right thing — and to take their word that the row wasn't edited after the fact.
Every move the operator makes is a prev_hash-chained receipt anchored on a public chain. Your auditor recomputes the leaf, folds the proof and byte-matches the memo — without trusting a single thing we say.
Counts read from the public network aggregate. Where the live endpoint is unavailable, the page shows its last published values and degrades to "—" rather than guessing.
| Component | State |
|---|---|
| Gateway & dispatch | Operational |
| Receipt ledger | Operational |
| Merkle batching & anchoring | Operational |
| Public Verify API | Operational |
Component states reflect the live status read above; if the status endpoint is unreachable, this panel shows its last published baseline rather than a guess.
This is a genuine record of one move the operator made — the kind of evidence it writes for every action it takes. It carries only hashes and usage numbers, no prompt or response content. Press Verify and your own browser checks it end to end with SHA-256 via Web Crypto. Nothing is sent to Agentics, and you don't take our word for any of it.
receipt_id and batch_id, sort the keys, and SHA-256 the canonical JSON. The result must equal the published receipt_hash.prev_hash is the previous receipt's hash — tampering with any earlier receipt breaks the link.merkle_root.The math here is identical to the server's and to the six-line recipe. Run it in a fresh REPL with only a SHA-256 library — you will get the same leaf and the same root, byte for byte.
Paste any receipt_hash the operator wrote. The public sample folds fully in your browser; other hashes run the public ledger lookup. We never reveal another tenant's receipt body.
Verifying what the operator did finishes on infrastructure we don't control. The public anchor, the open verifier and the block explorer are all reachable without us — so an auditor can replay the operator's full chain of custody, then forward it, without ever logging into Agentics.
inputs_hash, prev_hash, model, outcome. No prompt or response body.receipt_hash; it folds through sibling hashes to a batch merkle_root.Three doors out of Agentics. Each one lets a reviewer confirm the same receipt without trusting a single byte we serve beyond a public hash.
Read the anchored Merkle root straight from the public blockchain — the transaction does not touch Agentics.
Open the anchor →Run the six-line recipe in a fresh REPL with only a SHA-256 library; you get the same leaf and the same root, byte for byte.
See the open recipe →Download the receipt bundle and hand the whole chain of custody to your GRC team or external assessor to fold themselves.
Download the bundle →We publish status honestly. "In progress" means exactly that — an audit underway, not a badge we haven't earned.
Observation window open; report expected 2026.
Stage 1 readiness underway.
BAA available for healthcare pilots.
Article 12 logging built in; high-risk obligations apply Aug 2026.
Live certification records load from /api/trust/certifications when available; the cards above are the current published baseline.
By default, prompt and response content stays out of the ledger entirely — the operator records only hashes and metering. In self-host mode, not even those leave your VPC. The sub-processors below handle the control plane the operator runs on.
| Sub-processor | Purpose | Data |
|---|---|---|
| Netlify | Static hosting & edge functions | Request metadata |
| Public blockchain | Merkle-root anchoring | Root hashes only |
| Managed Postgres | Receipt ledger & metering | Hashes & metering |
| Model providers | Inference (your chosen vendors) | Your prompts, per your config |
Self-host customers replace the ledger and anchoring with their own infrastructure; only the leaf hash and metering numbers cross to the Agentics control plane. See the data-plane split.
Hand the operating to an operator that proves every move — a portal your security team verifies without a questionnaire, and a chain an auditor folds without your help.