Internet-Draft PACE HTTP Binding November 2026
Nandakumar & Jennings Expires 20 May 2027 [Page]
Workgroup:
Agent Communication Protocols
Internet-Draft:
draft-nandakumar-agentproto-pace-http-00
Published:
Intended Status:
Standards Track
Expires:
Authors:
S. Nandakumar
Cisco
C. Jennings
Cisco Systems

PACE Binding over HTTP

Abstract

This document specifies how the dialog management of the Protocol for Agent Communication Exchange (PACE) is carried over HTTP. It maps PACE control operations onto HTTP resources, methods, and an event stream, and defines a header field that ties application requests to a dialog. The binding uses HTTP semantics only, so it works over HTTP/1.1, HTTP/2, and HTTP/3. Protocols that already run over HTTP, such as A2A and MCP, join a dialog without changes to their transports or messages. An optional track resource carries dialog content that no application protocol carries, such as authorization checkpoints. The document also describes where Oblivious HTTP can hide a participant's network address from the dialog host, and how the binding relates to A-SIP.

About This Document

This note is to be removed before publishing as an RFC.

The latest revision of this draft can be found at https://suhasHere.github.io/draft-nandakumar-agentproto-pace-http/draft-nandakumar-agentproto-pace-http.html. Status information for this document may be found at https://datatracker.ietf.org/doc/draft-nandakumar-agentproto-pace-http/.

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/.

Source for this draft and an issue tracker can be found at https://github.com/suhasHere/draft-nandakumar-agentproto-pace-http.

Status of This Memo

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.

▲

Table of Contents

1. Introduction

PACE [PACE] separates agentic dialog management from the transport that carries it. Its dialog management protocol (Section 3 of [PACE]) defines the dialog context (identifier, generation, state, controller, and participants), sixteen control operations, and the rules that participants and intermediaries follow when they propagate the context. [PACE] also binds that protocol to Media over QUIC Transport (MOQT) [MoQ-TRANSPORT].

Most deployed agent protocols run over HTTP. A2A [A2A] uses JSON-RPC over HTTP with Server-Sent Events for streaming, and MCP [MCP] uses its Streamable HTTP transport. These applications, and the HTTP infrastructure in front of them (load balancers, API gateways, reverse proxies, and authorization servers), need dialog management that does not require a new transport. This document defines that binding.

With it, an application gets the PACE dialog model without changing its HTTP stack:

The dialog context and control messages are exactly those of [PACE]. This document adds no control operations, control message members, or states. It defines how the existing ones are carried over HTTP. One dialog can use this binding and the MOQT binding at the same time (Section 9).

1.1. Scope

This document specifies the HTTP resources that host a dialog (Section 3), the mapping of control operations onto them (Section 4), an event stream that delivers control messages (Section 5), invitations (Section 6), a header field that ties application requests to a dialog (Section 7), an optional track resource (Section 8), interworking with the MOQT binding (Section 9), and the effect of HTTP versions (Section 10), Oblivious HTTP (Section 12), and A-SIP (Section 13).

Dialog content, such as chat, model output, tool calls, and media, is carried by the application protocol (Section 7), except for the content of a track resource (Section 8). This document does not define real-time media over HTTP. A dialog that needs it carries media over MOQT under the same dialog identifier.

1.2. Requirements Language

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.

1.3. Terminology

This document uses the terms dialog, dialog context, dialog-id, participant, principal, invitee, controller, intermediary, dialog host, propagation relationship, flow, log, and log position as defined in Section 1.3 of [PACE]. It uses the HTTP terms client, server, origin server, intermediary, resource, and representation as defined in [RFC9110]. Where the two meanings of "intermediary" could be confused, this document says "PACE intermediary" or "HTTP intermediary".

Dialog host:

As defined in Section 1.3 of [PACE]. In this binding, it is the HTTP origin server that hosts a dialog's resources: it keeps the dialog's control log, accepts control messages from participants, and delivers them on event streams. It is not the source of dialog context, unless it is also the controller (Section 2.2).

Control log:

The ordered sequence of control messages that the dialog host has accepted for a dialog.

Control log position:

An unsigned integer that the dialog host assigns to each control log entry, starting at 1 and increasing by one per entry. It orders the control log and is the resumption point of an event stream (Section 5.3). It is neither a dialog generation nor a log position of the dialog log (Section 3.11 of [PACE]), which orders dialog content. In this binding, dialog log entries are objects on a track resource (Section 8.4).

Dialog URI:

The URI of the dialog resource on the dialog host (Section 3.4).

Inbox:

An HTTP resource at which an agent receives invitations (Section 6).

2. Architecture

┌────────────────────────────────────────────────────────────────────┐
│  Application Protocols (A2A, MCP, AutoGen, Poppy, ...)             │
├────────────────────────────────────────────────────────────────────┤
│  PACE Dialog Management: dialog-id | lifecycle | propagation       │
│  ([PACE], Section 3)                                               │
└────────────────────────────────────────────────────────────────────┘
╔════════════════════════════════╗  ┌────────────────────────────────┐
║ PACE HTTP Binding              ║  │ PACE MOQT Binding              │
║ dialog resources | control log ║  │ namespaces | ctrl tracks       │
║ event stream | inboxes         ║  │ content tracks | priority      │
║ PACE-Dialog header field       ║  │ ([PACE], Section 4)            │
╠════════════════════════════════╣  ├────────────────────────────────┤
║ HTTP versions | priority       ║  │ MOQT: pub/sub | relays |       │
║ MOQT interworking gateway      ║<>│ caching                        │
╚════════════════════════════════╝  ├────────────────────────────────┤
┌────────────────────────────────┐  │ WebTransport over HTTP/3,      │
│ HTTP Semantics                 │  │ or native QUIC                 │
├──────────┬──────────┬──────────┤  └────────────────────────────────┘
│ HTTP/1.1 │ HTTP/2   │ HTTP/3   │
│ TLS/TCP  │ TLS/TCP  │ QUIC     │
└──────────┴──────────┴──────────┘

  ╔══╗ defined in this document     ┌──┐ defined elsewhere
  ╚══╝                              └──┘
Figure 1: PACE HTTP Binding Layering

The parts drawn with double lines are defined in this document. The dialog management protocol and the MOQT binding are defined in [PACE]. Both bindings carry the same dialog context and control messages, and a gateway can join HTTP and MOQT participants in one dialog (Section 9).

The binding uses only HTTP semantics [RFC9110], so the same resources and messages work over HTTP/1.1 [RFC9112], HTTP/2 [RFC9113], and HTTP/3 [RFC9114]. Section 10 describes how each version affects dialog control.

2.1. Roles

In the MOQT binding, every participant is a MOQT endpoint and a relay fans messages out. HTTP is client/server, so this binding adds a dialog host, which takes the relay's place for control messages:

  • Each participant is an HTTP client of the dialog host. It POSTs its control messages to the dialog URI and receives every participant's control messages on the dialog host's event stream.

  • The dialog host stores accepted control messages in the control log and delivers them to every authorized participant.

  • The controller remains the only source of dialog state (Section 3.3.2 of [PACE]). The dialog host does not commit, merge, or change dialog state; it forwards the controller's messages unchanged.

A participant that is also the dialog host appends its control messages to the control log directly, without HTTP requests.

2.2. Hosting Models

Any HTTP origin that implements this document can host a dialog. Three models are common:

Controller-hosted:

The controller is the dialog host, and other participants are its HTTP clients. This suits an agent that opens dialogs with many clients.

Invitee-hosted:

The controller is an HTTP client of the first invitee, which hosts the dialog. This is the usual case for A2A and MCP, where a client agent opens a dialog with a remote agent or tool server. POSTing OPEN to the invitee's dialog collection is also the invitation (Section 6.1). A-SIP [ASIP] dialogs are invitee-hosted: the principal is the controller, and the agent hosts the dialog (Section 13).

Hub-hosted:

A dialog host that is not a participant, such as an agent platform or gateway, hosts the dialog for all participants. This suits multi-party dialogs whose participants do not serve HTTP.

The hosting model does not change the dialog. In every model, the controller is the participant named in controller_id, only the controller assigns generations, and participants authenticate the controller through key-bound presentations in the credentials member of its control messages (Section 7.1.4 of [PACE]), not through the identity of the dialog host.

The choice of host matters when participants act for principals whose interests conflict, such as a consumer's agent and a brand's agent disputing a charge ([DIALOG-UC], UC1; Section 14.1). In such a dialog, the participant that is not the host SHOULD be the controller, or the dialog SHOULD be hub-hosted by a party both trust.

   Invitee-hosted                         Hub-hosted

 +-------+  POST OPEN, UPDATE   +-------+     +-------+      +-------+
 |   A   |--------------------->|   B   |     |   A   |      |   B   |
 | ctrl- |<---------------------| dialog|     +-------+      +-------+
 | ler   |  event stream (SSE)  |  host |       |   ^          |   ^
 +-------+                      +-------+  POST |   | SSE POST |   | SSE
                                                v   |          v   |
                                              +---------------------+
                                              |     dialog host     |
                                              +---------------------+
Figure 2: Invitee-hosted and Hub-hosted Dialogs

3. Dialog Resources

A dialog host exposes a small set of resources. This section defines them, how clients find them, and how control messages are represented.

3.1. URIs and Discovery

This document does not define fixed paths ([RFC8820]). Three URIs are needed before a client has a dialog, so an agent advertises them in its Agent Card (Section 7.2.3 of [PACE]), or a deployment configures them:

dialogs:

The dialog collection, to which a controller POSTs OPEN (Section 4.4).

inbox:

The inbox, at which the agent receives invitations (Section 6.2).

inbox_type:

push or pull: whether senders POST invitations to the inbox, or the agent GETs them from it (Section 6.2). Present with inbox.

join:

The join URI, at which a client resolves a join code to a dialog (Section 4.7). Present only if the dialog host accepts join codes.

The dialog host returns every other URI, such as a dialog URI or a track resource, in its responses. An Agent Card that advertises this binding includes:

{
  "pace": {
    "bindings": ["http", "moqt"],
    "http": {
      "dialogs": "https://agent-b.example/pace/dialogs",
      "inbox": "https://agent-b.example/pace/inbox",
      "inbox_type": "push",
      "join": "https://agent-b.example/pace/join"
    },
    "moqt": {
      "relay": "moqt://relay.example:4443"
    }
  }
}

