Signed Permissions and Action Receipts for Automated Agents

]> Signed Permissions and Action Receipts for Automated Agents

hello@prova.red

Security AI agent authorization evidence delegation receipt transparency log post-quantum This document specifies records with which a third party can establish, later and without network access, what an automated agent, such as an artificial intelligence (AI) agent, was permitted to do and what it recorded doing. The person for whom the agent acts, the principal, signs a permission with a passkey; the permission carries limits that a verifier can check mechanically. The agent signs a receipt for each action with Ed25519 and the Module-Lattice-Based Digital Signature Algorithm (ML-DSA-87). Receipts are chained and entered in a log whose signed tree heads are time-stamped. A verifier reports, separately, whether the records are sound and whether each recorded action stayed within its permission. The content of each record is specified independently of its encoding; one encoding, JSON Web Signature (JWS) over canonical JavaScript Object Notation (JSON), is defined. Note to Readers Note to the RFC Editor: please remove this note before publication. What this document adds to other work is stated in . This revision defines an executor () and states when its records show a receipt that was never written (); no record changes. lists the changes since -01, and those since -00. The spelling "acknowledgement" is kept throughout, in prose as well as in identifiers, because it is the format's own label ("provared.acknowledgement.v0"). This document was announced on the audit@ietf.org list, where the proposed Agent Use of Delegation and Interaction Traceability (AUDIT) working group is discussed. While that group is being formed, detailed comments are welcome in writing: by email to the author, or as issues at https://github.com/provared/provared/issues.

Introduction A principal signs a permission for an agent: which actions, with which services, within which limits, from when until when. The agent signs a receipt for each action it takes; a service may countersign it. A recorder appends receipts to a log and periodically signs its tree head, which a Time-Stamping Authority (TSA) time-stamps. Later, with no network access, a verifier checks the records and answers three separate questions: whether the records are sound, whether every signature could be verified on that device, and whether each recorded action stayed within its permission. This document specifies the records and the verifier's rules: evidence, not enforcement. Nothing in this document stops an action when it is attempted, and an action for which no receipt was written leaves no trace in the agent's own log (). It names the role of an enforcement point that refuses an action before it takes effect, an executor (), but does not specify how an executor decides or keeps its records, how records are carried, how keys and trust anchors are distributed, or what to do about a finding (). When an automated agent acts for a person, the questions asked afterward are the same: was the action authorized, by whom, within what limits, did the other party agree, and when? Authorization protocols answer at the moment of a request, typically with tokens that are not kept as evidence. This document specifies records that a third party can verify later, without network access. Each record is signed by the party that made it. Whoever keeps the log can still leave out or delay entries; states how far that reaches. The content model ( through ) says what each record holds, who signs it, and how a verifier judges it, apart from how records are written as bytes. This document defines one encoding (): JSON Web Signature (JWS) over JavaScript Object Notation (JSON) in one canonical form ; states what another encoding, such as one with Concise Binary Object Representation (CBOR) Object Signing and Encryption (COSE), has to define. Logs use the Merkle tree of , and time-stamps come from a TSA . Agents sign with Ed25519 and the Module-Lattice-Based Digital Signature Algorithm ML-DSA-87 side by side; a signed tree head adds the Stateless Hash-Based Digital Signature Algorithm SLH-DSA . Other drafts () already have principal-signed authorizations, signed and hash-chained receipts for each action, passkey approval of one exact action, signed budgets enforced when an action is attempted, a cumulative limit checked afterward against the amounts that a decision point recorded, and delegation that only narrows. This document adds three things. First, the permission that the principal signs with a passkey carries limits that a verifier can check mechanically (totals, single amounts, counts, and totals or counts within a rolling period) and conditions (the other party's countersignature, or the principal's approval of one action). Second, a cancellation can be acknowledged by the agent. Third, it specifies a verifier that adds up the signed receipts themselves and says, from the records alone and after the fact, whether each recorded action, including a helper agent's, stayed within the permission. The records are evidence, not a verdict: a sound record can show an agent acting outside its permission. This document is the core of a published format description ; lists the parts specified only there.

Conventions and Terminology The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in BCP 14 when, and only when, they appear in all capitals, as shown here. The identifiers that uses in labels and member names are given in parentheses after each term.

Principal:: The person who signs a permission with a passkey ("issuer").
Passkey:: A credential in a device, unlocked by user verification such as a biometric or a personal identification number (PIN).
Agent:: Software that acts for the principal. It deals with services, which may countersign its receipts.
Helper agent, or helper:: An agent that acts under a delegation ().
Service:: The other party to an action, named in a permission's "with"; it may countersign ().
Executor:: Software, other than the agent, that takes actions for the agent or holds what they need, such as a credential, and refuses an action that its check of the permission does not allow; specifies one such check (). A permission names an executor in "with", as it names a service; to countersign, the executor needs its key set there ().
Permission:: The principal's signed statement of which agent may do what, within which limits, with whom, and when ("slip").
Action receipt, or receipt:: The agent's signed statement that it took one action ("stub"). It is not a Receipt in the sense of Supply Chain Integrity, Transparency, and Trust (SCITT) ().
Delegation:: An agent's signed hand-over of part of its permission ("pass").
Record:: A signed statement of one of the eight kinds of .
Log:: A sequence of entries, only ever added to ("book").
Entry:: One record together with what is carried beside it, as one element of a log ().
Recorder:: Whoever keeps a log.
Signed tree head, or head:: The recorder's signed statement of a log's size and root ("seal").
Chain:: The receipts of one agent under one permission or one delegation, each naming the one before ().
Verifier:: Anyone, or any software, that verifies records ("checker").
Core verifier:: A verifier that implements this document and none of the parts specified only in ().
Digest:: The SHA-256 hash of some bytes.
Encoding:: How records, keys, and logs are written as bytes and how signatures are carried (, ).
Problem:: A reason why an entry, or the log, cannot be relied on.
Sound:: Of an entry or a log: having no problem.
Finding:: A statement that a sound receipt or delegation lies outside its permission. A finding is not a problem.
Compared:: Of a receipt or delegation: judged against its permission ().
Counted:: Of a time-stamp: from a trusted TSA, on a record whose signatures were all verified ().
Intact:: Of a log: no problem was found and everything was verified ().

The base64url encoding is that of , without padding. Where a rule is followed by a code in parentheses, such as "(chain-broken)", an entry that breaks the rule has a problem. A verifier MUST report that code for it, unless it stopped at an earlier problem of the same entry (). Every finding of a compared receipt or delegation is reported: each code once, except over-period-limit, which is reported once for each period limit exceeded. lists the codes.

Overview and Example Once the principal has signed a permission, the agent signs a receipt for each action, naming the permission and the receipt before it. The recorder writes each receipt, with any countersignature and approval, as one log entry, and periodically appends a time-stamped signed tree head. This example follows the demonstration published with ; the parties and orders are invented. An office agent may order supplies up to 200 GBP in total and 100 GBP for one order, and send two messages in any hour. Every order needs the supplier's countersignature, and an order above 60 GBP the principal's approval. The permission's content is shown in the JSON encoding (), with spaces and line breaks added, and values abbreviated: ", ""], "name": "Agent"}, "id": "", "issuer": {"key": "", "name": "A. Person", "origin": "https://sign.example.org", "rpId": "example.org"}, "limits": [ {"action": "supplies.order", "max": 200, "unit": "GBP"}, {"action": "supplies.order", "each": 100, "unit": "GBP"}, {"action": "message.send", "count": 2, "per": 3600}], "never": ["destroys", "impersonate"], "purpose": "Keep the office stocked with paper and toner.", "requires": [ {"action": "supplies.order", "need": "countersignature"}, {"above": 60, "action": "supplies.order", "need": "approval", "unit": "GBP"}], "type": "provared.slip.v0", "validFrom": "2026-10-05T09:00:00Z", "validUntil": "2026-10-12T09:00:00Z", "with": [{"id": "supplier", "keys": ["", ""], "name": "Example Stationery"}]} ]]> The log then holds these entries ("receipt n" has "seq" n; "cs" is a countersignature): The content of the receipt at entry 5, shown across lines, is: ","previous":"", "seq":4,"slip":"", "type":"provared.stub.v0","when":"2026-10-05T09:40:00Z", "with":"supplier"} ]]> The countersignature at entry 5 has the content {"stub": "<digest of the receipt at 5>", "type": "provared.countersignature.v0", "when": "2026-10-05T09:40:12Z"}. Given the thumbprint of the principal's passkey, the digest of the recorder's key set, and the digest of the TSA's certificate (), a verifier finds no problem and verifies every signature: the log is intact. It reports that the agent did not stay within its permission, at entries 4 and 5.

Common Rules through are the content model; is the JSON encoding. Maps are written here as in JSON: {"unit", "value"} is a map with exactly those two members.

Records and Signers A record is of one of eight kinds. Each is signed by one party, with these methods, in this order; X is the identifier of the kind in the labels of : Kinds of record and their signers

Kind of record	X	Signed with
Permission	slip	the principal's passkey ()
Action receipt	stub	Ed25519, ML-DSA-87
Countersignature	countersignature	Ed25519, ML-DSA-87
Approval	approval	the principal's passkey
Delegation	pass	Ed25519, ML-DSA-87
Cancellation	cancellation	the principal's passkey
Acknowledgement	acknowledgement	Ed25519, ML-DSA-87
Signed tree head	seal	Ed25519, ML-DSA-87, SLH-DSA-SHA2-256s

The content of a record holds a member "type" whose value is "provared.X.v0". Every signature of a record covers its kind as well as its content, so that a signature made for one kind of record is not accepted as a signature on another; the encoding says how (). The suffix "v0" marks this draft, so that a record of a later, frozen version is distinguished from a draft one.

Content The content of a record is a map from member names, which are text, to values. A value is a map of the same kind, a list of values, text, an integer from 0 to 2^53 - 1, or one of the values of . There are no others: no true, false, or null, no fractions, and no negative numbers. Text is a sequence of Unicode scalar values; its length is counted in code points. The encoding writes the content in one form, which a verifier tests. "type" MUST match the kind of record that the encoding labels (payload-type-mismatch). A map MUST hold exactly the members listed for it, each in its stated form (bad-field).

Values

Bytes:: A sequence of bytes, of the length stated for each member. Identifiers, digests, and the parts of keys are bytes.
Identifier:: An "id" is 16 random bytes. No two records in a log hold the same "id" (duplicate-id).
Time:: A date and time in Coordinated Universal Time (UTC), to the second, with no fraction and no offset. It MUST denote a moment that exists: 29 February in a year that is not a leap year, an hour of 24, and a second of 60 are refused (bad-field).
Digests:: A digest is 32 bytes. A record's digest is that of its content, in the bytes that the encoding writes and that its signatures cover; it covers no signature. Records name one another by it. A "sha256" member holds a document's digest: records never hold documents.
Name:: Text of 1 to 200 code points, chosen by the writer. Except for the reserved names of documents (), a name is not checked against anything.
Amount:: Exactly {"unit", "value"}, where "value" is an integer and the unit is 1 to 16 ASCII letters, digits, ".", "-", or "_", beginning with a letter or digit.

Keys A key is a public key of one of these methods, and of no other (bad-key):

Ed25519:: 32 bytes ().
ML-DSA-87:: 2,592 bytes ().
SLH-DSA-SHA2-256s:: 64 bytes ().
ES256:: A P-256 public key, two coordinates of 32 bytes ().
RS256:: An RSA modulus of 2,048 to 8,192 bits, with the public exponent 65,537 ().

The key set of an agent or a service is exactly one Ed25519 key followed by one ML-DSA-87 key. A recorder's key set adds one SLH-DSA-SHA2-256s key. A principal's passkey is one ES256, RS256, or Ed25519 key. An Ed25519 key, wherever it appears, MUST NOT encode a y-coordinate greater than or equal to p = 2^255 - 19, and MUST NOT encode the y-coordinate of any of the eight points of small order, whatever the sign bit (bad-key). With a key of small order, anyone can produce a signature that verifies; a y-coordinate of p or more gives one point two encodings. requires the first check () but not the second, and libraries differ on both, so a verifier performs both itself. A verifier is told which principals it trusts by the thumbprints of their passkeys, and which recorders it trusts by the digests of their key sets. The encoding defines both ().

