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 · Technical gear

Reviewed and published, version 1.0.0.

Big Widget Company, its keys, the BW-Ledger registry and all cards, field names and tiers below are course-owned synthetic fixtures. They are modelled on public RFC 9943, RFC 9942, RFC 8785 and W3C VC 2.0 text, not on private One Receipt excerpts or test vectors, and they are not One Receipt conformance results or evidence about any real deployment. The runnable bundle is in bundle/. The results quoted below are the author's own run of it; they cover the synthetic exercise only, not conformance or any real control. Legal records support their own case only; nothing here is legal advice.

Scope

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).

This gear formalises what an offline verifier can conclude from a signed, content-free action record, and what it cannot. It separates three groups of predicates over a record R:

PredicateMeaningEstablished by
Int(R, k) ∧ Orig(R, I)JCS(R) is unchanged since signed under key k; k is bound to issuer ISignature verification conditional on a trust policy T (key binding, non-compromise)
Att(R)I asserts the claims in R (rule applied, decision, approver, what was committed)R itself, given Int ∧ Orig; evidence against I's later denial while T holds; not proof of the claims or of the process that produced them
Eff(c) / True(R) / CompControl c operates as declared across the relevant cases; the output was correct, fair or lawful; the record set is completeIndependent testing, sampling, reconciliation or review outside R

The core claim of the module: Verify(R, T) = pass entails Int ∧ Orig under T, and therefore Att as a claim bound to I; it entails nothing about Eff, True or Comp.

The AiGovOps Foundation's manifesto describes a gate as leaving "a signed receipt that holds no private content and that a stranger can verify offline, without an account and without trusting us."1 Its Practice site gives the receipt's contents as "hashes, decision, tier, policy hash, key id" and its exclusions as "prompts, outputs, payloads, personal data".2 We read "without trusting us" as removing reliance on the Foundation's say-so, not as removing T: a relying party still has to choose which keys to accept. The course map keeps the Foundation's draft One Receipt specification as author and checker context only (Level 500 decision 10). This gear does not quote or depend on it.

ConcernPublic anchor
Signed statements, relying-party trust, registration semanticsRFC 9943 (SCITT architecture), Standards Track, June 20263
Inclusion and consistency proofs ("receipts" in the transparency sense)RFC 9942 (COSE Receipts), Standards Track, June 20264
Deterministic JSON for hashing and signingRFC 8785 (JCS), Informational (not a standard), June 20205
Verification versus validation of issuer claimsW3C VC Data Model 2.0, Recommendation, 15 May 20256
A declared control that did not operateSEC Release 34-70694 (Knight Capital), 16 October 20137
Deployer answerable for an automated answer, on the facts of one claimMoffatt v. Air Canada, 2024 BCCRT 1498
The Foundation's gate, receipt and three-yes termsPractitioner Manifesto1; Practice home page2

Integrity and origin are conditional on a trust policy

The fixture

Synthetic receipt R1, the payload of bundle/cases/M/receipts/R1.json (course-owned; H is SHA-256, hashes shown as hex):

{
  "action": "refund.propose",
  "agent_version": "bw-refunds-agent build 2026.11.1 (fictional)",
  "amount_band": "above-limit",
  "approval_ref": "APR-0042",
  "approver_role": "warranty-lead",
  "claimed_tier": "C3",
  "decision": "held-for-approver",
  "input_commitment": "29f6add40e1157a2ccb266781c33607cce3c02f9bfa0cdd49fad55f4eb85040b",
  "issuer": "bw-refunds-service",
  "key_id": "bw-refunds-2026-11",
  "output_commitment": "9b067607c89fceb81cd7de68d6fda620e52ff5f22baa7f16e26e0610820131b3",
  "policy_hash": "18fd2565bef501be97da004f136e0f6e28397db7c9e6a8f1461167bd6a6d2572",
  "prev": "9a4206a99df233f45506e690c6493a4f528181dd37d04623047b519f2613f8d0",
  "rule_id": "BW-REF-3",
  "rule_version": 4,
  "time": "2026-11-03"
}

The signature σ is Ed25519 over JCS(R1) with the private key for bw-refunds-2026-11. time is a date only: the precision this fictional design needs. prev = H(JCS(payload of the preceding receipt)).

