IETF agentproto Standardization Begins — AI Agent Communication Standards Are Changing

Until now, the AI agent ecosystem has been heavily fragmented in terms of network communication due to non-standardized JSON specifications and custom streaming implementations. The 'agentproto' session, officially launched at IETF 126, is the first step toward moving away from such ad-hoc data wrapping and standardizing agent communication into an official network protocol specification. In this post, we analyze the newly proposed core drafts and explore the architectural shifts that backend and full-stack developers need to pay attention to.

The Limits of Fragmented Agent Communication and the Need for Standardization

Currently, LLM output streaming and tool calling are implemented using disparate transport protocols like WebSockets, SSE, and HTTP POST, along with proprietary JSON formats. This leads to significant parsing overhead at the middleware level when different frameworks or agents communicate. Every time a gateway or proxy server processes network packets, it must parse and reassemble the unique stream formats pouring in real-time.

This communication fragmentation not only wastes server resources but is also the biggest obstacle hindering interoperability between frameworks. If every agent uses a different specification for exchanging data, backend architecture inevitably becomes tightly coupled to specific agent SDKs or libraries.

The agentproto discussions initiated at IETF 126 are an attempt to fundamentally solve this by establishing standard specifications at the transport and payload levels. With recognized standards in place, backend developers will be able to integrate various agents reliably and efficiently without heavy stream-conversion middleware.

SSE-based LLM Streaming Standard: draft-spk-agentproto-llm-stream

The newly proposed draft-spk-agentproto-llm-stream-00 standard defines the haphazardly fragmented LLM streaming response specifications into a single transport envelope based on Server-Sent Events (SSE).

Previously, the structure of JSON chunks delivered via streaming varied by AI provider and framework. This forced API gateways and middleware proxies relaying traffic to repeatedly perform unnecessary computations to parse text and reassemble structures every time a packet passed through.

This draft unifies the event layout representing the start of a stream, text chunk delivery, metadata representation, and completion/error states. Because relay servers and clients are guaranteed a consistent transport envelope, intermediate middleware can pass packets through lightly without the need for separate serialization/deserialization, significantly relieving bottlenecks in the network pipeline.

Combining for Ultra-Low Latency: MCP over MoQT

The new standard proposal, draft-jennings-agentproto-mcp-over-moqt-00, addresses the specification for running the Model Context Protocol (MCP) over Media over QUIC Transport (MoQT), a QUIC-based media transport protocol. This is a standard infrastructure definition designed to implement ultra-low latency real-time interaction between large-scale agents across networks, moving beyond the limitations of existing stdio methods or web-based SSE transport that were restricted to local inter-process communication.

Existing stdio or SSE transport methods revealed limitations in complex multi-agent collaboration environments. Due to their strongly unidirectional nature or reliance on a single stream per connection, queue bottlenecks occurred at the network layer whenever numerous tool calls and real-time state changes overlapped. MoQT, by contrast, fully leverages QUIC’s multiplexing and partially reliable transmission features to send multiple independent conversation streams and tool calls simultaneously as independent tracks without interference.

The greatest technical advantage of this combination is precise priority control based on the nature of the messages. Bandwidth can be optimized by assigning low priority to resource sinks or background data transfers handled by agents, and high priority to immediate user feedback or critical tool execution results. Furthermore, by applying MoQT's inherent relay architecture, it opens an environment where tool and agent skill information can be delivered with extremely low latency—within milliseconds—via globally distributed cache infrastructure.

Backend Agent Design Direction in the Era of Standardization

The shift toward stateless architecture, represented by the IETF's agentproto standardization and MCP v2.0, signifies that the era of custom protocols tied to specific frameworks is coming to an end. Now, rather than writing code coupled to a specific AI SDK, backend developers should focus on building standard-based, stateless tool definition layers that can be reused in any environment.

As agent communication becomes standardized, system observability is also becoming more refined. The recent MCP v2.0 distributed tracing specification proposes a way to pass trace contexts through JSON-RPC metadata fields. When combined with OpenInference or OpenTelemetry-based tools, it is possible to track multiple agent and tool execution flows as a single waterfall trace without performance degradation.

Future backend agent design will hinge on the flexibility and interoperability of flows. Architecting systems that proactively adopt standard protocols rather than getting locked into a specific platform will be the most reliable roadmap for determining future development productivity.