Hybrid Signatures A receipt, a countersignature, a delegation, and an acknowledgement carry two signatures over the same content, in this order: first Ed25519 (), verified as requires; then ML-DSA-87, the pure (not pre-hashed) ML-DSA.Verify of with an empty context, as requires. A signed tree head carries a third: SLH-DSA-SHA2-256s, the pure slh_verify of with an empty context. An empty context is the zero-length string, not a single zero byte. Each signature is over its own signing input, which the encoding defines and which covers the kind of record (). Each is verified with the key at the same position in the applicable key set: the agent's or a service's keys in the permission, a helper's keys in its delegation, or the recorder's keys in the head. Every signature MUST verify; a signature that fails is a problem (signature-invalid). A signature is exactly 64 bytes (Ed25519), 4,627 bytes (ML-DSA-87), or 29,792 bytes (SLH-DSA-SHA2-256s). An Ed25519, ML-DSA-87, or SLH-DSA-SHA2-256s signature of any other length is a problem (signature-invalid) on every verifier, whether or not the verifier implements the method. This rule covers every signature of a record, a passkey's Ed25519 signature included; it does not reach a TSA's signature inside a time-stamp (). A signature of the right length whose algorithm the verifier lacks is not verified (). An entry none of whose signatures was verified is not evidence: what it says MUST NOT be shown as fact.

Ed25519 Verification leaves some verification choices to implementations, and implementations that choose differently accept different sets of signatures. With public key A, signature halves R and S, message M, base point B, group order L, and n*P for the point P multiplied by the integer n, a verifier MUST:

refuse S unless, read as a little-endian integer, it is less than L;
refuse A or R unless it decodes to a point on the curve, which includes refusing an encoded y of p or more ();
refuse A or R of small order, that is, one of the eight points whose order divides 8, including the identity element; and
accept only if S*B = R + k*A, where k is the SHA-512 hash of the 32-byte encoding of R, then the 32-byte encoding of A, then M, read as a little-endian integer and reduced modulo L before the multiplication. Comparing the encoding of S*B - k*A with the 32 bytes of R is the same test, since rule 2 makes R's encoding unique. A signature that satisfies only the equation multiplied by the cofactor 8, 8*S*B = 8*R + 8*k*A, is refused.

Rules 1 and 2 restate ; rules 3 and 4 choose where it leaves choices. These rules apply to every Ed25519 signature, a passkey's included; a key whose point is the sum of a point of large order and a point of small order (a mixed-order key) is not refused by these rules.

Passkey Signatures A permission, an approval, and a cancellation carry one signature by the principal's passkey. To sign, the signer requests an assertion from the passkey with user verification "required". The challenge is the SHA-256 hash of the record's signing input, which the encoding defines and which covers the record's kind and content. The record carries the authenticator data, the client data, and the signature exactly as the passkey returned them (). A verifier checks the signature against the "key", "rpId", and "origin" of the "issuer" of the permission concerned. It follows as far as it applies to a later check with no state, and MUST confirm that:

the client data is UTF-8 with no byte order mark and is a JSON object, read by a JSON parser: white space and member order are not constrained, and a repeated member is read as its last occurrence (passkey-bad-data);
its "type" is "webauthn.get" (passkey-wrong-type);
its "challenge" is the base64url of the SHA-256 hash of the record's signing input (passkey-challenge-mismatch);
its "origin" is the same string as the issuer's, and "crossOrigin" is not the JSON value true (passkey-origin-mismatch); other members are not used;
the authenticator data is at least 37 bytes (passkey-bad-data) and begins with the SHA-256 hash of "rpId" (passkey-rpid-mismatch);
its flags have "user present" (bit 0) and "user verified" (bit 2) set (passkey-user-not-present, passkey-user-not-verified) and "attested credential data" (bit 6) clear. Without "extension data" (bit 7), the authenticator data is exactly 37 bytes (passkey-bad-data). Other flags and any further bytes are not examined; in particular, the rule that "backup state" (bit 4) is clear whenever "backup eligible" (bit 3) is clear is not checked; and
the signature verifies over the authenticator data followed by the SHA-256 hash of the client data (signature-invalid). An ES256 signature is an Elliptic Curve Digital Signature Algorithm (ECDSA) signature () stored as an ECDSA-Sig-Value in strict Distinguished Encoding Rules (DER) : one SEQUENCE with a one-byte length, holding two positive INTEGERs of 1 to 33 bytes in their shortest form, with nothing after them (passkey-bad-data). Either value of s that verifies is accepted. An RS256 signature is as .

The signature counter, the credential identifier, and the user handle are not used. For an approval or a cancellation, a failure is reported as approval-invalid or cancellation-invalid. If the verifier was given thumbprints of trusted passkeys, the issuer's key MUST be one (issuer-not-expected); if it was given none, it MUST say that the key was not compared with a trusted key. The "rpId" and "origin" of the issuer are part of what a verifier trusts, not only the thumbprint ().

Records Relied On An entry that relies on another record names it by its digest. The named record MUST be earlier in the log and sound; otherwise the entry has a problem:

slip-missing or slip-unusable, for a permission that is missing or not sound;
pass-missing, for a delegation that is missing or not sound, or pass-mismatch for a delegation under another permission; and
cancellation-not-found, for a cancellation.

A permission or a delegation is judged as it stood when it was itself read. A problem that a later entry adds to it (dated-after-stamp, ) changes nothing for the entries that rely on it, though it remains a problem of the log. A cancellation named by an acknowledgement is judged again once the whole log has been read; if it has a problem then, the acknowledgement is reported cancellation-not-found.

The Permission A permission's content holds exactly these members, all of them required except "passes":

"type":: "provared.slip.v0"
"id":: An identifier.
"issuer":: The principal: exactly "key", "name", "origin", and "rpId", as specified below.
"agent":: Exactly "keys" (a key set) and "name", and optionally "software": 1 to 16 maps {"name", "sha256"}, digests of the program and settings the principal approved. It is a statement, not proof of what ran.
"actions":: 1 to 64 action names, none repeated.
"limits":: 0 to 64 limits ().
"requires":: 0 to 64 conditions ().
"never":: 0 to 16 names, none repeated ().
"with":: 0 to 64 services, {"id", "name"} or {"id", "keys", "name"}; "id" has the form of an action name, may begin "provared.", and is unique. A service with no "keys" cannot countersign.
"passes":: An integer from 1 to 10 ().
"validFrom", "validUntil":: Times; "validUntil" is later than "validFrom". The permission covers "validFrom" up to, but not including, "validUntil".
"purpose":: Text of 1 to 1,000 code points.

"rpId" is the WebAuthn Relying Party Identifier (RP ID): 1 to 253 lower-case ASCII letters, digits, ".", and "-", beginning and ending with a letter or a digit. The member "origin" is at most 300 characters and MUST have the following form (bad-field). It is the form in which a browser serializes the origin of a site named by a domain name (), and a verifier can check it without a parser of web addresses and without Unicode tables:

the scheme, which MUST be "https", or "http" only with the host "localhost";
"://";
the host: 1 to 253 characters, made of labels separated by ".", each label 1 to 63 lower-case ASCII letters, digits, and "-", neither beginning nor ending with "-", and the last label not all digits; a name in another script appears in its "xn--" form and is taken as it is; and
optionally ":" followed by a port, only where the port is not the scheme's default (443 for "https", 80 for "http"), in digits with no leading zero, from 1 to 65,535.

Nothing else may follow. The host MUST be "rpId" or end with "." followed by "rpId". An action name is 1 to 64 lower-case ASCII letters, digits, ".", "-", and "_", beginning with a letter or a digit. Names are compared exactly. Names beginning "provared." are reserved for the shared list of , and an action name that begins so MUST be on it (bad-field). Any other member is a problem for a core verifier (bad-field); this includes the members by which covers fields ().

Limits, Conditions, and Prohibitions A limit names an "action" from "actions" (bad-field) and holds exactly one of "max", "each", and "count": = 1) {"action","max","per","unit"} as "max", within any period of "per" seconds {"action","count","per"} as "count", within any period of "per" seconds ]]> "per" is from 1 to 31,622,400 seconds (366 days). Two limits MUST NOT agree in all three of: "action"; which of "max", "each", or "count" they hold; and "per", or its absence (bad-field). Every "unit" named for one action, in limits and conditions, MUST be the same: a receipt gives one amount. A condition is {"need": "countersignature"} or {"need": "approval"}. It may hold "action", which MUST be one of "actions" (bad-field); without it, the condition applies to every action. The members "above" and "unit" are either both present or both absent, and are present only together with "action"; they restrict the condition to amounts greater than "above" in that unit. Two conditions MUST NOT have the same "need" together with the same "action", or the same "need" and both without "action" (bad-field). The need "countersignature" asks for the service's countersignature (); "approval" asks for the principal's approval. "never" names kinds of action and rules of conduct from . A permission MUST NOT allow, in "actions", a shared action of a kind that its "never" names (bad-field). A rule of conduct is the principal's signed instruction; no check of a record shows that it was kept.

Action Receipts A receipt's content holds exactly:

"type":: "provared.stub.v0"
"id":: An identifier.
"slip":: The digest of the permission.
"seq":: Its place in its chain, from 0.
"previous":: The digest of the receipt before it; present if and only if "seq" is not 0.
"action":: An action name.
"amount":: Optional: an amount.
"with":: Optional: the "id" of a service.
"details":: Optional: 1 to 32 maps {"name", "sha256"}, the documents involved.
"approval":: Optional: the digest of an approval.
"pass":: Optional: the digest of the delegation a helper acts under.
"terms":: Optional, with "with": the digest of a service's terms .
"when":: The time of the action, as the agent states it.

