Product Proof Ledger
// The record it’s held to

Every autonomous decision, verifiable by your auditor.

The operator can’t act without writing a chained, anchored receipt — one you check without us. Each move it makes lands here: SHA-256 hashed, linked by prev_hash, Merkle-batched, anchored on a public chain. 2.1M receipts so far — verify any one of them below.

Book a demo Verify a receipt now →
// What it is

A log says what the operator did. This proves it.

Instead of asking you to trust a dashboard, the operator binds itself to a record it can’t rewrite. Every move it makes — the route it chose, the budget it capped, the action it blocked — writes a receipt: SHA-256 hashed into a leaf, linked to the prior receipt by prev_hash, folded into a Merkle batch, and anchored on a public chain. Change one receipt after the fact and the chain breaks.

The verification recipe is published, so your auditor recomputes the leaf, folds the Merkle proof, and confirms the on-chain anchor with nothing but a SHA-256 implementation — no account, no dashboard, no trust in us. The operator is governed like any other actor on the ledger, and every move it makes is checkable. Instead of an ROI slide you have to take on faith, the operator hands you a record you can’t edit.

// What the operator writes
  • One receipt per action. The operator can’t act without writing one, linked to the prior by prev_hash — tamper-evident by construction.
  • Merkle-batched, anchored. Batches fold to a single root anchored on a public chain — 2.1M receipts and counting.
  • You verify, not us. A published recipe reproduces the proof offline with one SHA-256 call.
// The proof

Don’t take our word for it — verify the operator’s receipt

Recompute the leaf, fold the Merkle proof, check the anchor memo against the root. Four real checks, no short-circuit, all of it in your browser.

A real operator decision, verified end to end

This is a committed receipt for one operator action, with its Merkle siblings and anchor. The math you run here is the same fold the server runs and the same one published in the docs. The bytes match the anchored root, or they don’t.

Same client-side verification shipped on the Trust portal. SHA-256 runs via Web Crypto. No Agentics call.

// Verify in your browser Anchored
receipt_idc4d8e2f0…4e5f
prev_hash1af67611…4a032
payload_hash2962f6b5…466dd
recomputed—
merkle_root14a24583…c058a
anchor_txblock 420669398 ↗
  • •Recompute leaf
  • •Chain integrity
  • •Fold Merkle proof
  • •Anchor memo == root

SHA-256 runs in your browser via Web Crypto. No Agentics call.

// The verifier

Fold it yourself

Instead of a trust-us API, the operator hands you the recipe. The verify call returns four real checks — recompute, chain, Merkle, anchor — and the offline path runs anywhere SHA-256 does.

curl https://agentics.you/api/proof/verify?hash=2962f6b5… \
  -H "Authorization: Bearer ak_…"
# → { receipt_recomputed, chain_ok, merkle_ok, anchor_ok, verified, steps[] }
// the published recipe — runs anywhere with SHA-256
delete receipt.receipt_id; delete receipt.batch_id;
const leaf = sha256Hex(JSON.stringify(canonicalize(receipt)));
const hashPair = (a, b) => sha256Hex(a <= b ? a + b : b + a);
let acc = leaf;
for (const s of bundle.merkle.siblings) acc = hashPair(acc, s);
acc === bundle.merkle.root; // → membership in the anchored batch

Read the receipt schema →

// In the console

Watch the operator’s record fill in

The Proof Ledger console shows every anchored batch, the latest Merkle root, and a verify panel for any receipt the operator wrote.

acme.agentics.you/console/proof-ledger/

Proof Ledger console

Anchored batches with their Merkle roots and on-chain links, beside a panel that verifies any receipt hash the operator produced.

Open Proof Ledger →
// The record it’s held to

Every other tool asserts. The operator proves — on a record you can’t edit.

Book a demo Read the docs → Verify a receipt →