Review · November 22, 2026
Agent Protocol over MoQ
The Problem
Agents are becoming multimodal. They need to exchange live audio and video alongside structured commands. The draft argues that HTTP/2 and gRPC are a poor fit for this, and that Media over QUIC (MoQ) is a good transport but has no notion of agent sessions or control messages.
Its answer is a new binary frame format carried inside MoQ objects and datagrams. The frame adds sessions, commands, file transfer, and heartbeats on top of MoQ.
This revision was posted in March 2026 and expired in September without an update. It is still cited by newer drafts, so it is worth knowing what it says.
How It Fits In
This is not an OAuth draft. It was submitted as an individual draft with no working group, and it now sits with the other AGENTPROTO-related submissions.
It predates the current round of MoQ agent drafts. PACE and MCP over MOQT both map agent traffic onto MOQT's own namespaces, tracks, and groups. This draft takes the opposite approach. It treats MoQ as a pipe and builds a second protocol inside it.
The dependencies are thin:
- QUIC (RFC 9000) is a normative reference.
- MoQ is only an informative reference, even though the whole draft sits on it. The citation is to "I-D ietf-moq-00" with an author list that matches no MoQ document.
- The WebTransport reference points to RFC 9220, which is the WebSockets over HTTP/3 RFC.
- Authorization depends on draft-liu-agent-operation-authorization, an individual draft by the same authors.
It references no OAuth RFCs. The JWT RFC is not cited either, even though a JWT is the only credential in the protocol.
What It Actually Does
Every message gets a 21-byte header: a magic number (0xA2A2), a version, a message type, an 8-byte session ID, a 4-byte stream ID, flags, and a payload length.
There are four message types:
- CMD: a JSON command such as
session_init,session_ack, orsubscribe_request - DATA: a chunk of a large file
- STREAM: one media sample
- HEARTBEAT: an empty liveness check
Two agents are involved, and there is no other role. Agent A opens a MoQ session to Agent B and sends session_init with a JWT. Agent B validates the JWT and replies session_ack with approved or denied. Every later frame carries the session ID in its header.
Once a session exists, an agent asks for a media track by sending subscribe_request as a CMD. The other agent answers track_ready, and the media then flows over normal MoQ pub/sub.
Payloads over 1400 bytes are split into chunks that share a stream ID. A session ID of zero means "session-less", for heartbeats and fire-and-forget commands.
For cross-domain discovery, the client fetches /.well-known/a2a over HTTPS and gets back a JSON object with a moq_endpoint URL.
So What Does Authorization Look Like?
There is one bearer JWT, sent once in session_init. That is the entire model.
The draft says the JWT contains an "operation claim" defined in the companion draft. It says nothing about who issues the token, how Agent A obtains it, what audience it carries, or how Agent B finds the keys to validate it. There is no authorization server in the picture and no metadata discovery.
The token is not bound to anything. Nothing ties it to the QUIC connection or to a client key, so any party that sees the frame can replay it. The inter-domain example sends session_init right after a 0-RTT handshake, and 0-RTT data is replayable by design.
The example token's header decodes to HS256. A shared symmetric key between agents in different organizations is not a workable trust model. It is only an example, but it is the only hint the draft gives.
Subscriptions are "validated against the agent's authorization token". No scope or claim syntax connects a token to a track name.
Session-less mode skips the handshake. The draft says authorization there is "typically pre-established or implicit". The Security Considerations section says implementations MUST validate tokens before processing any communication. Both cannot be true.
Session IDs MUST be cryptographically random, and the header table says they are a "UUIDv7 or hash". UUIDv7 leads with a timestamp, and a UUID is 16 bytes. The field is 8.
Interoperability Concerns
Two independent implementations could not talk to each other from this text.
The MoQ mapping is missing. The draft never says which track carries the frames, how tracks are named in MOQT's namespace and name tuples, or how two agents set up the pair of tracks needed for a two-way exchange over a pub/sub transport. The naming convention is given three times, in three different formats.
DATA and STREAM fields have no encoding. The draft lists fields like chunk_index, total_chunks, timestamp, and media_type. It also says these payloads are raw binary. Where the fields go is never stated.
Fragmentation does not work as written. Reassembly uses "order of arrival", but the draft allows DATA over datagrams, which arrive in any order. The last chunk clears the fragmented flag, which makes it look like a standalone frame. A payload of exactly 1400 bytes falls in neither size category.
The header has no byte order. CMD is "JSON or MessagePack" in one section and JSON-only in the next, with no field to signal which.
Flags have no meaning yet. "Compressed" names no algorithm. "Encrypted" names no scheme and no key management.
Acknowledgments contradict each other. CMD frames "require acknowledgment and retransmission", but no ACK message exists. HEARTBEAT is sent "without requiring acknowledgments" in one table and "should acknowledge receipt" in another.
Commands are incomplete. session_bye ends a session but is not in the action list. track_url appears in an example with an undefined moq:// scheme. Error codes are bare HTTP status numbers with no definitions.
The well-known URI will collide. The suffix a2a and the magic number 0xA2A2 borrow the name of Google's A2A protocol, which this draft has no relationship to. The example response uses a quic:// scheme that is not registered.
What Could Be Removed
Most of the frame layer duplicates what MoQ and QUIC already provide.
Application-layer fragmentation. MoQ objects are not limited to 1400 bytes, and QUIC streams already deliver large payloads reliably and in order. The entire DATA chunking scheme can go.
subscribe_request and track_ready. MOQT has SUBSCRIBE, with its own authorization token parameter. A second subscribe handshake in JSON adds a round trip and a second place for access control to go wrong.
HEARTBEAT. QUIC has keep-alives and idle timeouts.
The magic number and its registry. A track's name already tells a receiver what is on it. A registry under Standards Action for a single value has no purpose.
The STREAM metadata fields. Timestamps, sequence numbers, and keyframe markers belong to the MoQ media format work.
The compressed and encrypted flags, until they mean something.
The STUN/TURN/ICE mention. One sentence that says they MAY be used, with no explanation of how.
What is left is a session handshake carrying a token and a discovery document. That is a much smaller draft, and the token part is the part that needs the most work.
Writing Quality
The draft follows the Internet-Draft template and uses BCP 14 keywords, but only a handful of normative statements appear in 22 pages. Most of the text is descriptive tables.
The opening sentences have grammar errors ("a Agent-to-Agent", a stray comma in the first line of the introduction). Appendix headings are double-numbered ("Appendix A. Appendix A:"). The JSON section lists generic benefits of JSON as bullet points.
The examples disagree with the normative text. Session IDs appear as 0x123..., "abc-123", and "abc-123-def-456" for an 8-byte binary field. One deployment note says encryption overhead is minimal "due to short physical distance", which is not how encryption works.
The two incorrect references and the internal contradictions suggest the text was not reviewed closely before submission. The length is fine. The problem is that the pages are spent on tables instead of the rules an implementer needs.
Authors
Dapeng Liu (Alibaba Cloud) has 3 published RFCs, all from 2014 and 2015 on distributed mobility management and Mobile IPv6. Liu is not a new author, with 77 expired drafts on the profile, and chairs the DAWN working group. There are 14 active Internet-Drafts, almost all on agents: eight in OAuth on agent authorization and delegation, plus AGENTPROTO and MoQ agent drafts. Liu is writing at high volume right now.
Suresh Krishnan (Cisco) has 44 published RFCs from 2007 to 2026, including the IPv6 privacy address extensions (RFC 4941, RFC 8981). Krishnan is a current IAB member, was Internet Area Director from 2016 to 2020, and chairs AIPREF and the BPF working group. There are 14 active drafts, split between IAB process documents and agent authorization drafts co-authored with Liu.
Neither author has published an RFC in OAuth or MoQ.
Bottom Line
This is an early sketch, and it has been overtaken. It wraps a second framing protocol around MoQ and re-implements fragmentation, subscription, and keep-alive that the transport already has. It is not specified well enough to implement.
Liu's own later draft, Live Agent Interaction over MoQ, maps agent streams directly onto MOQT's object model and cites this one only informatively. That is the one to read for where this author's thinking went.
For OAuth people, the takeaway is the same as with every agent-over-MoQ draft so far. The transport gets designed first, and authorization is a bearer JWT in the first message with issuance, audience, and binding left undefined. If any of this work moves forward, that gap is where review is needed.