Review · November 22, 2026
Model Context Protocol and Agent Skills over Media over QUIC Transport
The Problem
MCP has two transports today: stdio and Streamable HTTP. With Streamable HTTP, a dropped response stream loses the in-flight request. There is no per-message priority, and shared caching is limited to what HTTP intermediaries offer.
This draft defines a third transport: MCP over Media over QUIC Transport (MOQT). Every MCP request and response becomes an object on a named pub/sub track. A response can outlive the connection that carried its request. Relays can cache public content such as tool listings once and serve it to every client.
It also adds something that isn't a transport at all: "Agent Skills", a way to distribute and optionally remotely execute multi-step instructions.
How It Fits In
This was submitted to AGENTPROTO, not OAuth. The fit with the AGENTPROTO charter is weak.
The charter says the dialog management protocol does not replace application-layer agent protocols, and that changes to MCP itself are the responsibility of MCP's maintainers. This draft is a new transport for MCP, and it defines a new JSON-RPC method (skills/invoke) and new error codes that are not part of MCP. That is exactly the kind of work the charter pushes back to the Linux Foundation's MCP project.
The chartered hook is PACE, the authors' proposed dialog management protocol over MOQT. PACE's MCP binding adopts the tracks defined here. So this draft is a dependency of one candidate for the chartered deliverable, not a deliverable itself.
The dependencies are mostly unfinished work:
- draft-ietf-moq-transport revision 22, still changing
- The MCP specification version 2026-07-28 and the MCP Tasks extension
- draft-ietf-moq-c4m for relay tokens and DPoP binding
- draft-nandakumar-agentproto-pace, an individual draft
- Poppy, a pre-1.0 spec from Sierra and Meta
On the OAuth side it references Protected Resource Metadata, DPoP, and Resource Indicators, all informatively. It extends none of them.
What It Actually Does
Everything lives in a namespace starting with (mcp, <server-id>). Tracks fall into two scopes.
Server scope holds content that MCP marks cacheScope: public: the catalog, public resources, and skills. The server publishes it once. Relays serve it to everyone from cache.
Client scope sits under (mcp, <server-id>, clients, <client-id>). It holds one client's requests, the server's responses, task state, and private resources.
The client ID is pairwise. The client derives it as a truncated HMAC of the server ID under a secret key, so it gets the same ID at the same server after a reconnect, and two servers can't correlate it. The draft says the client ID is not a credential. The server binds it to the authenticated principal of the first request it sees in that scope.
Request/response works like this:
- Each tool, each prompt, and each task gets its own request track and response track. Everything else goes on a control track pair.
- Each request is a new group on the request track. The response uses the same group ID on the response track.
- Progress notifications and the final result are objects in that group. The final result has the highest object ID.
- If the connection drops, the server keeps working and keeps publishing. The client reconnects, possibly to a different relay, and fetches the rest of the group.
There is no handshake. The catalog track replaces server/discover, the list calls, and list-changed notifications. A client subscribes and gets every update pushed.
The Tasks mapping is the most interesting part for anyone thinking about delegation. Each task gets its own namespace. A token scoped to that one namespace lets another party, such as the user's phone approving an action, participate in that task without access to anything else the client has. How that token gets issued is out of scope.
So What Does Authorization Look Like?
This is where OAuth people should pay attention. HTTP is gone, so every HTTP-bound piece of MCP authorization needs a replacement.
- Discovery: Protected Resource Metadata and AS metadata are fetched "out of band", from the server's HTTPS origin or a registry. There is no defined way to get from a
moqt://URI and a server ID to a metadata URL. - Token presentation: the token goes in MOQT's AUTHORIZATION TOKEN setup option and message parameter. Both are hop-by-hop and stop at the first relay.
- End-to-end credentials: when relays are in the path, credentials the MCP server must verify "travel in each request's
_meta". No_metakey is defined. - DPoP:
htmandhtuhave no MOQT equivalent. The draft points to the C4M DPoP binding, which replaces them with anactxclaim naming the MOQT action, namespace, and track. - Relay tokens: a Common Access Token "can be minted from the OAuth grant" so the relay never sees the OAuth token. Who mints it and how is not specified.
- Step-up: the server rejects with
UNAUTHORIZED, and the client gets a broader token.WWW-Authenticatecarried the required scope.UNAUTHORIZEDcarries nothing, so the client has to guess what to ask for.
The result is two token layers, one for relays and one for the MCP server, with the relationship between them undefined.
There is a real exposure here. An access token placed in _meta sits inside an object that relays are told to cache for recovery. The draft only says request tracks SHOULD be protected with Secure Objects, and only says it in the Poppy section. The Security Considerations section is a single word: "TODO".
The draft does catch one subtle problem. Client and server publish under the same namespace, and only the track name separates a request track from a response track. A namespace-scoped publish token would let a client publish the server's response track. The draft requires publish tokens to be scoped to full track names. That is a good catch, and it shows how much authorization weight the namespace layout is carrying.
Interoperability Concerns
Authorization is not interoperable as written. Token use is a SHOULD. Token format, the _meta key, the token scope syntax, and the minting of relay tokens are all undefined. Two independent implementations would not be able to authenticate to each other.
Server ID has no defined form. It is the root of every namespace and the HMAC input for the client ID. The draft never says what it is, who assigns it, or what stops two servers behind one relay from claiming the same one.
The catalog is underspecified. "A JSON object whose members are those of the server/discover result together with" four list arrays. There is no schema. MCP list calls paginate, and the catalog must fit in one object.
Skills are a sketch. The registry object format is never defined. The metadata fields are listed by name with no types. The skills/invoke result has no schema beyond one example.
Tool names and resource URIs become namespace fields and track names. The only guidance is a 4,096-byte limit mentioned in the PACE section. Long resource URIs will hit it.
Retention is server's choice. The headline feature is recovering a response after a reconnect. The client has no way to learn how long the response is kept before it tries.
The draft is pinned to moving targets. It requires support for a long list of MOQT mechanisms from a specific draft revision, including fill fetch, SUBSCRIBE_TRACKS, and RENDEZVOUS_TIMEOUT. Any change in MOQT breaks it.
What Could Be Removed
Agent Skills. This is a new application-layer feature with a new JSON-RPC method and new error codes. It has nothing to do with transport. It belongs in the MCP project or a separate draft. Removing it would also take it out of the document title.
The Poppy section. It is informative, tracks a pre-1.0 third-party draft, and describes a JWT usage that the draft itself notes Poppy does not support.
Multi-Server Operation. It describes client behavior and ends by saying nothing happens at the protocol level.
The MOQT error tables. Three tables restate MOQT error codes with generic recovery advice like "back off with exponential delay".
The standalone priority table. Subscriber priority is a local decision. The numeric ranges do not affect interoperability.
The server listing via SUBSCRIBE_NAMESPACE. It is optional on both sides and is a discovery mechanism that needs its own design discussion.
What remains would be a tight transport mapping: the namespace layout, the request/response group convention, cancellation, the catalog, and Tasks.
Writing Quality
The writing is good. Sentences are clear, BCP 14 keywords are used correctly, and the examples match the normative text. The authors know MOQT thoroughly, and it shows in details like the PUBLISH_SKIPPED fallback and the rule against delivery timeouts on request tracks.
The quality is uneven by section. The track mapping is precise. Authorization is written as a description of how things could map, with almost no normative statements. Skills reads like a product feature list. Security Considerations is empty.
At 43 pages it is too long for a transport binding. About a third of the text covers things other than the binding.
Authors
All four authors come from the real-time communications and transport side of the IETF. None has published an RFC in OAuth.
Cullen Fluffy Jennings (Cisco) has 29 published RFCs from 2002 to 2026, including SIP identity (RFC 3325, RFC 4474), NAT behavior (RFC 4787), and JSEP for WebRTC (RFC 8829). There are 30 active Internet-Drafts on the profile, mostly Media over QUIC, plus a recent set of AGENTPROTO, OAuth, and WIMSE drafts co-authored with Nandakumar.
Ian Swett (Google) has one RFC, and it is a significant one: RFC 9002, QUIC Loss Detection and Congestion Control. Swett has 8 active drafts, is an editor of the MOQT transport draft, and co-authors the BBR congestion control draft. This is Swett's only agent-related draft.
Jonathan Rosenberg (Five9) has 72 published RFCs from 1999 to 2020, including SIP (RFC 3261), STUN, TURN, and ICE. Rosenberg has 9 active drafts, mostly on agents and vCon, including draft-rosenberg-oauth-aauth in OAuth and the AGENTPROTO use cases draft.
Suhas Nandakumar (Cisco) has 9 published RFCs from 2013 to 2025, all in real-time media: STUN and TURN URI schemes, RTP taxonomy, SDP and ICE. There are 36 active Internet-Drafts on the profile. Most are Media over QUIC, including the transport draft and C4M. About ten are recent AGENTPROTO, OAuth, and WIMSE drafts, including PACE. Nandakumar is writing at very high volume right now.
Bottom Line
The transport mapping is competent work by people who know MOQT. Recovery after reconnect and push-based catalog updates are real improvements over Streamable HTTP.
The authorization story is not ready. Moving MCP off HTTP removes the anchors that Protected Resource Metadata, WWW-Authenticate, and DPoP all depend on, and the draft replaces them with "out of band" and a pointer to draft-ietf-moq-c4m. If this moves forward, the OAuth working group should review how access tokens are carried in _meta through caching relays, and how relay tokens are derived from an OAuth grant.
The bigger question is venue. AGENTPROTO's charter rules out changing MCP, and the MCP project owns its transports. This draft needs a conversation with the MCP maintainers before it needs a working group.