The Protocol Layer: Watching the Theory Play Out in Real Time

Earlier this year I finished a sixteen-part series — The Firm Under AI — tracing what happens to the theory of the firm when agentic AI enters the picture. The core argument, built from Coase through Chandler and into the platform era, was this: firm boundaries are determined by transaction costs, and the history of organisational form is largely a history of technologies that shift those costs. Every time a new coordination technology matures — the telegraph, the divisional corporation, the internet platform — the boundary between what firms do internally and what they buy from markets shifts with it.

I argued that agentic AI would drive the most significant such shift since the rise of digital platforms.

Last month, Google published a Developer’s Guide to AI Agent Protocols. It is framed as a tutorial — building a restaurant supply chain agent, adding protocols one by one. Read it alongside the theory and it reads as something else: a detailed account of the mechanism by which the shift is happening, published openly, in real time. It is worth noting that Google is not a neutral narrator here — A2A is their protocol, and the guide positions them at the centre of the stack. That does not invalidate the evidence, but it shapes what is emphasised.

Post 15 examined the emerging ecosystem — Salesforce, SAP, Atlassian, and the consulting firms converging on agent protocols. This post examines the mechanism: what exactly each protocol layer does to the cost structure that has historically justified the firm.

Six Protocols, Six Transaction Cost Problems

The Google guide introduces six protocols. Each one closes a distinct gap in what autonomous agents can do without human mediation. Oliver Williamson decomposed the costs that make firms necessary into categories: search and information, bargaining, enforcement, monitoring. The six protocols map onto those categories with notable precision.

MCP — Information Costs at the Tool Layer

Model Context Protocol connects an agent to tools and data. Created by Anthropic and donated to the Linux Foundation, MCP defines a standard interface between an AI model and external capabilities — databases, APIs, file systems, web search. Before MCP, every tool integration was a bespoke wrapper. After MCP, a server built once works across every major AI client.

In Williamson’s terms, MCP eliminates information costs at the tool layer. The standard interface means an agent can discover and use any MCP-compatible capability without bespoke integration. The search cost of tool access approaches zero.

A2A — Negotiation Costs at the Agent Layer

Agent-to-Agent Protocol connects agents to other agents. Created by Google, now Linux Foundation-governed with over 150 participating organisations (per Google’s guide). Each agent publishes an Agent Card at a well-known URL describing its capabilities, authentication requirements, and endpoint. A client agent reads the card, selects the right specialist, and delegates.

The Agent Card is a capability advertisement in a standard format. What Williamson called bounded rationality friction in inter-agent contracting — the cost of establishing mutual understanding before transacting — disappears into the protocol. The agents do not negotiate their interface. The interface is given.

UCP — Bargaining Costs at the Commerce Layer

Universal Commerce Protocol standardises the commercial transaction lifecycle — catalog discovery, selection, checkout, payment — in typed schemas that remain consistent regardless of supplier or transport. Five wholesale distributors, one checkout flow.

Bargaining costs are not just the cost of finding a supplier. They are the cost of transacting with them — the integration work, the format mismatches, the bilateral negotiation of terms. UCP standardises that cost away for structured commercial interactions.

AP2 — A Subset of Enforcement at the Payment Layer

AP2 handles payment authorisation within configured guardrails. The agent does not spend freely; it operates within a mandate written in configuration.

This maps to Williamson’s enforcement costs, though imperfectly. Enforcement in the full sense includes legal recourse, reputation mechanisms, and credible commitment. AP2 is narrower — it encodes spending limits into the protocol itself, making one dimension of enforcement structural rather than relational. It is a technical enforcement mechanism, not a complete institutional one. The gap matters — I address it below in Where This Breaks.

A2UI and AG-UI — Monitoring Costs at the Human Layer

A2UI allows an agent to compose interactive UI components from its results. AG-UI streams tool calls, reasoning traces, and status updates to the frontend in real time.

In Williamson’s framework, monitoring — verifying that an agent is performing as expected — is a transaction cost. Streaming the agent’s work and composing interactive results directly into a human interface reduces that cost substantially. The principal can watch the agent work rather than inspecting the output after the fact.