This document defines the member names under pace. PACE does not define a card format (Section 7.2.3 of [PACE]), so how these members are placed in a particular format, such as an A2A Agent Card extension or an SD-Card claim, is left to that format.

The example URIs in this document follow the pattern below. The pattern is illustrative only; clients MUST use the URIs the dialog host returns.

Table 1: PACE HTTP Resources
Resource Example URI Methods
Dialog collection /pace/dialogs POST
Dialog /pace/dialogs/{dialog-id} GET, POST
Track resource /pace/dialogs/{dialog-id}/tracks GET, POST
Inbox /pace/inbox POST (push), GET (pull)
Join URI /pace/join POST

A dialog host MUST respond to other methods with 405 (Method Not Allowed), with an Allow header field ([RFC9110]).

A dialog URI is an address, not a capability. Knowing a dialog URI MUST NOT grant access to the dialog; the dialog host authorizes every request (Section 11).

3.2. Media Types

A control message (Section 3.10 of [PACE]) is sent over HTTP as one JSON object with the media type application/pace+json (Section 15.1). The object is exactly the PACE control message, with no envelope.

A control message is an I-JSON message [RFC7493]. A dialog host and every receiver MUST reject one with duplicate member names, invalid Unicode, or numbers that I-JSON does not allow, because two parsers that resolve such input differently would act on different messages under one valid signature (Section 14.2).

This binding moves a control message between several serializations: the POST body, the single-line data of an event (Section 5), and the payload of a MOQT object (Section 9). A control message is therefore its JSON value, not its octets:

  • Wherever this document requires a message to be forwarded unmodified, the value is preserved: the same members, at every level, with the same values. Whitespace, member order, and string escaping can change.

  • Two messages are identical when their JCS [RFC8785] forms are equal.

  • Hashes and signatures over a message, or over an object it carries, are computed over a JCS form, so they survive re-serialization. Every key-bound presentation in credentials, whether a Workload Proof Token, a Key Binding JWT, or a PACE presentation JWT, binds itself to its control message with the message hash claim mth, which [WPT-MSG] defines. PACE computes mth under its pace canonicalization profile: over the JCS form of the message without its credentials member (Section 7.1.4 of [PACE]). The detached JWS signature of a checkpoint covers the JCS form of the checkpoint object without its signature member [PACE-AUTHZ].

Control messages are not compressed (Section 4.2.3 of [PACE]). A dialog host MAY apply HTTP content coding to a response, but the decoded representation is the unmodified control message.

3.3. The Dialog Collection

A POST of an OPEN to the dialog collection creates a dialog resource (Section 4.4). The dialog collection rejects any other control message type with 400 (Bad Request) and pace_reason unsupported-operation.

3.4. The Dialog Resource

The dialog resource represents one dialog. It supports:

POST:

Appends a control message to the control log (Section 4).

GET with Accept: application/pace+json:

Returns the latest context-carrying control message from the controller (Section 4.9).

GET with Accept: text/event-stream:

Opens an event stream of the control log (Section 5).

The dialog resource exists from the time OPEN is accepted until the dialog host discards it after termination (Section 4.11).

4. Control Operations over HTTP

A participant needs to send control messages to every other participant and to learn the outcome. This section defines how a participant POSTs a control message, how the dialog host reports its processing, and how each PACE operation maps onto that.

4.1. Sending a Control Message

A participant POSTs one control message per request to the dialog URI with Content-Type: application/pace+json. The dialog host processes the request as follows. Each step names the response when the step fails; Table 2 lists every status code with its pace_reason.

  1. Authenticate the HTTP client and check that it may send this message to this dialog (Section 11). The HTTP client identity MUST correspond to the sender_id of the message; a client MUST NOT send control messages on behalf of another participant. Failure: 401 (no or invalid HTTP authentication), 403 (the sender is not authorized, or has been revoked), 404 (no such dialog, or the client may not learn of it), or 503 (authorization cannot be determined).

  2. Validate the message as a PACE control message (Section 3.10 of [PACE]): required members, member types, version, size, and I-JSON (Section 3.2). Failure: 400 (the message is malformed, or its version or type is not supported), 413 (the message is too large), or 415 (the body is not application/pace+json).

  3. If the message is a duplicate, respond as Section 4.3 describes.

  4. Check that the dialog has not been terminated or expired, except for a STATE needed to complete synchronization (Section 4.11). Failure: 410 (the dialog has been terminated or has expired).

  5. If the message is an UPDATE, REVOKE, or TERMINATE from the controller, check that its generation is exactly one more than the generation of the latest such message in the control log. Failure: 409 with pace_reason stale-generation.

  6. Append the message to the control log, assign it the next control log position, and deliver it on every open event stream for the dialog. Respond with 202 (Accepted), or 201 (Created) for OPEN, with the assigned position in the PACE-Log-Position header field (Section 15.2).

A dialog host MUST NOT modify a control message. It MUST NOT reorder control log entries after assigning positions, and it MUST deliver entries to each event stream in control log position order. Section 14.1 describes what participants can detect when a dialog host breaks these rules.

A 202 (Accepted) response means only that the message is in the control log. It does not mean that any participant has received or applied it. Participants learn the outcome from later messages on the event stream: the controller's UPDATE commits an ACCEPT, REJECT, JOIN_REQUEST, LEAVE, or DECLARE (Section 3.3.2 of [PACE]); CANCEL_ACK answers a CANCEL; and ERROR reports a refusal.

4.2. Status Codes

HTTP status codes report the dialog host's processing of a request. They are distinct from PACE ERROR messages, which a participant sends when it does not apply an operation (Section 3.8 of [PACE]). A dialog host that rejects a request responds with a problem details object [RFC9457] (application/problem+json). When a PACE reason (Section 3.8.1 of [PACE]) applies, the object carries it in the pace_reason extension member, and carries the message_id of the rejected message, if any, in pace_message_id.

Table 2: Dialog Host Status Codes
Status Condition pace_reason
201 (Created) OPEN accepted; dialog resource created  
202 (Accepted) Message appended to the control log  
400 (Bad Request) Unparsable, not I-JSON, missing a required member, or reused message_id (Section 4.3) malformed
400 (Bad Request) Unsupported control-message version unsupported-version
400 (Bad Request) Unrecognized type, or not OPEN at the dialog collection unsupported-operation
403 (Forbidden) Sender not authorized, or invalid join code unauthorized
403 (Forbidden) Sender has been revoked participant-revoked
403 (Forbidden) Inbox sender has opted out (Section 6.3) unwanted-contact
404 (Not Found) No such dialog, or the client may not learn of it  
409 (Conflict) OPEN for a dialog-id that already exists  
409 (Conflict) Controller generation is not the next one stale-generation
409 (Conflict) Track object out of order or changed (Section 8)  
410 (Gone) The dialog has been terminated or has expired dialog-terminated
425 (Too Early) Message received in early data (Section 14.3)  
429 (Too Many Requests) Contact limits or join code attempt limits exceeded (Section 6.3, Section 4.7)  
503 (Service Unavailable) Authorization cannot be determined authorization-unavailable

Other status codes have their meanings from [RFC9110]; for example, 401 when HTTP authentication is missing or invalid, 413 when a message exceeds the dialog host's limit, and 415 when the body is not application/pace+json.

For example, a dialog host rejects a controller's UPDATE whose generation is not the next one:

HTTP/1.1 409 Conflict
Content-Type: application/problem+json

{
  "type":
    "https://iana.org/assignments/pace/errors#stale-generation",
  "title": "Generation is not the next expected generation",
  "status": 409,
  "pace_reason": "stale-generation",
  "pace_message_id": "1b9d6bcd-bbfd-4b2d-9b5d-ab8dfbbd4bed"
}

A refusal by a participant is a dialog-level answer, not an HTTP error, even when that participant is the dialog host. For example, a controller-hosted dialog that refuses a JOIN_REQUEST accepts the request with 202 and appends the controller's ERROR (Section 3.3.2 of [PACE]). The outcome is then visible to every participant that tracks the control log, whatever the hosting model.

4.3. Retries and Duplicates

POST is not idempotent, but PACE control messages are: each carries a unique message_id, and reprocessing a duplicate MUST NOT repeat its side effects (Section 3.3.3 of [PACE]).

  • A client that does not receive a response MAY repeat the POST with the identical message (Section 3.2); it need not send the same octets.

  • A dialog host that receives a message whose sender_id and message_id match a control log entry MUST NOT append it again, and MUST respond as it did to the original, including the original PACE-Log-Position.

  • A message that reuses a message_id and is not identical is rejected with 400 (Bad Request) and pace_reason malformed.

4.4. Opening a Dialog

The controller opens a dialog by POSTing OPEN (Section 3.3 of [PACE]) to the dialog collection of the dialog host. The controller generates the dialog-id (Section 3.2 of [PACE]); the dialog host does not assign it. In the following example, agent-a, the controller, opens an invitee-hosted dialog (Section 2.2) with agent-b, which hosts it at agent-b.example:

POST /pace/dialogs HTTP/1.1
Host: agent-b.example
Authorization: DPoP eyJhbGciOi...
DPoP: eyJ0eXAiOiJkcG9wK2p3dCIs...
Content-Type: application/pace+json
Accept: application/pace+json, text/event-stream

{
  "version": 1,
  "type": "OPEN",
  "dialog_id": "550e8400-e29b-41d4-a716-446655440000",
  "generation": 0,
  "sender_id": "agent-a",
  "message_id": "6f1c7c6e-3a3e-4b5e-9c55-0b8b4b1d0e11",
  "context": {
    "dialog_id": "550e8400-e29b-41d4-a716-446655440000",
    "generation": 0,
    "controller_id": "agent-a",
    "state": "pending",
    "participants": [
      {"participant_id": "agent-a", "state": "active"},
      {"participant_id": "agent-b", "state": "invited"}
    ]
  },
  "parameters": {"supported_protocols": ["a2a"]},
  "credentials": "eyJ...",
  "nonce": "q0v8pS2l7yY3mY0b1i4o9A"
}

parameters, credentials, and nonce are control message members (Section 3.10 of [PACE]). parameters carries the dialog parameters that the controller proposes (Section 3.5 of [PACE]); credentials carries agent-a's credential with its presentation for agent-b, which has no nonce yet (Section 7.1.4.2 of [PACE]); and nonce is the value to which agent-b binds its presentation in ACCEPT. The HTTP request itself is authorized with a DPoP-bound access token [RFC9449].