Document names that begin "provared." are reserved. In a receipt's or an approval's "details", a name that begins so MUST be one of the seven names of : "provared.arguments", "provared.http-request", "provared.http-response", "provared.trace-id", "provared.request-id", "provared.event-id", or "provared.error" (bad-field). Of these, only "provared.trace-id", "provared.request-id", and "provared.event-id" may be named more than once in one record (bad-field). states the exact text whose digest each reserved name carries; a core verifier checks the names, not the digests. The permission and any delegation named are records relied on (). Both signatures MUST verify with the agent's keys or, for a helper, with the "to" keys of its delegation (signature-invalid). A core verifier accepts no terms entry, so it reports a receipt that holds "terms" as terms-not-found. The receipts of the permission's own agent form one chain, and those under each delegation another. In each chain, in log order, the first has "seq" 0. Each later one has the next "seq" and names the one before in "previous" (chain-broken), and is not dated before it (time-went-backwards). A receipt with a problem keeps its place in its chain, provided its content could be read and the records it relies on were found: the next receipt is checked against it. So one break is reported once. A countersignature has exactly the content {"stub": the receipt's digest, "type": "provared.countersignature.v0", "when": a time}, and states that the action took place with the service. It is carried in the receipt's log entry and signed with the key set the permission gives for the service the receipt names in "with". A verifier MUST confirm "stub" (countersignature-wrong-stub), that such keys exist (countersignature-not-possible), and both signatures (countersignature-invalid). A receipt without a countersignature is one-sided. This is a reported state, not a problem: such a receipt shows only what the agent stated. Where an executor () is to countersign, a receipt names the executor in "with", since a countersignature is verified with the keys that the permission gives for the service the receipt names. The party beyond the executor, if there is one, is then not named in "with", and the permission's "with" does not limit which such parties the agent deals with; a reserved document name such as "provared.http-request" can bind the receipt to the call the executor made. Where that party countersigns instead, the receipt names it, and the executor is not named. An approval is the principal's approval of exactly one action. Its content holds exactly "type" ("provared.approval.v0"), "id", "slip", "action", and "when", and optionally "amount", "with", and "details". It is signed with the permission's passkey and carried in the receipt's entry, and the receipt names it by its digest. The receipt MUST name the approval in its entry (approval-mismatch), and an approval it names MUST be there (approval-not-found). The approval's "slip", "action", "amount", "with", and "details" MUST match the receipt's, each present in both or neither (approval-mismatch). Its "id" MUST NOT be that of an approval in an earlier entry (approval-reused) or of another record (duplicate-id). Its passkey signature MUST verify against the permission's "issuer" (approval-invalid). It MUST NOT be dated more than 300 seconds after the receipt, which was signed after it (approval-dated-after-stub). An approval shows that the passkey approved the action, not that the principal read it.

Delegation "passes" says how many times in a row a permission may be delegated: 1 lets its agent delegate to a helper, 2 lets that helper delegate once more, up to 10. Without it, a permission may not be delegated. A delegation's content holds exactly:

"type":: "provared.pass.v0"
"id":: An identifier.
"slip":: The permission's digest.
"from":: The digest of the delegation its writer acts under; absent when the writer is the permission's own agent.
"to":: The helper: exactly {"keys": key set, "name": name}.
"actions":: As in a permission.
"limits":: As in a permission, naming only these "actions".
"validFrom", "validUntil":: Its validity, as in a permission.
"when":: When it was written.

It is signed by its writer: with the agent's keys or, with "from", the "to" keys of that delegation (signature-invalid). The permission and the delegation in "from" are records relied on (). Its depth is 1 without "from", otherwise one more than that of "from"; a depth above 10 is a problem (pass-too-deep). A verifier reports these findings for a delegation:

pass-not-allowed, if its depth exceeds "passes" (taken as 0 when "passes" is absent);
pass-wider, if any of its "actions" is not among its writer's, or its validity begins earlier or ends later than its writer's;
outside-valid-time, if "when" is outside its writer's validity; and
after-cancellation, as sets out.

"Its writer's" means the permission's, or, with "from", the delegation's named there. A receipt under a delegation is compared with the permission exactly as the agent's own receipts are, and shares their totals, conditions, and "never". It is also compared with its own delegation and with every delegation above it, each treated as a permission for its "actions", "limits", and validity; the totals of a delegation include everything done under delegations from it. A finding code already reported for a receipt is not repeated. Every receipt under a delegation reported pass-not-allowed, or under a delegation below it, is reported pass-not-allowed. Because the limits of the permission and of every delegation above always apply, a delegation never widens what the verifier accepts as within the permission.

Cancellation and Acknowledgement A cancellation has exactly the content {"id", "slip", "type": "provared.cancellation.v0", "when"}, and is signed with the permission's passkey and verified against its "issuer" (cancellation-invalid); the permission is a record relied on (). Its entry may hold "stamps" over its digest (), which the principal can obtain at once. The effective cancellation of a permission is the first cancellation of it in the log that is sound when read and whose passkey signature, and that of its permission, were verified. Every receipt and delegation under the permission that follows the effective cancellation in the log is reported after-cancellation. adds a stricter rule for a time-stamped cancellation. A receipt before it in the log is also reported, unless a time-stamp on an earlier head shows that the receipt existed by the cancellation's time, within 300 seconds. This document does not specify that rule (). Without that rule, a core verifier can miss receipts made after a cancellation. A cancellation does not show that the agent was told; an acknowledgement is the agent's signed statement that it was. Its content holds exactly "cancellation" (a digest), "id", "slip", "type" ("provared.acknowledgement.v0"), and "when", and optionally "pass". It is signed with the agent's keys or a helper's (signature-invalid). The permission, any delegation named, and the cancellation, which MUST cancel the same permission (cancellation-not-found), are records relied on (). An acknowledgement changes no finding, and its "when" is not compared with the cancellation's; its signer SHOULD NOT date it before the last receipt or delegation its agent wrote. sets out how a verifier uses it with the principal's own copy.

Logs, Signed Tree Heads, and Time-Stamps

The Log A log is a sequence of entries, numbered from 0. Each entry holds one record, with what is carried beside it: a permission; an action receipt, optionally with a countersignature and an approval; a delegation; a cancellation, optionally with time-stamps; an acknowledgement; or a signed tree head, optionally with time-stamps. Any other entry is a problem (unknown-entry). A core verifier reports the four further kinds of ("refusal", "terms", "vouching", "withdrawal") in the same way, and so never calls such a log intact. The same permission MUST NOT appear twice (duplicate-slip), nor the same delegation (duplicate-id). A log MUST NOT exceed 100,000 entries (too-large). gives the form of a log in the JSON encoding. The leaves of the tree are the entries as the encoding writes them, in log order; the root is the Merkle Tree Hash of with SHA-256. Inclusion and consistency proofs are checked against a size as well as a root, so the two are kept together. A verifier given a root or a size to expect MUST compare it (root-mismatch).

Signed Tree Heads A signed tree head's content holds exactly "type" ("provared.seal.v0"), "id", "by" (exactly {"keys": the recorder's key set, "name"}), "size" (at least 1), "root", "previous" (the previous head's digest, absent for the first), and "when". A head is signed with the three keys in "by" and appended as the next entry, so each head covers those before it. A verifier holding the whole log MUST confirm that:

the three signatures verify (signature-invalid);
"size" is its own place in the log, and "root" the root of the entries before it (seal-mismatch);
"previous" names the nearest earlier head, or is absent if there is none (seal-chain-broken);
"when" is not before that head's (time-went-backwards); and
if given digests of trusted recorders' key sets, that of "by.keys" is one (sealer-not-expected); if given none, it MUST say that the keys were not compared with trusted keys.

adds rules that compare a head's "when" with the times its entries state and with earlier heads' time-stamps (time-went-backwards). This document does not specify them ().

Time-Stamps "stamps" holds 1 to 4 time-stamps, none repeated. A time-stamp is either an TimeStampToken or a block time-stamp of . A TimeStampToken is at most 12,288 bytes; its "messageImprint" has the hashAlgorithm SHA-256 and a hashedMessage equal to the 32 bytes of the record's digest, not hashed again. A block time-stamp holds exactly "block" and "proof", both bytes (); a core verifier does not count it, and so answers no to the second question of . Time-stamps are read only if none of the record's own signatures failed. A verifier MUST confirm that:

the token is one element with nothing after it, laid out as and require: signed data of version 3 with exactly one signer, of version 1 or 3, enclosing a TSTInfo of version 1 (stamp-bad-data);
it meets these rules of DER (stamp-bad-data):
- definite lengths in their shortest form, with a length field of at most four bytes, and single-byte tags;
- every constructed element exactly filled by its parts;
- every INTEGER and OBJECT IDENTIFIER in its shortest form; every BOOLEAN 0x00 or 0xFF; every NULL empty; every BIT STRING with at most 7 unused bits;
- genTime and each certificate's validity times in the one form DER gives them, denoting a moment that exists;
- the public key of the signing certificate written exactly as its own specification sets out, with no unused bits: RSA as , with the parameters present and NULL and two positive INTEGERs with nothing after them; ECDSA as , as an uncompressed point; Ed25519 as , with no parameters and 32 bytes; and
- at most 4,000 elements, none more than 24 levels deep, in each of the signed data, the enclosed TSTInfo (read from its OCTET STRING), and an RSA public key; at most 8 digest algorithms, 8 certificates, 16 signed attributes, 4 values in one attribute, 8 identifiers in a signing-certificate attribute, and 16 TSTInfo extensions.
The order of SET OF elements and the omission of DEFAULT values are not checked;
the "messageImprint" is as above (stamp-wrong-data);
the signed attributes hold a content type of id-ct-TSTInfo, and the TSTInfo's message digest made with the signer's digest algorithm (SHA-256, SHA-384, or SHA-512). They also hold ESSCertIDv2 (, ), with SHA-256 (the default), SHA-384, or SHA-512, or ESSCertID (), with SHA-1, ESSCertIDv2 being used if both are present; the first identifier in the attribute names the certificate, which the token carries; the issuerSerial is not compared. Each of these attributes appears at most once and holds exactly one value, as and require (stamp-invalid);
the signature over the signed attributes verifies with that certificate's key (stamp-invalid). The signature algorithm names the signer's digest algorithm (for RSA, rsaEncryption is also accepted). The accepted methods are RSASSA-PKCS1-v1_5 with a modulus of 2,048 to 8,192 bits and an odd public exponent from 3 to 2^32 - 1 (with an exponent of 1, anyone can produce a signature that verifies); ECDSA on P-256 or P-384; and Ed25519 . An Ed25519 key that refuses, or a key of any other kind or on any other curve, is refused (stamp-invalid); and
"genTime" lies within the certificate's validity, the seconds field of any "accuracy" is at most 300, and no TSTInfo extension is critical (stamp-invalid). The certificate's extensions are not examined, since the certificate is trusted by its digest.

A verifier is told which TSAs it trusts by the digest of each TSA's certificate in DER; it builds no chain, checks no revocation, and asks no outside party. A time-stamp counts only if its TSA is trusted and every signature of its record was verified (for a cancellation, also its permission's). A sound time-stamp from a TSA not trusted MUST be shown as such, with its certificate's digest; a time-stamp that does not count MUST NOT be used as a time. Times are taken to the second, rounded down. A counted time-stamp at time T shows that the record existed by T. On a sound signed tree head, it also shows that every entry before the head existed by T. An entry existed by the earliest such T of any later sound head. A verifier MUST report "existed by", never "existed at", and MUST say which entries the last counted time-stamp reaches. It MUST report dated-after-stamp for a head or a cancellation whose "when" is more than 300 seconds after the earliest time its counted time-stamps state, and for an entry whose "when", or the "when" of a countersignature or approval carried in it, is more than 300 seconds after the time by which the entry existed.

Verification

The Three Answers A verifier is given the log and, optionally, the size and root it expects, the thumbprints of the passkeys it trusts, and the digests of the key sets of the recorders and of the certificates of the TSAs it trusts. It makes no network request. It gives three answers, kept apart:

Was a problem found? Yes if any entry, or the log, has one.
Was everything verified? Yes only if every entry was read as far as its signatures, and no signature or time-stamp in the log was left unverified because the verifier does not implement its method.
Did each action stay within its permission? Yes only if no problem was found, every receipt and delegation was compared, and none gave a finding.

A verifier MUST call a log intact only if no problem was found and everything was verified. A receipt or delegation is compared only if it is sound, at least one of its signatures was verified and none failed, and its permission's passkey signature was verified. So the third answer can be yes while the second is no: for example, a verifier without ML-DSA-87 compares receipts on their Ed25519 signatures alone. When the second answer is no, a verifier MUST say that the third rests only on the signatures it verified, and MUST name the signing methods it lacked. A verifier checks each record's encoding (in the JSON encoding, its envelope, labels, and content, ), then its members, and then finds the records it relies on, in that order. At the first problem in those steps, it reports that problem's code and checks nothing further in that entry. Once an entry's members have been read, and before the records it relies on are looked up, its "id" is compared with the identifiers seen so far and then recorded; an approval's "id" is compared and recorded once the approval has been matched to its receipt. Every other problem of an entry (a signature, its place in its chain, a countersignature, an approval, a repeated "id") is reported. Anything the verifier did not expect is a problem (check-failed), never a pass. Each problem and finding is reported with its entry's number. Two verifiers agree if they give the same three answers, find problems at the same entries, and report the same findings for each entry.

Findings A verifier reports these findings at the receipt concerned:

action-not-allowed:: "action" is not in "actions".
prohibited:: "action" is a shared action of a kind that "never" names.
party-not-allowed:: "with" names no service of the permission.
outside-valid-time:: "when" is outside the permission's validity.
amount-missing:: A limit with a "unit", or a condition with "above", applies to the action, and the receipt has no amount in that unit (once a receipt).
over-limit, over-each-limit, over-count-limit:: The running total exceeds "max"; the amount exceeds "each"; with this receipt, the number exceeds "count".
over-period-limit:: Within the period ending at this receipt, the total exceeds "max" or the number "count".
countersignature-missing, approval-missing:: A condition applies, and the entry holds no countersignature, or no approval.
after-cancellation, pass-not-allowed:: As and set out.

