Welcome back to part four of our deep dive into the world of agentic commerce.
In our previous articles, we’ve covered the strategic shift toward AI agents, the importance of brand control in a "headless" shopping world, and the high-level architecture of Google’s Universal Commerce Protocol (UCP). If you missed those, I highly recommend catching up on the news section before we roll up our sleeves.
Today, we’re going into the trenches. We’re moving past the "what" and focusing on the "how."
There is a quiet war brewing in the background of the digital economy. It isn't a war of brands or marketing budgets; it’s a war of interoperability. The victors will define how money moves and how data is exchanged for the next decade.
For the technical leads at government agencies, higher ed institutions, and enterprise B2B firms, understanding the interplay between the AP2 protocol, the MCP protocol, and Google’s UCP isn't just "nice to know": it’s the difference between building a future-proof system and being stuck in another legacy trap.
The Tower of Babel Problem in Agentic Commerce
The biggest threat to the success of AI-driven shopping is fragmentation. If an AI agent: whether it’s a LLM-based personal assistant or a specialized procurement bot: has to learn a bespoke API for every single merchant, the system collapses under its own weight.
We’ve spent twenty years trying to solve this with "integrations." We built connectors for HubSpot, Marketo, and Salesforce. We fought with technical SEO audit mistakes just to get search engines to understand our data.
But agentic commerce requires something more robust. It requires a common language that handles discovery, context, and secure payment without human intervention.
Enter the three pillars of the new commerce stack:
- MCP (Model Context Protocol): The "Context" Layer.
- UCP (Universal Commerce Protocol): The "Orchestration" Layer.
- AP2 (Agent Payments Protocol): The "Settlement" Layer.
MCP: Giving the Agent a Map
The MCP protocol (Model Context Protocol) is arguably the most critical development for AI agents since the invention of the transformer model.
Think of MCP as the bridge between an LLM's brain and your organization’s data. In the context of commerce, MCP allows an agent to call a merchant’s API and actually understand what it’s looking at.
Instead of an agent trying to "scrape" a website or guess at a schema, MCP provides a standardized way for agents to:
- Browse product catalogs.
- Retrieve real-time inventory and pricing.
- Initiate the "cart" creation process.
For our clients in government or higher education, MCP is how you allow a constituent’s agent to query available parking permits or a student’s agent to find the correct course materials. It provides the context required to move from a chat bubble to a transaction.
UCP: The Universal Translator for Checkout
While MCP handles the conversation and discovery, Google UCP handles the state of the transaction.
As I’ve mentioned before, I’m a big fan of UCP because it doesn't try to replace your existing payment processor. It doesn't care if you use Stripe, PayPal, or a custom government payment gateway.
UCP acts as the universal translator.
When an agent needs to move from "I want this" to "I am buying this," it hits a UCP endpoint. UCP standardizes the checkout and payment states. It tells the agent exactly what the next step is: whether that’s "Payment Approved," "Requires Biometric Auth," or "Submit Shipping Address."
By mapping 1:1 to standard retail operations, UCP ensures that an agent doesn't need to know the specific quirks of your backend database. It just needs to know the UCP language. This modularity is why Google is winning the interoperability war; they aren't building a wall, they're building a foundation.
AP2: The Secure Handshake (Agent2Agent)
Now, let’s talk about the money. This is where most enterprise stakeholders start to sweat: and for good reason.
The AP2 protocol (Agent Payments Protocol) is designed to solve the security nightmare of "delegated authority." How do you give an AI agent permission to spend $500 without giving it your credit card number to keep in its "pocket"?
AP2 works through a system of mandates:
- CartMandate: The merchant signs a quote, locking in the price and terms for a specific period.
- PaymentMandate: The user (the human) signs a digital authorization on their device (using biometrics like FaceID).
The agent never sees the raw financial data. It simply carries these signed mandates between the user, the merchant, and the payment provider.
In an A2A (Agent2Agent) scenario, my shopping agent might talk to your store’s sales agent. They exchange UCP-compliant signals and AP2-signed mandates. It’s a secure, encrypted, and fully audited handshake. For government agencies concerned with PII and PCI compliance, this isn't just a feature: it’s a requirement.
Why Modularity and Extensibility Are the Real "War"
The "war" isn't between Google and OpenAI, or between UCP and AP2. The real war is between Open Standards and Closed Gardens.
In the old world of digital marketing, we were at the mercy of the platforms. If a social media giant changed their algorithm, your traffic died. If a search engine changed their indexing rules, your revenue plummeted.
Interoperability flips the script.
By adopting MCP, UCP, and AP2, you are choosing data sovereignty. You are building a system where your data is portable and your transactions are standard.
- Modularity: You can swap out your LLM provider (MCP) without breaking your checkout flow (UCP).
- Extensibility: You can add new payment methods (AP2) without re-engineering your entire product catalog.
This is the "technical marketing" approach I've advocated for twenty years at MM Sanford. It’s about building systems, not just buying tools.
The Road to Implementation: A Phased Roadmap
For those of you sitting in IT or Marketing at a large-scale institution, this might feel like a lot to digest. You’re likely dealing with organizational inertia and a lack of technical talent.
Here is how I suggest you approach this transition:
Phase I: Core Data Alignment (The Foundation)
Stop thinking about your website as a collection of pages. Start thinking about it as a structured data repository.
- Ensure your product or service schema is flawless.
- Audit your current API documentation.
- Goal: Make your data "readable" for basic MCP discovery.
Phase II: Interactive Readiness (The Context)
Implement an MCP gateway. This allows you to experiment with "Chat-to-Commerce" features without committing your entire infrastructure.
- Use your MCP gateway to connect your catalog to one or two major LLM platforms.
- Monitor how agents query your data.
- Goal: Achieve high-fidelity discovery in AI overviews and agentic queries.
Phase III: Complex Orchestration (The Transaction)
Integrate Google UCP into your checkout flow.
- Map your current checkout states (Pending, Authorized, Captured) to UCP standards.
- Implement AP2 mandate support to allow for secure, delegated payments.
- Goal: Enable a complete, end-to-end purchase within an agentic interface.
Addressing the Skeptics: Privacy and PII
I know what the legal department is going to say. "We can't let an AI touch our payment data."
This is exactly why the AP2 protocol is so vital. Unlike the "stored card" models of the past, agentic commerce using these protocols is inherently more secure. Because the agent only handles mandates: which are cryptographic proofs of intent: there is no raw PII being passed around like a hot potato.
If you are a government agency handling tax payments or a university handling tuition, the audit trail provided by a UCP/AP2 integration is actually superior to a standard web form. Every step is signed, timestamped, and verifiable.
Final Thoughts: Ownership Matters
As we wrap up part four, I want to leave you with one thought: Don’t let the platforms own your customer relationship.
If you rely on a closed "buy button" inside a single AI app, you are a tenant on their land. But if you implement interoperable standards like UCP, MCP, and AP2, you are the landlord. You own the endpoint. You own the data. You own the relationship.
In our fifth and final installment of this series, we’ll move away from the protocols and look at the "Big Picture": How Agentic Workflows are Redefining Conversion for Higher Ed and B2B. We'll look at real-world scenarios: from student enrollment to complex B2B lead gen: and show you how to tie all this tech together into a system that actually moves the needle.
If you need help navigating this "interoperability war" or need a consultant to look at your current stack, don't hesitate to contact us. We specialize in turning this technical chaos into streamlined, actionable business outcomes.
Stay technical, stay pragmatic, and I’ll see you in part five.
Key Takeaways for the Skimmers:
- MCP is for discovery and context; it's the language agents use to understand your "stuff."
- UCP is for orchestration; it standardizes the checkout process across all payment providers.
- AP2 is for security; it uses mandates to allow agents to pay for things without seeing your credit card.
- Interoperability is the only way to avoid platform lock-in and maintain data sovereignty.
- Start with a phased roadmap: align your data, then your context, then your transactions.
Ready to dive deeper? Check out our solutions page to see how we help enterprise brands lead the charge in the agentic era.