bundle/ holds VERIFY.md, a standard-library verifier verify.py (Ed25519 verification written out in plain Python, a JCS subset with no floats and ASCII keys only, and Merkle audit-path checking), trust/card-T.json, four cases (M, N, P, S) covering absent, passing, mismatching and bad-signature proofs, one synthetic auditor record, and MANIFEST.sha256 pinning every file. Keys were generated fresh by author/build_bundle.py and the private keys were not kept. No private vector was used. The author's run is recorded in VERIFY.md. The claimed-tier precondition below is covered by the builder's regression tests (tests/test_receipt5006.py), which are not an independent check. Any run of the shipped CLI loads Card T's synthetic keys from the handout, so a matching run does not test key discovery and is not conformance evidence or a review.

Trust policy T (course-owned; bundle/trust/card-T.json, which in real use the verifier assembles itself rather than taking from the bundle under test):

What the standards license

Sorting R1's statements

StatementPredicateLicensed by Verify(R1, T) = pass?
JCS(R1) is the byte string σ was computed over (the transmitted JSON's layout is irrelevant)IntYes
R1 was issued by bw-refunds-serviceOrigYes, conditional on T1 ∧ T2
BW-REF-3 v4 was evaluated and the refund heldAttOnly as the issuer's claim, bound to its key
The committed output was what the agent actually producedAttOnly as the issuer's claim; σ authenticates the statement, not its generation
BW-REF-3 holds every above-limit refundEffNo
The warranty-lead reviewed the claim before approvingEffNo; approval_ref is itself attested
The bundle contains every receipt the service emittedCompNo
The refund was correct and fairTrueNo

The Air Canada decision illustrates the gap between Att and True. On the facts of one small claim, the tribunal held Air Canada responsible for all information on its website, including its chatbot's answer, where that answer conflicted with the airline's own linked bereavement policy page, and found negligent misrepresentation.8 A verifiable signed transcript of that answer would have been the airline signer's attestation to the transcript, which was not the issue, and said nothing about its accuracy, which was. The decision does not describe the chatbot's architecture, it is not a general rule for all chatbots, and nothing here claims a receipt would have changed the outcome.

Verifier-computed assurance

The fictional rule card

Define a set of named proofs and a fictional tier ladder A (course-owned; not a One Receipt level, a Practice mark or a certification):

ProofCheck
p_sigσ verifies over JCS(R) under a key admitted by T1
p_polpolicy_hash = H(bytes of the bundled policy file)
p_chainfor every receipt in the supplied range, prev equals the hash of its predecessor, back to the bundle's declared anchor
p_rega BW-Ledger inclusion proof for R, verifiable under T3

P(C1) = {p_sig}, P(C2) = P(C1) ∪ {p_pol, p_chain}, P(C3) = P(C2) ∪ {p_reg}.

Each proof evaluates to one of {pass, fail, absent}. Let S, F and A be the passed, failed and absent sets, and t_claim the issuer's claimed tier. The verifier computes

tier(R) = none if p_sig ∉ S; otherwise max { t ∈ {C1, C2, C3} : t ≤ t_claim ∧ P(t) ⊆ S },

absent(R) = P(t_claim) ∩ A, failed(R) = P(t_claim) ∩ F.

All three are reported, and failed proofs are reported as findings to the record's owner, not as gaps. If p_sig fails, the verifier stops: no other field of R can be relied on. The verifier's output is a separate record; it never edits R's signed data.

Precondition: t_claim ∈ {C1, C2, C3}. The formula needs a known claimed tier to set the cap, and P(t_claim) is undefined otherwise. A receipt whose claimed tier is missing or not on the ladder is invalid input: reject it rather than assign a tier. The teaching verify.py enforces this in assess before any proof is evaluated: claimed_tier must be a string equal to C1, C2 or C3, with no case folding or trimming. Otherwise it raises, prints Rejected receipt: invalid claimed_tier: expected a string equal to C1, C2 or C3 to stderr and exits 2. Under --all, one invalid claim rejects the batch and no computed tier is printed. Exit 0 means the report ran, not that every proof passed. None of the four cases has an invalid claimed tier; VERIFY.md (step 3, "Claimed-tier precondition", and the tier-example commands under step 4) shows how to make one on a copy. The regression tests also sign malformed claims with a synthetic fixture key, so the rejection is not just a signature failure. From the repository root:

python3 -m unittest discover -s tests -p 'test_receipt5006.py'

Case M and the other cases

In the author's run (python3 verify.py --all), R1 gives S = {p_sig, p_pol, p_chain}, F = ∅, A = {p_reg}: the bundle contains no BW-Ledger proof. t_claim = C3, so tier(R1) = C2, absent(R1) = {p_reg}, failed(R1) = ∅.

Caset_claimSFAtier
MC3p_sig, p_pol, p_chain∅p_regC2
NC2p_sig, p_pol, p_chain, p_reg∅∅C2 (capped by claim)
PC3p_sig, p_chain, p_regp_pol (bundled rule text edited)∅C1
SC2∅p_sig (value changed after signing)—none

In the bundle, p_reg is the course's simplified log: a Merkle audit path from H(0x00 ‖ H(JCS(R))) to a root in a tree head that BW-Ledger signed. It is a teaching model, not an implementation of RFC 9942's encoding.

Three properties of this design, stated precisely:

  1. Monotone in passing evidence, capped by claim. Adding a passing proof can raise the tier up to t_claim; the issuer's assertion of C3 contributes nothing to S. This is the point of 500.6-b: the claimed level is an input to be tested, not an outcome.
  2. Orthogonal to Eff and True. No proof in A observes control operation or output accuracy.
  3. Silent on Comp. p_chain shows the supplied range is internally consistent relative to its anchor. It does not show the range contains every emitted receipt, and it cannot detect an action that bypassed the emitter. Comp needs an expected set E from a source outside the issuer's sole control (for example, the above-limit payments in an independent ledger for the window), and an identity-preserving match: every e ∈ E maps to a distinct receipt by reference. Equal cardinality is not enough: one omission plus one duplicate preserves |E|.

    A consistency proof is a different property. RFC 9942 lists proofs "that a database is append-only (proof of consistency)" alongside inclusion proofs.4 In the course's reading, such a proof between two trusted checkpoints shows that the later checkpoint extends the earlier one, under the trusted log key and proof assumptions. It compares those two states only: by itself it does not rule out a split view shown to other verifiers or changes outside those checkpoints. It says nothing about events that never produced a log entry, so it does not bound Comp. Case M supplies no E, so no Comp claim is made.

What p_reg actually proves

RFC 9942: "CBOR Object Signing and Encryption (COSE) Receipts prove properties of a Verifiable Data Structure (VDS) to a verifier", including "proofs that a document is in a database (proof of inclusion)".4 RFC 9943: "A Receipt is a signature over one or more VDP that a Signed Statement is registered in the VDS", and "It is universally verifiable without online access to the TS."3

Registration may involve policy checks: a Registration Policy is "the precondition enforced by the TS before registering a Signed Statement".3 But RFC 9943 is explicit about accuracy: "registering a Statement only proves it was produced by an Issuer."3 So p_reg buys inclusion of R in the log state the proof is against, under T3, plus whatever the registry's published policy checked. A single inclusion proof does not by itself establish that the registry presented the same log to every verifier; that needs consistency proofs between trusted checkpoints and some way to compare what different verifiers saw, which this module does not cover. Nor does p_reg strengthen Orig beyond what T1 ∧ T2 already give. It is not certification of R's content.

Terminology clash: a COSE/SCITT Receipt is an inclusion proof about a log entry; the course's receipt is the signed event record R itself.4 In Case M, the absent artefact is the former.

Content-free evidence for a consequential action

Proposal, hold, approval, execution

The agent emits refund.propose; it has no payment capability. The manifesto's rule, "No direct model-to-tool path for consequential actions",1 is met here by routing every above-limit proposal through the gate and the warranty-lead.

EventRecorded inEvidence type
ProposalR (refunds service)Att
Hold (held-for-approver)RAtt
Approval or decline (approval_ref)Follow-on receipt from the refunds serviceAtt; the human review itself is unobserved
Payment executionPayments ledger, not written by the agentSeparate record; independent only if its operators are

Commitments

For each private object x (the claim record, the proposed refund), the course design stores in R

c_x = H(r_x ‖ JCS(x)),

where r_x is a random value retained, with x, in Big Widget's private service record. An authorised auditor holding (x, r_x) recomputes c_x and checks equality, binding the private record to the signed event without publishing it. In the bundle, verify.py --open does this for R1's input with the synthetic (x, r_x) in auditor-only/; in real use that pair never travels with the receipt.

The properties depend on assumptions this module states but does not derive or cite:

The further-learning courses below treat these properties formally; they are optional and nothing here depends on them.

Canonicalisation

Both σ and every c_x depend on byte-exact serialisation. RFC 8785, an Informational RFC rather than a standard: "Cryptographic operations like hashing and signing need the data to be expressed in an invariant format so that the operations are reliably repeatable."5 JCS requires that "JSON object properties MUST be sorted recursively", comparing code units "treated as unsigned integers, independent of locale settings", and serialises numbers according to ECMA-262 Section 7.1.12.1.5 Practical consequences for the receipt schema (the course's guidance):

Field design and the residual claim

Field groupPurposeExcluded alternative
action, rule_id, rule_version, policy_hashBind the decision to exact rule textFree-text policy description
agent_versionIdentify the acting systemModel name only
input_commitment, output_commitmentBind private contentExported prompt and output
amount_bandShow why the gate appliedExact amount
decision, approver_role, approval_refGate outcome and accountable roleApprover's name
timeOrdering at approved precisionExact timestamp where not needed
prev, key_id, σChain, integrity, origin—

Residual claims R cannot carry, however well designed:

  1. Completeness (Comp). R proves nothing about above-limit refunds for which no receipt was emitted. p_chain detects gaps within the supplied range, not actions that bypassed the emitter.
  2. Gate efficacy (Eff). decision: held-for-approver is attested by the same system whose gate is in question.
  3. Human review quality (Eff). approval_ref shows an approval was recorded, not that review occurred.

Each needs independent observation. The course's example uses three methods, each with a bounded scope:

None establishes a universal claim about future refunds. The output is a dated, scoped coverage statement, which is what the manifesto's checklist asks for: "I know my system's coverage number, or I know that I do not."1

The Knight order is the canonical illustration of declared-but-inoperative controls. Knight assigned a $2 million gross position limit to an account but "did not link this account to any automated controls concerning Knight's overall financial exposure"; it lacked "a control to compare orders leaving SMARS with those that entered it"; its primary monitoring tool "relied entirely on human monitoring"; 97 automated e-mails referencing the error were not designed as alerts and were generally not reviewed.7 A deployment missed one of eight servers, with no second-technician review and no written procedure requiring one.7 Rule 15c3-5(e) requires a system "for regularly reviewing the effectiveness" of the controls, distinct from documenting them.7 The order records findings in a settled proceeding that Knight neither admitted nor denied, except as to jurisdiction; it imposed a $12 million civil penalty and Knight undertook to retain independent consultants.7 The analogy to reconciliation is the course's: a receipt chain reconciled against an independent ledger is an Eff test; the chain alone is not. The order does not mention seeded tests. It is a 2012 software case, not a generative-AI case, and no claim is made that receipts would have prevented it.

The three yeses as verifier obligations

The manifesto maps its gates to timing.1 Applied to Big Widget's refund receipts:

Summary

Further learning (not cited, not required; nothing in this gear depends on them): MIT OpenCourseWare 6.858 Computer Systems Security (Fall 2014; threat models, capabilities, information flow) and University of Cambridge Cryptography (2025–2026; signatures, hash functions, Merkle trees, commitment protocols). 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. 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. ↩ ↩ ↩ ↩ ↩ ↩ ↩ ↩ ↩ ↩ ↩ ↩
  4. 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. ↩ ↩ ↩ ↩ ↩ ↩
  5. 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. ↩ ↩ ↩ ↩
  6. 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. ↩ ↩ ↩
  7. 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. ↩ ↩ ↩ ↩ ↩ ↩
  8. 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. ↩ ↩

Next: the quiz