A condition with "above" applies only if the amount is in its unit and greater than "above"; an amount missing or in another unit is amount-missing. Only compared receipts count toward totals. Totals and counts without "per" accumulate in log order over every compared receipt for the action under the permission, across all chains including the current one. Once a total is exceeded, every later receipt for that action is reported too. A limit with "per" P is evaluated for each compared receipt X, dated t, over the period that ends at X. That period holds: every receipt for the action, in any chain and anywhere in the log, dated later than t - P and earlier than t; those dated exactly t that precede X in the log; and X itself. Because a later entry may state an earlier time, period limits are settled only once every receipt has been read. Periods are counted in seconds; there are no calendar days and no time zones.

The JSON Encoding This section specifies the JSON encoding: how records, keys, and logs are written as JSON , and how signatures are carried, with JWS .

Envelope and Labels Every record is a JWS in the General JWS JSON Serialization (). It MUST hold exactly the members "payload" and "signatures". Each element of "signatures" MUST hold exactly "protected" and "signature" and, for a passkey signature, also "header", which holds exactly "authenticatorData" and "clientDataJSON" (bad-envelope). A passkey's authenticator data and client data are stored there, and its signature in "signature", each exactly as returned. The signing input of every signature is the JWS Signing Input () formed from "protected" and "payload" as carried. Every value written in base64url, in a record's envelope or content or in a log entry, is that of , without padding, and is read strictly: a verifier MUST refuse padding, a character outside the alphabet, a length that leaves 1 when divided by 4, and unused bits that are not zero (bad-base64url; in a key, bad-key; in "authenticatorData" and "clientDataJSON", passkey-bad-data). The decoded "signature" of an Ed25519, ML-DSA-87, or SLH-DSA-SHA2-256s signature MUST have its method's length (; signature-invalid). The protected header of each signature, once decoded, MUST be exactly the UTF-8 bytes of {"typ":"<typ>","alg":"<alg>"}, with no white space and the two members in that order, where <typ> and <alg> are as follows. This header is a fixed text, compared as bytes; it is deliberately not in the canonical member order of . A verifier compares bytes and interprets nothing else. A header that is not a known text is a problem (unknown-type). One that belongs to another kind of record than the one expected is a problem too (payload-type-mismatch). The number and order of the signatures are those of (bad-signatures-layout). <typ> is "vnd.provared.X.v0+json", with X as in : the subtype of the record's media type, written without its "application/" prefix as allows. The placeholder <alg> names the method of the signature: "Ed25519", "ML-DSA-87", "SLH-DSA-SHA2-256s", or "prova.red/webauthn/v0" for a passkey. A passkey's signature is its assertion signature over the authenticator data and the client data (); the JWS Signing Input enters it only through the challenge. The "typ" value is used for explicit typing (); since it is signed, every signature covers the kind of record. The name "Ed25519" is registered by and "ML-DSA-87" by . The name "prova.red/webauthn/v0" is collision-resistant () and is not registered. The name "SLH-DSA-SHA2-256s", which gives the parameter set, is neither registered nor collision-resistant, one of which says an "alg" value should be; this document fixes it as a private-use value, compared byte for byte. It follows the naming of , which registers the 128s parameter sets with the same key form (AKP), pure mode, and the empty context, so that a registration of this name with that meaning would be compatible.

Content and Values The content of a record is the decoded "payload", and its digest is the SHA-256 hash of those bytes. It MUST be a JSON object in UTF-8, in the canonical form of : a verifier serializes it again and refuses it if a single byte differs (payload-not-canonical). This refuses repeated member names, white space, and members out of order. The content MUST hold only objects, arrays, strings, and integers from 0 to 2^53 - 1. It holds no "true", "false", "null", fractions, exponents, or negative numbers, and no unpaired surrogate, even escaped. Objects and arrays MUST NOT nest more than 8 levels deep, the content itself being the first (payload-not-canonical). The signed bytes are verified as signed; the canonical form is a test, never a rewrite. A map is written as an object, a list as an array, text as a string, and an integer as a number. The values of are written so:

Bytes:: In base64url, read strictly as sets out.
Time:: "YYYY-MM-DDTHH:MM:SSZ", an date-time (bad-field).
Key:: A JSON Web Key (JWK) of exactly one of the shapes below, with no other member (bad-key).

These follow (the Octet Key Pair, "OKP", key type), (the Algorithm Key Pair, "AKP", key type), and ; "n" has no leading zero byte. A key set is an array of keys. A record MUST NOT exceed 65,536 characters, counted as the length of "payload" plus the lengths of every string in its signature entries, "header" included (too-large).

Thumbprints and Key-Set Digests A passkey is named by its key thumbprint: with SHA-256, over the members required by , for "OKP", and for "AKP". A recorder is named by the digest of its key set: the SHA-256 hash of the key set written in the canonical form of .

Logs A log is UTF-8 text, one entry to a line, each line ended by a line feed except perhaps the last. A log with no entry, an empty line, or a byte order mark is a problem (not-json); so is a line ending in a carriage return (line-not-canonical). Each line is a JSON object in the canonical form of , with records as values (line-not-canonical). It holds exactly the members of one kind of entry (): "slip" (a permission); "stub", optionally with "countersignature" and "approval" (an action receipt); "pass" (a delegation); "cancellation", optionally with "stamps"; "acknowledgement"; or "seal" (a signed tree head), optionally with "stamps" (unknown-entry). A line MUST NOT exceed 131,072 bytes (too-large). The leaves of the tree are the lines' bytes, without line feeds. In "stamps", a TimeStampToken is a string, in base64url. A block time-stamp is an object of exactly "block" and "proof", each a string (bad-field) in base64url ().

Other Encodings Another encoding could carry the same content model: for example, one using COSE_Sign () over deterministically encoded CBOR (). This document does not define one. Such an encoding has to define:

the bytes of a record's content, in one form that a verifier tests, so that a record's digest is fixed; it may write member names in another fixed form, such as short integer labels;
how the signatures are carried, in the number and order of , and the signing input of each, which covers the kind of record (with COSE, perhaps by the "typ" header parameter ) and its content;
how each signature names its method, in fixed bytes that a verifier compares: with COSE, the "alg" of each signer, which has values for Ed25519 and ML-DSA-87 , but none yet for SLH-DSA-SHA2-256s or the passkey signature;
the passkey's challenge, the SHA-256 hash of that signing input, and where the authenticator data and client data are stored;
how bytes, times, and keys are written (with COSE, keys as COSE_Key), and the thumbprints () and key-set digests by which a verifier is told whom it trusts;
the form of a log and of its entries, which are the leaves of the tree; and
its size limits, and the codes for problems of its own form.

The rest of the content model, the three answers, and the findings apply unchanged. A record's digest depends on its encoding, so records that name one another, and the entries of one log, are in one encoding. The thumbprints and key-set digests by which a verifier is told whom it trusts also depend on the encoding: a key's JWK thumbprint and its COSE_Key thumbprint differ.

Relationship to Other Work

Agent receipts:: has the user sign an authorization (WebAuthn being one way) with allowed and denied actions, prohibitions, and a time window, logged before the agent acts; its delegations may only narrow, within a depth limit, and can be revoked. and (which expired on 22 October 2026) specify signed, hash-chained action receipts, with a recorded policy decision or a gate run before execution. Here the permission carries limits on amounts, counts, and periods, and anyone can compare each recorded action with it afterward.
Audit records:: records an authorization decision and the effect that followed, as one in-toto predicate in a DSSE envelope, with a canonicalization contract and what a retaining party keeps beside a record so that it can later be dated from anchors it does not control; it defines no policy. Where a decision applied a cumulative limit set by a document named by digest, the record states the limit and the amounts that the decision point counted as committed, held, and requested; a verifier derives from them whether the decision was within the limit, and a party that holds every record under one limit checks them against one another (). specifies a JSON logging record with mandatory fields for the agent, the authorizing principal, the action's class, and its outcome, hash-chained with SHA-256 over and optionally signed with ECDSA P-256, ML-DSA-65, or Ed25519, or with ECDSA P-256 and ML-DSA-65 side by side; it requires a denial or an escalation to be recorded before execution, recommends a recorder independent of the agent at its higher trust levels, and maps the record to regulatory logging requirements. states which evidence answers which audit question and separates missing evidence from a negative observation; the three answers of and the omission limits of are of that kind. None has the principal sign the limits against which a verifier compares each recorded action: the first checks a cumulative amount against the amounts that the decision point recorded, not against the actions' own signed records, and has no limits on counts, single amounts, or periods. The permission here could be the document that sets such a limit, or the authorization under which a decision recorded by the first two was made.
EMILIA Protocol receipts:: In , an enrolled approver, never the initiator, signs a context bound to one exact action before it is executed, preferably with a WebAuthn credential whose challenge is the hash of that context, with user verification required. The executor records one-time use in shared atomic state; the receipt, which carries a log inclusion proof, can be verified offline. In , an issuer signs with Ed25519 a capability holding a closed scope, a budget in explicit units, an expiry, and any parent; its issuance can itself be approved by such a receipt. Delegation only narrows, and is funded from the parent's budget. An overspend or a replayed operation is refused when an operation is reserved, and revocation is checked then and again just before the action takes effect, within one atomic store. That document states that it provides no offline or cross-domain double-spend prevention, and that a committed operation is not verifiable evidence unless a signed record covers it; Section 13 of that document lists what such evidence should hold. Together, the two EMILIA documents provide enforcement before an action takes effect, in the executor's atomic state, and evidence of what was authorized, in the authorization receipt. An approval here () corresponds to the first document, and a signed total with narrowing delegation to the second. The difference is where the limits live and who checks them: there, the executor's store refuses an operation; here, the principal's passkey signs the limits, which may also bound single amounts, counts, and periods and set conditions, each action is a signed receipt that the service may countersign, and any verifier decides afterward, from the records alone, whether each action stayed within the permission. This document does not stop an action when it is attempted, and an action for which no receipt was written is found only in another party's records (). The two designs could be combined: an executor () that refuses an operation before it takes effect, and receipts from which any verifier can later check each action against the limits the principal signed.
SCITT profiles:: A SCITT Transparency Service registers Signed Statements and returns Receipts proving inclusion in its log; a SCITT Receipt proves registration, not an action. records a principal class and an ALLOW or DENY verdict, keeps pre-execution authorization apart, and does not claim that a named approver authorized the action. has the operator sign each record, with an independent custodian as Transparency Service; a principal's constraints appear only as an optional text field and references to credentials. records one action per capsule, with its disposition and the constraints evaluated, and leaves permission to authorization records it references by digest. None defines a permission signed by the principal, with limits that a verifier compares receipts against. That content model could be carried by a SCITT profile, with heads or receipts registered as Signed Statements, also guarding against truncation and split views ().
OAuth and GNAP:: Token Exchange expresses delegation through the "act" claim (); Rich Authorization Requests and the Grant Negotiation and Authorization Protocol (GNAP) grant detailed rights. All yield tokens issued by a server for access, not records signed by the principal. Transaction Tokens carry one call's context through a trust domain; a receipt can hold a token's digest in "details".
Attenuating tokens:: lets a holder derive offline tokens with equal or narrower capabilities, within depth and lifetime limits, checked before each call; macaroons , Biscuit , and User Controlled Authorization Network (UCAN) narrow capabilities likewise. Delegation here also only narrows, but is checked over recorded actions, with totals and periods across many of them.
WIMSE:: Workload Identity in a Multi System Environment (WIMSE) gives workloads identities; applies WIMSE and OAuth to AI agents. A WIMSE credential for an agent's keys would say which workload held them.
Credentials and mandates:: A permission resembles a credential (, ) and a mandate of the Agent Payments Protocol , by which a user authorizes purchases within limits; but it is checked against receipts, and handles no payment.
Agent auditing:: The approved request for a working-group-forming session on Agent Use of Delegation and Interaction Traceability (AUDIT) at IETF 127 , dated 8 October 2026, lists and as its architecture and solution drafts, and a data model for records among the new work required; at the time of writing (October 2026) the proposed group's charter is still being revised. The architecture's first work item leaves the encoding open, CBOR and COSE or JSON and JWS, with detached payloads. In its terms, a permission records an initial grant, an approval a step-up approval, and a cancellation a revocation, which are kinds of Authorization Transition Record; a delegation is a Delegation Record. It places Action Records where an action took effect and binds each to its authorizing token; here the agent's receipt names its permission by digest, and the countersignature comes from the side where the action took effect. Its records share a correlation identifier, which this document does not define (). This document offers the permission with limits and the comparison rule as content that any record format in that work could carry.

