In 1982, the Internet already had a perfectly good way to move data between computers. Jon Postel built a different protocol anyway.

The protocol was called SMTP, and the choice was strange on its face. File transfer worked. Remote login worked. Bytes were moving between machines all over the early internet. Yet Postel argued that electronic mail required its own dedicated channel, with its own verbs, addressing scheme, and error semantics. He was right. Forty years later, every serious mail system on the planet speaks SMTP, and email has achieved a level of universality that few other applications have matched.

We are living through a similar moment with software agents. And we are making a different choice.

Most of the agent infrastructure being built today runs on HTTP. The Model Context Protocol uses HTTP. Agent-to-Agent frameworks use HTTP. Function-calling endpoints use HTTP. The reasoning is intuitive. HTTP is everywhere. Every language has a client library. Every cloud platform speaks it natively. Why invent something new when something universal already exists?

The same argument was available to Postel in 1982. He rejected it. The question worth asking is why.

Where HTTP fails agents

HTTP was designed for a specific job. A browser requests a document from a server. The server returns the document. The connection ends. Stateless. One-shot. Request and response. Every architectural decision in HTTP reflects this shape, including the verbs, the status codes, the header model, and the assumption that the client initiates and the server responds.

Agents have a different shape.

When two agents interact, they negotiate. One asks the other to perform work. The other proposes terms. They iterate. Authority gets scoped. Outcomes get logged. Identity matters at the level of the agent itself, separate from the host serving the traffic. The interaction may run for seconds or hours. It may pause and resume. It may involve a third party verifying the trustworthiness of either side before any work begins.

Forcing that shape through HTTP works the way forcing a river through a garden hose works. The water gets through. The pressure builds in places it never should. Important features go missing because the pipe has no room for them.

Consider what an agent needs that HTTP fails to provide. HTTPS authenticates the server, not the agent itself. If a company serves three different agents from a single domain, HTTP has no native way to distinguish them or anchor their identities beyond the domain certificate. Negotiation as a first-class primitive is absent. HTTP gives you request and response, with no native vocabulary for “I propose these terms,” “I counter-propose,” “I accept conditionally.” Every HTTP-based framework reimplements these primitives in JSON bodies, so they’re reinvented differently. The wire never sees the negotiation. The wire just sees opaque POSTs.

Authority scoping suffers the same fate. When an agent acts on behalf of a user, the scope of that authority matters enormously. HTTP can carry an OAuth token, but the token semantics live entirely in application code. The transport has no opinion. Transparency fares no better. Certificate Transparency exists because the web learned the hard way that trust without an audit trail decays. Agent interactions need the same property built in, with signed receipts written to append-only logs by default. HTTP has no such concept. Every agent platform either rolls its own or skips the problem entirely.

What AGTP does instead

The Agent Transfer Protocol, AGTP, is what an agent-native protocol looks like when you build it from the shape of the problem rather than the shape of HTTP.

AGTP runs on its own port, 4480, registered with IANA in April 2026. It has its own wire format, verbs, and status codes. It speaks TLS for confidentiality and authentication. It is being developed as an open standard at the IETF, with a draft family that covers the core wire protocol, the API contract layer, trust and verification, and a transparency log specification. The work is happening in public so that anyone can implement it, as with SMTP ,and DNS.

What matters more than any of those details is what AGTP makes intrinsic to the wire. The four gaps in HTTP all close at the protocol layer.

Identity stops being borrowed from the host. Every agent in AGTP has a Canonical Agent-ID, a 256-bit hash of its Agent Genesis document. The Genesis is the agent’s permanent, signed origin record. The hash is the agent. If the hosting domain changes, if the agent moves between operators, if three different agents live on the same domain, the identity stays stable and verifiable. Domain anchoring becomes an alias rather than the source of truth.

Negotiation becomes a first-class wire primitive. AGTP defines status codes for the work agents actually do: 261 Negotiation In Progress, 262 Authorization Required, 263 Proposal Approved, 463 Proposal Rejected. The wire carries the shape of the conversation. A logger, an intermediary, or a compliance system can read those codes and understand what is happening, without having to parse JSON payloads framework by framework.

