
One Receipt: evidence a stranger can verify · Standard gear
Reviewed and published, version 1.0.0.
Big Widget Company, its people, its keys, its registry and every card below are made up. The cards and the runnable bundle in bundle/ are course-owned synthetic teaching examples, not One Receipt conformance tests and not real deployment evidence. The results quoted below are the author's own run of that bundle; run it yourself to check them. Every real document and case is cited. Where we do not know something, we say so.
What this module does
Figure data as text
Verification is not truth
W3C draws a line between verifying and validating.
| Part | Wording | Sources |
|---|---|---|
| Verifying | "Verification of a credential does not imply evaluation of the truth of claims encoded in the credential." | [s5] |
| Validating | A verifier "validates the included claims using their own business rules before relying on them." | [s5] |
This figure covers only part of this module's first objective (verifying versus validating), not the full statement-sorting exercise. The synthetic receipt is not a W3C credential (s5).
In Level 400 you practised handing an evidence bundle and a VERIFY.md to a stranger who checks it offline. This module asks the harder question: when the stranger's check passes, what exactly have they learned?
The answer has three layers, and most mistakes come from collapsing them:
| Layer | The question | What can establish it |
|---|---|---|
| Integrity and origin | Was this canonical data signed with this key, and is it unchanged since? Does the key belong to who we think? | Signature verification, under stated key and trust assumptions |
| Attestation | What does the issuer claim happened: which rule ran, what was decided? | Only the issuer's word, now bound to a key |
| Effectiveness and truth | Did the control actually work? Was the output true, fair or lawful? | Independent observation, testing or review, outside the receipt |
The AiGovOps Foundation's manifesto describes the receipt a gate leaves as one "that holds no private content and that a stranger can verify offline, without an account and without trusting us."1 Its Practice site lists what that receipt carries ("hashes, decision, tier, policy hash, key id") and what it never carries ("prompts, outputs, payloads, personal data").2 Our reading of "without trusting us": the stranger need not take the Foundation's word for the result. It does not remove the stranger's own decision about which key to trust, which this module makes explicit.
The course map keeps the Foundation's draft One Receipt specification as author and checker context only (Level 500 decision 10). This module does not quote it or depend on it, and makes no claim about what any real One Receipt implementation does. It teaches from public standards and from its own cards.
By the end you will be able to:
- sort statements about a signed record into integrity/origin, attestation and effectiveness, naming the key and trust assumptions each depends on (500.6-a);
- explain why a verifier withholds a higher assurance level when a required proof is missing, using a fictional rule card (500.6-b);
- design content-free receipt evidence for one consequential Big Widget Company action, and name the control claim it still cannot prove (500.6-c).
Two cases about what evidence does not show
A record of what the chatbot said is not a record that it was right
In November 2022 a passenger asked the chatbot on Air Canada's website about bereavement fares. The chatbot said the reduced fare could be requested after travel, within 90 days of the ticket being issued, while the airline's own bereavement page, which the answer linked to, said the policy did not apply to completed travel.3 In a decision dated 14 February 2024 on the passenger's small claim, British Columbia's Civil Resolution Tribunal held that Air Canada is responsible for all the information on its website, including what its chatbot says, found negligent misrepresentation and ordered it to pay damages.3
Imagine the airline had kept a signed record of that exchange. Verified under a key the reader trusts, it would be evidence that the holder of the airline's key signed that transcript, and it would make that transcript hard for the airline to disown. It would not show how the words were produced, and it would not make them true. In that case the words were the problem. The decision turns on its own facts: it does not describe how the chatbot was built, it is not a general rule for every chatbot, and nothing here suggests a receipt would have changed the outcome.
A control that exists is not a control that works
On 1 August 2012, Knight Capital's automated order router, SMARS, processed 212 small retail orders and sent millions of orders into the market over about 45 minutes, obtaining over 4 million executions in 154 stocks; Knight lost over $460 million.4 The Securities and Exchange Commission's order, dated 16 October 2013, records findings that Knight neither admitted nor denied, except as to jurisdiction.4
Several findings are about controls that were present on paper but did not act:
- Knight assigned a $2 million gross position limit to one account, but did not link it to any automated controls on the firm's overall exposure.4
- Its main risk monitoring tool "relied entirely on human monitoring" and did not generate automated alerts about the firm's financial exposure.4
- Before the market opened, an internal system sent 97 automated e-mails that referenced the error; Knight had not designed them as alerts, and staff generally did not review them.4
- During deployment a technician did not copy the new code to one of eight servers; Knight did not have a second technician review the deployment and "had no written procedures that required such a review."4
The rule Knight was found to have violated, Rule 15c3-5, requires a system "for regularly reviewing the effectiveness" of risk controls, as distinct from having them.4 Knight undertook to retain independent consultants to review its compliance.4
This is a 2012 software case, not a generative-AI case, and there is no suggestion that receipts would have prevented it. It is here for one lesson: a signed statement that "a position limit is in place" could have been true, signed and verified, and still said nothing about whether the limit stopped anything.
What a verified signature establishes
The synthetic bundle
Big Widget Company runs an AI refunds agent that proposes goodwill refunds on warranty claims. It proposes; it cannot pay. A course rule, BW-REF-3, says refunds above the agent's limit must be held for a named human approver, the warranty-lead. Each gate decision produces a signed receipt.
This module ships a runnable synthetic bundle in bundle/, in the Level 400 shape:
VERIFY.md: the steps a stranger runs offline, with no account, no network and no extra packages;verify.py: the verifier, in plain Python, short enough to read before you trust it;trust/card-T.json: Card T, the keys you choose to trust and why;cases/M,cases/N,cases/P,cases/S: four bundles, each with signed receipts, the rule textBW-REF-3-v4.txtand, for two of them, a BW-Ledger registry proof;auditor-only/: one synthetic private record, so you can try opening a commitment;MANIFEST.sha256: a hash of every file, so you can tell you have the pinned version.
It uses Ed25519 signatures over canonical JSON. Every key, hash and signature in it is real arithmetic over made-up data. Nothing in it comes from a private test vector.
The results below are the author's run, and an author's run is not a check. Any run of verify.py takes Card T's synthetic keys from the handout, so a matching run shows the exercise works. It does not show that anyone found the keys independently, and it is not a conformance result. The repository's regression tests for the verifier are the builder's tests, not an independent check.
Card R1 (synthetic receipt, course-owned; the signed file is bundle/cases/M/receipts/R1.json)
| Field | Value |
|---|---|
| Issuer | Big Widget Company refunds service |
| Key id | bw-refunds-2026-11 |
| Action | refund.propose for one warranty claim |
| Rule applied | BW-REF-3 version 4, with the policy file's hash |
| Decision | held-for-approver |
| Approver | role warranty-lead, opaque approval reference APR-0042 |
| Input / output | commitments only (see below); no customer text |
| Claimed assurance | C3 (see the rule card in the next section) |
| Previous receipt | the hash of the receipt before it in the chain |
| Signature | Ed25519 over the canonical data; valid under Card T's key in the author's run |
Card T (trust assumptions, course-owned)
- The verifier accepts that key
bw-refunds-2026-11belongs to Big Widget Company's refunds service, because it appears in the company's published key list, and records the date it fetched that list. - The verifier assumes the private key was not compromised or misused before the receipt was signed.
- The verifier trusts receipts from the fictional registry BW-Ledger, signed with its listed key.
Three kinds of statement
When the check reports "signature valid" for Card R1, sort what follows:
| Statement | Kind | Holds if |
|---|---|---|
"This record's canonical data has not changed since it was signed with bw-refunds-2026-11." | Integrity | The signature checks over the canonical form (a re-spaced copy of the same data still checks; a changed value does not; VERIFY.md step 4 lets you try both) |
| "The refunds service issued this record." | Origin | Assumptions 1 and 2 hold |
| "Rule BW-REF-3 v4 was applied and the refund was held for an approver." | Attestation | Only the issuer says so; the signature binds the issuer to the claim, it does not prove it |
| "The agent really produced the committed output, the way the record says." | Attestation | Only the issuer says so; a signature authenticates the statement, not the process that produced its contents |
| "The approver really reviewed the refund, and the hold rule stops every over-limit refund." | Effectiveness | Not established by the receipt; needs independent observation |
| "The refund decision was correct and fair to the customer." | Truth | Not established by the receipt |
The public standards draw the same lines.
- Verification is not truth. The W3C Verifiable Credentials Data Model 2.0 says: "Verification of a credential does not imply evaluation of the truth of claims encoded in the credential."5 It separates verification from validation: a verifier "validates the included claims using their own business rules before relying on them."5 Card R1 is not a W3C credential; the vocabulary is useful context.
- Trust is the relying party's decision. The SCITT architecture, RFC 9943, says a Relying Party "MUST trust the verification key or certificate and the associated identity of at least one Issuer of a Receipt", and that "It is the role of the relying party to decide which TSs and Issuers they choose to trust for their scenario."6 Card T makes that decision visible instead of assumed.
- Keys can fail. RFC 9943 notes that "Issuers and TSs can both be compromised" and that it is important "to clearly communicate when keys are compromised".6 If assumption 2 fails, the origin statement fails with it.
- Signing makes the issuer accountable, not honest. "Transparency does not prevent dishonest or compromised Issuers, but it holds them accountable."6
So a valid signature gives you evidence against denial: while assumption 2 holds, the issuer will find it hard to disown the claim or quietly change it. That is worth a great deal. It is not evidence that the claim is true, that the process it describes ran as described, or that the control works.
Assurance the verifier computes, not the issuer claims
The fictional rule card
The verifier, not the issuer, decides what the evidence supports. This module teaches that with its own fictional rule card. The tiers C1 to C3 are a teaching device: not a One Receipt level, not a Practice mark and not a certification.
Card A (fictional course assurance rule)
| Tier | Every one of these proofs must be present and pass |
|---|---|
C1 | Signature valid under a key in Card T |
C2 | C1, plus: the policy hash in the receipt matches the policy file in the bundle, and every receipt in the supplied range links to its predecessor, back to the bundle's stated starting point |
C3 | C2, plus: a registry receipt from BW-Ledger, valid under assumption 3, showing this signed record was registered |
Rules:
- The verifier records each proof as pass, fail or absent.
- It assigns the highest tier whose proofs all pass, never higher than the tier the issuer claims.
- It lists each absent proof and each failed proof by name, separately. Absent means the evidence was not supplied; it may exist elsewhere. Fail means the evidence was supplied and contradicts the record, for example a policy file whose hash differs from the one in the receipt. A failure is a finding to report to the record's owner, not a gap to fill later.
- If the signature fails, the result is
none. Nothing else in the record can be relied on, and the verifier stops and reports it. Rule 2 needs a claimed tier to cap the result. If the claimed tier is missing, or is not
C1,C2orC3exactly, the record is invalid input: reject it and assign no tier.verify.pydoes this before it computes anything, even when the signature is valid. It printsRejected receipt: invalid claimed_tierand exits with code 2; with--all, one bad claim rejects the whole batch and no tiers are printed (VERIFY.md, step 3, "Claimed-tier precondition"). None of the four cases has a bad claim. To see the rejection, follow thetier-examplecommands under step 4 ofVERIFY.md, or run the regression tests from the repository root:python3 -m unittest discover -s tests -p 'test_receipt5006.py'Exit code 0 means the report ran, not that every proof passed. Read the printed tier and the absent and failed lists.
Case M: the missing registry evidence
Run python3 verify.py cases/M from bundle/.
| Check | Author's run |
|---|---|
Signature under bw-refunds-2026-11 | pass |
Policy hash matches BW-REF-3-v4.txt | pass |
| Chain links back to the bundle's starting point | pass |
| BW-Ledger registry receipt for R1 | absent |
The issuer claimed C3. The verifier records C2, with the absent proof: registry receipt from BW-Ledger for R1. The receipt's signed data is not changed by this; the verifier's result is a separate record beside it.
Why withhold C3? Because the card says C3 needs a proof that is not there, and the issuer's claim is not a substitute for the proof. The claim is the very thing being checked.
The bundle has three more cases. In the author's run:
| Case | Issuer claims | What is different | Result |
|---|---|---|---|
| N | C2 | Every proof passes, including a registry proof | C2: never more than the claim |
| P | C3 | The bundled rule text has been edited, so its hash does not match the receipt | C1, with p_pol failed: a finding to report |
| S | C2 | A value was changed after signing | none: stop and report |
What the chain check does and does not show
A passing chain check shows that the receipts you were given link up, each to the one before, back to the bundle's starting point. It does not show you were given every receipt the system emitted, and it says nothing about actions that never produced a receipt. A missing above-limit refund leaves no gap in the chain.
Completeness needs an independent list of what should be there, kept by someone the issuer does not control, and matched item by item against the receipts. For example: take every above-limit payment in the payments ledger for the same dates, and find the approval receipt for each one by its reference. A matching count is not enough. One missing receipt and one duplicate give the right count and hide the gap.
A registry's consistency proof answers a different question. RFC 9942 lists proof "that a database is append-only (proof of consistency)" separately from proof of inclusion.7 In this course's reading, such a proof can show that a later checkpoint extends an earlier one, provided you trust the log's key and both checkpoints. It compares those two states only. On its own it does not rule out the log showing someone else a different view, or changes outside the two checkpoints. And it cannot show that every refund produced a receipt in the first place, so it is not a completeness check.
The Case M bundle supplies no independent list, so this module makes no completeness claim for it. If you are asked whether the set is complete, the honest answer is "not known", with the name of whoever holds the payments ledger.
What even C3 would not mean
A registry receipt proves something narrow. RFC 9942 defines COSE Receipts as proofs of properties of a verifiable data structure, such as "proofs that a document is in a database (proof of inclusion)".7 RFC 9943 is blunt about what registration means: "registering a Statement only proves it was produced by an Issuer."6
So a C3 result would add: this record was included in BW-Ledger, as of the point the registry receipt covers, under assumption 3. One inclusion proof does not by itself show that the registry showed every reader the same log, and it does not make the refund right, show the approver reviewed it, or show BW-REF-3 stops over-limit refunds. Registration is neither truth nor certification. And C2 is not "worse evidence of a working control" than C3: no tier says anything about effectiveness.
A note on words: in RFC 9942 and RFC 9943, a "Receipt" is a proof that something was registered in a log.67 In this course, the "receipt" is the signed record of the action itself. Keep the two apart when you read the standards.
Designing content-free evidence for one consequential action
The action, step by step
Big Widget Company's refunds agent may propose a goodwill refund. A refund above the agent's limit, if approved, moves money, so the proposal is a consequential action. The Foundation's manifesto sets the rule for those: "No direct model-to-tool path for consequential actions."1 Here the agent's only route to money runs through the gate and a named person.
| Step | Who records it | What kind of evidence |
|---|---|---|
| Agent proposes the refund | Refunds service, in a receipt | Attested by the service |
Gate holds it for the warranty-lead | Refunds service, in a receipt | Attested by the service |
warranty-lead approves or declines | Refunds service, in a receipt with approval_ref | Attested by the service; the lead's actual review is not observed |
| Payment is made (only after approval) | Payments ledger, which the agent does not write | A separate record; independent only if the ledger's operators are |
You design the receipt for steps 1 to 3.
Commitments instead of content
The receipt must let a stranger check the decision without exposing the customer's claim, the chat or the agent's reasoning. The course's design: for each private item, the receipt carries a commitment, a hash of the item together with a random value kept in Big Widget's private service record. The receipt shows nothing readable. Later, an authorised auditor holding the private record and the random value can recompute the hash and confirm the record matches what was committed. VERIFY.md step 5 lets you try this with one synthetic record.
That design rests on assumptions we state rather than prove:
- The random value is long, fresh for each item, and kept secret. If it leaks, anyone who can guess the item can test the guess, and small items such as an amount are easy to guess.
- The hash function resists collisions, so the issuer cannot later find a different record that matches the same commitment.
- The surrounding fields do not give the secret away. A commitment is only as private as the metadata next to it.
The optional further-learning courses below cover the cryptography behind these assumptions. Nothing in this module depends on them.
Your receipt fields (course design)
| Field | Example | Why it is there |
|---|---|---|
action | refund.propose | Names the one action |
rule_id, rule_version, policy_hash | BW-REF-3, 4, hash of the policy file | Which rule, which exact text |
agent_version | the deployed agent build id | Which system acted |
input_commitment | commitment to the claim record | Links to private content without exposing it |
output_commitment | commitment to the proposed refund | Same, for the agent's output |
amount_band | above-limit | Enough to show why the gate applied, without the exact amount |
decision | held-for-approver, then approved or declined | What the gate decided |
approver_role, approval_ref | warranty-lead, an opaque reference meaningful only inside Big Widget | Who answers for it, without a name |
time | only as precise as the purpose needs | When |
key_id, signature | bw-refunds-2026-11, signature | Integrity and origin, under Card T |
Kept out of the receipt: the customer's name, contact details, claim text, chat transcript, the agent's draft wording, the exact amount and the approver's name. Those live in the private service record, under Big Widget's own data rules.
Metadata can still identify. An exact timestamp, an amount band and an approval reference, put together with other records, may single out one customer. Keep each field as coarse as its purpose allows, and have Big Widget's privacy owner, a named person, approve the field list before the agent goes live. This module does not claim any field list is anonymous.
To sign and hash JSON reliably, both sides must serialise it the same way. RFC 8785, an Informational RFC rather than a standard, exists because "hashing and signing need the data to be expressed in an invariant format so that the operations are reliably repeatable"; among other rules, it sorts object properties recursively.8 Canonical form makes the hash repeatable. It supplies no privacy and no truth.
The claim the receipt still cannot prove
The receipt shows that the refunds service says it held the refund for the warranty-lead, and binds it to that statement. It cannot show:
- that the hold rule fires for every above-limit refund, including ones that never produced a receipt;
- that the
warranty-leadactually reviewed the claim before approving.
Those are control-effectiveness claims. They need independent observation. This course's example uses two tests, run by someone who did not build the agent:
- Seeded tests. Submit known above-limit refunds and check each is held. This shows the gate held the cases tried, on the days they were tried. It says nothing about cases unlike them.
- Reconciliation. Match every above-limit payment in the payments ledger for a period, one by one, to its approval receipt. This covers the payments the ledger recorded in that period, and only if the ledger is independent of the agent. It cannot see proposals that were never paid.
The two tests look at different things: the seeded test looks at the cases the tester tried, on the days they tried them; reconciliation looks at real payments in its own period. Neither proves the gate will hold every future refund. Together they give a tested, dated and bounded claim, which is what the manifesto's checklist asks a practitioner to know: "I know my system's coverage number, or I know that I do not."1
Knight's order shows why such tests matter. It had a position limit, but the limit was not linked to anything that would stop orders, and there was no control "to compare orders leaving SMARS with those that entered it."4 The SEC's rule asks for a system for reviewing control effectiveness, not only a description of controls.4 The seeded refunds are the course's example; the SEC order does not mention them.
A good receipt makes that independent test cheaper: the tester knows exactly which rule, version and decision to look for. It does not replace the test.
The three yeses for Big Widget's refund receipts
The manifesto ties each movement to a time.1
- Get to Yes, "before a rule or a system ships" and "before a single action runs".1 BW-REF-3 is written and versioned. The limit is set. The
warranty-leadis named as the person who can release a hold. The gate's answers are "go ahead · only this far · wait for a person · no";1 an above-limit refund gets "wait for a person". The privacy owner approves the receipt's field list. Big Widget's security lead publishes the key and the date it took effect. - Stay at Yes, "while it runs, in real time".1 Every gate decision leaves a receipt. Seeded tests and reconciliation run on a schedule, by someone who did not build the agent, and their coverage is written down, or "not known" if it is not. A hold nobody answers is not a yes.
- Recover to Yes, "after — on demand, on incident".1 Triggers include a failed signature, a failed policy hash, a payment with no matching approval receipt, or a suspected key compromise. Above-limit proposals stay held. The security lead stops accepting the key from the suspected time and tells relying parties, as RFC 9943 asks issuers to "clearly communicate when keys are compromised".6 The
warranty-leadreviews the affected refunds against the private records. A paused agent or an announced fix is not proof of recovery. Big Widget is back at yes only when fresh checks pass and thewarranty-leadand security lead record that they agree.
Check yourself
- Integrity and origin come from the signature over canonical data, under the key and trust assumptions you write down. Change the assumptions and the conclusion changes.6
- Attestation is the issuer's claim, bound to its key. Verification does not make it true, and it does not show how the contents were produced.5
- Assurance is computed by the verifier from proofs that pass; an absent proof caps the result, a failed proof is reported as a finding, and a failed signature means
none. Registration proves who produced a statement, not that it is true.6 - Completeness needs an independent list of what should be there, matched item by item. A linked chain is not a complete one, and, in this course's reading, a consistency proof7 shows only that a later trusted checkpoint extends an earlier one, under the log and proof assumptions you trust. It does not show that every action made a record.
- Effectiveness needs independent evidence outside the receipt, and each test covers only what it tried, as the Knight order shows for controls that existed but did not stop anything.4
- Content-free receipts use canonical serialisation8 and, in this course's design, commitments under stated assumptions; they never carry "prompts, outputs, payloads, personal data".2
- Unknowns are an answer. "I don't know yet" is always an answer, and the Practice site says it "always pairs you with someone".2 Write "not checked" or "not known", and name who will check.
Words to know: integrity, origin, attestation, trust assumption, relying party, assurance tier, absent versus failed proof, registry receipt, inclusion and consistency proofs, commitment, canonicalisation, control effectiveness.
Further learning (not cited, not required; nothing in this module depends on them): MIT OpenCourseWare 6.858 Computer Systems Security (Fall 2014) and the University of Cambridge Cryptography course (2025–2026) cover threat models, signatures, hashes and commitments in depth. See levels/500/universities.md.