Design Rationale Passkeys are on the devices people use, resist phishing, and record user verification; no device offers a post-quantum passkey. The JSON encoding is defined first because an implementation uses it, and JSON text suits a log of one entry to a line. Two signatures side by side can each be verified by any library, and a verifier lacking one says so. Composite signatures would make one of the two, but that draft pairs ML-DSA-87 only with ES384 or Ed448, never with Ed25519. Verification needs no network, because a record may be checked years later, when its writers have gone. Post-quantum signatures are used from the start: if Ed25519 is forged in future, a record carrying only Ed25519 could be made afterward and not told apart from a genuine one; SLH-DSA rests on hash functions alone. The tree is that of Certificate Transparency, the covering of fields in that of , and the time-stamp that of the Time-Stamp Protocol.

Parts Specified Elsewhere specifies these parts, out of scope here: one-page proofs of single entries, with a permission's names and purpose covered by the disclosures of ; vouching records, by which an organization states that a key belongs to a name, and their withdrawal; a service's signed refusals and terms; time-stamps from a public blockchain; further date rules; the principal's own copy of a cancellation, handed to a verifier; the exact texts whose digests the reserved document names of carry (), which bind a receipt to a web request, an answer, a call's arguments, an identifier for the call from either side, or an error text; and the check before acting (), by which the software around an agent asks, before an action, whether it would stay within the permission. How records are carried, how keys are distributed, and what to do about a finding are out of scope too.

Open Issues

Labels: standards-tree media types , a registered passkey method, and the brand in the identifiers. The brand stands in the media types, in the passkey method name, in the "type" values "provared.X.v0" of the content model (), and in the reserved action prefix "provared." of and . On adoption, all of these would be renamed, with a "type" such as "agent-permission.v0" and a prefix chosen by the group; the "v0" label is what keeps the two from being confused, and the vendor-tree media types would then need no registration. registers SLH-DSA-SHA2-128s and SLH-DSA-SHAKE-128s, not SLH-DSA-SHA2-256s.
Canonical form: is Informational (Independent stream), not in the downref registry; this document could define the narrowed form, which is short.
Client data: refusing repeated members, or the limited verification algorithm of ; public suffixes; extension bytes; backup flags.
requires SHA-512 with Ed25519 when signed attributes are present; also accepts SHA-256 and SHA-384, which version 0.6.0 of the implementation refuses ().
Timing: whether to bring in the date rules of and , and whether 300 seconds is the right allowance.
A COSE encoding (), and detached payloads; a member for a correlation identifier shared with other audit records (); SCITT registration; consistency proofs (); composite signatures; a registry for shared action names; whether to answer "within its permission" when not everything was verified.
Retries: no rule links the attempts of one operation. Each attempt for which a receipt is written counts toward totals and counts, even where the receipt names an error ("provared.error"), and receipts that name the same "provared.request-id" are not taken as one operation. counts a retried operation once, by a key that the agent assigns to the operation and carries in each attempt, and not by the request's digest.
What a countersignature attests: "the action took place with" the service () does not say whether the service accepted the action, completed it, or only let it through, and states no outcome; an executor () may countersign before the outcome is known. and record a decision and what followed it apart.