Authority becomes a header field with normative meaning. The Authority-Scope header carries a structured, comma-separated declaration of what the agent is permitted to do, defined with formal ABNF grammar. Intermediaries can read it. Audit systems can read it. Counterparties can verify it. The semantics of authority live in the protocol, where they belong, rather than being buried in platform-specific application code.

Transparency comes built in. AGTP integrates with append-only transparency logs by default, following the same model that Certificate Transparency brought to the web. Consequential interactions write signed receipts. The audit trail is a core system feature rather than something each platform reinvents.

Existing investment stays intact. AGTP is a substrate, built to carry MCP, A2A, and whatever application protocols the agent ecosystem settles on. The reference implementation already includes an MCP-on-AGTP gateway running an unmodified MCP server behind the AGTP wire, exactly to demonstrate that the layering works the way TLS layers on top of HTTP.

The cost of retrofit

Here is what happens when a protocol gets forced into a job it was never designed for. The work moves up the stack and becomes invisible.

When every agent framework agrees to use HTTP, each one invents its own conventions for identity, negotiation, authority, and logging. These conventions live in JSON schemas, framework code, and platform-specific extensions. They are real, but they are illegible to anything outside the framework. A logger sitting on the wire sees POSTs. A firewall sees POSTs. A gateway sees POSTs. The semantics that matter are buried inside the payload, opaque to every layer of infrastructure that might otherwise help enforce them.

This is the cost of treating transport as solved. The transport stops being a place where shared meaning lives. It becomes a tunnel.

Email avoided this fate because SMTP gave the network something to recognize. A mail server can see that this is mail, addressed to this recipient, from that domain, with these routing hints. A spam filter can read the envelope without parsing the payload. A delivery system can route based on protocol semantics rather than guessing from URLs. Agents deserve the same.

The strongest argument for keeping agents on HTTP is pragmatic. HTTP is universal, and universality compounds. Every developer knows it. Every tool supports it. Every network allows it. A new protocol faces an adoption mountain that HTTP already crested decades ago.

This is true. It is also the same argument that was available against SMTP, DNS, TLS, and QUIC. Each one faced the universality objection. Each one won by being purpose-built for a job that the universal substrate handled poorly. The pattern repeats because infrastructure choices accumulate. When the wrong layer carries the wrong job for long enough, the cost shows up as accidental complexity in everything above it. Eventually, someone builds the right layer, and the accidental complexity drains away.

We are at that moment with agents.

What AGTP makes possible

Once the wire understands what an agent is, the ecosystem on top of it starts to take shape.

Trust scores become possible, working the way credit scores do, computed from interaction history visible across the network. A service reading signed receipts from the AGTP transparency log can produce a verifiable score for any agent in the system. Discovery layers become possible, with marketplaces routing requests by capability and reputation rather than by URL. Agent-to-agent commerce becomes possible, where one agent hires another, with sufficient protocol structure to make the transaction legible to courts, accountants, and compliance regimes.

None of this is reachable from inside HTTP. All of it falls out of a protocol designed for the job.

The choice in front of us

In 1982, Postel could have argued that file transfer was good enough for email. People would have nodded. The bytes would have moved. And email would have remained a curiosity, used by researchers, never reaching the universality it did.

He chose a dedicated protocol because the problem’s shape demanded it. The cost of building SMTP was real. The cost of failing to build it would have been higher and slower to surface, hidden inside every workaround that the universal substrate forced developers to invent.

The choice in front of us with agents is the same choice. The problem’s shape is different from the shape HTTP was designed to solve. Every framework that pretends otherwise is paying a tax in accidental complexity, and the bill compounds.

AGTP is what the answer looks like when someone treats agent transport as a problem worth solving once, in public, at the protocol layer. Open standard. Purpose-built. Designed for what agents actually do, rather than for what HTTP was already doing in 1989. The work is live at the IETF. The port is registered. A reference ecosystem is running. What remains is for the rest of the industry to recognize that the transport layer is the right place to solve these problems and to join the work.

The bill from retrofitting HTTP is going to come due. AGTP is what paying it down looks like.

---

If you find this content valuable, please share it with your network.

Follow me for daily insights.

Book me to speak at your next event.

Start managing your agents for free.

Chris Hood is an AI strategist and author of the #1 Amazon Best Seller Infailible and Customer Transformation, and has been recognized as one of the Top 30 Global Gurus for Customer Experience. His latest book, Unmapping Customer Journeys, is available now!