
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
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).
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:
| Predicate | Meaning | Established by |
|---|---|---|
Int(R, k) ∧ Orig(R, I) | JCS(R) is unchanged since signed under key k; k is bound to issuer I | Signature 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) / Comp | Control c operates as declared across the relevant cases; the output was correct, fair or lawful; the record set is complete | Independent 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.
| Concern | Public anchor |
|---|---|
| Signed statements, relying-party trust, registration semantics | RFC 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 signing | RFC 8785 (JCS), Informational (not a standard), June 20205 |
| Verification versus validation of issuer claims | W3C VC Data Model 2.0, Recommendation, 15 May 20256 |
| A declared control that did not operate | SEC Release 34-70694 (Knight Capital), 16 October 20137 |
| Deployer answerable for an automated answer, on the facts of one claim | Moffatt v. Air Canada, 2024 BCCRT 1498 |
| The Foundation's gate, receipt and three-yes terms | Practitioner 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):
- T1 (binding):
bw-refunds-2026-11↦bw-refunds-service, from Big Widget's published key list fetched on a recorded date. - T2 (non-compromise): the private key was under the issuer's sole control up to signing time.
- T3 (registry): receipts from BW-Ledger signed with its listed key are accepted.
What the standards license
- RFC 9943 defines a Signed Statement as "an identifiable and non-repudiable Statement about an Artifact signed by an Issuer".3 Read operationally, non-repudiation is evidence against the issuer later disowning the claim, and it is only as strong as
T1 ∧ T2. It is not a truth property, and it does not attest how the statement's contents were generated. - Trust in the key is an input, not an output: a Relying Party "MUST trust the verification key or certificate and the associated identity of at least one Issuer of a Receipt".3 "It is the role of the relying party to decide which TSs and Issuers they choose to trust for their scenario."3
T1is exactly this decision, made explicit. T2can fail: "Issuers and TSs can both be compromised", and RFC 9943 leaves "Revocation strategies for compromised keys" out of scope.3 A verifier that cannot exclude compromise at signing time must stateOrigas conditional onT2, and should record the key-list fetch date it relied on.- VC 2.0 separates verification (proofs check, statement is "an authentic and current statement of the issuer or presenter") from validation, where "Verifiers trust certain issuers for certain claims and apply their own rules"; it adds that "Verification of a credential does not imply evaluation of the truth of claims encoded in the credential."6 The vocabulary transfers; R1 is not a W3C credential.
- RFC 9943 also says: "Transparency does not prevent dishonest or compromised Issuers, but it holds them accountable."3
Sorting R1's statements
| Statement | Predicate | Licensed by Verify(R1, T) = pass? |
|---|---|---|
| JCS(R1) is the byte string σ was computed over (the transmitted JSON's layout is irrelevant) | Int | Yes |
R1 was issued by bw-refunds-service | Orig | Yes, conditional on T1 ∧ T2 |
| BW-REF-3 v4 was evaluated and the refund held | Att | Only as the issuer's claim, bound to its key |
| The committed output was what the agent actually produced | Att | Only as the issuer's claim; σ authenticates the statement, not its generation |
| BW-REF-3 holds every above-limit refund | Eff | No |
The warranty-lead reviewed the claim before approving | Eff | No; approval_ref is itself attested |
| The bundle contains every receipt the service emitted | Comp | No |
| The refund was correct and fair | True | No |
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):
| Proof | Check |
|---|---|
p_sig | σ verifies over JCS(R) under a key admitted by T1 |
p_pol | policy_hash = H(bytes of the bundled policy file) |
p_chain | for every receipt in the supplied range, prev equals the hash of its predecessor, back to the bundle's declared anchor |
p_reg | a 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) =
noneif 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) = ∅.
| Case | t_claim | S | F | A | tier |
|---|---|---|---|---|---|
| M | C3 | p_sig, p_pol, p_chain | ∅ | p_reg | C2 |
| N | C2 | p_sig, p_pol, p_chain, p_reg | ∅ | ∅ | C2 (capped by claim) |
| P | C3 | p_sig, p_chain, p_reg | p_pol (bundled rule text edited) | ∅ | C1 |
| S | C2 | ∅ | 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:
- 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.
- Orthogonal to
EffandTrue. No proof in A observes control operation or output accuracy. Silent on
Comp.p_chainshows 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.Compneeds 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 noCompclaim 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.
| Event | Recorded in | Evidence type |
|---|---|---|
| Proposal | R (refunds service) | Att |
Hold (held-for-approver) | R | Att |
Approval or decline (approval_ref) | Follow-on receipt from the refunds service | Att; the human review itself is unobserved |
| Payment execution | Payments ledger, not written by the agent | Separate 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:
- Hiding requires r_x to be uniformly random, fresh per object, secret and long enough that guessing it is infeasible, and treats H as hiding its input. If r_x leaks, any low-entropy x (an amount, a short claim category) can be recovered by guessing and testing.
- Binding relies on the collision resistance of H: the issuer should not be able to open c_x to a different x′.
- Metadata leakage is outside the commitment.
time,amount_bandandapproval_ref, joined with other records, may identify a customer. Minimise their precision, makeapproval_refopaque outside Big Widget, and have the privacy owner approve the schema. No field list here is claimed to be anonymous.
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):
- keep values that must hash identically across implementations as strings or small integers (
rule_version: 4), and avoid floats in signed fields; - canonicalise before both hashing and signing, and have the verifier re-canonicalise rather than trust the transmitted bytes' layout;
- remember that JCS supplies repeatability only: no confidentiality and no truth.
Field design and the residual claim
| Field group | Purpose | Excluded alternative |
|---|---|---|
action, rule_id, rule_version, policy_hash | Bind the decision to exact rule text | Free-text policy description |
agent_version | Identify the acting system | Model name only |
input_commitment, output_commitment | Bind private content | Exported prompt and output |
amount_band | Show why the gate applied | Exact amount |
decision, approver_role, approval_ref | Gate outcome and accountable role | Approver's name |
time | Ordering at approved precision | Exact timestamp where not needed |
prev, key_id, σ | Chain, integrity, origin | — |
Residual claims R cannot carry, however well designed:
- Completeness (
Comp). R proves nothing about above-limit refunds for which no receipt was emitted.p_chaindetects gaps within the supplied range, not actions that bypassed the emitter. - Gate efficacy (
Eff).decision: held-for-approveris attested by the same system whose gate is in question. - Human review quality (
Eff).approval_refshows an approval was recorded, not that review occurred.
Each needs independent observation. The course's example uses three methods, each with a bounded scope:
- Seeded tests by someone who did not build the agent: establish
Effonly over the seeded cases and the window in which they ran. - Reconciliation of the payments ledger against the receipt chain, one-to-one by reference: establishes, for the ledger's window, that every above-limit payment recorded there has a distinct approval receipt, conditional on the ledger's independence from the agent. Its population is executed payments, not proposals; an unpaid proposal is invisible to it.
- Sampled audit of approvals against private records using the commitments: estimates review quality on the sample, with the sample size and selection stated.
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:
- Get to Yes ("before a rule or a system ships" and "before a single action runs"1): BW-REF-3 versioned and hashed; limit set;
warranty-leadnamed as the only role that releases a hold; gate outcomes from "go ahead · only this far · wait for a person · no";1 receipt schema approved by the privacy owner; T1 published by Big Widget's security lead with an effective date. - Stay at Yes ("while it runs, in real time"1): one receipt per gate decision; scheduled seeded tests and reconciliation by someone independent of the agent's builders; coverage recorded, or recorded as unknown; unanswered holds do not become approvals.
- Recover to Yes ("after — on demand, on incident"1): triggers are p_sig or p_pol failing, a reconciliation break, or suspected key compromise. Hold all above-limit proposals; the security lead withdraws T1 for the key from the suspected time and notifies relying parties, since "It is important for Issuers and TSs to clearly communicate when keys are compromised";3 the
warranty-leadre-reviews affected refunds from private records; verification is rerun under the new key. A paused agent or an announced fix is not recovery. Recovery is claimed only when fresh checks pass and both named people record it.
Summary
Verify(R, T) = pass⇒Int ∧ Origconditional on T, henceAttbound to the issuer; nothing about how R's contents were produced.36- tier(R) is computed from passing proofs and capped by the claim; absent and failed proofs are reported separately; a failed signature gives
none. Inclusion proves registration, not accuracy.34 p_chainis internal consistency, notComp.Compneeds an independent expected set matched item by item; in the course's reading, a consistency proof between trusted checkpoints4 shows the later one extends the earlier one, under the trusted log and proof assumptions, not that no event is missing.- Content-free receipts use commitments (course design, stated assumptions) over JCS-canonical objects; JCS gives repeatability only.5 Receipts never carry "prompts, outputs, payloads, personal data".2
EffandTrueneed independent observation outside R, each method bounded in scope; Knight shows the cost of controls that were declared but not linked to anything that would stop the harm.7
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.