Destill.ai · Proof of Agent Work
Proof of Agent Work · POAW

A machine made a decision. Who can prove what it did?

AI agents now approve payments, triage claims, write code and talk to customers. When one of them gets it wrong, the only witness is a log that the operator controls. Proof of Agent Work turns that log into evidence: signed, dated by an independent authority, and checkable by anyone. The record on the right is being verified live in your browser. Try to change it.

Why · the problem we start from

Trust in a machine's decision should not depend on trusting the people who run it.

01 · Liability moves into software

Software becomes a product

From 9 December 2026 the EU Product Liability Directive covers software, AI included. A court can order evidence to be disclosed, and a product with no credible evidence can be presumed defective.

Directive (EU) 2024/2853, Art. 4, 9, 10
02 · Logs are mandatory, trust is not

The law asks for logs

High-risk AI systems must log events automatically and keep them for at least six months. The law does not say how anyone can tell whether a log was rewritten after the fact.

EU AI Act, Art. 12 and Art. 26(6)
03 · Evidence, not assurances

A receipt instead of a promise

We believe the honest answer to "did the agent really do that?" is a record that the operator, the vendor and the insurer can all check, and that none of them can quietly change. That is what POAW is.

Seven minutes, hand-drawn

The whole case in one film.

What a receipt is, what the EU AI Act and the Product Liability Directive ask for, where it earns its keep first, and how it becomes an open standard. One scene says what it does not do.

Voice: neural text-to-speech · music CC BY 4.0 (Kevin MacLeod) · legal references on the end card.

Short on time? The 42-second version for claims departments.

Voice: neural text-to-speech · the claim in the film is example data · Deutsche Fassung

How · in plain words

Three questions, three checks. None of them needs our software.

Every run of an agent is written as a receipt. Each receipt answers three questions, and each answer can be checked with tools your own engineers already have.

1 · Is it unchanged?

Every step, in order

Each step gets a fingerprint, and the fingerprints are chained into one root value. Change, remove or reorder a single step, and the root no longer matches.

2 · Who signed it?

A key the operator published

The root is signed with a post-quantum signature (ML-DSA-65, the NIST FIPS 204 standard). The public key is published on the operator's own domain, so nobody has to trust a key that travels inside the record.

3 · When did it exist?

Dated by a third party

An independent time-stamping authority (RFC 3161, here DigiCert) stamps the signature. Nobody can backdate the record afterwards, us included.

What a valid receipt does not tell you: whether the agent decided well, or whether every action was logged. It proves what was recorded, by whom, and by when. The logging point is part of every pilot design, and we say so first.

What · for your role

Pick your seat at the table.

You are accountable for what your agents do. Now you can show it.

"If an agent of ours causes a loss, can I prove to a court, a regulator or our insurer what actually happened?"

  • One sentence: every agent run becomes a receipt that your customers, your insurer and a court can verify without taking your word for it.
  • Why it pays: credible evidence is becoming the price of AI-liability cover and of a defensible position under the new Product Liability Directive.
  • What it costs you: a library inside your own systems. Nothing leaves your premises, there is no hosted service to depend on.
  • What it is not: a claim that your agents are right. It is proof of what they did.

Open format, stock tooling, no vendor in the verification path.

"Does this bind us to a vendor, and can my team verify it independently?"

  • Format: poaw-receipt/2, COSE_Sign1 (/1 receipts still verify). SHA-256 Merkle root over the steps, ML-DSA-65 signature (FIPS 204), RFC 3161 timestamp token, key resolved via did:web.
  • Verification: our published check script and stock OpenSSL 3.5 or later, offline. We ran it on 21 October 2026; the commands are below. One changed byte fails every check.
  • Integration: a JavaScript signing library that runs inside your runtime. The logging point (which agent steps are recorded) is the design decision of the pilot.
  • Known gaps, stated first: keys are in software today (HSM on the roadmap), no public transparency log yet, no hosted API.

Turn a questionnaire answer into something you can see working.

"How do I price, reserve for, or recover on a loss caused by an AI agent?"

  • Underwriting: instead of "a human approves every payment", you see signed runs that show whether the approval step was actually there.
  • Claims: the exact sequence of steps, what the agent received, what it estimated, who approved it, with certainty that it is the record written at the time.
  • Recovery: the operator signs with its own key and an independent authority dates it. Neither vendor nor insured can later say the log was something else.
  • Boundary: a receipt proves what was recorded, not that the decision was correct or that everything was recorded. Your actuaries should read that before anyone quotes it.

Logs the law asks for, in a form you can defend.

"We must log. Can we show the logs are genuine when it matters?"

  • EU AI Act Art. 12 / 26(6): automatic event logging and six months of retention. A signed, timestamped receipt is a log whose integrity can be demonstrated, not just asserted.
  • Product Liability Directive: evidence disclosure on court order (Art. 9) and presumption of defect without it (Art. 10). A receipt is evidence you can disclose without rebuilding it.
  • Data protection: sensitive content is recorded as a hash, never in clear text. The record proves that something was there and unchanged, without revealing it.
  • Honest wording: mapping to AI-Act duties is not a claim of conformity. Our evidence pages say so in the same breath.
Pairs with · the second half of the NI-Stack

POAW proves what the agent did. AEGIS screens what it is told.

AEGIS, the CPU-first guardrail

A sovereign injection and content screen that runs on a commodity CPU before any GPU spend, so the prompt never leaves your premises. It runs on one plain CPU core in front of every model call. We publish no detection rate until a reproducible public rerun exists.

Disclosed gaps: role-play and story-style jailbreaks are the largest open gap; benign non-English text gets several times more false alarms than English (an opt-in dampener reduces them); paraphrased attacks are not caught by the pattern layer. Background and preprints at destill.ai/research.

