MCP over MoQT Standard Unveiled — Breaking the 100ms Barrier for AI Agents

Have you ever tried connecting multiple AI agents to work together on a task? It's not very noticeable when you're just using local coding tools alone, but as soon as multiple agents start passing tools back and forth over the internet, the response latency becomes painfully obvious.

To solve this frustrating bottleneck, the IETF's agentproto working group is rapidly pushing for a standard that runs the Model Context Protocol (MCP) over Media over QUIC Transport (MoQT), aiming to bring network latency down to under 100ms. I'd like to give you an easy, intuitive look at these exciting shifts in next-generation agent networks that communicate at lightning speed, similar to real-time video streaming.

The Hidden Bottleneck of Current MCP: What is the 'Tool Tax'?

When you chain several AI agents together, there are moments when responses slow down significantly. One of the culprits is the heavy 'tool specification' data exchanged behind the scenes every time an agent uses a tool.

To understand what tools are available and how to use them, agents must fetch the entire schema containing the tool's structure every single time. In academic circles, this is known as the 'tool tax.' In existing Server-Sent Events (SSE) environments, even a small increase in the number of tools creates nearly 50,000 tokens of unnecessary structural overhead, which severely hampers agent performance.

The MCP over MoQT architecture was introduced to resolve this issue dramatically. It supports gating technology and smart caching, allowing agents to fetch only the necessary tool information at the right moment instead of downloading the entire specification every time. This significantly reduces unnecessary network traffic and enables instant agent responsiveness.

A Simple Guide to the Keys of High-Speed Streaming: MoQT and QUIC

Think of how YouTube live streams maintain a seamless, buffer-free playback. MoQT is the media technology used to flow large volumes of video data smoothly across the web in real-time. Bringing this high-performance streaming tech into the conversation rooms of AI agents is the core of this new standard.

In traditional SSE setups, agents had to exchange heavy, complex tool specification schemas in their entirety whenever a tool was invoked. This 'tool tax'—often reaching tens of thousands of tokens in structural overhead—was a primary cause of network latency. MoQT solves the tool tax by splitting agent tools, resources, and notification data into independent real-time 'tracks,' allowing only the modified data to be transmitted quickly, without needing to resend redundant schemas.

The foundation for this high-speed streaming highway is QUIC, a UDP-based high-speed communication protocol. It skips the complex packet handshake steps required for initial connections and begins carrying data from the very first packet, reducing latency to near zero.

Here is an example configuration file for mapping an agent's MCP messages to MoQT tracks. This structure treats each data flow as an independent track address for lightweight transmission.

{
  "mcpServers": {
    "database-agent": {
      "transport": "moqt",
      "url": "moqt://localhost:4433",
      "tracks": {
        "tools": "mcp/database-agent/tools",
        "resources": "mcp/database-agent/resources",
        "notifications": "mcp/database-agent/notifications"
      }
    }
  }
}

Using this approach, agents can subscribe only to the necessary data tracks without having to reload the entire tool list every time. As an IETF draft specification proposed in July 2026, it is still in an experimental phase and being actively refined, but it is already attracting attention as the key to boosting communication speeds between remote agents beyond local networks.

Practical Open-Source Tools Developers Can Try Today

This high-speed communication standard is not just theory on paper. Although it is a fresh IETF draft proposal from July 2026 and currently experimental, an early open-source ecosystem is rapidly forming that developers can use to run and verify it.

The first tool to note is the core runtime, agentproto/ts. This acts as a daemon program running in the background, handling local agent workflows and managing secure tunnels. If you need to connect a local MCP server behind complex private networks or firewalls to the outside world, the caddy-mcp plugin is a great solution. It functions as a secure reverse proxy, bypassing tricky local NAT environments to pass QUIC streams through smoothly.

With the addition of moq-rs, a low-level transport library maintained by Cloudflare, an environment has been created where developers can directly handle large-scale data tracks. For instance, you can integrate this new technology into your MCP configuration file by setting up a MoQT transport tunnel as shown below.

{
  "mcpServers": {
    "moqt-tunnel": {
      "command": "npx",
      "args": ["@agentproto/cli", "daemon", "--local-port", "8080"],
      "transport": "moqt",
      "config": {
        "relay_url": "moqt://relay.agentproto.dev",
        "control_track": "mcp/control"
      }
    }
  }
}

It's quite intuitive, right? While it's still in the early build phase before official standardization, experimenting with these tools is enough to catch a glimpse of the potential of the ultra-low-latency agent networks to come.

The 100ms High-Speed Agent Era We Are Facing

Moving away from heavy, slow synchronous calls, an era is coming where AI agents exchange data in real-time, just like lightweight network microservices. High-speed MCP communication leveraging MoQT and QUIC is the most certain lead to solving the latency bottlenecks that occur when multiple agents collaborate.

Of course, this standard is a fresh internet draft proposed in July 2026 and is still an experimental technology, too early for immediate production service deployment. However, tinkering with early open-source projects like agentproto/ts to experience the coming changes in advance will be an exciting journey in its own right.

Let's keep a close eye on how this high-speed agent ecosystem, reacting at under 100ms without network bottlenecks, will continue to evolve!