On success the dialog host responds with 201 (Created) and a Location header field giving the dialog URI. Dialog URIs are opaque (Section 3.1), so the controller checks the dialog itself: it MUST verify that the first entry of the dialog's event stream is its own OPEN, unchanged, and otherwise treats the dialog host as untrusted (Section 14.1). If the request's Accept header field includes text/event-stream, the dialog host MAY send the event stream for the new dialog as the response content, starting with the OPEN at control log position 1 (Section 5). This saves the controller a separate GET. Otherwise the response content is empty or a representation of the OPEN. For example, agent-b answers agent-a's OPEN above with the event stream, whose first entry is that OPEN:

HTTP/1.1 201 Created
Location: /pace/dialogs/550e8400-e29b-41d4-a716-446655440000
PACE-Log-Position: 1
Content-Type: text/event-stream
Cache-Control: no-store

id: 1
event: OPEN
data: {"version":1,"type":"OPEN","dialog_id":"550e8400-...",...}

A dialog host MUST reject an OPEN whose dialog_id already exists with 409 (Conflict), unless it is a duplicate (Section 4.3). Since dialog-ids are random UUIDs, a collision indicates a faulty or malicious sender. The controller can open the dialog again with a new dialog-id.

The dialog host makes the dialog visible to each invitee listed in the OPEN context, and to no one else. An invitee that hosts the dialog already has the OPEN. Any other invitee learns of the dialog from an invitation that the dialog host sends to the invitee's inbox: an HTTP resource, advertised in the invitee's Agent Card (Section 3.1), at which an agent receives invitations (Section 6.2).

4.5. Accepting or Rejecting

Each invitee (Section 1.3 of [PACE]), such as agent-b in the example above, answers with ACCEPT or REJECT, with in_reply_to naming the OPEN, or the UPDATE, that invited it. An ACCEPT carries three control message members (Section 3.10 of [PACE]): parameters, the dialog parameters the invitee accepts (Section 3.5 of [PACE]); credentials, its credential with a presentation bound to the controller's nonce from the OPEN (Section 7.1.4 of [PACE]); and nonce, a fresh value to which the controller binds its next presentation.

How the invitee gets the OPEN and sends its answer depends on the hosting model (Section 2.2):

  • In an invitee-hosted dialog, the invitee is the dialog host. It received the OPEN as the controller's POST, and appends its answer to the control log directly.

  • Otherwise, the invitee is an HTTP client of the dialog host. It learns of the dialog from an invitation (Section 6), reads the OPEN from the event stream or a snapshot (Section 4.9), and POSTs its answer to the dialog URI.

An active participant answers a parameter proposal in an UPDATE, and acknowledges a SEGMENT, in the same way (Section 3.3.2 of [PACE], Section 3.7.1 of [PACE]).

The controller reads the answer on its event stream and commits it with an UPDATE at the next generation, marking the invitee active or rejected. The dialog becomes active with the first such UPDATE that marks an invitee active (Section 3.3.2 of [PACE]).

Before an invitee accepts, the dialog host MUST NOT deliver it any dialog content and MUST limit its event stream to the controller's control messages and its own (Section 5.5).

4.6. Joining a Dialog

A prospective participant that knows a dialog URI asks to join by POSTing JOIN_REQUEST to it. The dialog host accepts the request from a client that is not a participant only as Section 11 allows. The prospective participant MAY then GET the event stream, which the dialog host limits as for an invitee (Section 5.5).

The controller admits the joiner with an UPDATE that sets its state to invited. The joiner then sends ACCEPT, and the controller's next UPDATE marks it active. A controller that declines sends ERROR policy-rejected (Section 3.3.2 of [PACE]), and the dialog host then ends the joiner's event stream.

Other participants see the JOIN_REQUEST on the event stream and MUST ignore it, as in Section 4.3.2 of [PACE]. A joiner therefore discloses in its credentials only claims that every participant may see.

4.7. Joining with a Join Code

A participant on a channel that cannot carry the dialog URI, such as a PSTN call, can join from another channel with a join code (Section 3.4.6 of [PACE]). The controller issues the code to an existing participant, and the code is conveyed over the call. A client that has the code but not the dialog URI resolves the code first:

  1. The client POSTs {"join_code": "..."}, with Content-Type: application/json, to the join URI, which the agent advertises in its Agent Card (Section 3.1) or in a Link header field with the relation type pace-join (Section 15.3).

  2. The dialog host responds with 200 (OK) and {"dialog_id": "...", "dialog_uri": "..."}. Resolving does not use up the code.

  3. The client POSTs JOIN_REQUEST, carrying join_code, to the dialog URI. The dialog host responds with 202, as for any control message.

The dialog host accepts both requests from an otherwise unauthorized client. For both, it:

  • MUST accept each code in one JOIN_REQUEST only, and MUST reject a code that is unknown, expired, or already used with 403 (Forbidden) and pace_reason unauthorized, without saying which; and

  • MUST limit attempts per client, per code, and per dialog, and respond with 429 (Too Many Requests) [RFC6585] beyond the limit, because codes read aloud are short.

The dialog host makes these checks before it appends a JOIN_REQUEST, so that guesses reach neither the controller nor the other participants. They add to the controller's own checks (Section 3.4.6 of [PACE]), and the controller still decides admission. The code authorizes only the JOIN_REQUEST; later requests use the client's own credentials (Section 11).

4.8. Updating, Declaring, Revoking, and Leaving

The controller POSTs UPDATE, REVOKE, and TERMINATE, each with the complete context at the next generation (Section 3.3.3 of [PACE]). Because the dialog host checks generation continuity (Section 4.1), two concurrent state changes from the controller cannot both be appended: the second receives 409 (Conflict), and the controller resends after reading the control log.

A participant leaves by POSTing LEAVE. The controller commits it with an UPDATE marking the participant left, and SHOULD send TERMINATE if it is then the only active participant (Section 3.3 of [PACE]).

Any active participant POSTs DECLARE to state its own descriptors, such as its kind, consent, or posture, or its observations of others (Section 3.4.2 of [PACE]). The controller commits it with UPDATE. The dialog host MUST NOT withhold a DECLARE from the event stream, even when the dialog host is the controller, so that every participant can check the committed values against it.

The controller POSTs SEGMENT to start or end a segment (Section 3.7.1 of [PACE]). From a SEGMENT with phase start to the matching SEGMENT with phase end, the dialog host applies the segment rules of Section 5.5.

When the dialog host appends a REVOKE (Section 3.4.7 of [PACE]), it MUST:

  • stop delivering control messages and content for the dialog to the revoked participant, after delivering the REVOKE itself as the last event on its stream, and then end that stream;

  • stop forwarding requests to the revoked participant, and cancel any request it holds only to propagate the dialog to it; and

  • reject later requests from the revoked participant for the dialog with 403 (Forbidden) and pace_reason participant-revoked.

4.9. State Requests and Snapshots

A GET on the dialog URI with Accept: application/pace+json returns a snapshot: the latest context-carrying control message from the controller, that is, the OPEN, UPDATE, REVOKE, TERMINATE, or STATE with the highest generation in the control log. The dialog host returns it unmodified, with the PACE-Log-Position of that entry and an ETag that changes whenever the snapshot changes. A client MAY use a conditional GET with If-None-Match to poll for changes.

The snapshot is a copy of a controller message, not a message from the dialog host. A participant that applies it MUST verify the origin and integrity of the controller's presentation in credentials (Section 7.1.4.3 of [PACE]) and apply the generation rules of Section 3.3.3 of [PACE], as for the same message on the event stream, so it need not trust the dialog host to leave it unchanged. Verification does not show that the snapshot is current: a dialog host can return an older message of the controller. A participant ignores a snapshot whose generation is lower than the latest it has accepted, and uses STATE_REQUEST when it needs the latest state.

A snapshot does not replace STATE_REQUEST. A participant that needs a fresh context bound to its own nonce, for example after a gap in generations or when it resumes after a disconnection (Section 3.9 of [PACE]), POSTs STATE_REQUEST with its last_accepted_generation, nonce, and credentials, and the controller answers by POSTing STATE (Section 7.1.4.1 of [PACE]).

Snapshot responses MUST carry Cache-Control: private, no-cache, so that shared HTTP caches do not store them and private caches revalidate before reuse ([RFC9111]).

4.10. Cancellation

CANCEL (Section 3.6.1 of [PACE]) asks the participants doing some work to stop it, without ending the dialog. A participant sends it by POSTing it to the dialog URI, like any other control message. Besides the members every control message has, CANCEL carries:

scope:

Which work to stop, as Section 3.6.1 of [PACE] defines: operation, one application request the sender made; dialog, all work the sender started in this dialog, including work delegated from it; or subtree, the work in the dialogs delegated from this one.

target:

With scope operation only: the application request to stop. Over MOQT, a request is named by its track; over HTTP, it is named by its protocol and request identifier, as an object with these members:

protocol:

The protocol identifier of Section 8 of [PACE], such as mcp, a2a, or ext.

request_id:

The application's identifier for the request, such as the JSON-RPC id or the A2A task identifier.

uri:

Optional. The target URI of the application request.

For example, agent-a asks agent-b to stop the MCP tool call t1 that it made to https://tools.example/mcp:

{
  "version": 1,
  "type": "CANCEL",
  "dialog_id": "550e8400-e29b-41d4-a716-446655440000",
  "generation": 1,
  "sender_id": "agent-a",
  "message_id": "0c5b7c1e-9f2a-4d3b-8e6f-2a1b3c4d5e6f",
  "scope": "operation",
  "target": {
    "protocol": "mcp",
    "request_id": "t1",
    "uri": "https://tools.example/mcp"
  },
  "credentials": "eyJ..."
}

An ERROR that rejects an application operation uses the same form (Section 3.8.1 of [PACE]).

Each receiver doing the affected work applies the cancellation through the application protocol's own mechanism and POSTs CANCEL_ACK.

Closing an HTTP connection, resetting an HTTP/2 or HTTP/3 stream, or abandoning an application request MUST NOT be treated as CANCEL. Conversely, a CANCEL does not by itself close any HTTP request; the application protocol ends its own responses when the work stops. CANCEL travels on its own HTTP request, so it does not wait behind streamed application responses. Section 10.1 describes how to keep it ahead of content.

4.11. Termination and Expiry