Implementation Status This section records the status of known implementations of the protocol defined by this specification at the time of posting of this Internet-Draft, and is based on a proposal described in . The description of implementations in this section is intended to assist the IETF in its decision processes in progressing drafts to RFCs. Please note that the listing of any individual implementation here does not imply endorsement by the IETF. Furthermore, no effort has been spent to verify the information presented here that was supplied by IETF contributors. This is not intended as, and must not be construed to be, a catalog of available implementations or their features. Readers are advised to note that other implementations may exist. Provared 0.6.0, by the author, covers this document and in two languages: a JavaScript library for Node.js 24.7 or later, with no dependencies, with a command-line verifier and a verification page that runs from one file; and a Python library for Python 3.11 or later, which depends on the package "cryptography". The Python library has no SLH-DSA yet, so it reports the third signature of a signed tree head as not verified. Version 0.6.0 also implements parts added to the format description after the version cited as (a record of an action the agent's side did not take, signed tree heads held by another party, and witness statements beside a head); a core verifier reports these as problems. It refuses some time-stamps that accepts: a string written in parts; elements of a SET OF out of DER order in the signed attributes, in the TSTInfo, or in a certificate; a BIT STRING whose unused bits are not zero; a second signing-time attribute; and an Ed25519 time-stamp whose digest algorithm is not SHA-512 or carries parameters, as requires. A TSA that follows its standards produces none of these. Both libraries are tested against one set of test vectors, each an input with the expected answer, published in the repository for any implementation to use. Four further Python packages put an agent framework's tool calls behind the check before an action and write a receipt for each call: "provared-langchain", listed among the middleware in LangChain's documentation, and "pydantic-ai-provared" are published; "provared-agno" and "provared-hermes" are in the repository only. The repository also holds, unpublished, a gateway that acts as an executor () for web services: it holds their credentials, refuses calls that the permission does not allow, writes the receipt for each call it makes, naming the service in "with", and asks that service to countersign. The author records the tool calls of their own coding agent with the library, under a permission signed with a passkey; the record is published at https://prova.red/records/. Maturity: marked as a draft. Licensing: Apache License 2.0 (: Creative Commons Attribution 4.0). Location: https://github.com/provared/provared (tag v0.6.0), the npm package "provared", and the Python package "provared". Contact: the author. Dates: version 0.1.0 was published to the npm registry on 5 October 2026, version 0.5.0 on 16 October 2026, and version 0.6.0 on 25 October 2026, all in UTC; the repository's change log heads the same versions 6, 17, and 25 October 2026. The rules of were confirmed against both libraries, on Node.js 24.19.0 with OpenSSL 3.5.7 and on Python 3.14.7 with "cryptography" 50.0.2 and the OpenSSL 4.0.3 bundled with it. No independent implementation is known. Provared is used by the author as a trademark; it is not registered. Anyone may use the identifiers in this document to implement this document.

Security Considerations Making or widening a permission requires a signature by the principal's passkey; making or changing any other record requires its signer's keys. Without the keys that signed a chain, a receipt cannot be removed from the middle of the chain, moved within it, or changed without a verifier reporting it (chain-broken, signature-invalid). Whoever holds those keys can re-sign the chain from any receipt onward. Anyone can remove the last receipts of a chain, unless a head held by someone other than the recorder covers them, or the service has kept a countersignature of one of them. A verifier that holds a copy of a signed tree head, or of its size and root, obtained from someone other than the recorder, detects any change, addition, or removal before that head (root-mismatch). Trusting the recorder's keys protects against everyone except the recorder, who can sign a shortened or reordered history. A counted time-stamp shows that the entries before a sound head existed by its time. Once a permission is covered by a head whose keys the verifier trusts, two of the head's three signatures, which are post-quantum, cover the permission's entry. The passkey signature on the permission itself is classical. What the head adds is that the permission, as it stands in the log, cannot be replaced afterward by anyone without the recorder's keys, even if its passkey signature later becomes forgeable; it does not make the principal's signature post-quantum. What this document does not protect against:

No trusted keys:: With no trusted keys named, "intact" means only that the log is consistent with itself. Anyone can make such a log.
Omission, one side's word:: An agent that writes no receipt leaves no trace in its own log, and no check of that log shows the gap. Only another party's records can show it: a countersignature kept by the service, or the records of an executor () that refuses any action the permission does not allow, or any action without a verified approval, and records each action it allows (the strongest class of has such an executor, which checks that document's own authorizations). An executor's records show the gap only if the action cannot take place without the executor, and if the executor keeps them where the agent's side cannot change them. A permission whose "with" names no service but the executor, and that requires a countersignature for every action, makes each receipt in the log that lacks the executor's countersignature a finding (countersignature-missing, or party-not-allowed for a receipt that names another party). A receipt that was never written is found only by comparing the executor's own records with the log, which this document does not specify. A cancellation the principal signed can be left out of the log by whoever keeps it, after which every later receipt reads as within the permission; only the principal's own copy of the cancellation, handed to the verifier (, out of scope here), answers this. A one-sided receipt, an acknowledgement, and the times stated in records, on which period limits depend, rest on the signer's own statement.
Truncation and split views:: The last head, with everything after it, can be removed unnoticed unless someone else holds that head. A recorder can keep two logs that differ after some entry, with heads for each; no consistency proof is defined. Handing heads to others lets them be compared.
One log only:: approval-reused and duplicate-id hold within one log, and so do totals, counts, and periods. Receipts for one permission written into two logs, or into a log that was started afresh, are not added together: each log can be within its limits while the two together are not. A recorder that keeps one log for each permission avoids this; the format does not close it.
Service keys:: The keys of a service in "with" are stated by the principal. A countersignature shows that a holder of those keys signed; it does not show who that holder is. A principal who lists keys they control can countersign their own agent's receipts. A compromise of a service's keys lets anyone countersign in its name: a countersignature is only as strong as the service's keys.
Agent keys held by the recorder:: Such a recorder can write and sign another history. A time-stamp then shows only when; countersignatures still stand against it.
Passkeys:: A passkey shows that a device signed after verifying a user, not who held it, nor that the principal read what was signed; a compromised device or page can show one thing and have another signed. The challenge is opaque to the principal. Any party that can choose the challenge at an origin under the issuer's "rpId" (the site's operator, any script at that origin, or any subdomain of the "rpId") can obtain a signature on a record of its choosing by presenting it as a sign-in: the client data of a sign-in and of a record are the same shape. So a passkey trusted for records SHOULD be created for an "rpId" used for nothing but signing records, the signing page SHOULD show the record before asking, and a verifier MAY be told the "origin" it expects as well as the thumbprint. The counter is not used, so a cloned passkey goes unseen. An "http://localhost" origin is for tests only.
Time-stamp keys:: A TSA is trusted by certificate digest, without revocation, and its time is checked against the certificate's validity, not the verifier's clock. A compromised TSA key can stamp any time; a verifier that learns of it MUST stop trusting it. Up to four TSAs lessen the dependence on one.
Renewal:: TSA signatures are classical, and certificates age; so the times by which entries existed rest on classical signatures and have no post-quantum protection. A later head covers earlier heads' entries, time-stamps included, so stamping it by a newer TSA extends the evidence, as evidence records do.
Stripping:: Signatures are fixed in number, order, and label, and their keys are given elsewhere (), so removing or replacing one is caught.
Ed25519 alone:: Without ML-DSA-87, what is compared rests on Ed25519 alone. Such a verifier cannot tell a record made with the agent's Ed25519 key alone from a genuine one. A verifier whose library applies other rules than MUST add the missing checks.
Malleable signatures:: An ECDSA signature can be altered into another valid one. A record digest covers only content, so no digest changes; the entry does, and a later head shows it.

A verifier MUST treat every byte of a record as untrusted, and answer a failed check with a code, not a crash. It SHOULD replace control, invisible, and direction-changing characters before showing text from a record. Member names are plain strings: "__proto__" is like any other.

Privacy Considerations Following : keys repeat in every record a party signs, so records in different logs can be linked. Document digests are not salted, so whoever can guess a document can confirm that a receipt names it; a writer can add a random value to a document first. A TSA learns the digests it stamps, when, and who asked. An entry cannot be erased without breaking later heads, so records should hold no more personal data than needed; names may be pseudonyms, and defines covered names and purpose. The members "origin" and "rpId" name the site where the principal signed. A verifier makes no network request.

IANA Considerations This document has no IANA actions. On adoption, a later version is expected to request standards-tree media types for each kind of record. It would also request a JWS algorithm name for the passkey signature, and one for the third signature of a signed tree head ().

References Normative References Key words for use in RFCs to Indicate Requirement Levels In many standards track documents several words are used to signify the requirements in the specification. These words are often capitalized. This document defines these words as they should be interpreted in IETF documents. This document specifies an Internet Best Current Practices for the Internet Community, and requests discussion and suggestions for improvements. Ambiguity of Uppercase vs Lowercase in RFC 2119 Key Words RFC 2119 specifies common key words that may be used in protocol specifications. This document aims to reduce the ambiguity by clarifying that only UPPERCASE usage of the key words have the defined special meanings. Enhanced Security Services for S/MIME This document describes four optional security service extensions for S/MIME. [STANDARDS-TRACK] Internet X.509 Public Key Infrastructure Time-Stamp Protocol (TSP) This document describes the format of a request sent to a Time Stamping Authority (TSA) and of the response that is returned. It also establishes several security-relevant requirements for TSA operation, with regards to processing requests to generate responses. [STANDARDS-TRACK] Algorithms and Identifiers for the Internet X.509 Public Key Infrastructure Certificate and Certificate Revocation List (CRL) Profile This document specifies algorithm identifiers and ASN.1 encoding formats for digital signatures and subject public keys used in the Internet X.509 Public Key Infrastructure (PKI). Digital signatures are used to sign certificates and certificate revocation list (CRLs). Certificates include the public key of the named subject. [STANDARDS-TRACK] Date and Time on the Internet: Timestamps This document defines a date and time format for use in Internet protocols that is a profile of the ISO 8601 standard for representation of dates and times using the Gregorian calendar. The Base16, Base32, and Base64 Data Encodings This document describes the commonly used base 64, base 32, and base 16 encoding schemes. It also discusses the use of line-feeds in encoded data, use of padding in encoded data, use of non-alphabet characters in encoded data, use of different encoding alphabets, and canonical encodings. [STANDARDS-TRACK] Enhanced Security Services (ESS) Update: Adding CertID Algorithm Agility In the original Enhanced Security Services for S/MIME document (RFC 2634), a structure for cryptographically linking the certificate to be used in validation with the signature was introduced; this structure was hardwired to use SHA-1. This document allows for the structure to have algorithm agility and defines a new attribute for this purpose. [STANDARDS-TRACK] Elliptic Curve Cryptography Subject Public Key Information This document specifies the syntax and semantics for the Subject Public Key Information field in certificates that support Elliptic Curve Cryptography. This document updates Sections 2.3.5 and 5, and the ASN.1 module of "Algorithms and Identifiers for the Internet X.509 Public Key Infrastructure Certificate and Certificate Revocation List (CRL) Profile", RFC 3279. [STANDARDS-TRACK] Cryptographic Message Syntax (CMS) This document describes the Cryptographic Message Syntax (CMS). This syntax is used to digitally sign, digest, authenticate, or encrypt arbitrary message content. [STANDARDS-TRACK] ESSCertIDv2 Update for RFC 3161 This document updates RFC 3161. It allows the use of ESSCertIDv2, as defined in RFC 5035, to specify the hash of a signer certificate when the hash is calculated with a function other than the Secure Hash Algorithm (SHA-1). [STANDARDS-TRACK] The Web Origin Concept This document defines the concept of an "origin", which is often used as the scope of authority or privilege by user agents. Typically, user agents isolate content retrieved from different origins to prevent malicious web site operators from interfering with the operation of benign web sites. In addition to outlining the principles that underlie the concept of origin, this document details how to determine the origin of a URI and how to serialize an origin into a string. It also defines an HTTP header field, named "Origin", that indicates which origins are associated with an HTTP request. [STANDARDS-TRACK] JSON Web Signature (JWS) JSON Web Signature (JWS) represents content secured with digital signatures or Message Authentication Codes (MACs) using JSON-based data structures. Cryptographic algorithms and identifiers for use with this specification are described in the separate JSON Web Algorithms (JWA) specification and an IANA registry defined by that specification. Related encryption capabilities are described in the separate JSON Web Encryption (JWE) specification. JSON Web Key (JWK) A JSON Web Key (JWK) is a JavaScript Object Notation (JSON) data structure that represents a cryptographic key. This specification also defines a JWK Set JSON data structure that represents a set of JWKs. Cryptographic algorithms and identifiers for use with this specification are described in the separate JSON Web Algorithms (JWA) specification and IANA registries established by that specification. JSON Web Algorithms (JWA) This specification registers cryptographic algorithms and identifiers to be used with the JSON Web Signature (JWS), JSON Web Encryption (JWE), and JSON Web Key (JWK) specifications. It defines several IANA registries for these identifiers. JSON Web Key (JWK) Thumbprint This specification defines a method for computing a hash value over a JSON Web Key (JWK). It defines which fields in a JWK are used in the hash computation, the method of creating a canonical form for those fields, and how to convert the resulting Unicode string into a byte sequence to be hashed. The resulting hash value can be used for identifying or selecting the key represented by the JWK that is the subject of the thumbprint. Edwards-Curve Digital Signature Algorithm (EdDSA) This document describes elliptic curve signature scheme Edwards-curve Digital Signature Algorithm (EdDSA). The algorithm is instantiated with recommended parameters for the edwards25519 and edwards448 curves. An example implementation and test vectors are provided. CFRG Elliptic Curve Diffie-Hellman (ECDH) and Signatures in JSON Object Signing and Encryption (JOSE) This document defines how to use the Diffie-Hellman algorithms "X25519" and "X448" as well as the signature algorithms "Ed25519" and "Ed448" from the IRTF CFRG elliptic curves work in JSON Object Signing and Encryption (JOSE). The JavaScript Object Notation (JSON) Data Interchange Format JavaScript Object Notation (JSON) is a lightweight, text-based, language-independent data interchange format. It was derived from the ECMAScript Programming Language Standard. JSON defines a small set of formatting rules for the portable representation of structured data. This document removes inconsistencies with other specifications of JSON, repairs specification errors, and offers experience-based interoperability guidance. Algorithm Identifiers for Ed25519, Ed448, X25519, and X448 for Use in the Internet X.509 Public Key Infrastructure This document specifies algorithm identifiers and ASN.1 encoding formats for elliptic curve constructs using the curve25519 and curve448 curves. The signature algorithms covered are Ed25519 and Ed448. The key agreement algorithms covered are X25519 and X448. The encoding for public key, private key, and Edwards-curve Digital Signature Algorithm (EdDSA) structures is provided. Use of Edwards-Curve Digital Signature Algorithm (EdDSA) Signatures in the Cryptographic Message Syntax (CMS) This document specifies the conventions for using the Edwards-curve Digital Signature Algorithm (EdDSA) for curve25519 and curve448 in the Cryptographic Message Syntax (CMS). For each curve, EdDSA defines the PureEdDSA and HashEdDSA modes. However, the HashEdDSA mode is not used with the CMS. In addition, no context string is used with the CMS. JSON Canonicalization Scheme (JCS) Cryptographic operations like hashing and signing need the data to be expressed in an invariant format so that the operations are reliably repeatable. One way to address this is to create a canonical representation of the data. Canonicalization also permits data to be exchanged in its original form on the "wire" while cryptographic operations performed on the canonicalized counterpart of the data in the producer and consumer endpoints generate consistent results. This document describes the JSON Canonicalization Scheme (JCS). This specification defines how to create a canonical representation of JSON data by building on the strict serialization methods for JSON primitives defined by ECMAScript, constraining JSON data to the Internet JSON (I-JSON) subset, and by using deterministic property sorting. Certificate Transparency Version 2.0 This document describes version 2.0 of the Certificate Transparency (CT) protocol for publicly logging the existence of Transport Layer Security (TLS) server certificates as they are issued or observed, in a manner that allows anyone to audit certification authority (CA) activity and notice the issuance of suspect certificates as well as to audit the certificate logs themselves. The intent is that eventually clients would refuse to honor certificates that do not appear in a log, effectively forcing CAs to add all issued certificates to the logs. This document obsoletes RFC 6962. It also specifies a new TLS extension that is used to send various CT log artifacts. Logs are network services that implement the protocol operations for submissions and queries that are defined in this document. Fully-Specified Algorithms for JSON Object Signing and Encryption (JOSE) and CBOR Object Signing and Encryption (COSE) This specification refers to cryptographic algorithm identifiers that fully specify the cryptographic operations to be performed, including any curve, key derivation function (KDF), and hash functions, as being "fully specified". It refers to cryptographic algorithm identifiers that require additional information beyond the algorithm identifier to determine the cryptographic operations to be performed as being "polymorphic". This specification creates fully-specified algorithm identifiers for registered JSON Object Signing and Encryption (JOSE) and CBOR Object Signing and Encryption (COSE) polymorphic algorithm identifiers, enabling applications to use only fully-specified algorithm identifiers. It deprecates those polymorphic algorithm identifiers. This specification updates RFCs 7518, 8037, and 9053. It deprecates polymorphic algorithms defined by RFCs 8037 and 9053 and provides fully-specified replacements for them. It adds to the instructions to designated experts in RFCs 7518 and 9053. ML-DSA for JSON Object Signing and Encryption (JOSE) and CBOR Object Signing and Encryption (COSE) This document specifies JSON Object Signing and Encryption (JOSE) and CBOR Object Signing and Encryption (COSE) serializations for the Module-Lattice-Based Digital Signature Standard (ML-DSA), a Post-Quantum Cryptography (PQC) digital signature scheme defined in US NIST FIPS 204. Secure Hash Standard (SHS) National Institute of Standards and Technology Module-Lattice-Based Digital Signature Standard National Institute of Standards and Technology Stateless Hash-Based Digital Signature Standard National Institute of Standards and Technology Web Authentication: An API for accessing Public Key Credentials - Level 3 World Wide Web Consortium Information technology - ASN.1 encoding rules: Specification of Basic Encoding Rules (BER), Canonical Encoding Rules (CER) and Distinguished Encoding Rules (DER) International Telecommunication Union Informative References Evidence Record Syntax (ERS) In many scenarios, users must be able prove the existence and integrity of data, including digitally signed data, in a common and reproducible way over a long and possibly undetermined period of time. This document specifies the syntax and processing of an Evidence Record, a structure designed to support long-term non-repudiation of existence of data. [STANDARDS-TRACK] Media Type Specifications and Registration Procedures This document defines procedures for the specification and registration of media types for use in HTTP, MIME, and other Internet protocols. This memo documents an Internet Best Current Practice. Privacy Considerations for Internet Protocols This document offers guidance for developing privacy considerations for inclusion in protocol specifications. It aims to make designers, implementers, and users of Internet protocols aware of privacy-related design choices. It suggests that whether any individual RFC warrants a specific privacy considerations section will depend on the document's content. Improving Awareness of Running Code: The Implementation Status Section This document describes a simple process that allows authors of Internet-Drafts to record the status of known implementations by including an Implementation Status section. This will allow reviewers and working groups to assign due consideration to documents that have the benefit of running code, which may serve as evidence of valuable experimentation and feedback that have made the implemented protocols more mature. This process is not mandatory. Authors of Internet-Drafts are encouraged to consider using the process for their documents, and working groups are invited to think about applying the process to all of their protocol specifications. This document obsoletes RFC 6982, advancing it to a Best Current Practice. OAuth 2.0 Token Exchange This specification defines a protocol for an HTTP- and JSON-based Security Token Service (STS) by defining how to request and obtain security tokens from OAuth 2.0 authorization servers, including security tokens employing impersonation and delegation. JSON Web Token Best Current Practices JSON Web Tokens, also known as JWTs, are URL-safe JSON-based security tokens that contain a set of claims that can be signed and/or encrypted. JWTs are being widely used and deployed as a simple security token format in numerous protocols and applications, both in the area of digital identity and in other application areas. This Best Current Practices document updates RFC 7519 to provide actionable guidance leading to secure implementation and deployment of JWTs. Concise Binary Object Representation (CBOR) The Concise Binary Object Representation (CBOR) is a data format whose design goals include the possibility of extremely small code size, fairly small message size, and extensibility without the need for version negotiation. These design goals make it different from earlier binary serializations such as ASN.1 and MessagePack. This document obsoletes RFC 7049, providing editorial improvements, new details, and errata fixes while keeping full compatibility with the interchange format of RFC 7049. It does not create a new version of the format. CBOR Object Signing and Encryption (COSE): Structures and Process Concise Binary Object Representation (CBOR) is a data format designed for small code size and small message size. There is a need to be able to define basic security services for this data format. This document defines the CBOR Object Signing and Encryption (COSE) protocol. This specification describes how to create and process signatures, message authentication codes, and encryption using CBOR for serialization. This specification additionally describes how to represent cryptographic keys using CBOR. This document, along with RFC 9053, obsoletes RFC 8152. OAuth 2.0 Rich Authorization Requests This document specifies a new parameter authorization_details that is used to carry fine-grained authorization data in OAuth messages. CBOR Object Signing and Encryption (COSE) "typ" (type) Header Parameter This specification adds the equivalent of the JSON Object Signing and Encryption (JOSE) "typ" (type) header parameter to CBOR Object Signing and Encryption (COSE). This enables the benefits of explicit typing (as defined in RFC 8725, "JSON Web Token Best Current Practices") to be brought to COSE objects. The syntax of the COSE type header parameter value is the same as the existing COSE content type header parameter. Grant Negotiation and Authorization Protocol (GNAP) The Grant Negotiation and Authorization Protocol (GNAP) defines a mechanism for delegating authorization to a piece of software and conveying the results and artifacts of that delegation to the software. This delegation can include access to a set of APIs as well as subject information passed directly to the software. CBOR Object Signing and Encryption (COSE) Key Thumbprint This specification defines a method for computing a hash value over a CBOR Object Signing and Encryption (COSE) Key. It specifies which fields within the COSE Key structure are included in the cryptographic hash computation, the process for creating a canonical representation of these fields, and how to hash the resulting byte sequence. The resulting hash value, referred to as a "thumbprint", can be used to identify or select the corresponding key. Selective Disclosure for JSON Web Tokens This specification defines a mechanism for the selective disclosure of individual elements of a JSON data structure used as the payload of a JSON Web Signature (JWS). The primary use case is the selective disclosure of JSON Web Token (JWT) claims. CBOR Object Signing and Encryption (COSE) Receipts CBOR Object Signing and Encryption (COSE) Receipts prove properties of a Verifiable Data Structure (VDS) to a verifier. VDSs and associated Proof Types enable security properties, such as minimal disclosure, transparency, and non-equivocation. Transparency helps maintain trust over time and has been applied to certificates, end-to-end encrypted messaging systems, and supply chain security. This specification enables concise transparency-oriented systems by building on Concise Binary Object Representation (CBOR) and COSE. The extensibility of the approach is demonstrated by providing CBOR encodings for Merkle inclusion and consistency proofs. An Architecture for Trustworthy and Transparent Digital Supply Chains Traceability in supply chains is a growing security concern. While Verifiable Data Structures (VDSs) have addressed specific issues, such as equivocation over digital certificates, they lack a universal architecture for all supply chains. This document defines such an architecture for single-issuer signed statement transparency. It ensures extensibility and interoperability between different transparency services as well as compliance with various auditing procedures and regulatory requirements. Transaction Tokens CrowdStrike Practical Identity LLC Defakto Security Transaction Tokens (Txn-Tokens) are designed to maintain and propagate user identity, workload identity and authorization context throughout the Call Chain within a trusted domain during the processing of external requests (e.g. such as API calls) or requests initiated internally within the Trust Domain. Txn-Tokens ensure that this context is preserved throughout the Call Chain thereby enhancing security and consistency in complex, multi-service architectures. Workload Identity in a Multi System Environment (WIMSE) Architecture Palo Alto Networks Zscaler University of the Bundeswehr Munich The increasing prevalence of cloud computing and micro service architectures has led to the rise of complex software functions being built and deployed as workloads, where a workload is defined as software executing for a specific purpose, potentially comprising one or more running instances. This document discusses an architecture for designing and standardizing protocols and payloads for conveying workload identity and security context information. AI Identity Management System Defakto Security AWS Zscaler Ping Identity OpenAI Okta This document proposes best practices for authentication and authorization of AI agent interactions. It leverages existing standards such as the Workload Identity in Multi-System Environments (WIMSE) architecture and OAuth 2.0 family of specifications. Rather than defining new protocols, this document describes how existing and widely deployed standards can be applied or extended to establish agent authentication and authorization. By doing so, it aims to provide a framework within which to use existing standards, identify gaps and guide future standardization efforts for agent authentication and authorization. SD-JWT-based Verifiable Digital Credentials (SD-JWT VC) MATTR Authlete Inc. Ping Identity This specification describes data formats as well as validation and processing rules to express Verifiable Digital Credentials with JSON payloads with and without selective disclosure based on the SD-JWT format. SLH-DSA for JOSE and COSE mesur.io Tradeverifyd University of the Bundeswehr Munich Digital signatures are used within JSON Object Signing and Encryption (JOSE) and CBOR Object Signing and Encryption (COSE) to protect the integrity and authenticity of messages, such as JSON Web Signatures and signed COSE structures. This document specifies JOSE and COSE serializations for the Stateless Hash-Based Digital Signature Standard (SLH-DSA), a Post-Quantum Cryptography (PQC) digital signature scheme defined in US NIST FIPS 205. The conventions for the associated algorithm identifiers, signatures, public keys, and private keys are also specified. PQ/T Hybrid Composite Signatures for JOSE and COSE Huawei Huawei Entrust Limited Nokia This document describes JSON Object Signing and Encryption (JOSE) and CBOR Object Signing and Encryption (COSE) serializations for Post- Quantum Traditional (PQ/T) hybrid composite signatures. The composite algorithms described combine the Module-Lattice-Based Digital Signature Algorithm (ML-DSA) as the post-quantum component and either the Elliptic Curve Digital Signature Algorithm (ECDSA) or the Edwards-Curve Digital Signature Algorithm (EdDSA) as the traditional component. Verifiable Agent Conversation Records Autonomous agents based on large language models increasingly perform consequential tasks on behalf of humans and other agents. Demonstrating that recorded agent behavior truthfully represents actual behavior is essential for accountability, compliance, and human oversight. This document defines a data format for verifiable agent conversation records using CDDL, with representations in both JSON and CBOR. The format captures session metadata, message exchanges, tool invocations, reasoning traces, and system events in a structured, extensible CDDL definition for verifiable agent conversation records. COSE is used as the signing method to allow for native interoperability in SCITT Transparency Services and the CDDL definition allows for seemless integration in Evidence as specified in RFC 9334. The specification supports cross-vendor interoperability by defining a common representation that accommodates translation from multiple existing agent implementations with distinct data structure layouts that are typically represented in JSON. Agent Delegation Receipts Authproof This document defines the Agent Delegation Receipt: a signed record of what a human principal authorized an AI agent to do, for how long, and under what instructions. The receipt carries a scope, hard boundaries, a validity window, and a hash of the operator's stated instructions, all signed by the authorizing key. Version -11 replaces the draft's earlier custom signature format with two standard profiles: a JWS profile (RFC 7515) over JCS-canonicalized JSON (RFC 8785) as the primary wire format, and a COSE_Sign1 profile (RFC 9052) for constrained environments. It also specifies scope attenuation rules for multi-agent delegation chains, a revocation registry model with cascade semantics, and the limitations of what receipts can and cannot prove. Version -12 resolves the unknown- fields question raised on the IETF oauth mailing list: authorization fields are closed (verifiers reject unknown top-level body fields rather than silently ignoring them), the "metadata" object is the defined extension point, and one-time-use receipts fail closed without a durable consumption store. Version -13 incorporates independent-implementation feedback: it pins the orchestratorSignature verification key to the sub-receipt signer's key, states the receipt-issuance computation order explicitly, and guides issuers on default boundaries versus explicit allowances. Version -14 adds a pointer to content profiles for verification of what the agent produced, following implementer feedback. Version -15 adopts the grant/execution vocabulary of [CHEN-AGENT-USE-CASES]: the receipt as Execution Layer Evidence for a Grant Layer Authority. It adds delegatee holder binding for sub-receipts -- a parent names the delegatee's public key, closing a bearer-copy issuance gap found in review -- deprecates orchestratorSignature as redundant, sketches an OAuth authorization_details binding so a token can reference its receipt, and states normative custody requirements for the authorizing key. The delegateeKey field is a wire-format addition; -14-era verifiers will reject receipts carrying it, which is the intended fail-closed version behavior. Signed, Hash-Chained Action Receipts for AI Agents kriya native This document specifies a format for action receipts: compact, individually signed JSON records that state that a specific AI agent attempted a specific action at a specific time, under a specific policy decision, and what the outcome was. Receipts are linked into an append-only hash chain so that deletion, insertion, reordering, or modification of any previously recorded receipt is detectable by a verifier that holds only the records and the signer's public key. The format is deliberately small and self-contained. Verification requires no network access, no service operated by the producer of the receipts, and no state beyond the records themselves and a trust anchor obtained out of band. This document specifies the record fields, the canonical byte sequence that is signed, the chain linkage rule, the verification procedure, and test vectors. A SCITT Profile for AI-Agent Action Receipts NordenSoft This document profiles the IETF SCITT (Supply Chain Integrity, Transparency, and Trust) architecture for AI-agent action receipts: tamper-evident, signed, offline-verifiable records of what an autonomous agent was recorded as doing at the governed boundary, under which recorded principal class, with what recorded verdict, and -- where the issuer records one -- under which policy identity. Each receipt is a signed record over a canonical JSON payload, hash- chained so that each record commits to its predecessor, and presented either bare -- the payload with its own native signature -- or enveloped in a COSE_Sign1. This revision specifies how such a receipt is carried as a SCITT Signed Statement, with the protected claims a Transparency Service requires, so that a receipt can be registered. Registration obtains a Transparency Service's signed proof that the statement was registered in its log -- a property a self-signed chain cannot provide alone. It does not, by itself, give an offline holder non-equivocation: that requires consistency proofs and monitoring of the log, which this profile does not specify. The profile makes a deliberately narrow, checkable claim: this is an issuer-authenticated, signature-verifiable, tamper-evident record of the action, the recorded principal class, the recorded verdict, and any policy identity the receipt carries. It explicitly does not claim that the agent was correct, safe, or wise, that the recorded inputs were true or complete, that a named approver authorized this exact action before it ran, that a downstream controller succeeded, or that any physical effect occurred. This revision separates those last three as distinct claims with independent failure behaviour, states the boundary of a shared action digest, and keeps a deterministic offline policy-replay capability out of scope. AI Agent Execution Profile of SCITT Veridic Inc. Veridic Inc. This document defines a SCITT (Supply Chain Integrity, Transparency, and Trust) profile for creating independently verifiable, tamper- evident records of autonomous AI agent actions. The profile defines the AgentInteractionRecord (AIR) as the COSE_Sign1 signed statement payload for material agent actions; maps SCITT roles to the agent execution context, with the Agent Operator as Issuer and an independent Evidence Custodian as Transparency Service; specifies Registration Policy requirements including hash chain integrity, temporal ordering, and sequence completeness; defines a redaction receipt mechanism for privacy-preserving evidence custody; and provides compliance mappings to EU AI Act Articles 12 and 19, DORA, NIST AI RMF, MAS AI Risk Management Guidelines, PCI DSS, and MiFID II. An Agent Action Capsule Profile for SCITT Action State Group, Inc. This document defines a SCITT statement profile for recording what an AI agent did: the Agent Action Capsule. A Capsule is a digest- committed record of one agent action carrying its verdict-level disposition (executed, blocked, denied, errored, timed out), the deterministic constraints that were evaluated, the effect that was committed together with a confirmed-effect binding that distinguishes a dispatched attempt from an observed result, and an honest human-in- the-loop flag. Capsules are identified independently of signing and MAY be authenticated by one or more COSE_Sign1 Producer Envelopes. Its Capsule ID can separately be made transparent by registration in a SCITT Transparency Service [I-D.ietf-scitt-scrapi]. A Capsule is recorded on every verdict, including refusals: a blocked or denied Capsule is the auditor-grade evidence that a gate worked. Attenuating Authorization Tokens for Agentic Delegation Chains Tenuo This document defines Attenuating Authorization Tokens (AATs), a signed credential format for task-scoped delegation in AI agent systems. An AAT encodes the tools an agent may invoke and the argument constraints that apply to those invocations. A token holder authorized to delegate can derive a token offline with equal or narrower authority, subject to the parent token's depth and lifetime limits. The resulting delegation chain is verifiable offline by any enforcement point that has the root issuer's trust anchor key. This specification profiles the OAuth Rich Authorization Requests format (RFC 9396) for tool-level capability claims, adds delegation- chain claims, and defines a core constraint vocabulary for argument restrictions. The chain verification algorithm authenticates each delegation step and enforces monotonic attenuation without network contact with the root issuer. Proof-of-Behavior Protocol for Autonomous AI Agents Autonomous AI agents execute actions — file writes, API calls, shell commands — on behalf of human principals. No standard mechanism exists for a third party to verify that an agent acted within its declared behavioral rules, that policy enforcement occurred before execution (not after), or that the action log has not been tampered with after the fact. This document defines the Proof-of-Behavior (PoB) protocol: a minimal, language-agnostic standard for tamper-evident audit trails and pre-execution policy enforcement in AI agent systems. The protocol specifies a signed receipt format, a hash-chain linking scheme, a policy gate contract, and a cross-agent reference mechanism. Authorization Receipts for High-Risk Agent Actions EMILIA Protocol, Inc. This document defines the EMILIA Protocol (EP) authorization receipt, an evidence artifact binding an enrolled approver key to one canonical action before execution. An approver-held key signs an Authorization Context containing the action hash, policy reference, shared authorization instance, per-signoff nonce, audience, and validity window. A Trust Receipt carries the signed contexts, terminal consumption record, and Merkle inclusion material so a relying party can verify the recorded event offline under independently selected log, directory, policy, and approver trust inputs. The receipt establishes only the guarantees of the selected verification profile. The mapping from an enrolled approver identifier to a natural person is asserted by the directory authority. Offline verification does not establish current revocation status, global non-replay, comprehension, legality, safety, or execution. Replay prevention requires an online atomic consumption store at the executor. The state-machine invariants are machine-checked under the assumptions stated in this document. This revision defines the closed EP-AUTHORIZATION-BUNDLE-v1 pre- execution profile and its verification algorithm. The bundle carries the Action Object, signed Authorization Contexts, signoffs, key proofs, and presentation evidence; it deliberately carries no terminal consumption or execution claim. An optional, profile- identified authorization binding can commit the human evidence to an independently verified native authorization artifact without replacing that artifact or making this receipt format depend on its transport or trust model. A receipt is evidence, not authorization. This document does not treat a local user interaction as an authorization decision. It defines one evidence artifact that an authorization architecture can use in a human-confirmation flow: the signed Authorization Context is action-bound confirmation evidence an authorization server MAY validate and bind to the grant it issues. The resulting Trust Receipt records terminal consumption and remains evidence; neither object makes the authorization decision. That decision remains with the authorization server. Bounded Capability Receipts and Durable Spend Control for Agent Actions EMILIA Protocol, Inc. Agents sometimes need bounded authority to perform more than one consequential action without obtaining a new human approval for every operation. A signed token alone cannot enforce a shared budget across replicas, survive retries safely, or distinguish an operation that never crossed an effect boundary from one whose outcome is unknown. This document defines a bounded capability receipt and a durable reserve-admit-reconcile protocol. The receipt binds an issuance authorization, a closed action scope, a budget with explicit units, a holder proof, an expiry, and any parent capability. The state protocol atomically refuses overspend and operation-key replay, fences concurrent owners, and charges an indeterminate operation when an external effect may have occurred. Delegation transfers rather than copies authority: all direct child allocations are funded by committed parent operations before child registration, and their aggregate cannot exceed the parent balance within one authoritative atomic state domain. It also defines narrowing-only delegation, explicit revocation inheritance for delegated authority, an optional admission-control epoch that can freeze new consequence admission, and evidence interfaces. It does not make a bearer token into human approval, does not provide cross-domain or offline global double- spend prevention, and does not claim that an authorized action was safe, lawful, or successfully executed. An Architecture for Auditing Agent Delegation and Interactions An Audit Record Format for AI Agent Authorization Decisions Agent Audit Trail: A Standard Logging Format for Autonomous AI Systems Task-Relative Evidence Requirements for Agent Auditing AUDIT - Agent Use of Delegation and Interaction Traceability The Provared format - draft version 0 Verifiable Credentials Data Model v2.0 World Wide Web Consortium Agent Payments Protocol (AP2) AP2 project Macaroons: Cookies with Contextual Caveats for Decentralized Authorization in the Cloud Biscuit specification Eclipse Biscuit project User Controlled Authorization Network (UCAN) Specification, Version 1.0.0 UCAN Working Group

Codes The JSON encoding (): not-json (not JSON; empty; byte order mark); bad-envelope (envelope members); bad-base64url (not strict base64url); unknown-type (unknown label); bad-signatures-layout (signatures in wrong number or order); payload-not-canonical (content not canonical); line-not-canonical (line not canonical). Any record (): too-large (over a size limit, and ); payload-type-mismatch (other kind of record); bad-field (member missing, unknown, or malformed); bad-key (key not allowed, or a weak Ed25519 key); signature-invalid (signature fails, or has the wrong length); check-failed (anything unexpected). Passkeys (): passkey-bad-data (malformed values); passkey-wrong-type (wrong "type"); passkey-challenge-mismatch (wrong challenge); passkey-origin-mismatch (other origin); passkey-rpid-mismatch (other "rpId"); passkey-user-not-present (flag clear); passkey-user-not-verified (flag clear); issuer-not-expected (key not trusted). Logs and receipts (, , ): unknown-entry (unknown kind of entry); duplicate-id ("id" or delegation twice); duplicate-slip (permission twice); slip-missing (permission not earlier); slip-unusable (permission not sound); root-mismatch (unexpected root or size); chain-broken (receipt missing, moved, or changed); time-went-backwards (dated before its predecessor); terms-not-found (terms not in the log); countersignature-wrong-stub (for another receipt); countersignature-not-possible (service has no keys); countersignature-invalid (fails); approval-mismatch (for something else); approval-not-found (not in the entry); approval-reused (used twice); approval-invalid (fails); approval-dated-after-stub (dated after its receipt). Delegations, cancellations, and heads (, , ): pass-missing (delegation not earlier or not sound); pass-mismatch (other permission); pass-too-deep (deeper than 10); cancellation-invalid (fails); cancellation-not-found (unusable); seal-mismatch (size or root wrong); seal-chain-broken (wrong "previous"); sealer-not-expected (recorder not trusted); dated-after-stamp (dated after a time-stamp); stamp-bad-data (malformed); stamp-wrong-data (for something else); stamp-invalid (signature or field fails). Findings (, ): action-not-allowed, prohibited, party-not-allowed, outside-valid-time, amount-missing, over-limit, over-each-limit, over-count-limit, over-period-limit, countersignature-missing, approval-missing, after-cancellation, pass-not-allowed, and pass-wider. The codes terms-unusable, terms-mismatch, outside-terms, cover-invalid, vouching-missing, acknowledgement-mismatch, proof-invalid, headers-invalid, and record-not-sound belong only to parts specified in .

Shared List Names that begin "provared." are reserved for this list; also gives each action's meaning. Shared action names are written below without their "provared." prefix: "data.read" stands for "provared.data.read". Kinds and rules of conduct are written as shown, with no prefix; a "never" list may name any of them.

"reads":: Looks at data without changing it. Actions: "data.read", "data.search", "message.read", "calendar.read", "code.read", "web.read".
"changes":: Creates or changes data in a way that can be put back. Actions: "data.create", "data.change", "message.draft", "calendar.change", "access.remove", "code.change", "system.configure".
"destroys":: Removes data or a resource in a way that may not be put back. Actions: "data.delete".
"sends":: Sends a message or data to a person, to the public, or to another system. Actions: "data.export", "message.send", "post.publish", "agent.instruct".
"commits":: Binds the principal to something: an order, a booking, an agreement, an account. Actions: "booking.make", "booking.cancel", "order.place", "order.cancel", "terms.accept", "form.submit", "account.create".
"grants":: Gives someone or something access or permission. Actions: "access.grant", "key.create".
"runs":: Runs a program or a command. Actions: "code.run", "code.release".
"enters":: Signs in to a system or an account. Actions: "account.sign-in".
"impersonate":: Never claim to be a human being, or to be anyone other than the agent of the principal who signed the permission.
"bypass":: Never go around an access control, a block, or a refusal.
"escalate":: Never obtain or use access that the agent was not given.
"conceal":: Never hide, alter, or leave out the agent's own records.
"deceive":: Never state what the agent has reason to believe is false, and never make up a record or a result.
"harass":: Never threaten, pressure, or attack a person.
"disclose":: Never pass information that is not public to anyone the permission does not name.
"continue-after-stop":: Never carry on after being told to stop.

Changes Since -01

defines an executor: software other than the agent that refuses an action its check of the permission does not allow, named in a permission as a service is. says how a receipt names an executor that countersigns, and states when an executor's records show a receipt that was never written, and that comparing them with the log is not specified.
and describe newer versions of two drafts: the cumulative limit of , and the signature methods, pre-execution records, and independent recording of .
adds retries and what a countersignature attests.
describes version 0.6.0, which refuses some time-stamps that accepts.
No record, and no rule that a verifier applies, changes.

Changes Since -00

The content model ( through ) is specified apart from its encoding. The JWS form is now , with its rules unchanged; states what another encoding, such as one with COSE, has to define. Log "lines" are now "entries" outside , and the codes in are grouped by where they arise.
No record's bytes change, but a verifier of -01 refuses some records that -00 accepted, to match versions 0.2.0 to 0.5.0 of the implementation. From version 0.2.0: an Ed25519 key that encodes a y of p or more, or the y of a point of small order, is refused as a key wherever it stands, used or not (bad-key; in a TSA's certificate, stamp-invalid), where -00 refused only a signature verified under such a key; an "origin" outside the exact rule of , which needs no parser of web addresses; a TSA's RSA public exponent that is not odd, from 3 to 2^32 - 1 (stamp-invalid); and a TSA certificate's public key not written strictly (stamp-bad-data). From version 0.4.0: an Ed25519, ML-DSA-87, or SLH-DSA-SHA2-256s signature whose length is not its method's is a problem on every verifier, whether or not it implements the method (signature-invalid; ), where -00 left it unverified on a verifier without the method. From version 0.5.0: a document name that begins "provared." in a receipt's or an approval's "details" MUST be one of the seven reserved names, and only the three identifiers among them may be named more than once in one record (bad-field; ), where -00 read every name as a label.
names more of what other drafts already have. compares the two EMILIA Protocol drafts and maps the records onto the AUDIT architecture's record types. says which records can show that a receipt was never written.
describes version 0.5.0 and a second implementation, in Python, by the same author.

Acknowledgements The author thanks Iman Schrock, whose comments on the audit@ietf.org list on 8 October 2026 led to the separation of the content model from its encoding and to the comparison in , and Nicholas Templeman and Lars Kersten Kroehl, for the discussion on that list, from 11 to 23 October 2026, of failure cases and of the number rule.