The Scope Creep Automated reviews of new AI-related working group submissions

Review · November 22, 2026

Model Context Protocol and Agent Skills over Media over QUIC Transport

draft-jennings-ai-mcp-over-moq -00View on Datatracker →

The Problem

MCP runs over stdio and Streamable HTTP today. The draft argues that HTTP's request-response model is a poor fit for an event-driven protocol, and that neither HTTP nor WebSocket offers prioritization or relay caching.

This draft defines a new transport: MCP over Media over QUIC Transport (MOQT). Each MCP primitive gets its own pub/sub track, with priorities per track type and relays that cache and fan out content.

It also adds "Agent Skills", which is not a transport feature. Skills are multi-step instructions that a client loads in stages and can ask the server to execute.

This revision is from March 2026 and has expired. The same four authors posted draft-jennings-agentproto-mcp-over-moqt in July with the same title. Datatracker does not link the two, so this review covers the original as submitted.

How It Fits In

The draft was not submitted to any working group. Its boilerplate names a "Model Context Protocol Working Group" with an example.org mailing list, which does not exist.

AGENTPROTO is the closest home, and the fit is weak. The charter says the working group does not replace application-layer agent protocols, and that changes to MCP belong to MCP's maintainers. This draft is a new MCP transport plus a new MCP capability, a new JSON-RPC method (skills/invoke), and new error codes.

It depends on two external specs:

It depends on zero OAuth RFCs. The words "OAuth", "token", and "authentication" do not appear as protocol concepts anywhere in the document.

What It Actually Does

The MCP host is the MOQT client. The MCP server is the MOQT publisher. Everything lives under a namespace of (mcp, <session-id>).

Session setup works like this:

  1. The client opens a QUIC or WebTransport connection and completes the MOQT handshake.
  2. The client sends a FETCH to a well-known track, mcp/discovery/sessions, with a nonce and client info.
  3. The server mints a session ID and returns it with the names of the control tracks.
  4. The client subscribes to the control tracks and sends MCP initialize.

An optional shortcut puts the initialize request inside the discovery FETCH. The draft says this cuts setup from 4 round trips to 2.

After that, each MCP primitive has its own track type:

  • Control: a pair of one-way tracks for initialize, ping, and teardown
  • Resources: one track per resource URI, with a new group per version
  • Tools: one track per tool, with a new group per invocation
  • Prompts: one track per prompt
  • Notifications and Logs: one track per category
  • Elicitation: a pair of tracks per request

A priority table ranks them. Session control is highest, user elicitation next, logs last.

Clients find out what a server offers in one of two ways. The first is a JSON catalog track. The second is MOQT's SUBSCRIBE_NAMESPACE, which lists track names natively.

Skills add four more track types: a registry, per-skill metadata, per-skill instructions, and a per-invocation execution track. The client matches a command like /commit against the registry, fetches metadata, then fetches the full instructions. From there the client's model either calls tools itself or sends skills/invoke and watches progress objects arrive.

So What Does Authorization Look Like?

There isn't any. Security Considerations is one word: "TODO".

MCP authorization is built on HTTP. Protected Resource Metadata is fetched from an HTTPS URL, the WWW-Authenticate header tells the client where to go, and the access token rides in the Authorization header. This draft removes HTTP and replaces none of it.

The only access control in the design is the session ID. It is a namespace component, and the draft lists "invalid session IDs" and "unauthorized access" as reasons a subscribe can fail. It never says how a server or relay decides who is authorized.

That matters more here than in a direct connection. Relays sit in the path, cache content "aggressively", and forward subscriptions. A relay needs a rule for who may subscribe to (mcp, <session-id>, tools) or publish on a client-to-server control track. The draft gives it none.

Elicitation is the sharpest case. Those tracks carry user consent responses and user input through relays. The draft says the design preserves privacy and does not say how.

Interoperability Concerns

Session discovery misuses FETCH. MOQT FETCH retrieves objects that already exist. Here it carries a JSON-RPC request in its parameters and causes the server to mint a new session. A relay that caches the response hands the same session ID to the next client.

