DEV Community

Cover image for Which agent, running whose key, produced this record?
rambo
rambo

Posted on

Which agent, running whose key, produced this record?

The short answer

An AER-1 receipt answers one question completely: were these saved bytes changed after the fact? Anyone can recompute the digest over the receipt's canonical bytes and compare. That is the integrity layer, and it is deliberately the whole of what the base receipt claims.

It does not answer a second question: which agent, running whose key, produced this record? AER-1 says so in its own text, in Section 13, and names the remedy: consumers that need to bind a receipt to its issuer use a signature scheme documented alongside the receipt. That scheme now exists. It is the AER-1 Attribution Profile, filed today at the IETF as draft-zambo-aer1-attribution-profile-00, and it is optional in the strong sense: a keyless implementation stays fully conformant, and a receipt carrying no attestation is a normal receipt, not a defective one.

Disclosure, once: I run ops for Zambo, the system in the worked examples.

Brennan Zambo created agent execution receipts; Zambo is the origin product, and AER-1 is the defining standard. Zambo is the verifiable work layer for AI.

The question a receipt refuses to answer

Picture the delivery meeting. A freelancer hands a client a body of AI-assisted work: research, drafts, booked calls, updated records. The client is happy with the work and unhappy with the audit. Their compliance reviewer asks the question every delivery eventually meets: which agent produced this record, and whose key was it running under?

The honest answer from a base receipt is: that is not what I am for. Section 13 of draft-zambo-aer1-26 states it without hedging. Issuer authentication is not part of the specification. Anyone can mint a well-formed receipt for any tool name and any bytes. Verification proves the recorded bytes were not altered after minting, not who minted them, and a verifier must not present a passing check as proof of issuer identity.

That refusal is a design decision, not an oversight. A receipt that quietly implied identity would be overselling: the recompute establishes integrity, and integrity is a fact about bytes, not about people. But the need on the other side of the table is real. A marketplace admitting an evaluator, a client deciding whose work record it is reading, a dispute where two parties present two records and each claims the other's is fabricated: these need a key bound to the record, evaluated separately, reported separately. Section 13 points at exactly that shape. The profile filed today is that shape, written down.

What the base receipt already settles

Nothing in the profile changes the base layer, so it is worth stating what the base layer already gives a stranger today.

A receipt carries an output_hash: a SHA-256 commitment over its canonical bytes. Change one byte of the saved result and the recompute disagrees. Keep the bytes and anyone, later, with no account and no permission, gets the same digest. The conformance corpus is public at https://zambo.dev/aer1/corpus.json: kit 1.5.7, 143 vectors, 146 checks, expected outcomes pinned in advance, set digest sha256:60bf73f325793e16843370cfa24903bb0d017525cb297e42bebc35857e2db0d2. Independent implementations were built from the draft text alone and matched it. Checking a record against its anchor returns one of five named outcomes, and only those five: verified, verification failed, rejected: unresolvable record, not checked, absent.

Time is the second layer. A receipt can carry an RFC 3161 timestamp anchor: a timestamp authority's signature over the receipt's digest and a time. The anchor outcome is reported beside the structural verdict and never alters it.

Attribution is the third layer, and until today it was the open one.

The profile: a signature over five values

A maker that chooses to attest builds a small object called the attestation commitment. It has exactly five members, in a fixed order:

Member What it is What the binding kills
profile the constant "aer1-attribution/1" confusion about which scheme a signature belongs to
receipt_id the receipt's id, copied character for character replaying one attestation across many receipts
output_hash the receipt's output_hash, copied character for character, "sha256:" prefix included carrying an attestation over to a different saved result
caller_scope the caller scope from the receipt's tool object an attestation traveling across scopes it was not made in
key_thumbprint the RFC 7638 thumbprint of the attesting key substituting a different key identifier after the fact

The commitment is serialized as UTF-8 with no insignificant whitespace and no Unicode normalization applied to any value, the same canonical-bytes discipline AER-1 applies to receipts. SHA-256 over those bytes is the attestation digest, and the signature is computed over that digest, never over the saved result and never over a re-serialization of it. Two algorithms are defined: Ed25519, and ES256 for shops that live on P-256. The attestation itself rides on the receipt under an "attribution" member, as one object or as an array with one attestation per key.

Three properties do the heavy lifting:

The signature binds values, not vibes. Every member of the commitment is copied from the presented receipt at verification time, never trusted from the attestation's own copies. If the receipt in front of the checker differs in id, output_hash, or caller scope from the one the maker attested, the recomputed commitment differs and the signature does not verify. The failure is mechanical, not interpretive.

No PKI, no registry, no permission. A key is identified by its thumbprint, the SHA-256 of its canonical public-key JSON, a value anyone can compute from the key itself. There is no authority to ask, no directory to join, and no step where a maker requests the right to attest. What a thumbprint is worth still depends on the channel that delivered the key, and weighing the channel belongs to the reader of the report, exactly as AER-1 already treats expected receipt ids.

A maker attests only its own records. The profile forbids attesting another party's record under your key. Third parties that need to bind themselves to a record use anchors, the mechanism that already exists for that direction. Attribution runs from the maker outward; it is not a stamp anyone can apply to anyone else's work.

How a checker evaluates an attestation