The controller ends the dialog by POSTing TERMINATE. After appending it, the dialog host:

  • delivers TERMINATE on every open event stream and then ends each stream;

  • responds to later POSTs for the dialog with 410 (Gone) and pace_reason dialog-terminated, except a duplicate TERMINATE, which receives its original response, and a STATE needed to complete synchronization (Section 3.6.2 of [PACE]); and

  • answers snapshot GETs with the TERMINATE for a retention period of its choosing, after which it MAY respond with 404 (Not Found) or 410 (Gone).

When expires_at passes, the dialog host treats the dialog as terminated in the same way, without appending a message. Expiry does not create a generation (Section 3.6.2 of [PACE]).

4.12. Summary of the Mapping

Every control message except OPEN is POSTed to the dialog URI, and every control message is delivered on the event stream. Some are also delivered elsewhere, as the last column shows.

Table 3: PACE Operations over HTTP
PACE Operation Sent by Also delivered
OPEN (to the dialog collection) Controller As an invitation to each invitee's inbox, unless it hosts the dialog (Section 6.2)
ACCEPT, REJECT Invitee or participant  
UPDATE Controller As an invitation to the inbox of each invitee it adds
JOIN_REQUEST Prospective participant  
LEAVE, DECLARE, STATE_REQUEST Participant  
SEGMENT, REVOKE Controller  
TERMINATE Controller Then every stream ends
STATE Controller Snapshot (Section 4.9)
CANCEL, CANCEL_ACK, LOG_STATUS, ERROR Any participant  

5. Event Stream

Participants need every control message pushed to them as soon as it is accepted, and need to catch up after a lost connection. The event stream does both with Server-Sent Events [SSE].

5.1. Format

A participant receives the control log by sending GET to the dialog URI with Accept: text/event-stream. The dialog host responds with 200 (OK) and an SSE stream. Each control log entry is one event:

  • id is the entry's control log position, in decimal.

  • event is the control message type.

  • data is the control message, serialized as JSON on a single line. The dialog host need not reproduce the octets the sender POSTed, but it MUST preserve the message's value (Section 3.2).

For example, the controller's UPDATE at generation 1 is the third entry of the control log, and a participant's CANCEL the fourth:

id: 3
event: UPDATE
data: {"version":1,"type":"UPDATE","generation":1,...}

id: 4
event: CANCEL
data: {"version":1,"type":"CANCEL","scope":"operation",...}

The dialog host MAY send SSE comment lines to keep idle connections open, and MAY send a retry field. Comments carry no dialog semantics; in particular, they do not count as activity for the dialog's idle timeout (Section 3.5.2 of [PACE]).

Event stream responses MUST carry Cache-Control: no-store.

A participant MUST process events in control log position order. Control log positions only order the log. The participant applies controller operations by generation (Section 3.3.3 of [PACE]), and treats a generation gap as a reason to send STATE_REQUEST. A receiver that does not recognize an event type MUST handle it as Section 3.10 of [PACE] requires for an unrecognized type.

5.2. Starting Position

An event stream starts at control log position 1 by default, so a new participant sees the complete control log, including the OPEN and every committed change. A dialog host MAY compact a long control log. If it does, it MUST keep, at a minimum, the latest context-carrying controller message and every later entry, and a stream that requests a compacted range starts at the oldest retained entry. A participant that receives a stream whose first entry is not the one it requested MUST send STATE_REQUEST before acting on state that may have changed (Section 3.9 of [PACE]).

5.3. Resumption

A participant that loses its event stream reconnects with GET and the Last-Event-ID header field set to the last control log position it processed, as [SSE] defines. The dialog host resumes the stream with the next entry, or with the oldest retained entry if those entries were compacted. The participant then:

  1. sends STATE_REQUEST, as Section 3.9 of [PACE] requires after any reconnection, and applies the controller's STATE only after authenticating the controller and checking its generation; and

  2. if it reads or publishes on a track resource, POSTs LOG_STATUS and resumes each track after its accepted position (Section 8.4).

The participant learns which application requests completed while it was away through the application protocol, such as A2A GetTask, not from the control log (Section 3.9 of [PACE]).

5.4. Polling

Some clients cannot hold a response open, such as clients behind proxies that buffer responses and clients that use Oblivious HTTP (Section 12). Such a client polls:

  • It sends the event stream GET with Last-Event-ID and the wait preference [RFC7240], for example Prefer: wait=30.

  • A dialog host that honors the preference sends the entries that follow Last-Event-ID and then ends the response. If there are none, it waits up to the requested number of seconds for one before ending the response. It includes Preference-Applied: wait.

  • The client sends its next poll with the last control log position it received.

  • A dialog host that does not honor the preference sends an ordinary stream.

Polling does not change which entries a client receives or their order. A track resource (Section 8) and a pull inbox (Section 6.2) are polled in the same way.

5.5. Visibility

The dialog host delivers to each client only what that client may see. A participant's state is the one in the latest committed controller context in the control log, not the one implied by the participant's own requests.

Table 4: Event Stream Visibility
Client state Delivered on the event stream
Invited or prospective (not yet active) Controller's control messages, and the client's own
active All control messages
left, rejected The committing UPDATE, then the stream ends
revoked The REVOKE, then the stream ends

Every active participant receives every control message, whatever its access or the segments in progress, so that each participant sees the whole lifecycle. Content is restricted further, by three rules. They apply to content on the track resource and to application requests that the dialog host relays.

Only what access allows:

A participant with an access descriptor (Section 3.4.1 of [PACE]) receives only the flows and modalities in its receive list, and may publish only those in its send list. Without access, it receives and publishes every flow.

Segment content stays in the segment:

The content of a segment is exchanged in the segment's own dialog, which only the participants the segment names can read. The others see only the SEGMENT control messages, which tell them that the segment took place.

Nothing new before a segment is acknowledged:

A participant that a segment does not name receives no content published after the SEGMENT until its ACCEPT naming the SEGMENT is in the control log (Section 3.7.1 of [PACE]), so it has seen the SEGMENT before later content reaches it.

The dialog host enforces these rules for content it hosts or relays. Each participant applies them to content that the application protocol carries directly (Section 7). These rules protect content only from other participants, and only as far as the dialog host follows them. Participants that do not trust each other to honor a segment, or that do not trust the dialog host, protect content end to end (Section 14.1).

6. Invitations and Discovery

When a controller opens a dialog, the invitee may not know that the dialog exists, or where it is hosted. It needs the dialog URI to read the OPEN and answer it. This binding gives it that URI in one of two ways:

An invitee can refuse an invitation and limit later contact from the same sender (Section 6.3). The same inbox also receives contacts outside any dialog, such as offers, and a follow-up dialog delivers updates to an agent that is offline (Section 6.4).

6.1. Invitation by OPEN

In an invitee-hosted dialog, the controller POSTs OPEN to the invitee's dialog collection (Section 4.4). That OPEN is the invitation: the invitee holds the dialog and needs nothing more. Participants that the controller invites later, with UPDATE, receive an inbox invitation.

6.2. Inbox Invitations

An inbox is an HTTP resource at which an agent receives invitations. The party that hosts the dialog sends each invitation: the dialog host, which in a controller-hosted dialog is the controller.

The invitation:

A JSON object with the media type application/pace-invitation+json (Section 15.1) and these members:

dialog_id:

The dialog identifier.

controller_id:

The controller's participant identifier.

invitee_id:

The invitee's participant identifier.

dialog_uri:

The dialog URI on the dialog host.

expires_at:

Optional. The time after which the invitation is void.

purpose, basis:

Optional. Copies of the purpose and basis parameters of the OPEN (Section 3.5.1 of [PACE]), so that the invitee can screen the invitation before it reads the dialog.

related_dialogs:

Optional. A copy of the related_dialogs member of the dialog context (Section 3.2 of [PACE]), for example naming the dialog that a follow-up continues.

What it proves:

Nothing. Like the MOQT invitation (Section 4.1.3 of [PACE]), an invitation only points to the dialog. It carries no dialog context and grants no access. The invitee reads the OPEN or UPDATE that invites it from the dialog URI and decides on that. The copied members are hints: where they differ from the control messages, the control messages apply, and the invitee SHOULD reject the invitation.

Push and pull inboxes:

An agent advertises its inbox URI in its Agent Card (Section 3.1), and whether the inbox is push or pull, in inbox_type:

  • A push inbox is on an HTTP server that the invitee operates. The sender POSTs the invitation to it, and the inbox responds with 202 (Accepted). The inbox authenticates the sender (Section 6.3) and SHOULD accept invitations only from agents the invitee is willing to hear from, as following does in the MOQT binding (Section 7.2.2 of [PACE]).

  • A pull inbox is on a server that the invitee can reach but does not operate, such as its dialog host or platform. This suits agents that cannot accept inbound HTTP connections, such as agents on user devices. The invitee GETs the inbox with Accept: text/event-stream and receives each invitation as an SSE event of type invitation, with an id that the inbox server assigns for resumption (Section 5.3). The inbox server delivers to each authenticated client only the invitations naming it as invitee_id.

Offline invitees:

An invitee that comes online late GETs its pull inbox without Last-Event-ID to receive pending invitations, and ignores those whose expires_at has passed.

6.3. Refusing Contact

An invitee needs to refuse unwanted contact, and to limit later contact from the same sender.

Refusing:

The invitee POSTs REJECT to the dialog URI. The REJECT MAY carry a result, such as reason unwanted-contact or no-stated-purpose, and contact_limits (Section 3.6.3 of [PACE]), for example an opt-out from later contacts by the same sender.

Purpose and basis:

A contact that no subscription or existing dialog covers SHOULD carry purpose and basis, and an invitee MAY refuse one that does not (Section 3.5.1 of [PACE]; [DIALOG-UC], UC3-4).

Applying limits:

An inbox applies the limits it has recorded to the sender it authenticates; limits with scope sender apply across dialogs. For a sender that has exceeded them, the inbox:

  • responds to a push invitation with 429 (Too Many Requests) [RFC6585], with a Retry-After field when retry_after was given, or, after an opt-out, with 403 (Forbidden) and pace_reason unwanted-contact; and

  • does not deliver such an invitation on a pull inbox.

Unauthenticated senders:

Limits cannot be tied to a sender that is not authenticated (Section 3.6.3 of [PACE]). An inbox SHOULD NOT accept push invitations from senders it cannot authenticate; one that does can limit them only per channel or address.

6.4. Follow-up and Offline Delivery

A participant can want updates after a dialog ends, such as a consumer agent waiting for a refund ([DIALOG-UC], UC3), even while it is offline.

Opening the follow-up:

The participant opens a follow-up dialog as its controller, with a related_dialogs entry of relation follow-up naming the original dialog (Section 3.2 of [PACE]). As controller, it sets the dialog's expires_at and ends it with TERMINATE. A related dialog is not a delegated one, so it survives the end of the original.

Receiving updates:

The other party publishes each update on the track resource. An offline subscriber receives the updates when it next reads the track resource from its last position (Section 5.3), so it needs no push endpoint. Each update is delivered at least once, and the subscriber discards duplicates by group and object ID, as for any replay of the dialog log (Section 3.11.2 of [PACE]). The dialog host keeps updates for at least the log_retention that the subscriber proposed. A deferred result in the original dialog can give the time of the next update in next_update_at, so the subscriber need not poll more often.

Contact without a dialog:

A party that contacts a principal with no follow-up dialog, such as with a renewal offer, sends an invitation to the principal's agent's inbox, with purpose and basis (Section 6.3).

6.5. Agent Cards

An agent publishes its Agent Card at an HTTPS URI, such as the A2A well-known Agent Card URI, and receivers verify it as Section 7.2.3 of [PACE] requires. Agent Card responses MAY be cached according to their HTTP cache headers; a card that is specific to a requester MUST be served with Cache-Control: private.

7. Correlating Application Requests

Dialog content is carried by the application protocol over its own HTTP transport, such as A2A JSON-RPC over HTTP or MCP Streamable HTTP. Those messages carry the dialog reference in their own extension points (Section 8.1 of [PACE]), which HTTP intermediaries do not parse. This binding adds an HTTP header field so that intermediaries and servers can correlate a request to a dialog without parsing its content.

7.1. The PACE-Dialog Header Field

PACE-Dialog is a Dictionary Structured Field [RFC9651] with these members:

id:

Required. A String carrying the canonical textual form of the dialog-id.

gen:

Optional. An Integer carrying the latest generation the sender knows.

uri:

Optional. A String carrying the dialog URI.

Receivers ignore members they do not recognize. For example, agent-a sends an A2A request to agent-b in the dialog, at generation 3, and names the dialog both in PACE-Dialog and in the A2A message metadata:

POST /a2a HTTP/1.1
Host: agent-b.example
Content-Type: application/json
PACE-Dialog: id="550e8400-e29b-41d4-a716-446655440000", gen=3

{"jsonrpc":"2.0","method":"SendMessage","id":"r1","params":{
 "message":{..., "metadata":{"org.ietf.agentproto/dialog-context":
 {"dialog_id":"550e8400-e29b-41d4-a716-446655440000",
  "generation":3}}}}}

A client SHOULD send PACE-Dialog on every application HTTP request that belongs to a dialog, in addition to the dialog reference in the application message. When both are present, they MUST name the same dialog-id; a receiver MUST reject a request in which they differ, with 400 (Bad Request). A server MAY send PACE-Dialog on responses.

Like every dialog reference, PACE-Dialog is a correlation value. It MUST NOT be treated as a credential, and a server MUST authorize the request independently of it (Section 3.2 of [PACE]). A server that receives a request naming a dialog in which the client is not an active participant SHOULD reject it with 403 (Forbidden).

The field gives HTTP intermediaries one place to apply dialog-level policy, such as routing all requests of a dialog to the same backend, rate limiting per dialog, or rejecting requests for a terminated dialog, and to record the dialog-id for audit. An HTTP intermediary MUST NOT add, change, or remove PACE-Dialog.

7.2. Application Protocols over HTTP

This binding does not change the HTTP transport, message format, or semantics of any application protocol. An MCP client and server keep Streamable HTTP, JSON-RPC, and MCP session handling; an A2A client and server keep their JSON-RPC or HTTP+JSON binding. PACE support is added beside them:

  • Application requests carry the dialog reference in the protocol's existing extension point, such as MCP _meta or A2A message metadata (Section 8.1 of [PACE]), and SHOULD carry the PACE-Dialog header field. Implementations that do not support PACE ignore both.

  • PACE control messages go to the dialog URI, not to the application endpoint (Section 4). A PACE component next to the application client or server sends and receives them; the application protocol does not see them.

  • A PACE CANCEL is applied through the protocol's own cancellation, so the application sees its native cancel (Section 4.10).

Table 5: Application Protocols over HTTP
Protocol HTTP transport Dialog reference Cancellation
MCP Streamable HTTP _meta, and PACE-Dialog PACE CANCEL applied as notifications/cancelled
A2A JSON-RPC or HTTP+JSON Message metadata, and PACE-Dialog PACE CANCEL applied as CancelTask
Other Protocol's own Protocol's extension point, and PACE-Dialog Protocol's own

PACE dialog-ids are distinct from application session and context identifiers, such as the MCP session identifier (Mcp-Session-Id) or the A2A contextId. A dialog-id MUST NOT be used as one of them (Section 8.1 of [PACE]). A dialog can contain one MCP session or A2A context, or span several, for example when an application reconnects.

An application server need not be the dialog host or implement PACE. A server that does not implement PACE works unchanged but does not enforce dialog membership. One that does, even when another origin hosts the dialog, tracks the control log or snapshot to know the participant set and state.

8. Dialog Tracks

Some dialog content has no application protocol to carry it:

For such content, a dialog host MAY offer a track resource. It holds the objects that participants publish on named tracks, in the sense of the MOQT binding (Section 4.1.2 of [PACE]), and delivers them on an event stream. A dialog host that hosts dialogs using PACE Authorization MUST offer a track resource, because it is the only way HTTP participants send and receive checkpoint objects (requests, responses, commitments, and assertions), which [PACE-AUTHZ] carries as a reliable flow named checkpoint at the Urgent Signals tier. In this binding, that flow is each participant's track named checkpoint on the track resource.

A dialog host that offers a track resource advertises its URI in a Link header field [RFC8288] with the relation type pace-tracks (Section 15.3) on the 201 response to OPEN and on snapshot responses:

HTTP/1.1 201 Created
Location: /pace/dialogs/550e8400-e29b-41d4-a716-446655440000
Link: </pace/dialogs/550e8400-e29b-41d4-a716-446655440000/tracks>;
      rel="pace-tracks"

Track payloads pass through the dialog host, which can read them unless participants protect them end to end; Section 14.1 requires this when the dialog host is untrusted.

Track payloads pass through the dialog host, which can read them unless participants protect them end to end; Section 14.1 requires this when the dialog host is untrusted.

Clients MUST use the advertised URI. Only active participants may publish to or read from a track resource, and an extension that defines a track can restrict access further. The dialog host authorizes track requests as it does control messages (Section 11), and stops accepting them when the dialog terminates (Section 4.11). Track responses MUST carry Cache-Control: no-store.

Real-time media is not carried on a track resource; a dialog that needs it uses MOQT (Section 10.2).

8.1. The PACE-Track Header Field

PACE-Track (Section 15.2) identifies an object or a position on a track resource. It is a Dictionary Structured Field [RFC9651] with these members:

name:

A String carrying the track name. Required.

g:

An Integer carrying the group ID. Required on POST.

o:

An Integer carrying the object ID within the group. Required on POST.

sender:

A String carrying the publisher's participant identifier. Used only on GET, to read one publisher's track from a position (Section 8.4).

8.2. Publishing an Object

A participant publishes one object per POST to the track resource. The request content is the object's payload, Content-Type is its media type, and PACE-Track identifies it. For example, a participant of a dialog hosted at hub.example publishes a checkpoint request as object 0 of group 4 on its checkpoint track:

POST /dialogs/550e8400-e29b-41d4-a716-446655440000/tracks HTTP/1.1
Host: hub.example
Content-Type: application/json
PACE-Track: name="checkpoint", g=4, o=0

{"type":"request", ...,
 "signature":"eyJhbGciOiJFUzI1NiJ9..9XUavKNq..."}

The publisher of an object is the authenticated HTTP client; a client cannot publish on another participant's track. The dialog host responds with 204 (No Content) when it stores the object.

  • Each publisher's objects on a track MUST be in increasing order of group ID, and of object ID within a group. A POST that goes backwards receives 409 (Conflict).

  • A POST that repeats a stored object with identical content receives 204 again; one that repeats it with different content receives 409 (Conflict). Content with a JSON media type (application/json or a +json suffix) is identical as defined in Section 3.2. Other content is identical when its octets are equal.

  • A JSON payload must be I-JSON; the dialog host rejects one that is not with 400 (Bad Request).

Other status codes are as in Table 2.

8.3. Reading Objects

