AqtaAqta

Check any record yourself: the public log

  • Seal
  • Transparency
  • Verifiable AI
  • Engineering

In short

Check a signed log head, a record inclusion proof and consistency with a head you pinned earlier. These checks establish inclusion and append-only consistency, not that every decision was recorded; the Aqta-operated witness publishes observations outside our infrastructure.
Pencil sketch: a taped ledger page headed "public log", each line a truncated hash, one line ringed in cyan, and a paper tag pinned to the page reading "size 153". The note reads "anyone can check the log".

Say you are reviewing an AI system's decisions, and we hand you a stack of signed records. Every signature checks out. That answers one question well: has this record changed since it was signed? It cannot answer two others that matter just as much. Does a record exist that you were never shown? And is the history you see today the history you saw last month?

Seal's public log lets you check whether a supplied leaf is included and whether a later signed head extends one you retained. It cannot reveal a decision that was never recorded, or establish that a supplied export is complete. The browser checker is public and needs no account.


What is in the log

The log is a Merkle tree built to RFC 6962, the same construction Certificate Transparency uses for web certificates[1]. It holds two kinds of record in one append order: the receipts Seal signs for model calls and, since 4 September 2026, the records it signs for agent actions.

Signed denials can be entries too. Support for signed model-policy denials dates from 16 July 2026; agent-action entries were added on 4 September. These are distinct from authentication failures, malformed requests and provider errors. Neither the receipt format nor an inclusion proof guarantees a record for every rejected request, or every action outside the signing path.

Each leaf is a hash of one signed record. The log shows the size and order of committed entries and nothing about their content: no prompt, no response, no arguments. The head of the tree (its size, root hash and time) is signed with the same published Ed25519 key that signs the records, and the endpoints need no credentials.

Check it in the browser

app.aqta.ai/transparency runs three checks in your browser, against the published key:

  1. The head. It fetches the current signed head and verifies the signature.
  2. Inclusion. Paste a record's id and it fetches an inclusion proof, then rebuilds the path from that record's leaf up to the signed root.
  3. Consistency. Pin today's head. Come back later and it proves the current log extends the head you pinned, with nothing beneath it rewritten.

To try it on a real refusal, take the action_id from app.aqta.ai/samples/sample-action.json: a signed BLOCKED record for a production-push request. The signature preserves the issuer's refusal assertion; it is not an independent observation of side effects. The sample is linked from app.aqta.ai/refusals.

Check it without our page

Optional terminal checks with the published verifier

The page is a convenience. The same checks run from a terminal with the published verifier, aqta-verify-receipt, with receipt and proof commands published on npm and PyPI:

bash
pip install aqta-verify-receipt==1.4.0

# Example issuer key, reviewed 8 November 2026.
# Confirm and pin the key through your trusted setup process.
KEY=9Y3Eiq6V8QjRDUM5nPqSwKIOPQaoEU4SbagfYFdvWa4

# 1. The head
curl -s https://api.aqta.ai/v1/public/transparency/sth -o sth.json
aqta-verify-proof sth.json --key "$KEY"

# 2. Inclusion of one record (a receipt id or an action id)
curl -s https://api.aqta.ai/v1/public/transparency/proof/05e9c6e2-ef87-49aa-a823-aa2b0ee4942c -o proof.json
aqta-verify-proof proof.json

# 3. The record itself
curl -s https://app.aqta.ai/samples/sample-action.json -o record.json
aqta-verify-receipt record.json --profile action-1 --key "$KEY"

One step is yours, not the tool's: compare the proof's root_hash and tree_size with the head you verified in step 1. The path proves that a leaf reaches that root; the signed head is what makes the root one we committed to. Change a single hash in the proof and the verifier answers computed root does not match root_hash.

For consistency, fetch https://api.aqta.ai/v1/public/transparency/consistency?old_size=<your pinned size>, run the same proof command on it, and check that old_root is the root you pinned and new_root is the root of today's head.

Held outside our infrastructure

A retained head gives you a comparison point. Aqta operates the witness: it is not an independent observer and does not guarantee complete coverage. Its value is the externally retained evidence of particular observations. A public repository, Aqta-ai/seal-log-witness, does the same job on a schedule. It checks each new head's signature, proves the head extends the last one it recorded, and countersigns it into Sigstore's public log, so a record of when that head existed lives outside Aqta. Run node scripts/check.mjs in a clone and it re-verifies the whole recorded chain offline[2].

The log's history is part of the log. After an ordering defect, it was re-anchored at size 153 on 27 August 2026. Heads pinned before then do not chain to the current log, and app.aqta.ai/transparency says so in a note that stays. A consistency proof from size 153 to today's head verifies with the same command as above.

What this does not prove

The log makes it harder to hide that a signed record existed. It cannot show a decision that was never signed. Leaves are hashes, so the log proves nothing about content. Inclusion binds a leaf to a signed head. The head's timestamp is an issuer assertion; external witnessing adds evidence of when that commitment was observed, not when the action ran. The public refusal sample carries an issuer timestamp of 22 August 2026; action records became log entries later. The terminal commands above check the record and proof separately[3]. A full record-to-log check must also recompute the entry's leaf from the signed record and compare it with the proof's leaf_hash. A valid path alone does not bind arbitrary record bytes to that leaf. Aqta operates the witness. Its value comes from where the evidence lives, in GitHub's history and Sigstore's log, and from the fact that anyone can fork it and run it on their own schedule.

Check the public log

Clarified inclusion versus completeness, the scope of signed denials, the separate record-to-leaf check and Aqta’s operation of the witness.