Level 500: Governance, safety and research · Module 500.6

A reviewer holds a long paper slip up to the window light while a colleague looks on.
Check the receipt

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

W3C draws a line between verifying and validating; Verifying: "Verification of a credential does not imply evaluation of the truth of claims encoded in the credential."; Validating: A verifier "validates the included claims using their own business rules before relying on them." This figure covers only part of this module's first objective (verifying versus validating), not the full statement-sorting exercise.
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).
Figure data as text

Verification is not truth

W3C draws a line between verifying and validating.

PartWordingSources
Verifying"Verification of a credential does not imply evaluation of the truth of claims encoded in the credential."[s5]
ValidatingA 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:

LayerThe questionWhat can establish it
Integrity and originWas 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
AttestationWhat does the issuer claim happened: which rule ran, what was decided?Only the issuer's word, now bound to a key
Effectiveness and truthDid 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:

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:

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:

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)

FieldValue
IssuerBig Widget Company refunds service
Key idbw-refunds-2026-11
Actionrefund.propose for one warranty claim
Rule appliedBW-REF-3 version 4, with the policy file's hash
Decisionheld-for-approver
Approverrole warranty-lead, opaque approval reference APR-0042
Input / outputcommitments only (see below); no customer text
Claimed assuranceC3 (see the rule card in the next section)
Previous receiptthe hash of the receipt before it in the chain
SignatureEd25519 over the canonical data; valid under Card T's key in the author's run

Card T (trust assumptions, course-owned)

  1. The verifier accepts that key bw-refunds-2026-11 belongs 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.
  2. The verifier assumes the private key was not compromised or misused before the receipt was signed.
  3. 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:

StatementKindHolds if
"This record's canonical data has not changed since it was signed with bw-refunds-2026-11."IntegrityThe 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."OriginAssumptions 1 and 2 hold
"Rule BW-REF-3 v4 was applied and the refund was held for an approver."AttestationOnly 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."AttestationOnly 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."EffectivenessNot established by the receipt; needs independent observation
"The refund decision was correct and fair to the customer."TruthNot established by the receipt

The public standards draw the same lines.

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)

TierEvery one of these proofs must be present and pass
C1Signature valid under a key in Card T
C2C1, 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
C3C2, plus: a registry receipt from BW-Ledger, valid under assumption 3, showing this signed record was registered

Rules:

  1. The verifier records each proof as pass, fail or absent.
  2. It assigns the highest tier whose proofs all pass, never higher than the tier the issuer claims.
  3. 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.
  4. If the signature fails, the result is none. Nothing else in the record can be relied on, and the verifier stops and reports it.
  5. Rule 2 needs a claimed tier to cap the result. If the claimed tier is missing, or is not C1, C2 or C3 exactly, the record is invalid input: reject it and assign no tier. verify.py does this before it computes anything, even when the signature is valid. It prints Rejected receipt: invalid claimed_tier and 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 the tier-example commands under step 4 of VERIFY.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/.

CheckAuthor's run
Signature under bw-refunds-2026-11pass
Policy hash matches BW-REF-3-v4.txtpass
Chain links back to the bundle's starting pointpass
BW-Ledger registry receipt for R1absent

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:

CaseIssuer claimsWhat is differentResult
NC2Every proof passes, including a registry proofC2: never more than the claim
PC3The bundled rule text has been edited, so its hash does not match the receiptC1, with p_pol failed: a finding to report
SC2A value was changed after signingnone: 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.

StepWho records itWhat kind of evidence
Agent proposes the refundRefunds service, in a receiptAttested by the service
Gate holds it for the warranty-leadRefunds service, in a receiptAttested by the service
warranty-lead approves or declinesRefunds service, in a receipt with approval_refAttested by the service; the lead's actual review is not observed
Payment is made (only after approval)Payments ledger, which the agent does not writeA 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 optional further-learning courses below cover the cryptography behind these assumptions. Nothing in this module depends on them.

Your receipt fields (course design)

FieldExampleWhy it is there
actionrefund.proposeNames the one action
rule_id, rule_version, policy_hashBW-REF-3, 4, hash of the policy fileWhich rule, which exact text
agent_versionthe deployed agent build idWhich system acted
input_commitmentcommitment to the claim recordLinks to private content without exposing it
output_commitmentcommitment to the proposed refundSame, for the agent's output
amount_bandabove-limitEnough to show why the gate applied, without the exact amount
decisionheld-for-approver, then approved or declinedWhat the gate decided
approver_role, approval_refwarranty-lead, an opaque reference meaningful only inside Big WidgetWho answers for it, without a name
timeonly as precise as the purpose needsWhen
key_id, signaturebw-refunds-2026-11, signatureIntegrity 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:

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:

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

Check yourself

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.

Sources

  1. s8 AiGovOps Foundation (2026). The AiGovOps Practitioner Manifesto. Official doc. Checked 2026-11-20 by source-checker role, separate Claude session (round-5 re-check), not the writer. ↩ ↩ ↩ ↩ ↩ ↩ ↩ ↩
  2. s9 AiGovOps Foundation (2026). The AiGovOps Foundation café — start with your problem (Practice home page). Official doc. Checked 2026-11-19 by source-checker role, separate Claude session (round-3 re-check, bc9acb0e), not the writer. ↩ ↩ ↩
  3. s7 Christopher C. Rivers, British Columbia Civil Resolution Tribunal (2024). Moffatt v. Air Canada, 2024 BCCRT 149. Record. Checked 2026-11-19 by source-checker role, separate Claude session (round-3 re-check, bc9acb0e), not the writer; official PDF (9 pp.) at this url, HTTP 200. ↩ ↩
  4. s6 U.S. Securities and Exchange Commission (2013). In the Matter of Knight Capital Americas LLC, Release No. 34-70694. Record. Checked 2026-11-19 by source-checker role, separate Claude session (round-3 re-check, bc9acb0e), not the writer. ↩ ↩ ↩ ↩ ↩ ↩ ↩ ↩ ↩ ↩ ↩
  5. s5 Manu Sporny; Dave Longley; David Chadwick; Ivan Herman (et al.) (2025). Verifiable Credentials Data Model v2.0. Standard. Checked 2026-11-19 by source-checker role, separate Claude session (round-3 re-check, bc9acb0e), not the writer. ↩ ↩ ↩
  6. s2 H. Birkholz; A. Delignat-Lavaud; C. Fournet; Y. Deshpande; S. Lasker (2026). An Architecture for Trustworthy and Transparent Digital Supply Chains (RFC 9943). Standard. Checked 2026-11-19 by source-checker role, separate Claude session (round-3 re-check, bc9acb0e), not the writer. ↩ ↩ ↩ ↩ ↩ ↩ ↩ ↩
  7. s3 O. Steele; H. Birkholz; A. Delignat-Lavaud; C. Fournet (2026). CBOR Object Signing and Encryption (COSE) Receipts (RFC 9942). Standard. Checked 2026-11-20 by source-checker role, separate Claude session (round-6 re-check), not the writer. ↩ ↩ ↩ ↩
  8. s4 A. Rundgren; B. Jordan; S. Erdtman (2020). JSON Canonicalization Scheme (JCS) (RFC 8785). Standard. Checked 2026-11-20 by source-checker role, separate Claude session (round-7 re-check), not the writer. ↩ ↩

Next: the quiz