The Coasean Reading

The six-layer stack is, in aggregate, a systematic reduction of every major category of transaction cost that bears on inter-agent coordination.

The mapping is not perfect. MCP and A2A overlap — MCP servers can be discovered dynamically, and A2A Agent Cards contain capability information that blurs the line between tool discovery and agent negotiation. AP2 handles only the payment dimension of enforcement; the larger institutional questions of liability, jurisdiction, and accountability remain untouched. These are protocols, not institutions.

But the direction is unambiguous. Each layer reduces a specific friction that has historically justified bringing coordination inside a firm rather than conducting it through markets.

What This Does to Firm Boundaries

The series argument was that agentic AI would shift the Coasean boundary — the point at which the marginal cost of internal coordination equals the marginal cost of market coordination. As protocol infrastructure drives the latter toward zero, that boundary moves. The firm no longer needs to own every specialist capability it deploys. It can discover and delegate to external agents at a cost comparable to internal coordination.

What is striking about Google’s tutorial is the phrase used to describe the agents a kitchen manager might query for wholesale pricing: they may be “built by different teams, on different frameworks, running on different servers.” And — this is the important part — “in some cases, the raw data might never be exposed by API but could be exposed via an agentic interface.”

That sentence describes a new kind of market structure. The supplier is not publishing data. It is publishing an agent that mediates access to data. The Agent Card is not an API specification. It is a capability advertisement from an autonomous intermediary. The market is not for information or services in the traditional sense — it is for agent-mediated outcomes.

This is the platform logic extended to the agent layer. In the series I traced how AWS, Salesforce, and their successors achieved scale by becoming the coordination layer between parties who might otherwise transact directly. Post 15 showed this already happening — Salesforce coordinating SAP, ServiceNow, and DocuSign agents through A2A without employing any of them. The Google guide describes the general mechanism behind those specific cases.

The implication for organisational form is that the relevant unit of make-or-buy analysis shifts from functions and teams to agents and capabilities. A firm deciding whether to build or buy compliance checking is no longer deciding whether to hire a compliance team or engage a consultancy. It is deciding whether to deploy its own compliance agent or discover one through A2A. The economics of that decision are different in kind, not just degree.

The Stack as Infrastructure

It is worth stepping back from the individual protocols to see what they compose into.

The six-layer stack is not a set of competing standards. It is layered infrastructure — in the same sense that TCP/IP, HTTP, and TLS compose into the infrastructure of the web, if the parallel holds. Each layer operates independently of the ones above and depends on the ones below. MCP is the foundation. A2A sits on top. UCP operates over REST, MCP, or A2A. AP2 handles payment within UCP flows. A2UI and AG-UI handle the human interface above all of it.

Before HTTP, networks existed but could not interoperate. After HTTP, the question shifted from “can these systems communicate?” to “what should they say to each other?” MCP and A2A adoption suggests the same shift is beginning at the agent layer — the question moving from “how do I integrate with this agent?” to “what should I ask it to do?” The analogy is suggestive, not proven. TCP/IP and HTTP had years of competing alternatives before winning. These protocols are months old. But the trajectory is clear enough to take seriously.

If it holds, the next decade of agent development will look less like building systems and more like composing them. Selecting from a landscape of specialist agents, tools, and commerce services that interoperate through standard protocols.

Post 16 ended with a specific claim about where the value lies: the firm persists as a trust anchor — the entity that holds liability, governs protocols, and bears accountability when systems fail. The protocol stack does not change that conclusion. It reinforces it. The cheaper market coordination becomes, the more clearly the irreducible institutional functions of the firm come into focus. Governance, liability, intent, accountability — these cannot be standardised into a protocol. They require an institution.

Competitive advantage in this landscape lives at two distinct levels. At the business logic layer, firms like Salesforce and SAP control proprietary protocols above the open infrastructure — the CRM and ERP interaction rules that determine what agents can actually do within specific domains. At the institutional layer, firms that understand their role as trust anchors — the entities that govern, bear liability, and make binding decisions when protocols encounter cases they were not designed for — will capture a different and more durable kind of value. The first is about controlling the rules of a specific game. The second is about being the institution that decides which games are played.