Tool invocation is described three ways. Section 2.1.3 has the client create a group and place the request in object 0, on a track the server publishes. The example in 9.2 sends a FETCH with a JSON body to tools/filesystem and names the tool in the payload. The skills flow fetches tools/git/status. Two implementers would pick different ones.

Relay caching can't work with this namespace. Every track sits under a per-client session ID. Two clients asking for the same documentation resource use two different track names. The relay has nothing to aggregate. The relay aggregation example works around this with a unified namespace that is never defined.

Two discovery mechanisms, both optional. Implementations "MAY support either or both". A client that only does catalog and a server that only does namespace discovery can't find each other's tools.

The catalog has no schema. It is shown as one example with fields like update_frequency and template_versions that are never defined.

Skills formats are prose. The registry, metadata, and instructions objects are described in a paragraph each. The skills and tools.progress capabilities shown in the examples are not in the MCP specification.

Namespaces are written two ways. Section 2 uses tuples like (mcp, <session-id>, control). Sections 3 through 5 use slash-separated strings. The draft never says how one maps to the other, or how a resource URI becomes a track name.

The draft is pinned to MOQT draft-16. The namespace discovery messages it relies on were new in that revision.

What Could Be Removed

Agent Skills. It is a new application feature with its own method, error codes, and data model. It takes up about a quarter of the draft and belongs in the MCP project.

Multi-Server Context Sharing. It describes how a client coordinates its own sessions. Nothing crosses the wire.

The priority table and dynamic adjustment list. Priorities are RECOMMENDED and applications MAY change them. They don't affect interoperability.

The lifecycle state chart. It introduces states that the normative text never uses.

Error recovery advice and log categories. "Retry with exponential backoff" and a list of log levels are implementation guidance.

One of the two discovery mechanisms. Pick one and require it.

What remains is the part worth specifying: the namespace layout, how a request and its response map to groups and objects, and session setup.

Writing Quality

This is an early sketch. Security Considerations, IANA Considerations, and Acknowledgments all say "TODO". The "About This Document" section still has template placeholders pointing at example.org.

The prose is readable and uses BCP 14 keywords, though sparingly. Most of the document is descriptive. Section 3.2 is titled "Proposed Session ID Discovery", and it reads like a proposal.

The examples disagree with the normative text in several places, as covered above. Some details are wrong. The introduction lists WebSocket as an existing MCP transport, and it isn't one. The WebTransport reference points to RFC 9297, which is HTTP Datagrams and the Capsule Protocol. The draft's own table calls MOQT implementations before draft-16 "legacy" while citing draft-16 as its normative base.

Parts of it read like marketing: "paradigm shift", "seamless integration", "comprehensive architecture". One example names an "Anthropic Server A" and uses /commit as the skill, which shows where the Skills concept came from.

At 37 pages it is long for what it specifies. Diagrams and JSON examples fill most of the space, and the actual track mapping fits in about five pages.

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) and NAT behavior (RFC 4787). There are 30 active Internet-Drafts on the profile. Half are Media over QUIC. Six are AGENTPROTO drafts, and there are two each in OAuth and WIMSE.

Ian Swett (Google) has one RFC: 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. The successor to this draft is the only agent-related one on the list.

Jonathan Rosenberg (Five9) has 72 published RFCs from 1999 to 2020, including SIP (RFC 3261), STUN, and ICE. Rosenberg has 9 active drafts, mostly on agents and vCon, including draft-rosenberg-oauth-aauth in OAuth.

Suhas Nandakumar (Cisco) has 9 published RFCs from 2013 to 2025, all in real-time media. There are 36 active Internet-Drafts on the profile. 23 are Media over QUIC, including the transport draft. Nine more are recent AGENTPROTO, OAuth, and WIMSE drafts. Nandakumar is writing at very high volume right now.

Bottom Line

The idea has merit. Per-track priorities and push-based updates are real gaps in Streamable HTTP, and these authors know MOQT as well as anyone.

This revision is a sketch of that idea. The tool invocation model is inconsistent, the relay caching story conflicts with the namespace design, and Skills is a separate feature attached to a transport draft.

For OAuth readers, the takeaway is what's missing. Moving MCP off HTTP removes every anchor that MCP authorization depends on, and this revision does not acknowledge the problem. Anyone following this work should read the successor draft instead, and check how it handles tokens through relays.