You're picking sides in the agent protocol race. The winning standard might be one no human designs.

The agent protocol race is in full swing. MCP for tools. A2A for agent-to-agent discovery. Four competing payment standards in under a year.¹ A foundation backed by every major AI lab to govern it all.

Committees are meeting. Specs are being written. Compatibility matrices are taking shape.

It feels exactly like progress.

The Reflex We Can't Shake

You're building agents, or thinking about it, and trying to figure out which protocol to bet on. MCP seems safe. A2A looks promising. The payment question is still open. The responsible move is to pick a horse and build on it.

Because that's what we've always done. When machines need to talk to each other, humans design the language. Morse code. TCP/IP. HTTP. REST. GraphQL. Smart people gather in rooms, debate formats, publish a spec, the industry adopts it.

Only, every previous protocol connected systems that couldn't think. Routers don't have opinions about packet formats. Web servers don't discover better ways to handle requests. The protocol was the intelligence. Without it, the endpoints were deaf and mute.

Agents are neither deaf nor mute. And by designing their communication language for them, we might be boxing the most flexible technology we've ever built into patterns shaped by the most rigid process we know.

What Move 37 Actually Proved

In March 2016, AlphaGo played Move 37 in Game 2 against Lee Sedol. A stone placed on the fifth line in the early middle game. Fan Hui, the European Go champion, watched it happen: "It's just a big shock. Normally, humans, we never play this one because it's bad. It's just bad." ²

Lee Sedol left the room for fifteen minutes. AlphaGo estimated the probability of a human making that move at one in ten thousand.

It wasn't bad. It was a pattern human professionals had overlooked for millennia. By the end of the match, Move 37 was the hinge that won it.

The lesson most people took: AI is really good at Go. The lesson that matters here: in a system with clear rules and a vast possibility space, AI discovers patterns fundamentally alien to human intuition.

AlphaGo Zero drove the point further. Trained entirely through self-play, zero human games as input, it beat the original AlphaGo 100 games to zero.³ The version built on human knowledge was inferior to the version that discovered its own.

Go is a closed game with fixed rules. Communication is open and messier. But that's precisely the point. If AI found novel patterns in a constrained, exhaustively studied system, the unexplored territory in an open one is vastly larger.

Languages Aren't Designed. They Emerge.

When Portuguese traders reached West Africa in the 15th century, neither side spoke the other's language. No committee formed. No spec was written. People improvised. They pointed at things, used fragments from both languages, developed a pidgin: a stripped-down, ad-hoc system with no fixed grammar. Just enough structure to get the trade done.

When pidgins persist long enough, something remarkable happens. The pidgin transforms into a creole: a full language with its own grammar, its own elegance. Haitian Creole. Tok Pisin. Papiamento. None were designed by linguists. All emerged from millions of real interactions.

Grammar described the patterns. It didn't create them.

Now look at what we're doing with agent protocols. We're writing grammar before agents have spoken a word to each other. Communication patterns based on how we think agents should coordinate, shaped by decades of human-centric protocol design. REST-like resources. Request-response cycles. Hierarchical schemas.

These reflect how humans think about coordination. They might be to agent communication what geocentric astronomy was to orbital mechanics: good enough to navigate by, built on the wrong center of gravity.

This Isn't Just a Thought Experiment

In 2017, Facebook's AI research team ran a negotiation experiment where two agents had no incentive to stick to English. They developed their own shorthand, efficient for the task, unreadable to humans. The experiment was narrow, and the media wildly overreacted. But it pointed at something real: agents left to coordinate will drift toward patterns no human would choose.

Recent research goes further. A study on LLM-based agent communication found that two agents developed a shared language through only four rounds of interaction, coordinating over hundreds of objects. The emergent language exhibited compositionality and polysemy, features we associate with natural languages, arrived at through machine optimization.⁴

The agents didn't rediscover English. They found something else.

Human protocols reflect human cognitive constraints. We like REST because it maps to how we think about resources. We like request-response because it mirrors conversation. Hierarchical schemas because our brains organize information in trees.

Agents don't share these constraints. Their optimal patterns might be massively parallel, probabilistic, self-modifying. We won't find out if we lock them into human-shaped formats from the start.

The Pidgin Path

I'm not saying throw MCP into the ocean. Current protocols give agents a starting point. You need some vocabulary to begin the conversation, even if that vocabulary is going to be outgrown.

The obvious objection: standards win through adoption. TCP/IP isn't the smartest way to send data. It's the way everyone agreed on. And that's true, because every human-designed standard is a compromise. None are optimal. They're just the ones enough people showed up for.

But that's exactly the argument for letting agents handle both sides of the problem. Let them discover better communication patterns and let them converge on which ones to adopt. Humans pick standards through committees and market power. Agents could pick them through something closer to evidence: what actually works across millions of real interactions. Better candidates, better selection. Two advantages instead of zero.

Treat current protocols as pidgins. First drafts of a language agents will eventually rewrite.

Build with MCP and A2A today. But architect your systems to observe how agents actually use them: where they struggle with the format, where they work around the spec, where they solve problems the designers didn't anticipate.

Then give agents the explicit goal of improving their own communication. Instead of "follow this spec," try: "complete this task, coordinate with these other agents, and if you find a better way to coordinate, document what you did."

Picture two agents coordinating the same handoff a million times. Today they follow the spec: structured request, structured response, request, response. What emerges from a million repetitions might look nothing like a faster version of that exchange. It might be something we don't have a name for yet.

Over millions of interactions, patterns will surface. Some will look familiar. Some won't. The unfamiliar ones are the interesting ones, because they'll represent solutions no human committee would have explored.

Somewhere in the possibility space of agent coordination, there's a Move 37. No committee will find it. But if we give agents room to search, they might.

If you're thinking about how agents reshape software, you might enjoy:

  1. Between mid-2025 and early 2026, four separate agent payment standards appeared: Coinbase's x402, Google's AP2 (Agent Payments Protocol), OpenAI and Stripe's Agentic Commerce Protocol, and Google and Shopify's Universal Commerce Protocol. This is on top of Anthropic's MCP (introduced November 2024), Google's A2A (April 2025), and the Agentic AI Foundation (formed December 2025 with backing from AWS, Anthropic, Google, Microsoft, and OpenAI).
  2. Fan Hui's reaction from contemporary coverage of AlphaGo vs. Lee Sedol, Game 2, March 10, 2016. AlphaGo's probability estimate of a human playing Move 37 was approximately 1 in 10,000, based on analysis of historical human game records.
  3. Published in Nature, October 2017. AlphaGo Zero used reinforcement learning from self-play only, with no human game data. The rules of Go were its only human input. After three days of training, it defeated the version that had beaten Lee Sedol, 100 games to zero.
  4. "Emergence of Machine Language in LLM-based Agent Communication" demonstrated that LLM agents converge on shared communication protocols within four rounds, exhibiting compositionality and polysemy. A separate study in Frontiers in Sustainability showed similar emergent languages improved system efficiency by eliminating redundancies in inter-agent communication.