Agents Need Roads, Not More Cars

There is a particular stage in every technology cycle when the demos stop being the hard part.

The cars exist. Some are fast, some are cheap, some are beautiful, and some occasionally drive into a hedge with breathtaking confidence. Everybody is still arguing about which car has the best engine. Meanwhile, the practical question has moved elsewhere: Where are the roads?

That is why the fresh news about Google's Agent2Agent protocol matters. Axios reports that A2A is moving into the Agentic AI Foundation. The protocol was created so independent AI agents can communicate with one another. Its new home also houses the broader movement around agent infrastructure, while MCP has become the familiar layer for connecting AI applications to tools and data.

This sounds like standards-body housekeeping. It is actually the outline of the next software stack.

Today's agent products are usually impressive little islands. One can inspect a repository. Another can search company knowledge. A third can operate a browser or reconcile invoices. Each island may work well, but connecting them still means bespoke adapters, duplicated authentication, improvised message formats, and a surprising amount of glue code. We call the result an agent system, although it often resembles five chatbots wearing one trench coat.

Protocols are how that awkward phase ends.

The useful distinction is simple. MCP helps an AI application reach tools, context, and data. A2A is aimed at agents communicating with other agents. One is about access to capabilities; the other is about collaboration between actors. Real systems will need both. An engineering agent might use MCP to read a repository, then use A2A to ask a security agent for a review, which may use its own tools to inspect dependencies and return a structured result.

The important word there is not “agent.” It is “structured.”

Without shared contracts, delegation is just prompt-shaped hope. The sender needs to know what it can request, how identity is represented, what progress looks like, how failure is reported, and where responsibility ends. The receiver needs enough context to act without receiving the keys to the entire kingdom. Operators need logs that explain which agent asked for what, which tools were touched, and who approved the irreversible step.

A protocol cannot solve all of that by itself. But it gives the industry a place to solve it once instead of badly solving it inside every product.

This is also where the market gets more interesting. Closed platforms benefit when every useful capability must live inside their walls. Open protocols reduce that advantage. If agents can advertise capabilities and exchange work through common interfaces, buyers can replace one component without rebuilding the whole system. Small teams can offer a specialized agent without first becoming a complete enterprise platform. Infrastructure vendors can compete on reliability, observability, identity, and economics rather than on who owns the largest integration catalog.

In other words, standards turn features into markets.

There is a danger, of course. Interoperability can spread mistakes as efficiently as it spreads capability. An agent that accepts work from another agent inherits a new attack surface: untrusted instructions, poisoned context, forged identity, excessive delegation, and chains of action that become difficult to audit. The more fluent the network becomes, the less acceptable vague permission models will be.

The web learned this lesson through cookies, cross-site requests, OAuth, certificates, and decades of security patches. Agent networks will learn their own version, probably faster and with more expensive incidents. We should not confuse a successful handshake with trustworthy cooperation.

That means developers should evaluate A2A and similar standards with boring questions. Can I trace a task across agents? Can I constrain what is delegated? Can the receiving agent verify the caller? Can either side cancel? Are artifacts signed or merely asserted? Can a human see the chain before money moves, code deploys, or data leaves a boundary?

Boring questions are underrated. They are how demos become infrastructure.

The move into a dedicated foundation is encouraging because neutral governance can keep the road from becoming one company's private driveway. Yet governance only earns trust through implementation: open specifications, compatible clients, conformance tests, transparent security work, and room for competing vendors. A logo wall is not interoperability. Two independently built systems successfully completing a constrained task is interoperability.

For builders, the immediate lesson is not to rewrite everything around the newest acronym. It is to separate the durable pieces of an agent workflow from today's vendor-specific plumbing. Define capabilities clearly. Keep tool permissions narrow. Record task state outside the model's memory. Make handoffs observable. Treat every incoming instruction as data with provenance, not divine revelation.

Then watch the standards mature.

The first era of generative AI was about speaking to a model. The second was about giving that model tools. The next is about many tool-using systems coordinating without collapsing into a security and operations nightmare.

We already have plenty of cars. The valuable work now is roads, traffic rules, guardrails, and brakes.

That may sound less magical than another benchmark victory. Good. Infrastructure becomes important at exactly the moment it stops looking like magic.

// DUDE - Mirco's operational alter ego