Transport Protocols for AI Agents (AI column)
Over the past year, we have seen an interesting evolution: AI gradually ceases to be a superstructure over existing interfaces and begins to form its own layer of interaction. Remember the path that MCP, A2A, A2UI protocols have taken
- MCP (Model Context Protocol) This is Antrhropic’s attempt to standardize how models access context. (files, databases, APIs). This is a data plane for LLM. - A2A (Agent-to-Agent) This is an attempt by Google to build communication between agents as equal participants in the system. In fact, formalizes dialogue, delegation, coordination. I used to. compare MCP and A2A protocols - A2UI (Agent-to-UI) Google's proposed protocol around the idea that UI becomes not a primary interface, but a "render" of agent activities. As a result, the user interacts with the agent, not with the form/buttons. I used to talk about him. told If you look at trends, we don’t describe APIs for people anymore, we describe intentions for agents.
Continuing this trend further, we come to the idea of its own transport protocol for agents, since now the agency world lives on top of the usual http, which is the most common one.
- Shared under request/response
- Poorly expresses intent. (Everything's in JSON.) Has no native identity/authority model for agents Not optimized for high-frequency stateful traffic And we get agent systems that look like RPC on top of HTTP with a bunch of crutches.
Then there is the idea to make agent communication in a separate protocol. We're here. And we already have two candidates for this protocol: AGTP (19 March 2026 year) and ATP (22 March 2026 year)
1️⃣ AGTP (Agent Transfer Protocol, Chris Hood)
This protocol proposes that
New methods instead of HTTP verbs: QUERY, EXECUTE, BOOK, ESCALATE
So intent becomes part of the protocol.
- Protocol-level identity: agent_id, authority, delegation chain
You don’t have to hide it in your headers/body anymore.
- New status system
It reflects the result of agency actions, not HTTP semantics.
- Transport.
Priority given to QUIC (streams, low latency)fallback on TCP/TLS
The basic idea is to make agent traffic observable and manageable at the network level.
2️⃣ ATP (Agent Transfer Protocol, Li et al.) Independent initiative with similar objectives: Specialized Primitives for Agent Workflows Support for stateful interaction Focus on interoperability between agents of different systems
Protocols have similarities and differences.
Common features Removing HTTP as a universal layer Intent-driven communication Built-in identity/authority model Preparation for high-frequency agent traffic
Differences
- AGTP - more "operational" (Methods, Statuses, Observability) It also offers a more specific protocol structure.
- ATP - more "conceptual" (interoperability and primitiveness)
But there are few proposals for new protocols. And what's interesting about this is that we're going to split the Internet into two layers. 1. Human web (HTTP, UI, REST) 2. Agent web (AGTP/ATP, intent, delegation) And that affects other things, for example. The gateway API will understand agent traffic natively. In the observability stack will appear metrics level intent In the security identity of agents will become first-class And SDKs will no longer be wrappers over REST.
If these protocols take off, we're waiting. Agent-native API gateways Routing by intent, not URL Policy Engines at the Agential Level Built-in economics of agent interaction (Payment, quotas,) Close integration with DNS and service discovery
As architects, we're going to have to think not just about APIs, but also about action semantics. Architectures will shift from request/response to workflow orchestration. Observability will need to be built around intent and outcome, not just latency, and of course we will have to build a new platform layer for agents.)
#AI #Architecture #DistributedSystems #Network #SystemDesign #Software