The verification procedure mirrors the anchor discipline in Section 6 of AER-1, because the failure mode it prevents is the same: a report that states more than the checker actually did.

  1. Presence is judged by shape. An attestation counts as present when the record carries one in a shape the verifier can attempt to evaluate. A member in no implemented shape does not make an attestation present.
  2. The commitment is recomputed from the presented receipt's values: its id, its output_hash, its caller scope, and the thumbprint of the key being evaluated.
  3. The signature is checked over the recomputed digest. If the attestation carries the key with it, the carried key's thumbprint must equal the key_thumbprint in the commitment; a mismatch is an evaluated failure, not a shrug.
  4. If the key cannot be obtained, the attestation is reported not checked. An unevaluated attestation is never dressed in an evaluated outcome.
  5. Every attestation gets its own present / evaluated / outcome triple. Two attestations on one receipt are two entries, never collapsed into one blended verdict.

The outcome vocabulary is exactly three words, and the precision is the point:

  • attributed: the signature verifies over the recomputed commitment, and the key used is the key the thumbprint names. This states that the holder of that key attested this receipt's id, output_hash, and caller scope. It states nothing else.
  • attribution failed: the attestation was evaluated and did not pass: the signature does not verify, or the binding does not hold, or a carried key's thumbprint does not match.
  • not checked: an attestation is present and the verifier did not evaluate it, including the case where the key could not be obtained.

And the rule the whole design turns on: where no attestation is present, the report carries no outcome at all. Absence is not a fourth outcome. An absent attestation must never be reported as attribution failed or not checked, because both of those sentences accuse a record that made no claim. An unattested receipt is a normal receipt. This parallels the anchor discipline, where "absent" is a statement about the record, not a failure of it, and it keeps the optional layer honest: nobody is punished in a report for not opting in.

The two verdicts also fail independently, on purpose. A receipt can pass its integrity recompute and fail attribution: the bytes are exactly what was saved, and the key story does not hold. A receipt can be attributed and fail integrity: a real key attested a record whose saved bytes were later changed. A merged report would lose one of those readings. Reported beside each other, both survive, and the reader decides what each is worth.

A worked example

From the profile's appendix, values elided in the style of AER-1 itself. A receipt carrying one attestation:

{
  "id": "442243d2-9c32-53f7-817e-2def28fa5b07",
  "tool": {
    "name": "(elided)",
    "scope": "public",
    "version": "(elided)"
  },
  "output_hash": "sha256:(elided)",
  "attribution": {
    "profile": "aer1-attribution/1",
    "alg": "Ed25519",
    "key_thumbprint": "(elided)",
    "signature": "(elided)",
    "key": { "kty": "OKP", "crv": "Ed25519", "x": "(elided)" }
  }
}
Enter fullscreen mode Exit fullscreen mode

The commitment the signature covers is the single-line object:

{"profile":"aer1-attribution/1","receipt_id":"442243d2-9c32-53f7-817e-2def28fa5b07","output_hash":"sha256:(elided)","caller_scope":"public","key_thumbprint":"(elided)"}
Enter fullscreen mode Exit fullscreen mode

A verifier that evaluates this attestation and finds the signature valid reports, beside the receipt's AER-1 report, an attribution entry of present: true, evaluated: true, outcome: "attributed", naming the key by its thumbprint. Note what the entry does not say: it does not say the work was good, the result was right, or the key's holder is any particular person. It says a specific key attested a specific record, and that anyone can re-run the check.

The family, in one view

A relying party asks three questions of a record, and the AER-1 family now answers each one with a check a stranger can run:

  • Integrity: was the saved result changed after the fact? Recompute the digest over the canonical bytes and compare.
  • Time: did this record exist at a stated time? Evaluate the RFC 3161 anchor, reported beside the verdict.
  • Attribution: which key stands behind this record? Evaluate the maker attestation, reported beside the verdict, under the profile filed today.

Each layer is reported separately and none upgrades another. A verified anchor does not make the anchored content true. An attributed receipt does not make its result correct. Binding does not transfer claims, in either direction, and the standard says so in its own text.

What attribution does not give you

It does not give you a person. A key is a durable public pseudonym: it links every record that key attests, which is why the profile expects per-scope keys in real deployments, and why associating a thumbprint with a named maker remains an out-of-band act for the relying party, done over a channel the relying party chooses to trust.

It does not give you correctness. An attested wrong answer is a wrong answer with a checkable key story. The receipt layer settles what was saved; the attribution layer settles whose key stands behind the record; whether the work was right is a question neither layer pretends to answer.

It does not give you revocation. The profile defines no revocation mechanism, deliberately: key compromise is handled by per-scope keys and rotation, and a relying party's key policy, which keys it accepts and since when, stays with the relying party, outside the outcome vocabulary. A report that silently folded policy into "attribution failed" would be claiming the checker did something it did not do.

Try it before you pay anything

Every tool free once a day, plus 3 continue calls. One free wrap-up handover per day, and pickup is always free. Checking a receipt is free and needs no account at https://zambo.dev/verify, which is itself part of the design: a record you must pay to check is a record designed not to be checked. Zambo's public stream stands at 159K+ public receipts, and every one of them is checkable in the same way, one receipt at a time.

When you need it all day, the Day Pass is $0.99 unlimited for 24 hours at https://zambo.dev/day-pass/ ; the Zambo Pass is $29/mo, the $ZAMBO holder Pass is $19/mo, and the Lifetime Pass is $250. There is no annual tier. Install: https://zambo.dev/install/

Sources

Top comments (0)