Review · November 22, 2026
MOQ Transport for Agent Protocols
Read This First
This draft is expired. Datatracker lists a single revision from March 2026 and marks it "expired and archived".
It is not formally replaced. In practice the work continued as PACE: draft-nandakumar-agentproto-moq-pace came from the same two authors four months later, and its "latest revision" link still points at this draft's filename. The current version is draft-nandakumar-agentproto-pace.
This review covers the starting point. Anyone preparing feedback should read the successor.
The Problem
A2A, MCP, and frameworks like AutoGen each define their own transport bindings. The draft calls this fragmentation.
Its answer is one shared transport: Media over QUIC Transport (MOQT). Agents connect to relays, publish messages as objects on named tracks, and subscribe to each other's tracks. The draft defines a generic mapping of request/response, streaming, and discovery onto MOQT, then applies it to A2A, MCP, AutoGen, and plain JSON-RPC.
How It Fits In
The draft header names the Media over QUIC working group. It predates PACE and was never adopted anywhere.
So does it fit AGENTPROTO? Only partly. The charter lists MoQ as a candidate transport binding, but the binding it asks for carries dialog context. This draft carries whole application protocols. It has no dialog identifier or lifecycle beyond an undefined {session} field.
Two parts are outside the charter:
- Application protocol bindings. The charter leaves changes to A2A and MCP to their maintainers. This draft remaps every A2A operation and adds a
moqtblock to the A2A Agent Card. - Discovery. The charter treats agent discovery as coordination with other areas. This draft builds it into the transport.
The dependencies are short and mostly unfinished:
- draft-ietf-moq-transport, revision 16, the only real protocol dependency
- The authors' own MCP over MOQT draft, which carries the entire MCP binding
- A2A 0.3.0 and MCP 2025-06-18, both specified outside the IETF
So how does it relate to OAuth? It doesn't. No OAuth RFC is referenced. The strings "bearer" and "oauth2" appear once, inside an example Agent Card.
What It Actually Does
Setup. Agents open a QUIC or WebTransport connection and run the MOQT handshake. Three new setup parameters declare an agent protocol version, a bitmask of supported protocols, and supported authentication schemes.
Naming. Every message lives on a track. The namespace is protocol / session / agent-id / category, and the track name is usually a request or task ID. The first field lets A2A, MCP, and others share one relay network.
Discovery. Each agent announces its namespace to the relay and publishes a capability card on a discovery track. Other agents subscribe to the namespace prefix and get notified as agents appear.
Request and response. The client publishes a request object on a request track and subscribes to a response track named with the same request ID. The server publishes the response there. The relay sits between them for every message.
Streaming. Long-running operations become a sequence of objects on one track. MOQT groups mark execution phases. Relays may cache recent groups so a late subscriber can catch up.
Priorities. MOQT's 0-255 priority range is split into seven tiers. Cancellations go first and bulk transfers last.
Bindings. A2A gets a full operation table: SendMessage is a publish, GetTask is a subscribe, ListTasks is a namespace subscription. MCP is delegated to the companion draft. AutoGen and generic JSON-RPC get a namespace and a track table each.
The relationship change is the relay. A2A and MCP over HTTP are two-party: client and server. Here a third party routes, caches, and can read every message.
What Should OAuth People Look At?
Security Considerations is one word: "TODO". These are the gaps it would need to cover.
There is nowhere to put a token. Over HTTP, every A2A or MCP request carries an Authorization header. Here a request is an object published to a relay. The draft defines no field, envelope, or track for a credential. The agent-auth-schemes setup parameter has no defined values, and it only covers the hop to the relay.
The server never authenticates the caller. MOQT setup authenticates an agent to its relay. The server agent sees an object forwarded by the relay. Nothing tells it who published the request or whether that caller is allowed to make it.
Reads become subscriptions. GetTask is a subscribe to {agent}/task/{task-id}. ListTasks is a namespace subscription. Anyone who can subscribe on the relay can read task state and enumerate task IDs. Access control has moved from the resource server to the relay, and the draft does not say how the relay decides.
Relays cache results. Task output sits in a relay cache for late joiners. Section 6.2 goes further and describes "cold storage for historical task logs and compliance data". Protection is TLS hop by hop, so the relay holds plaintext.
Nothing binds an agent ID to a namespace. Any agent can announce a2a/session-123/agent-bob. The Agent Card has a signature field with no algorithm, no key, and no trust anchor.
This is the same issue as every proposal to move MCP or A2A off HTTP. The existing authorization story depends on HTTP: Protected Resource Metadata, WWW-Authenticate challenges, and bearer tokens in headers. Replace the transport and all of it has to be rebuilt or mapped. This draft does not mention the problem.
Interoperability Concerns
The namespace layout contradicts itself. The discovery flow uses {proto}/{session}/discovery/{agent}. The A2A binding uses a2a/{session}/{agent}/discovery. Relays route on prefixes, so the field order matters.
The request path isn't workable as drawn. The client publishes to {server}/request, a namespace the server announced. Elsewhere the draft says the agent ID in the namespace is the publishing agent. The response track is {server}/response/{req-id} in the diagram and a track named {req-id} in the table. Nothing says how a server learns that a new per-request track exists.
The A2A operation table uses an undefined category. SendStreamingMessage maps to {agent}/stream. The A2A category table has request, response, task, notify, and discovery. There is no stream.
The A2A version doesn't match the content. The draft cites A2A 0.3.0. The operation names (SendMessage, SubscribeToTask, GetExtendedAgentCard) come from the later 1.0 naming. The task states listed ("queued", "running") are not A2A task states. The example Agent Card uses an authentication object and a single signature string, neither of which matches the 0.3.0 card.
Setup parameter names disagree. Section 3.1 defines agent-version and agent-protocols. The Agent Card example lists a2a-version and a2a-protocols. The protocol bitmask covers A2A and MCP and has no value for the other two bindings.
Groups have two meanings. "Each streaming response creates a new MOQT group" and "groups represent execution phases" appear in the same list. A late joiner gets different content depending on which one the publisher picked.
Sessions are undefined. Every namespace contains a session ID. Nothing says who creates it, how the other agent learns it, or when it ends.
Errors are missing. Section 2 lists error handling as a transport requirement. No section defines it.
The registries don't exist. The text refers to an "IANA Protocol Bindings Registry". IANA Considerations is "TODO", including the three setup parameter code points.
What Could Be Removed
The AutoGen binding. AutoGen is a framework, not a wire protocol. The message format shown is invented for this draft.
The generic JSON-RPC binding. It is the generic pattern from Section 3 restated with different category names.
Sections 5 and 6. The comparison table, the relay hierarchy, and the caching tiers argue for MOQT. None of it affects interoperability.
The per-binding priority tables. They repeat the general table with different labels.
The MCP section. It is three paragraphs summarizing another draft. A one-line reference does the same job.
What remains is the namespace convention, the request/response pattern, and the A2A mapping. Those need to be fixed and finished before anything else is added.
Writing Quality
The prose is clear and the diagrams are easy to follow. Someone new to MOQT can understand the model in one read.
It is an outline, not a specification. There are six BCP 14 keywords outside the boilerplate. Most of the normative content sits in tables with no surrounding rules. Security, IANA, Acknowledgments, and the orchestration patterns section are all "TODO".
There are signs of a fast edit:
- The abstract and introduction promise two bindings. The body has four.
- Sections 5 and 6 are titled for A2A only, left over from the draft's origin as an A2A transport.
- "ANNOUNCE" appears once, the old name for what the rest of the draft calls
PUBLISH_NAMESPACE. - RFC 9297 is cited as WebTransport. It is the HTTP Datagrams spec.
- The C4M, RFC 7540, RFC 8126, RFC 8446, and RFC 9000 references are never cited in the text.
- The MCP over MOQT reference points to
draft-mcp-over-moqt, which is not a real draft name.
At about 20 pages the length is fine. The problem is that a third of it is advocacy and repeated tables, while the mechanisms that need detail get one diagram each.
Authors
Both authors work at Cisco and come from the real-time media side of the IETF. Neither has published an RFC in OAuth.
Suhas Nandakumar has 9 published RFCs from 2013 to 2025, all in real-time media: STUN and TURN URI schemes (RFC 7064, RFC 7065), RTP taxonomy (RFC 7656), SDP and ICE (RFC 8839, RFC 8859). There are 36 active Internet-Drafts on the profile. Most are Media over QUIC, including the transport draft this one builds on. The rest are recent AGENTPROTO, OAuth, and WIMSE drafts. Nandakumar is writing at very high volume right now.
Cullen Fluffy Jennings has 29 published RFCs from 2002 to 2026, including SIP identity (RFC 3325, RFC 4474), NAT behavior (RFC 4787), MSRP (RFC 4975), and JSEP for WebRTC (RFC 8829). There are 30 active Internet-Drafts on the profile. Many are Media over QUIC, and several are agent drafts co-authored with Nandakumar.
Bottom Line
The idea is reasonable. Pub/sub with relays, priorities, and late join is a real fit for multi-agent streaming, and these authors know MOQT as well as anyone.
This revision is a first sketch. The namespace layout is inconsistent, the request path doesn't hold together, and the security section is empty.
The takeaway for OAuth readers is the relay. Putting a caching intermediary between client and server removes the HTTP anchors that A2A and MCP authorization rely on, and this draft offers nothing in their place.
Don't spend review time here. The draft is expired and the work moved to draft-nandakumar-agentproto-pace. Check there for how tokens and caller identity get through the relay.