| Internet-Draft | PACE Authorization | November 2026 |
| Nandakumar & Jennings | Expires 20 May 2027 | [Page] |
This document specifies the authority agents exercise in dialogs of the Protocol for Agent Communication Exchange (PACE): delegating work with a credential bound to the delegated dialog, pausing to ask for approval of a single action, and turning that approval into an authorization for only that action. It also covers proof that a principal approved, commitments between parties acting for different principals, and facts attested by third parties. It reuses OAuth, WIMSE, and agent-protocol mechanisms, defining only the glue to PACE and the security properties every profile must provide.¶
This note is to be removed before publishing as an RFC.¶
Status information for this document may be found at https://datatracker.ietf.org/doc/draft-nandakumar-agentproto-pace-authz/.¶
Discussion of this document takes place on the Agent Communication Protocols Working Group mailing list (mailto:agentproto@ietf.org), which is archived at https://mailarchive.ietf.org/arch/browse/agentproto/. Subscribe at https://www.ietf.org/mailman/listinfo/agentproto/.¶
This Internet-Draft is submitted in full conformance with the provisions of BCP 78 and BCP 79.¶
Internet-Drafts are working documents of the Internet Engineering Task Force (IETF). Note that other groups may also distribute working documents as Internet-Drafts. The list of current Internet-Drafts is at https://datatracker.ietf.org/drafts/current/.¶
Internet-Drafts are draft documents valid for a maximum of six months and may be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to use Internet-Drafts as reference material or to cite them other than as "work in progress."¶
This Internet-Draft will expire on 20 May 2027.¶
Copyright (c) 2026 IETF Trust and the persons identified as the document authors. All rights reserved.¶
This document is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (https://trustee.ietf.org/license-info) in effect on the date of publication of this document. Please review these documents carefully, as they describe your rights and restrictions with respect to this document. Code Components extracted from this document must include Revised BSD License text as described in Section 4.e of the Trust Legal Provisions and are provided without warranty as described in the Revised BSD License.¶
PACE [PACE] gives agents a common dialog: an identifier that spans hops, intermediaries, and connections; a lifecycle controlled by one participant; cancellation and termination that propagate along delegation chains; and a binding to MOQT. It says little about authority: who may act on whose behalf, and which actions need explicit approval. "Agentic AI Use Cases and Requirements" [UCREQ] draws the same line and leaves delegation, per-action authorization, and revocation to OAuth and WIMSE (Section 5 of [UCREQ]).¶
That work exists or is in progress (Section 1.1), but none of it says how an approval request travels between agents in a dialog, how a delegation is bound to the dialog it authorizes, or how the pieces compose in a chain of agents. This document:¶
states the security properties every deployment provides (Section 2);¶
specifies authorization checkpoints, through which an agent asks for approval of one action (Section 4);¶
specifies approval tokens, which authorize only the approved action (Section 5);¶
specifies principal confirmations, which only the principal can produce (Section 6);¶
specifies what agents of different principals use with each other: peer checkpoints, commitments that record terms each principal confirms, and assertions that carry facts with their source (Section 7); and¶
lists what evidence of approvals and actions records (Section 8).¶
The use cases in [DIALOG-UC], such as a consumer's agent disputing a charge with a brand's agent, or a tool that must reach the person behind an agent, motivate the peer checkpoints, principal confirmations, commitments, and assertions.¶
This document reuses existing mechanisms and defines only the glue to PACE. Figure 1 shows where each fits in the life of a delegated task.¶
1. Delegate 2. Ask 3. Approve 4. Act
+-------------+ +-------------+ +-------------+ +-------------+
| delegation |-->| checkpoint |-->| approval |->| request at |
| credential | | request | | token | | resource |
+-------------+ +-------------+ +-------------+ +-------------+
Actor Profile RAR Token Exchange DPoP
Txn-Tokens agent_action actor-bound mTLS
delegator-bound Txn Challenge, token exchange
chains AAuth CIBA, when a
WPT + message JWS + JCS person approves
binding OpenID4VP,
WebAuthn, SPC
-------------------------------------------------------------------
Throughout: revocation along the chain (Status List, token
revocation, delegation revocation events)
Delegate (Section 3): delegation credentials of the Actor Profile [ACTOR-PROFILE], Transaction Tokens [TXN-TOKENS], or delegator-bound chains [AGENT-DELEGATION] over Delegation Tokens [DELEGATION-TOKENS], presented with WIMSE credentials [WIMSE-CREDS] bound to their control message [WPT-MSG].¶
Ask (Section 4): the action as a RAR [RFC9396]
agent_action detail, a resource challenge from Txn Challenge
[TXN-CHALLENGE] or AAuth [AAUTH-ROSENBERG] [AAUTH-HARDT], a
JWS [RFC7515] over the JCS [RFC8785] form, and, when the
principal must confirm, OpenID4VP [OID4VP], WebAuthn [WEBAUTHN],
or SPC [SPC].¶
Approve (Section 5): Token Exchange [RFC8693] with actor-bound token exchange [ACTOR-BOUND], or CIBA [CIBA] when a person approves.¶
Act (Section 5.7): the approval token, sender-constrained with DPoP [RFC9449] or mTLS [RFC8705].¶
Throughout, revocation reaches every holder along the chain (Section 3.5) through Token Status List [STATUS-LIST], token revocation [RFC7009], and delegation revocation events [REVOCATION-EVENTS].¶
Appendix A surveys these and other related work, and what each leaves to this document.¶
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 [RFC2119] [RFC8174] when, and only when, they appear in all capitals, as shown here.¶
This document uses the terms dialog, dialog context, participant, controller, delegated dialog, and control message from [PACE].¶
The participant that opens a delegated dialog to have work done on its behalf; the controller of that dialog.¶
The participant that carries out the work, including an action that needs approval.¶
The participant that sends a checkpoint request: usually the performing agent; a relaying agent (Section 4.7); or, in a peer checkpoint, the party that needs approval.¶
The participant that answers a checkpoint: in a delegated dialog, the delegating participant or a participant it designates (Section 5.2); in a peer checkpoint, the counterpart. It can relay the decision to its principal or to its own approver.¶
The authorization server, or OpenID Provider, from which the approver obtains approval tokens (Section 5.2).¶
A signed request to authorize one action, and the signed response (Section 4).¶
A signed statement from a protected resource that refused an action, describing the action and the authorization it needs, such as an OAuth Transaction Authorization Challenge [TXN-CHALLENGE].¶
An authorization that covers only the action approved at a checkpoint (Section 5).¶
The credential a delegating participant presents in OPEN to convey the authority it delegates (Section 3).¶
A checkpoint whose approver acts for a different principal than the requester, outside any delegation (Section 7.1).¶
Proof, made with a key bound to the principal and not to any agent, that the principal approved one checkpoint request (Section 6).¶
Signed terms that two or more parties agree to, with each party's confirmation (Section 7.2).¶
A signed statement of a fact, asserted by its sender or attested by a named third party (Section 7.3).¶
Times in the JSON objects this document defines, such as deadline,
expires_at, and until, are date-time strings [RFC3339], as in
[PACE]. JWT claims, such as iat and exp, remain NumericDate
values.¶
Deployments use different credential formats, so this document states the properties they provide instead of relying on any one format.¶
Every deployment of PACE authorization MUST provide P1 to P8, whichever credential formats it uses. A deployment that uses commitments (Section 7.2) MUST also provide P9, and one that requires principal confirmations (Section 6) MUST also provide P10.¶
A delegation credential is accepted only for the delegated dialog it was presented in, by the participant it names, with its parent dialog (Section 3.1).¶
Authority conveyed by delegation never exceeds the authority of the delegating participant (Section 3.3).¶
Every participant can determine that a chain has one originator, and the party that authorized the chain can identify it (Section 3.3).¶
A checkpoint request is signed by its requester and a response by the approver, so no intermediate agent or relay can forge or alter either (Section 4.3).¶
An approval covers only the checkpoint it answers, identified by a hash of the request, and an approval token covers only that action, once, for the performing agent's key (Section 4.5, Section 5).¶
When a protected resource described the action in a resource challenge, decisions and displays are based on that challenge, not on agent-supplied text (Section 4.4).¶
Checkpoints expire at their deadline, and a request or response is acted on at most once, even when the dialog log redelivers it (Section 4.6).¶
When a delegation is revoked, the delegated dialogs that depend on it are terminated (Section 3.5).¶
An agreement between parties acting for different principals is complete only when each principal has confirmed it, each confirmation bound to the same hash of the terms, never on an agent's self-reported satisfaction or reported scores (Section 7.2).¶
A confirmation required from a principal is verifiable as made with a key bound to that principal, so neither the principal's agent nor a relaying agent can produce it (Section 6).¶
A receiver of delegated work needs to know that the authority was meant for this dialog and for itself, is no broader than the delegator's, and stops when revoked.¶
A delegating participant opens a delegated dialog as [PACE]
specifies: OPEN lists the parents in parent_dialog_ids, the
delegating participant is the controller, and the delegation
credential travels in the credentials member of OPEN.¶
Without this binding, a credential copied out of one OPEN could be
presented in another dialog. The presentation that accompanies a
delegation credential MUST include the mth claim of [WPT-MSG] with
the pace canonicalization profile, in whichever presentation form
[PACE] defines for the credential's mechanism: a Workload Proof
Token, a Key Binding JWT, or a PACE presentation JWT. In OPEN, which
is sent before the delegating participant has the delegatee's nonce,
the presentation has no nonce and the delegatee does not treat the
delegator as authenticated until the controller's later presentation,
bound to the delegatee's nonce, verifies; in later messages its
nonce is the verifier's nonce, as [PACE] requires.¶
A credential bound to no key cannot be bound to the message, so a receiver MUST NOT accept one as a delegation credential. The exception is a Transaction Token [TXN-TOKENS] within the trust domain that issued it, where the token service, not a key, establishes the chain (Section 3.2).¶
Because OPEN carries the dialog-id, parent_dialog_ids, and the
invited participants, the presentation is thereby bound to the
delegated dialog, its parent, and its audience (P1). A receiver MUST
verify mth before acting on the credential. Credential formats need
not change.¶
The presentation names who may accept it; the credential names where the authority may be used. A delegating participant SHOULD set the credential's audience to the resources the delegated task needs, no broader than its own, and SHOULD use a format in which a child's audience cannot exceed its parent's, such as a delegator-bound chain [AGENT-DELEGATION].¶
When the credential format can carry it, the delegating participant
SHOULD also include the parent dialog-id in the credential, as the
ctx claim of type dialog [AGENT-DELEGATION]. Within one trust
domain, a Transaction Token issued for the delegated work SHOULD carry
the dialog-id in tctx.dlg [DIALOG-BINDING].¶
Who vouches for each hop of a delegation chain depends on the deployment. Inside one trust domain, a token service issues each hop and is trusted to have checked it. Across domains, either a server at each boundary issues the next hop, or each delegator signs the hop it grants, so that a receiver can verify the chain itself. Whoever vouches for a hop also provides attenuation (P2) and originator traceability (P3) for it (Section 3.3).¶
| Deployment | Who vouches for each hop | Mechanisms |
|---|---|---|
| One trust domain | The domain's token service | Transaction Tokens with tctx.dlg; Token Exchange |
| A server at each domain boundary | The server at that boundary | Identity chaining; cross-domain Transaction Tokens [TXN-CHAINING]; Hardt AAuth call chaining |
| Agents that delegate directly across domains | The delegator, by signing the hop | Delegation Tokens [DELEGATION-TOKENS] with delegator binding [AGENT-DELEGATION]; Delegate SD-JWT under [AGENT-DELEGATION] |
Implementations MUST support delegation credentials that are:¶
JWT access tokens with act claims ([RFC8693]), interpreted as
the OAuth Actor Profile [ACTOR-PROFILE] defines;¶
bound by a cnf claim to the delegatee's key; and¶
presented with a PACE presentation JWT carrying mth, the form
[PACE] defines for a token bound by cnf (Section 3.1).¶
Each hop obtains a new token for the next delegatee by token exchange.¶
Implementations that accept delegation across administrative domains without an authorization server in the path MUST also support Delegation Tokens [DELEGATION-TOKENS] with delegator binding [AGENT-DELEGATION]. A chain that only an issuing server asserts does not show that each hop granted the next (Section 4.4 of [UCREQ], requirement B3-3).¶
Delegation can only narrow authority: a delegatee can do no more than its delegator (P2), and every chain leads back to one originator (P3). This section says how a receiver checks both, and how a participant that acts under its own authority is distinguished from one that passes on delegated authority.¶
When a receiver verifies a chain hop by hop, it MUST reject the credential if any hop conveys more authority than the hop before it (P2). It compares by the rules of the credential mechanism, such as Section 4.3 of [DELEGATION-TOKENS]. Where authority is expressed as RAR authorization details [RFC9396], the comparison is the relation of [RAR-NARROWING], under which details that cannot be compared are not narrower. A receiver that cannot compare the authority at some hop MUST reject the credential.¶
When an authorization server asserts the chain, as with nested
act claims, the server's narrowing at each exchange provides P2
(Section 3.6 of [ACTOR-PROFILE]).¶
A delegated dialog with several parents acts under the authority of each parent separately. The delegating participant presents one delegation credential per parent whose authority the work uses, and each operation in the delegated dialog MUST be authorized by one of them. Authority from different parents is not combined.¶
When OPEN lists more than one parent, each delegation credential
MUST name the parent dialog it derives from, as the ctx claim of
type dialog [AGENT-DELEGATION] does; a format that cannot name
it cannot be used in such a dialog. When parent_dialog_ids is
present, a receiver MUST reject a credential that names a dialog not
in it, and MUST reject two credentials that name the same parent.¶
A listed parent without a credential contributes no authority: an
operation that needs it fails authorization. A receiver MAY refuse
the OPEN with ERROR policy-rejected when its policy requires every
listed parent to be backed by a credential. When parent_dialog_ids
is withheld ([PACE]), the receiver relies on the credentials'
ctx alone, and the controller, which keeps the link, applies
revocation for each parent (Section 3.5).¶
A participant can also act under authority granted to it directly,
such as a booking service that calls a payment processor under its
own contract. That is not a delegation: the participant presents its
own credentials, and a delegation credential, if present, only shows
whom it acts for (Section 10.1 of [AAUTH-HARDT] reaches the same
outcome). The controller states which case applies with the dialog
parameter authority_basis in OPEN. Like the parameters in
Section 5.2, it is set by the controller and not negotiated;
a participant that disagrees sends REJECT.¶
own: the participant acts under authority granted to it
directly. A delegation credential, if present, is evidence only.¶
delegated: the participant passes on authority it received,
conveyed by the delegation credential in OPEN, subject to P1 to
P3.¶
When authority_basis is absent, it is delegated if OPEN carries
parent_dialog_ids or a delegation credential, and own otherwise.
A receiver MUST NOT accept onward delegation of a principal's
authority from a participant that declared own. With either value,
the authority passed SHOULD cover only the one action and parameters
the delegated work needs, for example a single agent_action detail
(Section 5.1).¶
Where the originator's identity must not be disclosed to every hop
(P3), the chain carries a pseudonym that only its issuer can resolve,
such as the per-chain pseudonym sub of [AGENT-DELEGATION]. An
issuer MUST NOT copy an identifier that another issuer directed to a
specific audience into a delegation credential.¶
A receiver MUST reject OPEN with ERROR delegation-cycle ([PACE]) if:¶
the delegation chain already names the receiver;¶
the chain names any agent twice ([AGENT-DELEGATION]); or¶
parent_dialog_ids contains the dialog's own dialog-id or repeats an
entry.¶
Depth limits, such as del_max_depth of [DELEGATION-TOKENS], bound
cycles that identifiers do not reveal, but do not replace this check.¶
Revoking a credential must stop the work done under it and under every credential delegated from it (P8).¶
A participant that learns that a credential its participation depends on was revoked MUST stop acting under it. If it controls a delegated dialog that depends on the credential, it MUST terminate that dialog, and PACE lifecycle propagation terminates the dialogs below it ([PACE]). Otherwise, it MUST LEAVE the dialog.¶
The credential's own mechanism reports the revocation: a Token
Status List [STATUS-LIST] entry, token revocation [RFC7009], or
a Shared Signals event [AIMS]. To reach holders further down the
chain, including holders in domains the revoking party does not
know, the revoking party sends a delegation revoked event
[REVOCATION-EVENTS], and each delegator relays it to the holders of
the credentials it delegated, in the credentials member of the
REVOKE or TERMINATE it sends them.¶
If a participant cannot check a credential's status within the
staleness bound its policy sets, it MUST NOT act under the credential
until it obtains a current answer, and MUST reject operations that
rely on it with ERROR authorization-unavailable ([PACE]). This
suspends the work without ending it: the participant stays in its
dialogs and resumes once the credential is shown valid. If its
policy limits how long work can stay suspended, it MAY terminate or
leave the dependent dialogs when that limit passes.¶
A controller that removes a participant with REVOKE also revokes the participant's delegation credential, if the controller issued it.¶
Credentials issued for a delegated dialog remain valid after the dialog terminates, until they expire or their issuer ends them. An authorization server that ties authority to a unit of work [BOUNDED-WORK] can end them when the dialog ends.¶
An agent that holds an SD-Card can obtain a delegation credential by
Token Exchange with its SD-Card as the actor token; the issued token's
act claim carries the SD-Card's sub and iss (Section 7.1 of [SD-CARD]).¶
Some actions need approval first, because a resource refused the call or the delegating participant's policy requires it, and the party that can approve is often another agent several hops away. A checkpoint carries the signed request to that party and the signed decision back.¶
Figure 2 shows a checkpoint from start to finish.¶
Resource Performing Approver Approval server agent issuer | | | | |<---- call ----| | | |-- refused, -->| | | | challenge(1) | | | | | | | | pause |-- checkpoint ------->| | | operation | request (2) | | | | signed; through | | | | relays, if any | | | | | | | | decide; may ask | | | the principal (3) | | | | | | | |-- token exchange->| | | | + actor proof | | | |<- approval token -| | | | (4) | | |<-- checkpoint -------| | | | response (5) | | | | | | |<-- call with -| | | | approval token| | | | (6) | | |
The performing agent reaches an action that needs approval: a resource refused the call, optionally with a resource challenge (Section 4.4), or its delegator's policy requires approval.¶
It pauses the operation and publishes a signed checkpoint request
on its checkpoint flow (Section 4.1, Section 4.2,
Section 4.3). Agents between it and the approver relay
the request unmodified (Section 4.7).¶
The approver decides, by its own policy or by asking its principal (Section 6).¶
To approve, the approver obtains an approval token for the one action, bound to the performing agent's key with the actor proof from the request (Section 5.3).¶
The approver publishes a signed checkpoint response carrying the outcome and the token (Section 4.5), before the request's deadline (Section 4.6).¶
The performing agent resumes the operation and presents the token to the resource, which checks it against the approved action (Section 5.7).¶
A checkpoint does not change the dialog context. Checkpoints can also pass between peers acting for different principals (Section 7.1) and be addressed to a principal through its agent (Section 6.6).¶
Each participant sends its checkpoint objects on its own checkpoint
flow of the dialog: a reliable flow of the PACE dialog log [PACE]
at the Urgent Signals priority tier. Each request, response,
commitment (Section 7.2), and assertion (Section 7.3) is one
object. Because the flow is reliable, the log's acceptance and replay
rules apply: after a reconnection, an object its receiver had not
accepted is made available again at the same position, and one it had
accepted is discarded as a duplicate. An approver therefore does not
ask its principal twice for the same request.¶
In the MOQT binding of [PACE], the flow is a checkpoint track in
the sender's dialog namespace, with each object in its own group,
Subgroup Delivery Mode, and no finite delivery timeout:¶
("pace", "dialogs", {dialog-id}, {agent-id}) -- "checkpoint"
¶
Other bindings define how they carry the flow.¶
A checkpoint request asks one participant to approve one action, and carries what the approver needs to decide and to obtain an approval token.¶
A request is a JSON object, published as one object of the sender's
checkpoint flow (Section 4.1). Times are RFC 3339 date-time
strings, binary values are base64url-encoded without padding, and the
request is signed as Section 4.3 specifies. Its members are
grouped below by purpose.¶
REQUIRED. The string request.¶
REQUIRED. A UUID version 4.¶
REQUIRED. The dialog in which the request is published.¶
REQUIRED. The requester's participant identifier.¶
REQUIRED. The participant asked to approve: in a delegated dialog,
the controller, or the participant named by the approver dialog
parameter (Section 5.2); in a peer checkpoint, the
counterpart (Section 7.1).¶
REQUIRED. The time after which the checkpoint is unresolved (Section 4.6).¶
REQUIRED. A fresh random value with at least 128 bits of entropy.¶
REQUIRED, except in an encrypted request (Section 6.6).
The action, its arguments as a JSON object, and its effect, as the
requester understands them. They are advisory when
resource_challenge is present (Section 4.4).¶
OPTIONAL. Free text describing the action. Unlike parameters, it
is not enforced by an approval token.¶
REQUIRED. The paused operation, in the form of the PACE CANCEL
target.¶
REQUIRED. The base64url-encoded SHA-256 hash of the object payload that started the paused operation.¶
OPTIONAL. The signed checkpoint request from a dialog below that this request relays, unmodified (Section 4.7).¶
OPTIONAL. Used together for a request that the relaying agents must not read (Section 6.6).¶
REQUIRED. See Section 4.3.¶
The following request asks a banking assistant to approve a transfer on behalf of the agent closing an account:¶
{
"type": "request",
"checkpoint_id": "6f1c0e9a-3c2d-4b7e-9a51-0d6c2f4e8b10",
"dialog_id": "550e8400-e29b-41d4-a716-446655440000",
"requester": "closure-agent",
"approver": "banking-assistant",
"action": "transfer",
"description": "Transfer the remaining balance",
"parameters": {"amount": "1520.00", "currency": "EUR",
"to": "DE89370400440532013000"},
"effect": "Moves funds out of the closing account; irreversible",
"target": {"namespace": ["a2a", "task"], "track": "t1"},
"operation_hash": "pLk2...",
"deadline": "2026-11-09T17:00:00Z",
"nonce": "Tq8m0vB1kRj3zXc5aYp2Lw",
"authorization_details": [{
"type": "agent_action",
"checkpoint_id": "6f1c0e9a-3c2d-4b7e-9a51-0d6c2f4e8b10",
"action": "transfer",
"parameters": {"amount": "1520.00", "currency": "EUR",
"to": "DE89370400440532013000"},
"bounds": {"amount": "max"}
}],
"resource_challenge": {"format": "oauth-txn-challenge",
"value": "eyJ..."},
"signature": "eyJ..."
}
¶
Signing lets a receiver detect changes made by relays and agents on the way.¶
The signature member of a checkpoint request or response is a JWS
[RFC7515] with detached payload, in Compact Serialization, over the
JCS [RFC8785] form of the object without its signature member,
made with the key bound to the signer's credential in the dialog.
Commitments (Section 7.2) and assertions (Section 7.3) are
signed the same way.¶
The JWS alg MUST be an asymmetric digital signature algorithm, and
MUST NOT be none or a MAC algorithm, because these objects are
relayed and kept as evidence (Section 8) and verified by parties
that share no key with the signer.¶
A receiver MUST verify the signature before acting on the object (P4).
It MUST also verify that the signer is the participant the object
names: the requester of a request, the approver of a response, the
proposer of a commitment, or the asserted_by of an assertion. An
object that fails either check is rejected with ERROR
unauthenticated ([PACE]).¶
When a protected resource describes the action itself, that description, not the agent's, is the one to trust.¶
When the action was refused by a protected resource that issued a
resource challenge, the performing agent MUST include it in
resource_challenge, unmodified, with format set to a value from the
PACE Resource Challenge Formats registry (Section 11.3). This
document defines:¶
| format | Challenge |
|---|---|
oauth-txn-challenge
|
OAuth Transaction Authorization Challenge [TXN-CHALLENGE] |
aauth-scope-challenge
|
AAuth Scope Challenge [AAUTH-ROSENBERG] |
aauth-resource-token
|
AAuth resource token [AAUTH-HARDT], possibly referencing an R3 per-call proposal [AAUTH-R3] |
The resource is then the authority on what the action is (P6). The
approver MUST validate the challenge as its specification requires,
MUST base its decision, and anything it displays to a person, on the
validated challenge, and MUST treat description, parameters, and
effect as advisory.¶
The challenge is redeemed by the party its specification allows (Section 5.6). A Transaction Authorization Challenge can be redeemed by the approver. An AAuth Scope Challenge is redeemed only by the client it was issued to, so the approver returns only its outcome.¶
An approver's approve does not authorize the action at the resource.
An authorization server that takes part can refuse, or issue narrower
authorization than approved, and the performing agent acts only within
the issued token.¶
A checkpoint response gives the approver's decision on one request, bound to that request by its hash.¶
A response is a JSON object, published on the approver's checkpoint
flow (Section 4.1), encoded as a request is
(Section 4.2) and signed as Section 4.3
specifies. Its members are:¶
REQUIRED. The string response.¶
REQUIRED. The checkpoint_id of the request.¶
REQUIRED. The base64url-encoded SHA-256 hash of the JCS form of the
signed request, including its signature, binding the response to
one request (P5).¶
REQUIRED. The approver's participant identifier, equal to the
approver of the request.¶
REQUIRED. A value from the PACE Checkpoint Outcomes registry (Section 11.3). This document defines:¶
approve: perform the action as requested.¶
approve-modified: perform the action with the response's
parameters, which replace the request's. The modified action
MUST be narrower than or equal to the requested one, as
Section 5.4 of [TXN-CHALLENGE] requires of authorization
servers; for an agent_action detail, as Section 5.1.1
defines, applied to the request's detail with its parameters
replaced. A requester that cannot determine that the modification
only narrows the request MUST treat the response as deny. With
resource_challenge, this outcome is used only if the challenge's
specification allows the approved details to differ.¶
deny: do not perform the action. The performing agent ends the
paused operation with an explicit error in the application
protocol, such as a failed A2A task or an MCP error result.¶
actor-proof-required: the approver needs a usable actor proof
(Section 5.5).¶
REQUIRED with approve-modified, except in a response to an
encrypted request. The modified arguments, as a JSON object.¶
In a response to an encrypted request only, and REQUIRED there with
approve-modified: the modified parameters, encrypted to the
requester (Section 6.6).¶
REQUIRED with deny: a reason from the ERROR reasons of [PACE],
such as insufficient-assurance. OPTIONAL with
actor-proof-required: expired, invalid, or details-mismatch
(Section 5.5).¶
With actor-proof-required only. actor_proof_aud, REQUIRED, is the
issuer identifier to use as the proof's aud. actor_proof_nonce,
OPTIONAL, is a nonce the approval issuer supplied.¶
OPTIONAL. A principal confirmation of the request
(Section 6). REQUIRED with approve or
approve-modified when the request's required_assurance has
from set to principal. For approve-modified, it covers the
response's parameters.¶
The requester MUST verify that request_hash matches a request it
sent and has not yet resolved, and MUST NOT apply an approval to any
other action. An approver MUST NOT approve a checkpoint that it
requested.¶
For example, the banking assistant approves the transfer requested in Section 4.2 for a lower amount:¶
{
"type": "response",
"checkpoint_id": "6f1c0e9a-3c2d-4b7e-9a51-0d6c2f4e8b10",
"request_hash": "x7Rb...",
"approver": "banking-assistant",
"outcome": "approve-modified",
"parameters": {"amount": "1500.00", "currency": "EUR",
"to": "DE89370400440532013000"},
"credentials": "eyJ...",
"signature": "eyJ..."
}
¶
Each checkpoint has a deadline and is answered at most once, so that
it neither blocks work forever nor authorizes an action twice. The
requester sets the deadline in the deadline member of its request
(Section 4.2), and identifies the checkpoint by the
request's checkpoint_id.¶
If no valid response arrives by the deadline, the requester MUST treat
the checkpoint as unresolved, MUST NOT perform the action, and halts
the affected operation. A late response is ignored. A requester MUST
accept at most one response per checkpoint_id. Neither requests nor
responses are sent in QUIC or TLS 0-RTT data (P7).¶
Log replay [PACE] does not extend a deadline. A requester that
resumes after its deadline treats the checkpoint as unresolved, and to
ask again publishes a new request with a new checkpoint_id. A
participant that sends checkpoints in a dialog SHOULD propose, or
accept, a log_retention dialog parameter [PACE] no shorter than the
longest time it allows between a request and its deadline.¶
An approver that waits for an authorization server bounds the wait by
the deadline: it passes the remaining time as the timeout of
[AAUTH-ROSENBERG] where that applies, and cancels a deferred token
request [DTR] when the deadline passes or the paused operation is
cancelled with PACE CANCEL.¶
An approver can resolve a checkpoint from policy, ask its principal,
or relay it to its own approver in the dialog above. To relay, it
publishes a new request in that dialog, with itself as requester and
the original signed request as relayed_request; a resource challenge
is carried in both, unmodified. It answers the original checkpoint
with the returned outcome or a stricter one. Each hop signs its own
request and response, so the decision path is verifiable end to end.¶
The approver above MUST treat the outer request, signed by the relaying agent, as the request it answers, hashing it in its response, and MUST NOT answer the inner request directly or act on it alone. It verifies the inner request and its resource challenge only as evidence of what the performing agent asked for. The same rule applies at every level of nesting.¶
Agent protocols already have ways to pause for approval: an A2A
[A2A] task enters auth-required or input-required, an MCP
[MCP] server sends an elicitation request, and a Poppy [POPPY]
Company Agent sends an authorization event. These prompts are unsigned, each uses its own
vocabulary, and an agent that translates between protocols cannot
carry one into another without loss. A checkpoint gives them a common,
signed form, while the native prompt keeps working for participants
that understand only the application protocol.¶
A performing agent that pauses an application operation with a native prompt asking to approve an action also publishes a checkpoint request for that action:¶
| Protocol | Native prompt | Checkpoint request |
|---|---|---|
| A2A | Task in auth-required or input-required that asks to authorize an action |
target names the task; the task stays in that state until the response |
| MCP |
elicitation/create that asks to confirm an action |
target names the paused request; the elicitation result follows the response |
| Poppy |
authorization event that asks to authorize an action |
target names the event |
The request's action, parameters, and effect describe the action
the prompt asks about, and operation_hash covers the object payload
that started the paused operation (Section 4.2). A native
prompt that asks for something other than approval of an action, such
as a Poppy authorization event asking the Personal Agent to sign in,
is not mapped.¶
When the response arrives, the native state is brought in line with it: the performing agent, as A2A server, moves the task on, and the participant that received an MCP elicitation answers it.¶
| Outcome | A2A task | MCP elicitation result |
|---|---|---|
approve, approve-modified
|
Task returns to working
|
accept, with the approved parameters |
deny, or unresolved at the deadline |
Task ends failed or rejected
|
decline, or cancel at the deadline |
The checkpoint response, not the native answer, is authoritative: a participant that receives both acts on the signed response. A mediator that translates between application protocols relays the checkpoint unmodified (Section 4.7) and translates only the native prompt.¶
An approval token is an access token that authorizes one approved action, for the performing agent only, and only once (P5). A checkpoint response is a statement between agents, and a resource server that never saw the checkpoint cannot rely on it. The approval token carries the approval to where the action happens, in a form the resource server already checks.¶
The token describes the action as an agent_action detail
(Section 5.1). The approver obtains it from the approval issuer
named for the dialog (Section 5.2), bound to the performing
agent's key with the actor proof from the request (Section 5.3,
Section 5.4, Section 5.5). When a resource
challenged the action, redeeming the challenge yields the token
instead (Section 5.6). The resource server checks the token as
Section 5.7 specifies.¶
When no resource challenged the action, the approval token describes
it with the RAR [RFC9396] authorization details type agent_action.
Besides the common fields of RAR, it has:¶
REQUIRED. The checkpoint the authorization answers. Absent in the
terms of a commitment (Section 7.2), which has its own
checkpoint_id.¶
REQUIRED. The operation, as the resource server understands it.¶
REQUIRED. The arguments the approval covers.¶
OPTIONAL. A JSON object naming top-level members of parameters
that an approver may change without changing the action
(Section 5.1.1). Each value is one of:¶
max: an upper limit, as a decimal string; an approver may lower
it.¶
min: a lower limit, as a decimal string; an approver may raise
it.¶
subset: a set, as a JSON array; an approver may remove elements.¶
A decimal string matches -?(0|[1-9][0-9]*)(\.[0-9]+)? and is
compared as an exact decimal, never as binary floating point. Only
the performing agent sets bounds, in its checkpoint request. A
performing agent MUST NOT name a parameter in bounds unless
performing the action with any value the bound permits is within the
authority it is requesting, and the action remains the same action to
the resource server.¶
OPTIONAL. The PACE dialog the action belongs to.¶
A token MUST NOT contain more than one agent_action detail, and MUST NOT combine it with other details or scopes that authorize the same
resource server to perform other actions.¶
This is the comparison of the agent_action type, defined here as
[RAR-NARROWING] allows a type to do. An agent_action detail B is
equal to or narrower than a detail A if and only if:¶
type, checkpoint_id, and action are equal; dialog_id is
equal or absent from both; and bounds is equal, in JCS form
[RFC8785], or absent from both.¶
Each common data field of Section 2.2 of [RFC9396] is present in
B exactly when it is present in A; identifier is equal; and for
locations, actions, datatypes, and privileges, every element
of B is an element of A.¶
parameters has the same member names in A and B, and each member
compares as follows:¶
Every other member is equal, in JCS form.¶
Anything else, such as an added or removed parameter, a bounded value
of another type, or a malformed decimal string, means B is not
narrower. A requester that finds an approve-modified response not
narrower treats it as deny; an authorization server that finds the
approved details not narrower than actor_authorization_details
rejects the request as [ACTOR-BOUND] specifies.¶
For example, with "bounds": {"amount": "max"} and a request for
"amount": "1520.00", "1500.00" is narrower, "1520.000" is equal,
and any change of to or currency is not narrower.¶
A performing agent needs to know whom to ask, and for which issuer to
make its actor proof. This document defines two dialog parameters for
the parameters member of OPEN and UPDATE [PACE]:¶
The participant identifier of the participant that answers checkpoints in the dialog. When absent, it is the controller.¶
The issuer identifier [RFC8414] of the approval issuer, which
performing agents use as the aud of actor proofs.¶
The controller sets both. Like purpose and basis in [PACE], they
are not negotiated: a participant that disagrees sends REJECT. A new
value applies to checkpoint requests sent after the UPDATE that
carries it is committed. A controller that delegates with a credential
from the authorization server it also uses for approval SHOULD set
approval_issuer to that credential's iss.¶
The approver holds the authority to grant the action, but only the performing agent may use the token. The approver therefore requests it with Token Exchange [RFC8693] and actor-bound token exchange [ACTOR-BOUND], sending:¶
subject_token: the approver's own token for the task;¶
actor_token: the request's actor_token when present, and
otherwise the credential the performing agent presented in the
dialog; its hash is the proof's ath;¶
actor_proof: the actor proof from the checkpoint request;¶
authorization_details: the single agent_action detail, as
approved;¶
actor_authorization_details: for approve-modified, the request's
authorization_details, over which azh was computed, so that the
authorization server can verify the narrowing; and¶
requested_token_type:
urn:ietf:params:oauth:token-type:access_token.¶
The authorization server verifies that the subject token authorizes the approver to grant the action, and obtains the resource owner's approval when its policy requires it. It then issues a token that:¶
carries the detail as approved;¶
names the performing agent in act;¶
is bound to the performing agent's key, as [ACTOR-BOUND] specifies; and¶
has a jti and a short lifetime.¶
The token MAY be a Transactional Access Token [TXN-AT]. If the authorization server changes the detail, the token response returns the changed detail, which is authoritative. The approver then answers the checkpoint:¶
with a token: approve or approve-modified, carrying the token in
credentials (Section 4.5);¶
when the authorization server denies the request with
access_denied, as for the device authorization grant
([RFC8628]): deny;¶
when it rejects the actor proof with invalid_actor_proof or
invalid_authorization_details ([ACTOR-BOUND]):
actor-proof-required, with the matching reason
(Section 5.5).¶
When the approval must come from a person the approver cannot prompt
directly, the approver sends the same authorization_details,
actor_token, and actor_proof in a CIBA request [CIBA] instead,
as [ACTOR-BOUND] describes. The performing agent never receives the
approver's credentials.¶
An actor proof waits in a checkpoint for the approver's decision, and
the performing agent never contacts the approval issuer. Its freshness
therefore rests on exp and jti:¶
The performing agent sets exp as soon after iat as the flow
allows [ACTOR-BOUND]; for a checkpoint, the latest useful exp is
the deadline. The approval issuer can reject a lifetime beyond its
policy.¶
The approval issuer accepts each jti once. Its record of accepted
jti values MUST be shared by every instance that accepts actor
proofs for it, keyed by issuer, audience, and jti, and kept until
the proof's exp. An instance that cannot reach the record MUST
reject the proof.¶
[ACTOR-BOUND] leaves nonce delivery to the actor out of scope. An
approval issuer that accepts actor proofs relayed through a
checkpoint SHOULD NOT require a nonce in them. If it does, the
approver answers actor-proof-required with actor_proof_nonce
(Section 5.5).¶
A participant or approval issuer whose clock it cannot trust, for example after a restart without a time source, MUST NOT accept actor proofs or checkpoint responses until it can, and treats the affected checkpoints as unresolved. A secure time source such as Roughtime [ROUGHTIME] can help.¶
An approver answers actor-proof-required when the request carried no
proof, when the proof's aud is not the approval issuer it will use,
or when that issuer requires a nonce. When the approval issuer
rejected the proof, the response also carries a reason:¶
expired:The proof had expired, or its lifetime exceeded the issuer's policy.¶
invalid:The proof failed another check, such as its signature or ath.¶
details-mismatch:The details did not hash to azh, or the approved details are not
equal to or narrower than those hashed.¶
The performing agent MAY send a new checkpoint request with a new
proof for that issuer, a new checkpoint_id, and the same deadline
or an earlier one; otherwise it treats the response as deny. An
approver sends actor-proof-required at most once per reason per
paused operation, counting the absence of a reason as one value.¶
A performing agent MUST NOT send a proof for an issuer unless the
controller named that issuer in approval_issuer, or the performing
agent trusts it by its own policy to receive its actor token.¶
When a resource challenged the action, the challenge is redeemed as its specification defines: the transaction authorization grant of [TXN-CHALLENGE], the agent authorization grant of [AAUTH-ROSENBERG], or the auth token request of [AAUTH-HARDT]. The resulting token, already bound to the challenged operation, is the approval token.¶
A resource server that receives a token with an agent_action detail
MUST:¶
validate the token and its sender constraint;¶
verify that the request is the operation named by action, and
that its arguments are within what the detail approves, compared as
in Section 5.1.1:¶
accept the token for one request only, recording its jti until it
expires. A request refused for another reason does not consume the
token.¶
If a check fails, it rejects the request with the error
agent_action_not_authorized (Section 11). The error tells the
performing agent, and through it the approver, that the request
exceeded or contradicted the approved action, as distinct from
invalid_token or insufficient_scope
(Section 5.3.2 of [OAUTH-2.1]).¶
An agent's approval shows only that the agent agreed. A principal
confirmation proves that the principal itself approved one checkpoint
request: it is made with a key the principal holds, such as one in the
person's wallet or authenticator, and the principal's agent does not
(P10). The principal_confirmation member of a checkpoint response is
an object with these members:¶
REQUIRED. A value from the PACE Principal Confirmation Formats registry (Section 11.3). This document defines those in Table 5.¶
REQUIRED. The confirmation, encoded as the format specifies.¶
| format | Confirmation | Bound to the request by |
|---|---|---|
oid4vp
|
A Verifiable Presentation [OID4VP] whose Key Binding JWT covers a pace_checkpoint transaction data object |
request_hash in the transaction data |
webauthn
|
A WebAuthn assertion [WEBAUTHN] | The challenge |
spc
|
A Secure Payment Confirmation assertion [SPC] | The challenge |
ciba-token
|
An approval token issued after the person approved through CIBA [CIBA] |
authorization_details with checkpoint_id (Section 5.1) |
The confirmation covers the request the response answers, identified
by request_hash. For approve-modified, the principal confirms the
modified action, and the binding value is instead the base64url-encoded
SHA-256 hash of the JCS form of the request with its parameters
replaced by those of the response and its signature member removed.¶
The requester, as verifier, sends a presentation request whose
transaction_data contains one pace_checkpoint object
(Section 6.2); it travels to the person's wallet with the
checkpoint, through the approver. The Key Binding JWT carries the
object's hash in transaction_data_hashes; its nonce is the
checkpoint request's nonce; its iat is the time of approval; and
its aud is the requester's participant identifier, because
[OID4VP] requires the verifier's Client Identifier there and the
requester uses its participant identifier as that value, with a
Client Identifier prefix that its wallet ecosystem accepts. The
value is the VP Token.¶
The challenge is the binding value, decoded from base64url. The
value is a JSON object with these members, each base64url-encoded:
credential_id, the WebAuthn credential ID; key, the credential's
COSE public key [WEBAUTHN]; and authenticator_data,
client_data_json, and signature, from the assertion. The User
Verified flag MUST be set when required_assurance has level
authenticated or higher. For spc, the payment instrument and
amount displayed to the person MUST equal those in the request's
parameters.¶
The token's authorization_details contain the request's
agent_action detail, with the same checkpoint_id; its acr and
auth_time claims give the assurance of the person's
authentication. It convinces only a requester that trusts the
issuing OpenID Provider, so it suits one trust domain or a
federation.¶
This document defines the [OID4VP] transaction data type
pace_checkpoint, with these members:¶
REQUIRED. The string pace_checkpoint.¶
REQUIRED. As [OID4VP] defines for every transaction data object.¶
REQUIRED. Those of the checkpoint request.¶
OPTIONAL, as [OID4VP] defines. When present, it MUST include
sha-256.¶
A wallet that receives a pace_checkpoint object MUST display the
action it describes and MUST NOT return a presentation covering it
unless the person approved. The verifier, which is the requester,
MUST, before accepting the presentation:¶
verify the presentation and its Key Binding JWT as [OID4VP] and
the credential format require, with nonce equal to the checkpoint
request's nonce and aud equal to the requester's participant
identifier;¶
verify that transaction_data_hashes contains the hash, with the
algorithm used, of the base64url-encoded pace_checkpoint object it
sent, as [OID4VP] specifies;¶
verify that the object's checkpoint_id and dialog_id equal those
of the checkpoint request, and that its request_hash equals the
binding value it computes itself from the request it sent and the
response it received; and¶
verify that the credential's confirmation key belongs to the principal (Section 6.3).¶
A presentation that fails any check is treated as absent.¶
The verifier MUST establish that the confirming key belongs to the principal, not to an agent. It accepts the key only when one of the following relates it to the principal, under its trust policy:¶
a credential issued to the person by an issuer the verifier trusts,
whose cnf is the confirming key, such as one presented with
oid4vp;¶
a public key credential that the principal registered with the verifier earlier, under the pairwise identifier by which the verifier knows the principal; or¶
for ciba-token, the OpenID Provider's assertion.¶
A key that is presented only in the agent's own credentials, or in a credential whose subject is the agent, MUST NOT be accepted. A relaying agent can deliver the confirmation but cannot produce it.¶
The verifier checks max_age against the time of approval (iat for
oid4vp, its receipt of a fresh assertion for webauthn and spc,
and auth_time for ciba-token), and acr_values against the
authentication context the format reports or its policy assigns. A
confirmation that fails a check is treated as absent.¶
The wallet, authenticator, or OpenID Provider shows the action from
the signed request: from resource_challenge when present (P6), and
otherwise from action, parameters, and effect, not description
alone. For oid4vp, a wallet that displays transaction data displays
the pace_checkpoint object together with the checkpoint request.¶
Some requests are meant for the person behind an agent, such as a card issuer's authentication challenge or a bank confirming a transfer, and the agent should neither read nor answer them. The requester, which can be a tool, then encrypts the request to the principal with these members:¶
An object with kid, REQUIRED, the key identifier of the
principal's encryption key, and jwk, OPTIONAL, the key itself,
obtained from a credential that relates it to the principal
(Section 6.3).¶
A JWE [RFC7516] in Compact Serialization, encrypted to that key,
whose plaintext is a JSON object with the members action,
parameters, effect, authorization_details, description, and
resource_challenge that would otherwise appear in the request, and
OPTIONAL response_key, the requester's public encryption key as a
JWK. These members are omitted from the outer object. The requester
MAY leave a copy of action in the clear for routing.¶
An encrypted request is for a principal confirmation, not for the
issuance of an approval token, so it MUST NOT carry actor_proof or
actor_token. The signature covers the outer object, including
encrypted. The approver is the principal's agent, or a participant
that represents the principal's device; the agent relays the request
to the device, which decrypts it. A request with encrypted_to MUST
carry required_assurance with from set to principal, so an
approve or approve-modified response is valid only with a
principal confirmation from the key holder. An agent MAY answer deny
on its own, for example when it cannot reach the person before the
deadline.¶
The principal can answer approve-modified only when the request
carries response_key. The response then carries the modified
parameters only in encrypted: a JWE in Compact Serialization,
encrypted to response_key, whose plaintext is an object with the
member parameters. Because response_key travels inside the
request's encryption, a relaying agent cannot substitute it. The
requester decrypts the parameters and checks that they only narrow the
request (Section 4.5). For an encrypted request, the
binding value of the principal confirmation is computed over the
request as decrypted: the outer object with encrypted_to and
encrypted replaced by the plaintext members.¶
Only the approver initiates CIBA (Section 5.3): when it cannot reach
the principal's device through the dialog, it can use CIBA through the
principal's OpenID Provider and answer with
ciba-token. A requester that can reach the principal without the
agent does not need a checkpoint; such contact is out of scope.¶
A tool that sends a later result of the work publishes it, as a participant authenticated by its own credentials, in the dialog in which it was invoked or, once that has ended, in a follow-up dialog [PACE].¶
Agents acting for different principals, such as a consumer's agent and a brand's agent, do not delegate to each other, but they still need approvals from each other, a record of what their principals agreed, and facts they can rely on. This section covers peer checkpoints, commitments (P9), and assertions.¶
Agents of different principals also need approvals from each other, although no delegation links them.¶
In such a dialog, either participant can publish a checkpoint request
naming the other as approver, for example when a brand's agent needs
the consumer to approve a refund's terms, or needs stronger or more
recent authentication of the consumer. The approver dialog parameter
does not restrict peer checkpoints, and the approver need not be the
controller.¶
The requester is the party that will act, and the approval gives it no
authority over the approver's resources. The request therefore carries
no actor_proof, and the response no approval token, unless the
action is performed at a resource that the approver's authorization
server protects.¶
The approver meets required_assurance within the dialog: when from
is participant, by presenting new credentials in its next control
message, such as DECLARE [PACE], bound to the request's nonce as
[PACE] describes for credentials, before it responds; when from
is principal, with a principal confirmation. A requester that
receives a response that does not meet required_assurance treats it
as deny; it MAY publish a new request without ending the dialog. An
approver that cannot or will not meet it answers deny with reason
insufficient-assurance [PACE].¶
The rules of Section 4 apply unchanged. Each side applies its
own policy, and a counterpart's cooperative posture [PACE], or its
declaration of agreement or low risk, never replaces a
required_assurance or a principal confirmation.¶
Parties of different principals need to know what was agreed and that each confirmed the same terms; an agent's statement that it is satisfied does not show this. A commitment records terms such as a refund, a rebooking, a price, or an action item, with an identifier that every party's records can share (P9).¶
{
"type": "commitment",
"commitment_id": "2b9d4c7e-1f3a-4e8b-9c6d-5a0f7e2b8d14",
"dialog_id": "550e8400-e29b-41d4-a716-446655440000",
"proposer": "brand-agent",
"parties": ["consumer-agent", "brand-agent"],
"terms": [{
"type": "agent_action",
"action": "refund",
"parameters": {"amount": "84.00", "currency": "EUR",
"order": "A-1093"}
}],
"terms_hash": "Qm9s...",
"cancel": {"until": "2026-11-14T09:00:00Z",
"terms": "Full reversal before the refund is issued"},
"expires_at": "2026-11-13T18:00:00Z",
"status": "proposed",
"confirmations": [],
"signature": "eyJ..."
}
¶
REQUIRED. The string commitment.¶
REQUIRED. A UUID version 4, chosen by the proposer, that identifies
the commitment in every dialog and record, including the
commitments member of a PACE result [PACE].¶
REQUIRED. The dialog, the participant that published this object, and the participants bound by the terms, including the proposer.¶
REQUIRED. An array of RAR [RFC9396] authorization details, such as
agent_action details (Section 5.1).¶
REQUIRED. The base64url-encoded SHA-256 hash of the JCS [RFC8785]
form of terms.¶
OPTIONAL. The checkpoint the commitment arises from, if any.¶
OPTIONAL. Until when (until), and on what terms, the party that
performs the action can still cancel or reverse it. After until, a
PACE CANCEL of the work can report only completed,
partially-reversed, or irreversible [PACE].¶
OPTIONAL. The time after which an unconfirmed commitment lapses,
with status expired.¶
REQUIRED. An array of the signed checkpoint responses that confirm the terms: empty when first proposed, and one or more per party once each has confirmed.¶
REQUIRED. As for checkpoints (Section 4.3), made by the proposer.¶
| status | Meaning |
|---|---|
proposed
|
Published; not yet confirmed by every party |
pending-principal
|
Every party's agent confirmed, but a confirmation required from a principal is outstanding |
confirmed
|
Every required confirmation is present |
rejected
|
A party denied it |
unconfirmed-counterparty
|
Confirmed by the proposer's side, but a party had assurance level none [PACE] when it agreed |
cancelled
|
Cancelled under cancel, or withdrawn before confirmation |
expired
|
expires_at passed before every required confirmation was present |
The proposer obtains each confirmation with a checkpoint request to the
party, with action commit and parameters
{"commitment_id": ..., "terms_hash": ...}: a peer checkpoint
(Section 7.1) for the other parties, and an ordinary one for
its own approver. A party confirms by answering approve;
approve-modified is not allowed, and a party that wants different
terms denies and proposes a new commitment. At each change, the
proposer republishes the commitment with the same commitment_id, a
new status, and the confirmations so far. Every party verifies each
confirmation against terms_hash before relying on the status.¶
Which confirmations are required follows from each party's policy and the posture of the dialog [PACE]:¶
When the parties act for different principals and the posture is
adversarial, each checkpoint request MUST carry
required_assurance with from set to principal, so the
commitment becomes confirmed only with a principal confirmation
from each principal, each bound to the same terms_hash (P9).¶
When the posture is cooperative, each party decides from its own
policy whether its agent's confirmation suffices, for example for
low-risk terms within the commit_scope that agent declared
[PACE].¶
An agent that confirms terms within its commit_scope but beyond
what it may confirm alone answers with its own confirmation and
leaves the status pending-principal. The principal's confirmation
or denial follows later, referring to the same commitment_id, in
the same dialog or in a follow-up dialog [PACE].¶
A commitment with a party whose assurance level is none, such as a
person on a telephone line without a credential, is
unconfirmed-counterparty until that party confirms it in a later
authenticated exchange.¶
Parties rely on facts they cannot check themselves, such as a carrier's proof of delivery or a payment provider's refund status. An assertion carries such a fact and says who stands behind it.¶
{
"type": "assertion",
"assertion_id": "9e4a0c1b-6d2f-4a7e-8b3c-1f5d9e0a2c47",
"dialog_id": "550e8400-e29b-41d4-a716-446655440000",
"claim": {"delivered": true, "shipment": "1Z999",
"at": "2026-11-10T14:02:00Z"},
"asserted_by": "brand-agent",
"attested_by": "https://carrier.example",
"evidence": {"format": "sd-jwt-vc", "value": "eyJ..."},
"signature": "eyJ..."
}
¶
REQUIRED. The string assertion.¶
REQUIRED. A UUID version 4, listed in the sources of a PACE
result [PACE] that relies on it.¶
REQUIRED. The dialog in which the assertion is published.¶
REQUIRED. The fact, as a JSON object.¶
REQUIRED. The participant that publishes the assertion.¶
OPTIONAL, and present together. The issuer identifier of a third
party that attests the claim, and its signed statement: with
format jws, a JWS [RFC7515] by that issuer whose payload, in
JCS form, equals claim; with format sd-jwt-vc, an SD-JWT VC
[SD-JWT-VC] whose iss is attested_by and whose disclosed
claims include every member of claim with the same values.¶
REQUIRED. As for checkpoints (Section 4.3), made by
asserted_by.¶
An assertion without attested_by is the sender's own statement, and
receivers MUST treat it as such, as they would a statement in content.
A receiver that relies on an attested assertion MUST verify the
evidence with the issuer's key, obtained under its own trust policy,
for example from the issuer's SD-JWT VC issuer metadata. It MUST treat
an assertion whose evidence fails verification, or does not match
claim, as the sender's own statement. A relaying participant relays
an assertion unmodified, and can only add its own assertion citing it.
A delegated party, such as a payment provider in a dialog opened by a
brand, reports its outcome as an assertion, so the brand's outcome to
the consumer can cite it.¶
A deployment that needs approvals and actions to be checkable by parties other than the operator adds an evidence mechanism; PACE authorization does not mandate one. Such a mechanism SHOULD record:¶
each OPEN of a delegated dialog, with its parent_dialog_ids and the
hash of the delegation credential presented;¶
each checkpoint request and response, in its signed form;¶
each action performed under an approval, referencing the response that approved it;¶
each commitment (Section 7.2) at each change of status, with its confirmations;¶
each assertion (Section 7.3) that a result cites;¶
each SEGMENT start and end [PACE], without the segment's content; and¶
each disclosure that a participant is an AI agent, such as the
DECLARE of its kind [PACE] or the announcement a telephone
gateway plays, with its time.¶
TRAIL [TRAIL] is one such mechanism: its gate-request and approval records can carry checkpoints, and its record of the action cites the approval. For HTTP calls along a chain, aggregate signatures [AGG-SIG] attribute changes to each hop.¶
The considerations of [PACE] apply. The threats below are specific to delegation and approval.¶
A credential or approval token is used for a different dialog, resource, or action. Mitigated by message binding (P1), single-action tokens bound to the performing agent's key (P5), and resource-side parameter checks.¶
A relaying agent forges an approval or alters the request. Mitigated
by signatures, request_hash, and relaying the original signed
request (P4, P5).¶
An approval for one checkpoint is presented for another. Mitigated by
request_hash, checkpoint_id, and the single-response rule (P5,
P7).¶
A crafted description misleads the approver. Mitigated by resource
challenges (P6), and otherwise by presenting parameters and
effect, which the approval token enforces.¶
Forbidden (Section 4.5), and detectable because the response is signed by the approver named in the request.¶
Approvers asked too often approve without reading. Approvers SHOULD resolve routine checkpoints by policy and reserve human approval for actions with significant effects.¶
An approver could name, in actor-proof-required, an issuer of its
choosing to collect actor proofs and tokens. The performing agent
sends proofs only to issuers the controller named or it trusts
(Section 5.5), and aud and azh bind each proof to one
issuer and one action.¶
Instances that keep separate records of accepted identifiers defeat
single-use rules. The jti record is shared
(Section 5.4), and resources apply the same rule to
approval tokens.¶
Work continues after revocation. Mitigated by terminating dependent dialogs (P8), short credential lifetimes, and enforcement points outside the agent, such as a TRAIL edge.¶
Mitigated by principal confirmations with a key related to the principal (P10) and by encrypted requests (Section 6.6). A relaying agent can still withhold a request; the deadline bounds the delay.¶
The confirmation is bound to the request, or the modified request,
and the display comes from the signed request or resource challenge;
for spc, the displayed amount and instrument must equal
parameters.¶
A counterpart declares a cooperative posture or low risk to obtain
weaker confirmation. Each party sets required_assurance from its
own policy (Section 7.1).¶
Every confirmation is bound to terms_hash, a change of terms is a
new commitment, and only bound confirmations complete a commitment,
never an agent's claimed satisfaction or reported scores (P9).¶
An unverifiable or mismatched attestation is treated as the sender's own statement (Section 7.3).¶
A receiver does not accept onward delegation from a participant that
declared authority_basis own (Section 3.3).¶
Delegation chains reveal intermediate agents to later hops, and
checkpoints can carry personal data in parameters. Deployments
SHOULD use pseudonymous originators (Section 3.3), protect
checkpoint objects end to end as [PACE] describes for content, and
include in a checkpoint only what the approver needs. A resource
challenge that carries parameters by digest, as R3 does, hides them
from intermediate agents.¶
When a delegated dialog crosses into a domain whose agents should not
learn which dialog it continues, the delegating participant MAY omit
parent_dialog_ids from OPEN and keep the link locally, as
[DIALOG-BINDING] does across trust boundaries. Lifecycle propagation
still works, because the controller holds the link; the receiver then
relies on the delegation chain alone for cycle detection.¶
A principal confirmation identifies the principal to the verifier. A principal that should not be linked across counterparties uses per-verifier keys and credentials, such as pairwise passkeys or batch-issued credentials, and discloses only the claims the verifier needs. Encrypted requests (Section 6.6) hide their parameters from relaying agents.¶
Every participant can read terms and claim. Parties include only
what the counterpart needs, use SD-JWT VC selective disclosure for
attested claims, and, where some participants must not see the terms,
agree in a segment [PACE] limited to the parties.¶
If [PACE] establishes a registry of dialog parameters, this document
registers approver, approval_issuer (Section 5.2), and
authority_basis (Section 3.3) in it.¶
This document asks IANA to create the following registries in the "Protocol for Agent Communication Exchange (PACE)" group that [PACE] creates, each with the Specification Required policy [RFC8126]. Each entry has a value, a description, and a reference.¶
PACE Checkpoint Outcomes (Section 4.5): approve,
approve-modified, deny, and actor-proof-required.¶
PACE Principal Confirmation Formats (Section 6):
oid4vp, webauthn, spc, and ciba-token.¶
PACE Resource Challenge Formats (Section 4.4):
oauth-txn-challenge, aauth-scope-challenge, and
aauth-resource-token.¶
The initial values reference this document.¶
[OID4VP] identifies transaction data types by string and has no IANA
registry. If the OpenID Foundation or IANA establishes one,
pace_checkpoint (Section 6.2) is to be registered with:¶
Type: pace_checkpoint¶
Description: Approval of one PACE checkpoint request, bound by its request hash¶
Change Controller: IETF¶
Reference: Section 6.2¶
This appendix lists related work, what each solves, and what it leaves to this document. Section 1.1 shows how the mechanisms this document uses fit together.¶
| Work | Solves | Leaves to this document |
|---|---|---|
| WIMSE credentials [WIMSE-CREDS], WPT [WIMSE-WPT], message binding [WPT-MSG] | Workload identity; proof of possession for HTTP and for messages | Use in delegation; the profile for control messages is in [PACE] |
| Dialog binding [DIALOG-BINDING] | Binding HTTP requests and Txn-Tokens to an agent dialog | Dialog lifecycle; delegation across domains |
| DPoP [RFC9449], mTLS [RFC8705] | Sender-constrained tokens | None |
| Token Exchange [RFC8693], actor-bound token exchange [ACTOR-BOUND] | A token for another party, bound to its key | Carrying the request between agents |
| Actor Profile [ACTOR-PROFILE] | Meaning and validation of act chains |
Binding to a dialog |
| Transaction Tokens [TXN-TOKENS] | Call context within one trust domain | Crossing domains |
| Identity chaining [ID-CHAINING], Hardt AAuth [AAUTH-HARDT] | A new token per hop from a server at each boundary or the person's server; missions | Peer delegation without a server |
| Delegation Tokens [DELEGATION-TOKENS], delegator-bound chains [AGENT-DELEGATION], Delegate SD-JWT [DELEGATE-SD-JWT] | Offline-verifiable attenuation, each hop signed by its delegator | Binding to a dialog |
| SD-Card [SD-CARD], SD-JWT [RFC9901] | Selective disclosure of agent claims | None |
| RAR [RFC9396] | Fine-grained authorization details | None |
| Rosenberg AAuth [AAUTH-ROSENBERG], Txn Challenge [TXN-CHALLENGE], R3 [AAUTH-R3], step-up [RFC9470] | A resource-signed challenge for one call, and a narrow token for it | Carrying it between agents; approval by a delegating agent |
| Deferred Token Response [DTR] | Waiting at the authorization server for an approval, and cancelling it | A deadline set by the requester |
| Transactional Access Tokens [TXN-AT] | Short-lived per-transaction tokens | Single use; issuance driven by the approver |
| Token Status List [STATUS-LIST], revocation [RFC7009], Shared Signals ([AIMS]), revocation events [REVOCATION-EVENTS] | Credential status, and revocation pushed down a chain | Effect on dialogs |
| Bounded Work [BOUNDED-WORK] | Authority that ends with the unit of work it was approved for | Propagation along dialogs |
| A2A [A2A], MCP [MCP], Poppy [POPPY] | Native approval prompts | A common, signed form |
| TRAIL [TRAIL], aggregate signatures [AGG-SIG] | Tamper-evident records; per-hop provenance over HTTP | None |
Delegation mechanisms differ in who asserts the chain: an authorization server (Token Exchange, Transaction Tokens); a server at each boundary, or the person's server (identity chaining, Hardt AAuth, which does not require downstream authority to be a subset of upstream authority, Section 10.1 of [AAUTH-HARDT]); or each delegator, signing its narrowed delegation to the next agent's key (Delegation Tokens extended by delegator-bound chains, and Delegate SD-JWT). Delegation across organizations with no server in the path needs the third kind [CROSS-ORG]. Each fits a different deployment, so this document requires properties (Section 2) rather than one format (Section 3.2).¶
Approval mechanisms (Rosenberg AAuth, Txn Challenge, R3) share a pattern: a resource refuses a risky call with a signed description of it, the call is approved, and an authorization server issues a narrow token for it. Each assumes that the agent receiving the challenge can take it to the approver. In a PACE deployment the approver is often another agent, which may relay to its own principal. [TXN-CHALLENGE] asks for a protocol that carries the challenge unmodified between agents (Section 4.5 of [TXN-CHALLENGE]), and [AIMS] notes that confirmation in the middle of a task is not standardized and that a confirmation obtained outside OAuth must become an authorization event. Checkpoints (Section 4) and approval tokens (Section 5) fill that gap, and also cover actions that no resource challenged.¶
| Requirement | Addressed by |
|---|---|
| A1-9 delegation without the client's primary credentials | Section 5, Section 3.2 |
| B2-2 checkpoint request describing the action and its effect | Section 4.2, Section 4.4 |
| B2-3 approve, deny, approve with modification | Section 4.5 |
| B2-4 response timeout | Section 4.6 |
| B2-5 approval covers only that action | Section 4.5, Section 5 |
| B2-6 per-operation authorization | Section 5 |
| B3-1, B3-4, B3-8 narrowing at each hop | Section 3.3 |
| B3-2 originator identity | Section 3.3 |
| B3-3 verifiable chain | Section 3.2 with [DELEGATION-TOKENS] and [AGENT-DELEGATION] |
| B3-6 provenance | Section 8 |
| B3-7 cycles | Section 3.4 |
| CMN-4 scope violation error |
scope-exceeded ([PACE]); agent_action_not_authorized
|
| CMN-10 revocation along a chain | Section 3.5 |
The following requirements are from [DIALOG-UC].¶
| Requirement | Addressed by |
|---|---|
| UC1-1 assurance and authentication age required mid-dialog |
required_assurance (Section 7.1) |
| UC1-2 approval verifiable as given by the human principal | Section 6 (P10) |
| UC1-5 identifier for each commitment |
commitment_id (Section 7.2) |
| UC1-6 cooperative path never lowers assurance | Section 7.1, Section 7.2 |
| UC4-2 authority limited to one action; own or onward delegation |
authority_basis (Section 3.3) |
| UC4-3 outcomes keep the source of each fact | Section 7.3 |
| UC6-1 cancellation window and terms before commit |
cancel (Section 7.2) |
| UC8-4 commitment unconfirmed by an unauthenticated counterparty |
unconfirmed-counterparty (Section 7.2) |
| UC10-2 commitment pending the principal's confirmation |
pending-principal (Section 7.2) |
| UC12-1 request to the principal that the agent cannot read or answer | Section 6.6 |
| UC12-2 later result from a tool, authenticated as the tool | Section 6.6 |
| UC12-3 answer verifiable as from the person | Section 6 |
| UC14-2 asserted versus attested claims | Section 7.3 |
| UC14-3 agreement completed by both principals' approvals | Section 7.2 (P9) |
| UC14-4 no selection from self-reported scores | Section 7.2 (P9) |
This document builds on the OAuth, WIMSE, and agent protocol work it references, and on the requirements in [UCREQ].¶