The protocols nobody calls the protocols

Most people watching the MCP releases are watching the wrong thing.

The story isn’t that Anthropic shipped another tool spec. It’s that the same architectural move just got copy-pasted into commerce, is about to land in data, and nobody is naming the pattern out loud. There’s a shape repeating across three protocols this year. None of the protocols name it. None of the press names it. And whoever names it first gets to set the vocabulary for what “trustworthy agent work” means for the next decade.

So let me name it.

Three protocols, one shape

In the last twelve months, three independent specs landed:

• MCP — Anthropic’s Model Context Protocol. Standardizes which tools a model is allowed to call, with what arguments, and how the result comes back.
• UCP — the Universal Commerce Protocol, announced by Google in January and now backed by a 10-member tech council that includes Amazon, Stripe, Shopify, Meta, and Microsoft. Standardizes which products an agent can put in a cart, what context it must pass at checkout, and which trust signals get verified at binding time.
• MAC — the framework I’ve been writing in client engagements as the verification layer for AI-assisted data work. Standardizes which acceptance criteria a data model has to pass before it ships and how those criteria are written down so a machine can grade against them.

Different domains. Different authors. Different launch dates.

Same shape.

Each one builds a verification vocabulary before the agent acts. MCP says: here’s what “calling a tool correctly” means in this environment. UCP says: here’s what “transacting correctly” means at this checkout. MAC says: here’s what “answering the business question correctly” means against this dataset. The agent doesn’t get to define correctness on the fly. The protocol pins it down in advance, and the agent is graded against it.

These are USB-C for three different walls of the agent house. The wall doesn’t change. The wires behind the wall don’t change. The plug standardizes — and standardizing the plug is what lets the wall hold any appliance you bring home.

Why all three landed in the same year

You don’t get three independent groups converging on the same architectural move by accident. Something in the substrate changed.

Here’s what changed: the underlying capability got cheap. The model that can call a tool, build a cart, or write a SQL query is a commodity now. What you can’t get cheap is the part that decides whether it did it right. When generation is the bottleneck, you ship the generator. When verification is the bottleneck, you ship the verifier. Three different industries hit the verifier-is-the-bottleneck wall in the same year, because the generator hit the floor in the same year.

The second thing that changed: the senior-operator advantage stopped scaling.

Used to be that you trusted the agent of action — whether that was a code editor, a buyer, or a data team — because the person operating it had a track record. “I’ve seen this before, it’s fine” was a real signal because the person saying it had spent a career carrying the analogies. That signal doesn’t extend to a thousand parallel agent runs at 3am. You can’t put a senior person behind every cart, every tool call, every model. You need the verification surface itself to carry the trust, because individual experience doesn’t fan out.

This is the Tesla FSD bet, transposed to white-collar work. No individual driver can rack up a billion miles. The fleet can — but only if there’s a standardized verification layer the fleet can learn against. The protocols getting written this year are the verification layer for the agent fleet. UCP isn’t really about commerce. It’s about whether agentic commerce can fan out without each merchant becoming a bespoke trust problem.

Watch Stripe for the receipt nobody else is collecting. Stripe sits on the UCP Tech Council and on OpenAI’s competing Agentic Commerce Protocol. The single most informed payments company in the market is hedging between two protocols at once — which is what you do when you’ve concluded the protocol layer is going to be load-bearing and you can’t afford to be locked out of either. That’s the tell. The market is pricing the verification surface as the thing worth fighting over.

The pattern names what’s worth betting on

Once you see the shape, the bet writes itself.

Don’t write tools inside the agent. Any model upgrade replaces those. Write the verification layer that survives every model upgrade — the layer that says “this output meets these criteria for this purpose” in language a human auditor and a machine can both read. That layer doesn’t get cheaper when the model gets cheaper. If anything, it gets more valuable, because the consequences of an unverified failure compound when the model is taking on more work.

For data engineers specifically: stop writing dashboards faster. The dashboard is the commodity output. The expensive thing — the only thing the next model upgrade can’t replicate — is the acceptance-criteria layer that tells you and the agent when the dashboard is right. Which scopes does this model need to cover? On what bases is it tested? What does “correct” mean for this metric, in this business, at this freshness? Write that down once and the next ten model upgrades make your work better, not obsolete.

This is what MAC is. But the pattern is bigger than data. Every domain in 2026 needs its targeting protocol — the spec that locks in what verification looks like at the binding moment of agentic action. Commerce got UCP. Tools got MCP. Data needs its equivalent. Healthcare, legal, finance, brokerage, scheduling — all behind the same wave. Whoever shows up with a credible spec inside the next 18 months sets the norms that hold for a decade.

The 18-month window

The protocols are being written this year. Not next year. This year.

The 10 companies on the UCP Tech Council today — Google, Amazon, Microsoft, Meta, Salesforce, Shopify, Etsy, Target, Wayfair, Stripe — are about to set the rules for agentic retail through 2035. Vote thresholds, eligibility-claim semantics, trust-signal byte formats, the whole shape. None of those decisions get reopened once the spec hits v1 and the implementations harden against it. That’s how protocols work. Once enough code depends on a primitive, the primitive becomes the floor.

Same goes for the data side. Whoever shows up with a credible verification protocol for AI-native data consumption — one a vendor can implement against, one a CFO can audit against, one another agent can grade against — gets a seat at the table that defines this layer for the rest of us.

The window is short. The seats are few. And the protocols nobody calls the protocols are the ones that decide who gets one.