Review · October 26, 2026
Actor Proofs, Having Each Actor Sign Its Own Delegation Hop
The problem it's solving
The Actor Profile puts actors in the act claim. The Actor Receipts companion has the AS sign a record of each hop. Both are the AS's word. A compromised or dishonest AS can mint a token claiming an agent participated in a delegation that the agent never saw.
This draft closes that gap by making the actor sign too. Before the AS issues a delegated token, the actor signs a small JWT saying "I am this actor, acting for this subject, and I consent to a token for these audiences." The AS validates it and embeds it in the token. Anyone downstream can verify the actor's signature with a key they trust independently of the AS.
The property this buys is non-repudiation. An AS can still issue whatever it wants. It just can't pin that issuance on an actor who didn't sign for it.
How it fits in the working group
This is the third document in a three-part suite, and it depends on the other two. It reuses prh, prh_alg, origin_jti, and sub_iss from Receipts, and its claim-pair and discovery conventions. It requires an act chain conforming to the Profile. Neither of those is adopted. Transaction Tokens and the Entity Profiles draft are also normative. The core references are Token Exchange, RFC 7523, Resource Indicators, Introspection, and Protected Resource Metadata.
It registers a lot for an optional companion: one token request parameter (actor_proof), five JWT claims, one media type, one AS metadata parameter, two PRM parameters, and two introspection members. It also asks IANA to amend four claims registered by Receipts so their descriptions cover proofs too.
Section 1.2 is honest that this is one of at least four competing designs for delegation evidence. Actor Chain keeps actor signatures at the AS and puts a commitment in the token. Delegation Chain carries AS-signed hop records that a delegator can countersign. Intent Admission does a single-hop intent artifact. This one carries actor-signed proofs inline with an explicit target binding. The draft says the comparison is "intended to inform, not preempt" convergence. The WG should have that conversation before adopting any of them.
What the mechanism actually does
The actor signs a proof JWT. Type actor-proof+jwt, asymmetric signature only. iss is the actor itself. sub is the user. act is a single-hop object naming the actor and its namespace. target.aud lists the audiences the actor agrees to, with optional target.resource to narrow further. aud is prohibited on the proof itself. exp is required and must outlast any token that will carry it.
The actor sends it with the token request. The new actor_proof parameter rides alongside a Token Exchange or JWT assertion grant request. It is not the actor_token and it does not authenticate anything. The AS authenticates the actor the normal way, then separately validates the proof.
The AS enforces the target binding. Every audience of the issued token must appear in target.aud. If target.resource is present, every resource indicator must match an entry exactly. The AS also lowers the token's exp to the proof's exp if the proof would expire first. Then it prepends the proof to actor_proofs.
Proofs chain by hash. Each new proof carries prh, the hash of the previous proof's exact compact serialization. The array is ordered newest to oldest and must be a contiguous outermost prefix of the act chain. Partial coverage is allowed so deployments can roll this out from the edge inward. actor_proofs_complete: true says every visible hop has a proof.
Reissuance carries proofs forward unchanged. A refresh or same-actor reissuance can't add a proof. It must preserve the array byte for byte, must not change sub, and must not extend exp past the oldest proof. Refresh takes the array from server-side state, not from the previous access token.
Consumers run eleven steps. Validate the outer token, check counts, resolve each actor's key from a trusted source, verify signatures and hash linkage, align each proof with its act hop, align sub, check the current token's audience against the newest proof's target, and cross-check sibling receipts if present. Any failure strips the token of actor-signed evidence. The token is rejected only if policy or PRM requires that evidence.
Strict mode is the default. A token whose audience exceeds the newest proof's target, or whose jti differs from a present origin_jti, is divergent and rejected unless the recipient has configured that issuer as a trusted reissuer.
So what does a proof actually prove?
Section 7.3 is unusually candid. A valid chain proves the covered actors signed their participation and hop-time target. It does not prove the delegation is still active, that any AS validated the hop, or that the actor consents to the current request. It conveys no authority. Authorization still has to evaluate the current token and current policy.
That's the right framing, and it raises the question of who needs this. Section 11.6 says the protection only holds if the RS requires proofs on every delegated token it accepts. A dishonest AS defeats that by issuing a token with no act at all. So this doesn't stop a bad AS from doing harm. It stops a bad AS from attributing harm to an innocent agent. That's an audit property, and the WG should decide whether it wants normative token-format changes for an audit property.
A related question: in most agent flows the actor is also the OAuth client and already signs the request with private_key_jwt or DPoP. The AS has an actor signature in hand. The draft explicitly says the actor_proof isn't the actor_token. What the proof adds over embedding the client assertion is sub and target. Whether that's worth a second signed artifact and a new parameter is a fair thing to ask.
Significant interoperability concerns
The trust anchor is out of scope. Section 2 says "This document does not standardize how actor signing keys are established." Section 11.3 says trust is per-key, per-deployment, non-transitive, and must come from a source independent of the issuer. Every security property in the document rests on that source. Two conformant deployments can verify each other's proofs only after exchanging actor keys through some unspecified channel. The draft points at Attestation-Based Client Auth and SPIFFE as examples, but neither is required.
The actor has to know three things before signing, and none of them has a mechanism. The act.iss the AS will emit comes from "deployment configuration." The prospective jti for origin_jti needs a challenge mechanism the draft declines to define. For an opaque inbound token, the newest inbound proof's hash needs "a mechanism it defines." Without these, origin_jti and receipt_jti can't be populated, and a chain can't be extended across an opaque token. The instance-binding story depends on a protocol step that doesn't exist.
Proofs get dropped in the common case. The token's exp is capped at the proof's exp. Actors are told to keep proof exp short. Refresh ends instance binding. Section 6 then gives the issuer three options when a retained proof is shorter-lived than the new token: shorten the token, drop the proofs, or fail. Once dropped, proofs come back only through a fresh delegated issuance. A long-running agent session on refresh tokens loses its actor-signed evidence after the first refresh. The property evaporates exactly where delegated sessions live.
Too many postures. Receipts-only, proofs-only, or both. Full or partial coverage. Strict mode or trusted reissuers, with retargeting as a separate permission. Subject continuity by exact match, by mapping rules, or unverified. Inline proofs, introspected proofs, or both with a conflict rule. Each fork is local policy. Two resource servers can look at the same token and disagree about whether it has actor evidence.
Token size. Each proof is 400 to 800 bytes. Receipts are similar. A three-hop chain carrying both companions adds several kilobytes to an access token in an Authorization header. The draft acknowledges this and suggests introspection as the escape hatch.
Mechanisms that could be removed
receipt_jti. Needs a prospective receipt identifier the actor can't get. The draft itself says most deployments useproof_jtion the receipt instead. Delete it and keepproof_jti.origin_jtion proofs. Same problem: no challenge mechanism. Either define the mechanism or drop the claim and rely on receipts for instance binding, which Section 11.4 already calls the RECOMMENDED posture.sub_profilein the proof'sactobject. It's optional, compared as a set, and when absent "the proof remains aligned." Half a page of rules for a value the actor may or may not sign.- Trusted reissuing issuers and retargeting permission (Section 11.4.1). Two-level policy override of strict mode. Ship strict mode only.
- The three-way lifetime rule in Section 6. Pick one behavior. Lowering the token's
expis the only one that keeps the evidence. - Refresh-token state guidance in Section 6.3. Four bullets of implementation advice with no keywords. Implementation guide material.
- Introspection delivery (7.4, 8.3, 9.3). Defer until a deployment needs opaque tokens with proofs. It adds inline-versus-introspected conflict rules and filtering rules that exist only to interact with the Profile's
chain_complete. - Section 10 companion-authoring rules. Useful if the suite grows. Premature for an individual draft.
What's left is the proof format, the actor_proof parameter, AS validation and embedding, hash linkage, consumer validation, metadata, and the threat model. That's a 25-page document.
Writing quality
Precise, consistent, and written by someone who has thought through the edge cases. Section 11.1 is the best part: a plain list of what this mitigates and what it doesn't, including compromised actor keys, downgrade by omission, and collusion. More drafts should have that section.
The -01 revision tightened things, dropping from 57 to 51 pages and from roughly 195 to 162 BCP 14 keywords. The "each rule has one home" approach means the text is dense with references like "step 9 of Section 7" and "Section 11.4.1," and a reader has to keep Receipts open since four claims and the discovery conventions are defined there. The examples use <proof-0> placeholders rather than real compact JWTs, so nobody can test the prh computation against the document.
Background of the author
Sole author, Karl McGuinness, listed as Independent, formerly at Okta.
- 0 published RFCs
- 16 active Internet-Drafts and 2 expired, as of mid-October 2026
- Co-author of ID-JAG, an adopted WG document, and of the Entity Profiles draft this one depends on
Not a new author, and writing at a very high rate. This is the third of three tightly coupled actor documents, all individual submissions, totaling close to 200 pages.
Questions worth raising
- Is non-repudiation against the AS a problem the WG wants to solve in the token format? If recipients trust the AS for
sub,scope, andaud, what changes when they stop trusting it foract? - Should the WG pick a delegation-evidence direction first? Four drafts now propose different artifacts for the same question. Adopting any one of them before comparing them locks in a shape.
- Can the actor's existing signature do this job? The actor already signs a client assertion or DPoP proof at the token endpoint. Embedding that, plus a target binding, might be a much smaller change than a new parameter and a new JWT type.
- Who defines actor key distribution? It's the whole trust model, and it's explicitly out of scope here.
For the AS-signed half of this design, read the companion Actor Receipts draft. For the competing approach that keeps actor signatures at the AS instead of in the token, read Actor Chain.