Together: a screened input and a signed outcome

Each AEGIS verdict can be written as a step into the POAW receipt. The record then shows not only what the agent did, but that the input was screened, with what result, before it acted. One receipt, both halves, verifiable without us.

For engineers · independent check

Our published check script and stock OpenSSL 3.5 or later, offline.

Run on 22 October 2026 against the sample below. All three checks passed. With a single changed byte, each of them failed. A second, independent check with the cbor2 library is in test_independent.py.

# 1. fetch the receipt, the check script, and our public key (also published in did.json)
curl -O https://destill.ai/poaw/sample-receipt.json
curl -O https://destill.ai/poaw/verify_receipt.py
curl -O https://destill.ai/poaw/destill-key-1.pem

# 2. decode the COSE_Sign1, check the profile headers, recompute the RFC 9162 root (stdlib only);
#    writes sigstructure.bin (RFC 9052 Sig_structure with the root as detached payload), sig.bin, token.der
python verify_receipt.py sample-receipt.json

# 3. ML-DSA-65 signature (FIPS 204, RFC 9964), stock OpenSSL 3.5 or later
openssl pkeyutl -verify -pubin -inkey destill-key-1.pem -rawin -in sigstructure.bin -sigfile sig.bin
#    -> Signature Verified Successfully

# 4. RFC 3161 timestamp over SHA-256 of the CBOR-encoded signature (RFC 9921 §3.1.1), against the TSA's chain
openssl ts -verify -token_in -in token.der -digest <printed by step 2> -CAfile <your CA bundle>
#    -> Verification: OK

The PEM file holds the same key as did:web:destill.ai#key-1, re-encoded for OpenSSL. Check the bytes against did.json; you do not have to take our word for it. Receipts in the earlier poaw-receipt/1 layout are still accepted by both verifiers.

Your receipt

Verify any POAW receipt.

Paste a poaw-receipt/2 bundle (or an older /1 one) or drop the file here. Nothing is uploaded. The only network call fetches the signer's public key from the domain named in its DID. The full check page, with reasons in German and English and photo seals: destill.ai/pruefen.

Download the sample
Format · a profile of published IETF standards

poaw-receipt/2 = COSE Receipt (RFC 9942) + SCITT Signed Statement (RFC 9943)

Since 22 October 2026 a POAW receipt is a tagged COSE_Sign1 that any RFC 9942 verifier can read. Nothing in the format is ours to license: the tree is RFC 9162, the signature RFC 9052/9964, the timestamp header RFC 9921. What this profile adds is the agent vocabulary and the did:web key rule. The earlier /1 layout is documented in the archived sample .

ElementMeaning
trace[]The agent's steps (application/poaw-trace+json): seq (1…n, contiguous), type, payload, ts. Sensitive content is a SHA-256 hash. A step may be withheld and replaced by its leaf_hash; the root still verifies (selective disclosure).
receipt (base64 CBOR)#6.18(COSE_Sign1): protected header, unprotected header, detached payload, signature.
protected: alg, typ, kid, cwt, vdsalg −49 = ML-DSA-65 (RFC 9964) · typ application/poaw-run-receipt+cose · kid the did:web key URL · cwt claims iss (the DID), sub (run id, urn:poaw:run:…), iat, poaw.key_custody, poaw.agent · vds 1 = RFC9162_SHA256.
payload (detached)The RFC 9162 Merkle root over the trace: leaf = SHA-256(0x00 ‖ JCS(step)), node = SHA-256(0x01 ‖ left ‖ right), split at the largest power of two. The verifier recomputes it and supplies it when checking the signature.
signatureML-DSA-65, pure, empty context, over the RFC 9052 Sig_structure ["Signature1", protected, "", root].
unprotected 396 (vdp)RFC 9942 inclusion proofs, one per disclosed step: [tree_size, leaf_index, path].
unprotected 270 (3161-ctt)An RFC 3161 TimeStampToken whose imprint is SHA-256 of the CBOR-encoded signature field, byte-string header included (RFC 9921 §3.1.1). It proves when the signature existed; step times are operator-asserted.
unprotected 394 (receipts)Reserved for Transparency Service receipts (RFC 9943 layer B). Empty today: no public log yet.

Profile text with every RFC section cited: POAW_SCITT_PROFILE.md (draft 0.1, on request). Core implementation shared by issuer and browser verifier: poaw-cose.js, tests incl. the RFC 9162 vectors from transparency-dev/merkle: poaw-cose.test.js.

Status, measured 22 Oct 2026

What exists, and what does not yet.

In place and verified

  • poaw-receipt/2 as a profile of RFC 9942/9943: issuer and browser verifier share one core; tree checked against the public RFC 9162 test vectors; signature and timestamp re-checked with a second CBOR library and stock OpenSSL 3.5; five deliberate mutations of the core each turn a test red.
  • This verifier, in the browser and via OpenSSL, as shown above; /1 receipts still verify.
  • Published issuer key at did:web:destill.ai.

Not yet

  • Hosted POAW API: today the library runs inside the operator's system. There is no public signing service.
  • Hardware key custody (HSM / enclave): keys are held in software, and the receipt says so in its signed poaw.key_custody claim.
  • Transparency Service (RFC 9943 layer B): header 394 is reserved, no receipt is registered in a public append-only log yet.
  • Qualified timestamp: the TSA used today is DigiCert (not an eIDAS QTSP), so the legal presumption of Art. 41(2) eIDAS does not attach.
  • Standards track: the profile is a draft 0.1, not submitted to the IETF or the Linux Foundation AAIF yet.

One agent workflow. Your verifier. Your team tries to break it.

A pilot covers one workflow and takes two to four weeks. The decision then rests on whether your people could forge, backdate or edit a record, not on a slide.