Where This Breaks

The series did not shy away from limits, and this companion piece should not either.

Not all coordination is parallelisable. Post 15 drew on Kim and Liu’s research across 180 agent configurations: parallelisable tasks see up to 80% improvement from multi-agent coordination; sequential reasoning tasks degrade by 39–70%. The protocol stack makes agent coordination cheap. It does not make it universally effective. A firm that delegates sequential analytical work to a chain of A2A-connected agents will get worse results than one that keeps a single capable agent (or human) on the task.

The enforcement gap flagged above is real. AP2 handles payment guardrails. It does not handle what happens when a supplier agent delivers fraudulent goods, when a procurement agent is manipulated into a bad contract, or when cross-jurisdictional agent coordination triggers regulatory liability that no single entity anticipated. Williamson’s enforcement costs include legal recourse, credible commitment, and reputation mechanisms. None of these are addressed by the protocol stack. They require institutions — entities with legal personality, liability, and standing to be held accountable. This is precisely the “trust anchor” role that Post 16 argued the firm must retain.

Protocol maturity is uneven. MCP and A2A are production-grade, Foundation-governed, and widely adopted. UCP, AP2, A2UI, and AG-UI are newer and less tested. Treating all six as equivalent overstates the current reality. The foundation layers are solid; the commerce and interface layers are still being proven.

The proprietary layer above the open layer. Post 15 flagged this: A2A is open, MCP is open-source, but Salesforce, SAP, and ServiceNow control proprietary protocol layers above the open infrastructure. The open layer enables interoperability; the proprietary layer above it captures value. Competitive advantage may not lie in the open stack itself, as the Google guide implicitly suggests, but in the business logic protocols built on top of it — and those are not open at all.

A Note on Governance

The governance structure of this infrastructure is not a footnote.

MCP and A2A are both now held by the Linux Foundation’s Agentic AI Foundation (AAIF), co-founded by Anthropic, OpenAI, Google, Microsoft, AWS, and Block, under Apache 2.0 licensing. Over 150 organisations participate in A2A governance (per Google’s developer guide).

The internet’s protocol governance took decades to stabilise — the IETF, W3C, and IANA emerged gradually from contested early battles. The agent protocol stack is being placed under neutral governance unusually quickly, before the commercial stakes have fully clarified. That speed is either reassuring or suspicious, depending on your prior about why the major AI providers are moving in the same direction simultaneously.

This is substantial enough to deserve its own sustained treatment. For now, the flag: the protocol layer is not purely a technical choice. It is a political economy, and the early decisions about who controls it will have long consequences.

What to Watch

The series made a prediction: that the transaction cost logic of the firm would reassert itself at the agent layer, and that protocol infrastructure would be the mechanism. Google’s developer guide reads like confirmation, arriving in the form of engineering documentation rather than economic analysis.

That is how these inflection points tend to announce themselves. Not with a theoretical paper but with a tutorial that quietly assumes the world it describes. Google’s guide assumes that agents will discover each other across organisational boundaries, transact autonomously, and coordinate without human mediation. It treats these as implementation details rather than remarkable claims.

Three things are worth tracking from here:

1. The first major cross-firm A2A production deployment — not a demo, not a partner announcement, but an actual value stream running across organisational boundaries through agent protocols. That is the moment the theory becomes operational.

2. The governance battles — which layer of the stack becomes the bottleneck, and whether the AAIF structure holds as the commercial stakes rise. History says open protocol governance is stable until the money gets large enough to test it.

3. The regulatory response — when autonomous agents coordinate procurement, hiring, or financial transactions across jurisdictions, liability questions that no protocol can answer will force institutional responses. The enforcement gap in this stack is where the interesting institutional design work will happen.

The stack is not finished. The protocols are young, the governance is untested, and the second-order effects on firm structure have barely begun to surface. But the direction is clear enough, and the mechanism is now visible in the open.

The Firm Under AI is a completed sixteen-part series on theory of the firm, transaction costs, managerial history, digital platforms, and agentic AI. The Google developer guide referenced throughout is Developer’s Guide to AI Agent Protocols (March 2026).