Your Next Customer Won't Click. They'll Delegate.
The commerce interface is changing. And it's not another redesign.
Think about the last time you booked a business trip.
You opened six tabs. You compared prices on three airline sites. You checked your credit card rewards portal. You pulled up the hotel loyalty app. You looked at Google Maps for the office address. You Googled cancellation policies. You re-entered your corporate card number on the fourth checkout page.
Now consider this instead:
"Book my Chicago trip. Keep it under travel policy. Prioritize hotels near the board office. Use loyalty points only if the redemption value makes sense. Book dinner for four on Tuesday. Ask me before the final purchase."
One instruction. An AI agent handles the rest — comparing options, checking policy compliance, querying loyalty status, booking the restaurant, creating the itinerary, then surfacing a single approval screen.
You don't browse. You delegate intent.
That shift — from human navigation to agent execution — is the premise behind agentic commerce. And if you're an engineer building systems that touch retail, payments, loyalty, fulfillment, or customer identity, this isn't a future-state thought experiment. The protocol stack making this possible is being standardized right now.
Why This Is an Architectural Problem, Not a UX Problem
Most discussions about AI agents in commerce focus on the customer experience side: "What will shopping feel like?" That's the wrong frame for engineers.
The more useful question is: What does your system need to expose for an AI agent to trust and transact with it?
Your landing pages, checkout flows, and banner ads were designed for a human with 200ms of attention. An AI agent has different requirements:
- Structured, machine-readable product data
- Programmatic access to pricing, inventory, cancellation policies, and promotions
- A secure, permissioned payment layer with auditable authorization
- Real-time fulfillment status with clear SLA signals If any of these are locked inside a human-facing frontend with no API surface, you don't just have a bad UX — you're invisible to agents.
The Six-Layer Stack Enabling Agentic Commerce
The acceleration here isn't coming from one model. It's coming from a stack of interoperability protocols converging at the same time.
1. Model Context Protocol (MCP)
Agents need more than prompts. They need a standardized way to call tools, retrieve context, and operate across systems without every team building one-off integrations.
In a commerce context, MCP means an agent can check your live inventory, apply a loyalty rule, read a return policy, and create a support case — all through a consistent interface. Think of it as the "USB standard" for agent-to-system communication.
2. Agent-to-Agent Protocol (A2A)
Commerce won't stay as one agent talking to one website.
Customer agents will negotiate with merchant agents. Broker agents will aggregate options across providers. Fulfillment agents will coordinate between inventory, shipping, and support. A2A, pushed forward by Google and the broader ecosystem, defines how agents exchange capabilities, task status, context, and multimodal outputs across vendor boundaries.
Without A2A, every agent integration is a bespoke negotiation. With it, agents interoperate like services in a well-designed microservices architecture.
3. Agent Payments Protocol (AP2)
This is the clearest sign that agentic commerce is leaving demo territory and entering the transaction layer.
The core primitive is the mandate — a structured object that ties together user intent, cart details, spending limits, and payment authorization into a single auditable unit.
{
"agent_id": "travel_agent_789",
"customer_id": "customer_123",
"allowed_category": "business_travel",
"max_transaction_amount": 1200,
"approval_required_above": 500,
"valid_until": "2026-06-30",
"purpose": "Chicago board meeting"
}
This isn't just payment data. It's identity + consent + policy + fraud control in one verifiable package.
Merchants need to know the agent had authority. Customers need revocation controls and spending floors. Payment networks need fraud signals. Enterprises need audit trails. The mandate solves all of these at once — without requiring a human to be in the loop for every transaction.
4. Computer-Use Agents
When APIs don't exist, agents use the browser.
Computer-use agents can click buttons, fill forms, and navigate UI flows — effectively automating workflows that were never designed for programmatic access. It's fragile at scale and hard to govern, but for niche domains where building a formal API isn't cost-justified, it's a working bridge to the agentic future.
The implication: even if you haven't invested in an API layer, agents will find a way in. Better to build the surface intentionally.
5. Contextual Personalization with Memory
Traditional personalization asks: "What did this user click last week?"
Agentic personalization asks: "What is this person trying to accomplish right now, given their current context, stated constraints, historical preferences, and active policy rules?"
The architectural shift is from collaborative filtering over past behavior to intent inference over live context. This requires memory architectures, preference stores, vector search, and policy-aware recommendation layers — not just a recommendation engine.
6. Dynamic Real-Time Planning
What makes the travel scenario actually work isn't the flight booking. It's the replanning.
If the flight changes, the itinerary adjusts. If the hotel sells out, the agent finds the next best option that still satisfies the policy constraints. If an expense crosses a threshold, the workflow escalates to a human approval step.
This is orchestration with conditional branching across external state — not a linear task list. The agent manages a live plan, not a static sequence.
The Three Ways Agents Interact With Your Business
┌─────────────────────────────────────────────────────────┐
│ AGENTIC COMMERCE INTERACTION MODELS │
├─────────────────┬──────────────────┬────────────────────┤
│ AGENT-TO-SITE │ AGENT-TO-AGENT │ BROKERED A2A │
│ │ │ │
│ Customer agent │ Customer agent │ Broker agent sits │
│ visits your │ talks directly │ between customer │
│ website via │ to your business │ and multiple │
│ browser or API │ agent │ merchants │
│ │ │ │
│ Your site is a │ Negotiation and │ Your business is │
│ machine-readable│ real-time offer │ one option in │
│ decision surface│ exchange layer │ someone else's │
│ │ │ ranking system │
└─────────────────┴──────────────────┴────────────────────┘
Agent-to-site is the starting point: an agent scrapes your catalog, reads your policies, and completes checkout via your existing interface or API. Your website stops being a purely human experience and becomes a machine-readable decision surface.
Agent-to-agent is where it gets commercially interesting. Instead of scraping, the customer's agent contacts your business agent directly:
Customer agent: "I need a hotel near downtown Chicago for three nights. My traveler has Gold status. Can you improve the offer if they add breakfast?"
Merchant agent: "Yes. 12% off if breakfast is bundled and the reservation is prepaid."
That's not a chatbot interaction. That's a commerce negotiation layer — requiring access to inventory, pricing, loyalty rules, margin thresholds, fraud signals, and payment authorization.
Brokered agent-to-site is the model every product leader should be paying attention to. A third-party broker agent sits between the customer and many businesses, comparing options and recommending a transaction. Think Expedia or Instacart, but generalized across categories and powered by agents instead of static search.
If the broker owns the customer relationship, your business becomes an option in someone else's ranking function. That ranking function will score on price, availability, reliability, refund flexibility, fulfillment confidence, and API quality — not brand loyalty.
The Six Domains to Audit Right Now
Agentic commerce isn't a marketing channel upgrade. It's an infrastructure readiness problem. Here's where to look first:
1. Agent Discoverability
Your catalog needs to be legible to agents — not just humans. That means structured metadata, accurate availability signals, machine-readable policies, and programmatic access via APIs or MCPs.
SEO doesn't disappear, but the question shifts from "can Google index this?" to "can an agent confidently determine when my offer is the best fit for a user's stated intent?"
2. Loyalty and Clienteling APIs
Most loyalty systems were built for humans checking points in a mobile app. Agents need to query loyalty tier status, unused reward balances, eligible promotions, redemption rules, and personalized offers — programmatically, with proper permissioning.
If your loyalty program is human-only, agents will skip it. If it exposes clean, secured APIs, agents can actively use it to make better decisions on behalf of the customer.
3. Payment Mandates and Fraud Defense
This is the hardest surface to get right.
Recommending a product is one thing. Spending money is another. Your payment system needs to answer: who authorized this agent, what is the spending limit, what categories are allowed, when is human approval required, and how does the merchant verify the agent had authority?
The mandate structure in the AP2 spec (see JSON above) gives you a template. The implementation details — token management, revocation, fraud signal integration, audit logging — are where most teams will underestimate the work.
4. API-First Commerce Platform
If core commerce actions (search, cart, pricing, promotions, checkout, order status, returns, support escalation) live only inside a frontend, agents will struggle or fall back to fragile browser automation.
The architectural shift is from website-first commerce to capability-first commerce. The website becomes one client. Agents become another. Both consume the same underlying APIs.
5. In-Store and Physical Handoff
Agentic commerce won't stay digital. A customer agent may pre-authorize a purchase, apply a loyalty benefit, and schedule a pickup — all before the customer walks into a store. If the in-store POS can't read that agent-initiated context, the handoff breaks.
Omnichannel isn't a new idea, but agentic commerce makes agent-initiated online journeys completing in physical channels a first-class requirement rather than a nice-to-have.
6. Real-Time Fulfillment and Returns APIs
Agents will track, change, cancel, return, and escalate on behalf of customers. That requires real-time visibility into order state, inventory, shipping, return eligibility, and replacement availability.
A slow or poorly documented fulfillment API doesn't just create a bad experience — it can cost you the sale before a human customer ever sees your brand, because the broker agent ranked you lower based on fulfillment confidence.
The Market Signal Behind This
McKinsey projects that by 2030, the US B2C retail market could see up to $1 trillion in orchestrated revenue from agentic commerce, with global projections reaching $3–5 trillion.
That's not a number to build a product roadmap around directly. But it's a signal worth taking seriously when deciding whether API-first commerce infrastructure is a 2-year investment or a 5-year one.
Claude's recent releases of finance-focused and small business agents is an early indicator of how quickly vertical specialization is happening. When vertical-specific agents exist and are being actively used, your industry isn't far behind on the adoption curve.
Key Takeaways
- The customer interface is shifting from clicks to delegated intent. Agents browse, compare, negotiate, and transact on behalf of users. Your checkout button may become an artifact of the human-browsing era.
- Three interaction models define agentic commerce: agent-to-site (machine-readable storefronts), agent-to-agent (negotiation layers), and brokered agent-to-site (third-party ranking systems you don't control).
- MCP, A2A, and AP2 are the protocol foundation. These three specifications are converging to make agents interoperable, transactable, and auditable at scale.
- Payment mandates are the trust primitive. AP2 mandates combine identity, consent, policy, and fraud control into a single auditable object — the unit of authorization for autonomous purchases.
- Six audit domains matter most right now: agent discoverability, loyalty APIs, payment mandates, API-first platforms, physical POS integration, and real-time fulfillment. Falling behind on any one of them makes you invisible or low-ranked in the agentic commerce stack.
Closing CTA
If agentic commerce scales the way the protocol investment suggests, the question for most product and engineering teams isn't whether to prepare — it's which surface to expose first.
So here's what I'm curious about: If an AI agent were evaluating your system right now, what would it find hardest to interpret — your pricing, your policies, your loyalty system, or your payment layer? And is that the same problem your human customers complain about?
Drop your answer in the comments. I suspect the answer is the same surface in both cases.
Top comments (0)