A participant reads the track resource with GET and Accept: text/event-stream. To receive one track, it MAY include PACE-Track with only name; to receive one publisher's track from a position, it includes name, sender, g, and o (Section 8.4). Otherwise it receives every track it may read. Each object is one event:

  • id is the object's position in the track resource, which the dialog host assigns. Track resource positions are distinct from control log positions and from log positions.

  • event is object.

  • data is a JSON object on a single line with the members sender (the publisher's participant identifier), track, g, o, and content_type. A JSON payload is in json, as a JSON value that the dialog host preserves as it does a control message (Section 3.2). Any other payload is in data, base64url-encoded without padding (Section 5 of [RFC4648]), with its octets preserved exactly.

For example, the checkpoint request that agent-b published as object 0 of group 4 is the twelfth object of the track resource:

id: 12
event: object
data: {"sender":"agent-b","track":"checkpoint","g":4,"o":0,...}

Because the dialog host re-serializes JSON payloads, signatures over them are computed over their JCS form, as for checkpoints (Section 3.2). A publisher whose payload is signed over its exact octets uses a non-JSON media type, so that the octets travel in data.

Resumption with Last-Event-ID and polling work as for the event stream (Section 5.3, Section 5.4). The dialog host chooses how long it retains objects, but no less than the dialog's log_retention parameter (Section 3.5 of [PACE]) when it is set. A client that resumes from a position that the dialog host no longer retains starts at the oldest retained object, and learns what it missed from the application or the publisher.

8.4. Log Replay and Rehydration

The dialog log of Section 3.11 of [PACE] maps onto track resources as follows:

  • A flow is one publisher's track on the track resource. In the positions of LOG_STATUS, flow has the form the MOQT binding uses (Section 4.2.4 of [PACE]), with an empty namespace and the track name as track.

  • A log entry is an object. Its log position is its group and object ID, encoded in accepted as {"group": G, "object": O}.

  • All flows on a track resource are reliable.

A receiver retrieves the entries of a flow from a given position with a GET on the track resource whose PACE-Track carries name, sender, g, and o. The dialog host starts the stream at the first object of that publisher's track after that group and object ID, and continues it live. A new client instance rehydrates the log in the same way.

The dialog host stores the objects it accepted, so a publisher whose POST received 204 (No Content) has made that entry available. After LOG_STATUS, a publisher re-POSTs, with identical content, only those entries above the reported accepted positions that the dialog host no longer holds; the dialog host accepts them as repeats.

Application requests carried over the application protocol's own HTTP transport (Section 7) are not dialog log entries in this binding. Their replay and completion status remain those of the application protocol, such as A2A GetTask or MCP Streamable HTTP resumption, and LOG_STATUS does not list them.

9. Interworking with the MOQT Binding

One dialog can have both HTTP and MOQT participants, such as a browser that carries voice over MOQT and a tool server that uses MCP over HTTP. The dialog keeps one dialog-id, controller, and generation sequence (Section 3.9 of [PACE]). A gateway, which is a PACE intermediary, joins the two:

Because the gateway forwards messages unchanged, participants authenticate one another end to end through credentials, whichever binding each uses. A CANCEL with scope operation names its target in the form of the binding the sender uses for the targeted work: a track for MOQT (Section 4.3.6 of [PACE]), or an application request for HTTP (Section 4.10).

10. HTTP Versions and WebTransport

The binding works over any HTTP version, but versions differ in how well they meet the transport requirements of Section 2.1 of [PACE], in particular that dialog control overtakes queued content.

HTTP/1.1:

A connection carries one request at a time, and an event stream occupies its connection while it is open. A participant therefore uses at least two connections: one for its event stream, and one for its POSTs and application requests. A CANCEL sent on a connection that is busy with a streamed application response waits behind it, so a participant SHOULD keep a separate connection available for control messages. HTTP/1.1 pipelining MUST NOT be used for control messages.

HTTP/2:

The event stream, control POSTs, and application requests are concurrent streams on one connection, so a CANCEL does not wait for other responses to finish. TCP still delivers all streams in order, so a lost packet delays every stream on the connection, including control messages.

HTTP/3:

Each request is on its own QUIC stream, so a loss on an application response does not delay control messages on other streams. QUIC also provides connection migration and 0-RTT (Section 14.3). HTTP/3 best meets the low-latency and interruption requirements of [PACE], and clients SHOULD prefer it when the dialog host supports it.

10.1. Priority

Dialog control is meant to overtake queued content (Section 5.3 of [PACE]). With the Extensible Prioritization Scheme [RFC9218], clients and dialog hosts:

  • SHOULD send control POSTs and event stream requests with urgency 0 (Priority: u=0), and SHOULD NOT mark them incremental;

  • SHOULD send application requests and responses at urgency 1 or greater, using lower urgency (higher values) for bulk transfers; and

  • SHOULD set the response priority of event streams to urgency 0.

The tiers of Section 5.3 of [PACE] map onto urgency as follows. Track resource requests and responses (Section 8) use the urgency of the track's tier; for example, the checkpoint flow uses Urgent Signals and therefore urgency 1.

Table 6: PACE Priority Tiers and HTTP Urgency
PACE tier Urgency
Dialog Control 0
Urgent Signals 1
Real-time Media, Interactive 2
Standard Operations 3
Discovery 4
Background 5
Bulk Transfer 6 or 7

A server applies priority signals according to its own policy and the requester's authorization, so a client cannot raise its traffic above what the server allows. This matches the subscriber-priority model of the MOQT binding.

10.2. WebTransport and the MOQT Binding

An application that needs real-time media, independent streams, or relay fan-out uses the MOQT binding (Section 4 of [PACE]). The MOQT binding runs over WebTransport over HTTP/3 [WEBTRANS-H3] or over native QUIC (Section 4.2.1 of [PACE]). A WebTransport session is established with an extended CONNECT request to an HTTP origin, so the same origin can offer both bindings, and one dialog can use both (Section 9).

The extended CONNECT request that establishes the WebTransport session SHOULD carry PACE-Dialog when the session is opened for one dialog, so that the origin can authorize and route it.

11. Authorization

Two questions are answered separately, as in the MOQT binding:

Table 7: Two Layers of Authorization
Question Who answers it How
May this HTTP client make this request? The dialog host HTTP authentication of the client (hop by hop)
Who sent this control message, and may they? Every participant credentials in the control message (end to end)

The dialog host needs the first to decide what to accept and deliver. Participants need the second so that they do not have to trust the dialog host.

Authenticating clients:

The dialog host authenticates each HTTP client, for example with an OAuth 2.1 access token [OAUTH-2.1] in the Authorization header field, or with a TLS client certificate. Access tokens SHOULD be sender-constrained with DPoP [RFC9449], so that a token read from a log or intercepted by an HTTP intermediary cannot be used by another client. This takes the place of relay authorization in the MOQT binding (Section 9.2.2 of [PACE]), which binds the same tokens with DPoP for MOQT [MoQ-C4M], so a participant that uses both bindings can use one key.

Authenticating senders:

Participants authenticate one another, and check authorization and delegation chains, through the credentials member of control messages (Section 7.1 of [PACE], Section 9.1 of [PACE]). The dialog host forwards them unchanged and need not understand them. HTTP authentication identifies a client only to the dialog host, so a participant MUST NOT treat the dialog host's acceptance of a message as proof of who sent it, unless the dialog host is itself the participant checking. A DPoP proof covers one HTTP request and is not forwarded. HTTP Message Signatures [RFC9421] with Content-Digest [RFC9530] MAY give the dialog host a signature over a request, but they cover its octets, which the event stream does not preserve (Section 3.2). Neither replaces the presentations in credentials, which bind the control message itself with mth (Section 7.1.4 of [PACE]).

Who may POST what:

The dialog host derives each client's permissions from the latest committed controller context:

Table 8: What Each Client May POST
Client May POST
Controller Any control message
active participant Any control message except OPEN, UPDATE, REVOKE, TERMINATE, STATE, and SEGMENT. The dialog host MUST accept its DECLARE, whatever its access.
Alternate controller Also an UPDATE that names itself as controller, to take over (Section 3.7.4 of [PACE])
invited participant ACCEPT, REJECT, and ERROR
Not in the dialog JOIN_REQUEST, if the dialog host's policy allows it, or if it carries a join_code (Section 4.7) or names a sponsor (Section 3.4.5 of [PACE])
left participant JOIN_REQUEST
rejected or revoked participant Nothing

The dialog host rejects any other request with 403 (Forbidden), or MAY respond with 404 (Not Found) to a client that has no relationship with the dialog, so as not to reveal that it exists. If it cannot determine authorization, it responds with 503 (Service Unavailable) and pace_reason authorization-unavailable. Participants make the same check themselves, for the sender they verify (Section 7.1.4.3 of [PACE]).

No list of dialogs:

A dialog host MUST NOT offer a resource that lists the dialogs it hosts to clients that are not authorized to see all of them, just as the MOQT binding restricts short prefix subscriptions (Section 9.2.2 of [PACE]).

11.1. Anonymous Authorization

A hop-by-hop credential identifies the participant to the dialog host, and links its requests across dialogs. Where the dialog host needs to know only that a request comes from a member of the dialog, it SHOULD authorize with holder-bound Privacy Pass tokens [RFC9576] instead, as the MOQT binding does at relays (Section 9.2.3 of [PACE], Section 9.3 of [PACE]):

  1. The dialog host challenges with the PrivateToken authentication scheme [RFC9577]. The controller's domain issues membership tokens to admitted participants, under public metadata derived from the dialog-id [PP-AGENTS].

  2. The participant presents a holder-bound token with a redemption proof in the proof auth-param [PP-AGENTS]. The proof covers the method and target URI, and, for a control message, the message itself with mth.

  3. Each token is redeemed once. Every request, including each poll of the event stream, consumes one; a participant that reads the event stream as one long response uses one per stream.

The dialog host then knows only that the client is a member. It cannot tell the controller from the others, so operations reserved to the controller still require the controller's own credential in credentials. Combined with Oblivious HTTP (Section 12), the dialog host learns neither which participant acted nor its network address, while participants still identify one another through credentials.

12. Oblivious HTTP

TODO: how Oblivious HTTP [RFC9458] can hide a participant's network address from the dialog host, where it applies, and where it does not.

13. Relationship to A-SIP

A-SIP [ASIP] defines a web API between a principal and an agent, with MOQT for real-time media and offline notification. It has the shape of the invitee-hosted model of this binding (Section 2.2):

Table 9: A-SIP and the PACE HTTP Binding
A-SIP PACE HTTP binding
GET agent URI (capabilities) GET Agent Card, which advertises the dialog collection (Section 3.1)
POST agent URI (create dialog) POST OPEN to the dialog collection (Section 4.4)
Dialog context resource Dialog snapshot (Section 4.9)
Log, with catch-up Event stream with Last-Event-ID (Section 5.3)
Chat over the web API The application protocol, or the track resource (Section 8)
Voice and video over MOQT, muxed or relayed The MOQT binding over WebTransport on the same origin, or through a relay (Section 10.2)
:pause, :resume Idle dialog, and resynchronization with STATE_REQUEST

An A-SIP dialog is a two-party PACE dialog whose controller is the principal and whose dialog host is the agent. PACE adds what A-SIP leaves open:

An A-SIP dialog resource could be represented by PACE dialog context, so that A-SIP and PACE clients can share a dialog.

14. Security Considerations

The security considerations of [PACE] and of HTTP [RFC9110] apply.

14.1. Dialog Host Trust

A dialog host plays the part of a delivery service: every message of a dialog passes through it, so participants rely on it to deliver messages, and it sees who talks to whom and when. This binding does not rely on it for anything else:

Table 10: What Participants Rely on the Dialog Host For
Property Relies on the dialog host? Protection
Integrity and origin of control messages and checkpoints No Key-bound presentations, signatures, and generations; changes are detected
Confidentiality of content No, when content is protected end to end End-to-end protection of track resource payloads and segment content (Section 9.2.1 of [PACE])
Delivery, timeliness, and ordering Yes, within limits Generations, sender checks, expiry, and the choice of host (Section 2.2)
Metadata: participants, timing, and volume Yes Inherent to hosting; Oblivious HTTP hides network addresses (Section 12)

A participant SHOULD treat a dialog host it does not operate as untrusted, and the rest of this section says what that requires. A dialog host sees every control message of the dialogs it hosts, including participant identifiers and credentials. It can delay, drop, or withhold messages, but it cannot forge or change them without detection:

  • participants authenticate the controller and one another through key-bound presentations whose mth covers the message (Section 7.1.4 of [PACE]);

  • checkpoints carry their own detached signatures [PACE-AUTHZ]; and

  • participants apply the generation rules to every controller message, so a dropped, reordered, or replayed UPDATE, REVOKE, or TERMINATE shows as a gap or a stale generation (Section 3.3.3 of [PACE]).

Every control message carries a presentation, which a sender may omit only where every party that forwards it is trusted (Section 7.1.4.3 of [PACE]). The dialog host forwards every message, so a participant that treats it as untrusted does not omit them, and rejects messages without one. For OPEN and JOIN_REQUEST, which are sent before the sender has a nonce, the presentation is the nonce-less form of Section 7.1.4.2 of [PACE]. The same section of PACE defines the sender binding, role check, and replay rules that let participants detect a forged or replayed message, such as a TERMINATE the controller did not send.

A participant SHOULD check that each message it sent appears unchanged on its event stream at the control log position given in the 202 (Accepted) or 201 (Created) response. A receiver discards a message that fails verification and does not act on it. A participant that detects a modified, misplaced, or missing message treats the dialog host as untrusted: it leaves the dialog, or continues through another dialog host or the MOQT binding (Section 9). It cannot report the dialog host through the dialog host itself.

Some misbehavior cannot be detected from the control log: dropping a message, reordering messages from participants other than the controller, and delivering different messages to different participants. Their effect on dialog state is limited, because only the controller's messages change it and each carries the complete context; a participant learns of a dropped message of its own only when no commit, CANCEL_ACK, or reply follows.

A dialog host that withholds a REVOKE or TERMINATE can keep a participant acting on stale state until the dialog expires or the participant reaches the controller another way. When the dialog host is untrusted, the controller sets expires_at, and participants use short-lived credentials.

The visibility rules of Section 5.5 decide what the dialog host delivers to each participant, but a dialog host could ignore them. When the dialog host is untrusted, participants MUST protect the payloads they publish on the track resource, and the content of segments, end to end (Section 9.2.1 of [PACE]), as PACE requires for MOQT relays that are not trusted with content. The visibility rules then limit only what each participant learns about the dialog, not whether it can read content.

credentials pass through the dialog host and are visible to every participant that reads the control log. Participants SHOULD use credentials bound to a key, with the key-bound presentations of Section 7.1.4 of [PACE], and sender-constrained tokens [RFC9449], so that credentials read from the log cannot be replayed. A credential bound to no key, such as a bearer token, can be replayed by any reader of the control log.

In a dialog between parties of conflicting interests ([DIALOG-UC]), the dialog host is often one of them, such as a brand that hosts dialogs opened by consumer agents. It can delay or withhold the other side's messages, such as a DECLARE that raises posture, a REJECT with contact_limits, or a CANCEL, and it learns the timing and metadata of every exchange. It cannot change what a participant declared, nor approve on the other principal's behalf [PACE-AUTHZ]. A participant that cannot accept these risks chooses the host as Section 2.2 describes and keeps its own record of what it sent.

14.2. JSON Parsing

A dialog host authorizes a message as it parses it, and each participant parses it again. If the parsers disagree, the dialog host can admit a message that a participant reads differently. For example, with a duplicate sender_id or amount member, one parser can keep the first value and another the last. A signature over the JCS form of one reading then verifies for a participant that acts on another. Requiring I-JSON (Section 3.2) at the dialog host and at every receiver removes the ambiguity. The generation is at most 2^53 - 1 (Section 3.10 of [PACE]). Amounts, account numbers, and other values that need exact decimal or 64-bit precision are carried as strings, as in [PACE-AUTHZ], because a JSON number can change value when it is parsed.

14.3. Early Data

TLS 1.3 early data, used by HTTP/1.1 and HTTP/2 over TLS and by HTTP/3 0-RTT, can be replayed. Clients MUST NOT send in early data a control message that changes state or cancels work (OPEN, ACCEPT, UPDATE, JOIN_REQUEST, LEAVE, DECLARE, SEGMENT, REVOKE, TERMINATE, CANCEL), a STATE_REQUEST (Section 11 of [PACE]), or a join code. A dialog host that receives such a request in early data MUST NOT process it before the TLS handshake completes: it either waits for the handshake to complete or responds with 425 (Too Early) [RFC8470].

14.4. Caching

Control messages, snapshots, event streams, track objects, and invitations are specific to the requester's authorization. Dialog hosts MUST mark them as this document specifies so that shared caches do not store them, and HTTP intermediaries MUST NOT serve a cached snapshot or event stream to a different client. Responses of a pull inbox and of a join URI also carry Cache-Control: no-store.

14.5. Resource Exhaustion

Event streams are long-lived. A dialog host SHOULD limit the number of concurrent event streams per client and per dialog, the size of control messages (Section 3.10 of [PACE]), and the retained control log, and SHOULD apply rate limits to POSTs per sender. A dialog host SHOULD NOT retain the control log of a terminated dialog beyond its retention period (Section 4.11).

14.6. Privacy

The privacy considerations of Section 9.3 of [PACE] apply. In this binding, HTTP intermediaries see request URIs, which contain dialog URIs, and the PACE-Dialog header field. Deployments that need to limit linkage SHOULD use fresh dialog-ids per dialog, pairwise or per-dialog participant identifiers, and dialog URIs that do not encode participant or task information. Access logs that record PACE-Dialog are subject to the same retention limits as other identifiers.

The dialog host also sees each participant's network address (Section 12).

15. IANA Considerations

15.1. Media Types

This document requests registration of the following media types in the "Media Types" registry.

15.1.1. application/pace+json

Type name:

application

Subtype name:

pace+json

Required parameters:

N/A

Optional parameters:

N/A

Encoding considerations:

binary (I-JSON [RFC7493], UTF-8)

Security considerations:

See the Security Considerations of this document and of [PACE].

Interoperability considerations:

Receivers reject duplicate member names. Signatures and hashes over the content are computed over a JCS [RFC8785] form, not over its octets (Section 3.2).

Published specification:

This document

Applications that use this media type:

Agents, tools, and dialog hosts that implement the PACE HTTP binding.

Fragment identifier considerations:

Same as for application/json [RFC8259].

Additional information:

Deprecated alias names for this type: N/A. Magic number(s): N/A. File extension(s): N/A. Macintosh file type code(s): N/A.

Person and email address to contact for further information:

Suhas Nandakumar snandaku@cisco.com

Intended usage:

COMMON

Restrictions on usage:

N/A

Author:

Suhas Nandakumar

Change controller:

IETF

15.1.2. application/pace-invitation+json

Registered with the same template as application/pace+json, except:

Subtype name:

pace-invitation+json

Applications that use this media type:

Agents and dialog hosts that deliver PACE invitations over HTTP.

15.2. HTTP Field Names

This document requests registration of the following fields in the "Hypertext Transfer Protocol (HTTP) Field Name Registry":

Table 11: HTTP Field Name Registrations
Field Name Status Structured Type Reference
PACE-Dialog permanent Dictionary Section 7.1 of this document
PACE-Log-Position permanent Item Section 4.1 of this document
PACE-Track permanent Dictionary Section 8 of this document

PACE-Log-Position is an Item Structured Field whose value is an Integer: the control log position of the entry that the response concerns.

15.4. Problem Types

This document requests that IANA create a "PACE Problem Types" registry in the "Protocol for Agent Communication Exchange (PACE)" group, with the Specification Required policy. It has one entry for each ERROR reason of Section 3.8.1 of [PACE], with the reason, a title, and a reference. The problem type URI of an entry has the form https://iana.org/assignments/pace/errors#{reason}.

16. References

16.1. Normative References

[PACE]
Nandakumar, S. and C. F. Jennings, "PACE: Protocol for Agent Communication Exchange", Work in Progress, Internet-Draft, draft-nandakumar-agentproto-pace-01, , <https://datatracker.ietf.org/doc/html/draft-nandakumar-agentproto-pace-01>.
[RFC2119]
Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, DOI 10.17487/RFC2119, , <https://www.rfc-editor.org/rfc/rfc2119>.
[RFC4648]
Josefsson, S., "The Base16, Base32, and Base64 Data Encodings", RFC 4648, DOI 10.17487/RFC4648, , <https://www.rfc-editor.org/rfc/rfc4648>.
[RFC7493]
Bray, T., Ed., "The I-JSON Message Format", RFC 7493, DOI 10.17487/RFC7493, , <https://www.rfc-editor.org/rfc/rfc7493>.
[RFC8174]
Leiba, B., "Ambiguity of Uppercase vs Lowercase in RFC 2119 Key Words", BCP 14, RFC 8174, DOI 10.17487/RFC8174, , <https://www.rfc-editor.org/rfc/rfc8174>.
[RFC8259]
Bray, T., Ed., "The JavaScript Object Notation (JSON) Data Interchange Format", STD 90, RFC 8259, DOI 10.17487/RFC8259, , <https://www.rfc-editor.org/rfc/rfc8259>.
[RFC8288]
Nottingham, M., "Web Linking", RFC 8288, DOI 10.17487/RFC8288, , <https://www.rfc-editor.org/rfc/rfc8288>.
[RFC8470]
Thomson, M., Nottingham, M., and W. Tarreau, "Using Early Data in HTTP", RFC 8470, DOI 10.17487/RFC8470, , <https://www.rfc-editor.org/rfc/rfc8470>.
[RFC8785]
Rundgren, A., Jordan, B., and S. Erdtman, "JSON Canonicalization Scheme (JCS)", RFC 8785, DOI 10.17487/RFC8785, , <https://www.rfc-editor.org/rfc/rfc8785>.
[RFC9110]
Fielding, R., Ed., Nottingham, M., Ed., and J. Reschke, Ed., "HTTP Semantics", STD 97, RFC 9110, DOI 10.17487/RFC9110, , <https://www.rfc-editor.org/rfc/rfc9110>.
[RFC9111]
Fielding, R., Ed., Nottingham, M., Ed., and J. Reschke, Ed., "HTTP Caching", STD 98, RFC 9111, DOI 10.17487/RFC9111, , <https://www.rfc-editor.org/rfc/rfc9111>.
[RFC9218]
Oku, K. and L. Pardue, "Extensible Prioritization Scheme for HTTP", RFC 9218, DOI 10.17487/RFC9218, , <https://www.rfc-editor.org/rfc/rfc9218>.
[RFC9457]
Nottingham, M., Wilde, E., and S. Dalal, "Problem Details for HTTP APIs", RFC 9457, DOI 10.17487/RFC9457, , <https://www.rfc-editor.org/rfc/rfc9457>.
[RFC9651]
Nottingham, M. and P. Kamp, "Structured Field Values for HTTP", RFC 9651, DOI 10.17487/RFC9651, , <https://www.rfc-editor.org/rfc/rfc9651>.
[SSE]
WHATWG, "HTML Living Standard: Server-sent events", n.d., <https://html.spec.whatwg.org/multipage/server-sent-events.html>.

16.2. Informative References

[A2A]
Linux Foundation, "Agent-to-Agent Protocol Specification", Version 1.0, , <https://a2a-protocol.org/latest/>.
[ASIP]
Rosenberg, J., "The Agentic Session Initiation Protocol (A-SIP)", Work in Progress, Internet-Draft, draft-rosenberg-agentproto-asip-00, , <https://datatracker.ietf.org/doc/html/draft-rosenberg-agentproto-asip-00>.
[DIALOG-UC]
Siyavud, F., "Agentic Dialog Use Cases", .
[MCP]
Linux Foundation, "Model Context Protocol Specification", Version 2026-07-28, , <https://modelcontextprotocol.io/specification/2026-07-28>.
[MoQ-C4M]
Lemmons, C., Simon, G., Nandakumar, S., and W. Law, "Authorization scheme for MOQT using Common Access Tokens", Work in Progress, Internet-Draft, draft-ietf-moq-c4m-02, , <https://datatracker.ietf.org/doc/html/draft-ietf-moq-c4m-02>.
[MoQ-TRANSPORT]
Nandakumar, S., Vasiliev, V., Swett, I., Ed., and A. Frindell, Ed., "Media over QUIC Transport", Work in Progress, Internet-Draft, draft-ietf-moq-transport-23, , <https://datatracker.ietf.org/doc/draft-ietf-moq-transport/>.
[OAUTH-2.1]
Hardt, D., Parecki, A., and T. Lodderstedt, "The OAuth 2.1 Authorization Framework", Work in Progress, Internet-Draft, draft-ietf-oauth-v2-1-17, , <https://datatracker.ietf.org/doc/html/draft-ietf-oauth-v2-1-17>.
[PACE-AUTHZ]
Nandakumar, S. and C. Jennings, "PACE Authorization: Delegation and Action Approval", Work in Progress, Internet-Draft, draft-nandakumar-agentproto-pace-authz-00, , <https://datatracker.ietf.org/doc/draft-nandakumar-agentproto-pace-authz/>.
[PP-AGENTS]
Nandakumar, S. and C. Jennings, "Privacy Pass for Delegated Agents: Delegation Attestation and Holder-Bound Tokens", Work in Progress, Internet-Draft, draft-nandakumar-privacypass-delegated-agents-00, , <https://datatracker.ietf.org/doc/draft-nandakumar-privacypass-delegated-agents/>.
[RFC6585]
Nottingham, M. and R. Fielding, "Additional HTTP Status Codes", RFC 6585, DOI 10.17487/RFC6585, , <https://www.rfc-editor.org/rfc/rfc6585>.
[RFC7240]
Snell, J., "Prefer Header for HTTP", RFC 7240, DOI 10.17487/RFC7240, , <https://www.rfc-editor.org/rfc/rfc7240>.
[RFC8820]
Nottingham, M., "URI Design and Ownership", BCP 190, RFC 8820, DOI 10.17487/RFC8820, , <https://www.rfc-editor.org/rfc/rfc8820>.
[RFC9112]
Fielding, R., Ed., Nottingham, M., Ed., and J. Reschke, Ed., "HTTP/1.1", STD 99, RFC 9112, DOI 10.17487/RFC9112, , <https://www.rfc-editor.org/rfc/rfc9112>.
[RFC9113]
Thomson, M., Ed. and C. Benfield, Ed., "HTTP/2", RFC 9113, DOI 10.17487/RFC9113, , <https://www.rfc-editor.org/rfc/rfc9113>.
[RFC9114]
Bishop, M., Ed., "HTTP/3", RFC 9114, DOI 10.17487/RFC9114, , <https://www.rfc-editor.org/rfc/rfc9114>.
[RFC9421]
Backman, A., Ed., Richer, J., Ed., and M. Sporny, "HTTP Message Signatures", RFC 9421, DOI 10.17487/RFC9421, , <https://www.rfc-editor.org/rfc/rfc9421>.
[RFC9449]
Fett, D., Campbell, B., Bradley, J., Lodderstedt, T., Jones, M., and D. Waite, "OAuth 2.0 Demonstrating Proof of Possession (DPoP)", RFC 9449, DOI 10.17487/RFC9449, , <https://www.rfc-editor.org/rfc/rfc9449>.
[RFC9458]
Thomson, M. and C. A. Wood, "Oblivious HTTP", RFC 9458, DOI 10.17487/RFC9458, , <https://www.rfc-editor.org/rfc/rfc9458>.
[RFC9530]
Polli, R. and L. Pardue, "Digest Fields", RFC 9530, DOI 10.17487/RFC9530, , <https://www.rfc-editor.org/rfc/rfc9530>.
[RFC9576]
Davidson, A., Iyengar, J., and C. A. Wood, "The Privacy Pass Architecture", RFC 9576, DOI 10.17487/RFC9576, , <https://www.rfc-editor.org/rfc/rfc9576>.
[RFC9577]
Pauly, T., Valdez, S., and C. A. Wood, "The Privacy Pass HTTP Authentication Scheme", RFC 9577, DOI 10.17487/RFC9577, , <https://www.rfc-editor.org/rfc/rfc9577>.
[WEBTRANS-H3]
Frindell, A., Kinnear, E., and V. Vasiliev, "WebTransport over HTTP/3", Work in Progress, Internet-Draft, draft-ietf-webtrans-http3-17, , <https://datatracker.ietf.org/doc/html/draft-ietf-webtrans-http3-17>.
[WPT-MSG]
Nandakumar, S. and C. Jennings, "Message Binding for Workload Proof Tokens", Work in Progress, Internet-Draft, draft-nandakumar-wimse-wpt-message-binding-00, , <https://datatracker.ietf.org/doc/draft-nandakumar-wimse-wpt-message-binding/>.

Appendix A. Example Flows

The examples below use the conventions of the examples in [PACE]. D is the dialog-id 550e8400-e29b-41d4-a716-446655440000, {D} in a URI is that dialog-id, and control messages are abbreviated to their type and key members. HTTP authentication fields are omitted.

A.1. Delegating a Task with A2A

Agent A (controller) delegates a task to Agent B over A2A. B hosts the dialog (invitee-hosted).

 A (controller)                                   B (dialog host)
  |                                                       |
  |-- POST /pace/dialogs  OPEN gen 0 (B invited) -------->|
  |<- 201 Location: /pace/dialogs/{D}, text/event-stream -|
  |<========= SSE id:1 OPEN ==============================|
  |                               B appends ACCEPT        |
  |<========= SSE id:2 ACCEPT ============================|
  |-- POST /pace/dialogs/{D}  UPDATE gen 1 (B active) --->|
  |<- 202 PACE-Log-Position: 3 ---------------------------|
  |<========= SSE id:3 UPDATE ============================|
  |                                                       |
  |-- POST /a2a  SendMessage  PACE-Dialog: id=D, gen=1 -->|
  |<- 200 text/event-stream (A2A task updates) -----------|
  |                                                       |
  |-- POST /pace/dialogs/{D}  TERMINATE gen 2 ----------->|
  |<- 202 ------------------------------------------------|
  |<========= SSE id:4 TERMINATE, stream ends ============|

The A2A request and its streamed response use A2A's own HTTP transport. The PACE control messages use the dialog URI. Both carry the same dialog-id.

A.2. Calling an MCP Tool from a Hub-hosted Dialog

Agent A opens a dialog on a hub, H, and adds an MCP tool server, fs-tool, which receives invitations in a push inbox.

  1. A POSTs OPEN (gen 0, fs-tool invited) to H's dialog collection. H responds 201 with the dialog URI.

  2. H POSTs an invitation to fs-tool's inbox: {"dialog_id":"550e...","controller_id":"agent-a", "invitee_id":"fs-tool","dialog_uri":"https://hub.example/pace/dialogs/550e..."}.

  3. fs-tool GETs the dialog URI as an event stream, reads OPEN, and POSTs ACCEPT. A POSTs UPDATE (gen 1, fs-tool active).

  4. A sends an MCP tools/call to fs-tool over Streamable HTTP, with PACE-Dialog: id="550e...", gen=1 and the dialog reference in _meta. fs-tool checks on its event stream that A is an active participant, and answers.

A.3. Interrupting a Long-Running Call

A has a streamed MCP call g1 in progress at code-tool over HTTP/3 when its user cuts in.

  1. A POSTs CANCEL to the dialog URI with Priority: u=0, scope operation, and target {"protocol":"mcp","request_id":"g1"}. On HTTP/3, the request is on its own QUIC stream, so it is not delayed by the streamed MCP response or by a loss on it.

  2. The dialog host appends CANCEL and delivers it on code-tool's event stream, which code-tool holds at urgency 0.

  3. code-tool applies the CANCEL as MCP notifications/cancelled, ends the MCP response with a JSON-RPC error, and POSTs CANCEL_ACK with outcome stopped.

Resetting the HTTP/3 stream of the MCP response would not have cancelled the work (Section 4.10).

A.4. Recovering after a Lost Connection

B's network changes while it is a participant in D. Its last processed event was control log position 7, and its last accepted generation is 3.

  1. B reconnects and GETs the dialog URI with Accept: text/event-stream and Last-Event-ID: 7. The dialog host resumes with entries 8 and 9: an UPDATE (gen 4) adding Agent C, and C's ACCEPT.

  2. B POSTs STATE_REQUEST with last_accepted_generation 3 and a nonce. The controller POSTs STATE (gen 4), which B receives on the stream, authenticates, and applies.

  3. B uses A2A GetTask to learn whether the task it was working on received new input while it was away, and does not infer that from the control log.

Appendix B. Acknowledgments

TODO

Authors' Addresses

Suhas Nandakumar
Cisco
Cullen Jennings
Cisco Systems