Looking Ahead 18 min read

The Future of Shopping

Emerging standards and protocols that will define the next era of e-commerce.

The Vision

Imagine a world where you tell your AI assistant "I need new running shoes for my marathon next month" and it handles everything: researching options, comparing prices, checking your preferences, and completing the purchase, all while you focus on training.

This isn't science fiction. The technology exists today. What's missing is standardisation: agreed-upon ways for AI agents to interact with merchants securely and reliably.

Several standards are emerging to fill this gap. Here's what you need to know.

Emerging Protocols

Universal Commerce Protocol (UCP)
Open industry standard (ucp.dev)
Active: v2026-03 (March update)

An open standard enabling AI agents to autonomously discover, shop, and complete purchases across any merchant, without human intervention at checkout. The March 2026 update added multi-item cart sessions and standardised product catalogue access endpoints, broadening UCP beyond single-item checkout flows.

Key Features
  • Manifest discovery at /.well-known/ucp
  • 4 transports: REST, MCP, A2A, Embedded
  • AP2: autonomous agent payment mandates
  • Full checkout session lifecycle API
Agentic Commerce Protocol (ACP)
by OpenAI + Stripe
Beta: v2026-01-30

OpenAI and Stripe's open standard for AI agents to complete purchases directly within AI applications. Defines a checkout session lifecycle and delegate payment API so the agent never touches raw credentials. The v2026-01-30 release expanded Shared Payment Token (SPT) support beyond Stripe to include Mastercard Agent Pay, Visa Intelligent Commerce, Affirm, and Klarna.

Key Features
  • Checkout session lifecycle API
  • Delegate payment via Shared Payment Token
  • REST and MCP compatible
  • First impl: ChatGPT Instant Checkout
Model Context Protocol (MCP)
by Anthropic (open governance)
Active: v2025-11-25

An open protocol for connecting AI agents to external systems via tools, resources, and prompts. Widely adopted across Claude, GPT-4o, Gemini, and other AI assistants. Governance transferred to the AAIF (Anthropic AI Interoperability Foundation) under the Linux Foundation in early 2026, with 97 million monthly SDK installs.

Key Features
  • Streamable HTTP + stdio transports
  • Tools, Resources & Prompts primitives
  • OAuth 2.1 authentication
  • Tasks API for long-running operations
WebMCP
W3C Community Group (Google, Microsoft)
Chrome 146 DevTrial

A browser-native JavaScript API that lets web pages expose tools directly to AI agents, using the user's existing authenticated session. In Chrome 146 DevTrial (not Standards Track yet); W3C Community Group draft published March 2026. Microsoft and Google are principal editors.

Key Features
  • navigator.modelContext browser API
  • registerTool() for custom actions
  • Uses user's live browser session
  • No backend server required
Agent-to-Agent Protocol (A2A)
Google + Linux Foundation (AAIF)
Stable · v1.0

An open standard for AI agent interoperability — any agent can delegate tasks to specialist agents using JSON-RPC over HTTP. An agent announces its capabilities via an agent.json card at /.well-known/agent.json; orchestrating agents discover and invoke it without any bespoke integration. Reached v1.0 stable in March 2026 under Linux Foundation governance, with over 50 partners including Microsoft, SAP, and Salesforce.

Key Features
  • Agent card discovery (/.well-known/agent.json)
  • Task lifecycle: submitted → working → completed
  • SSE streaming responses
  • Multi-agent orchestration
Agentic Product Protocol (APP)
by Klarna (open spec, Apache 2.0)
Active · v1.0

Klarna's open protocol for AI-native product discovery. Merchants expose a standardised product catalogue feed or self-hosted REST endpoint; AI agents query it to compare prices, check stock, and surface results in shopping assistants and AI search.

Key Features
  • Product search & offer endpoints
  • Google Merchant Center feed compatible
  • Self-hosted or Klarna-hosted path
  • /.well-known/agentic-product-protocol.json
Trusted Agent Protocol (TAP)
by Visa (Visa Intelligent Commerce)
Active · RFC 9421

Visa's protocol for cryptographically authenticating AI agents to merchants. Agents sign every request with an Ed25519 private key; merchants verify via Visa's public JWKS endpoint. Replaces CAPTCHA-based bot detection with verifiable agent identity, resolving the merchant challenge of distinguishing legitimate agents from malicious bots.

Key Features
  • HTTP Message Signatures (RFC 9421)
  • Ed25519 & PS256 signing algorithms
  • Browsing auth + payment auth tags
  • Consumer identity & payment containers
Mastercard Verifiable Intent
Mastercard (open standard, March 2026)
Active · Open Standard

An open standard launched 5 March 2026 that allows AI agents to attach a cryptographically signed "intent token" to a payment request. The token declares the agent's identity, the scope of the purchase, and the spending mandate granted by the consumer. Merchants and payment networks can verify this intent without any prior relationship with the agent — resolving a key trust gap in autonomous commerce.

Verifiable Intent works alongside existing card rails and is network-neutral: it does not require Mastercard as the payment network, though Mastercard's Agentic Tokens programme uses it as its identity layer. The standard is maintained by Mastercard and open for adoption by any payment network.

Key Features
  • Signed intent tokens on every request
  • Agent identity + purchase scope
  • Consumer spending mandate binding
  • Network-neutral, works on existing card rails

Payment Infrastructure

Protocols define the handshake between agent and merchant, but they don't solve custody of the payment credentials themselves. A new category of agentic payment infrastructure is emerging to fill that gap, handling the secure storage, tokenisation, and routing of payment details on behalf of AI agents.

Plain English · How tokenisation works

Your card number is sensitive. A 16-digit primary account number (PAN) is the key to your money, and handing it to every merchant, agent, and payment service that touches a transaction is a security problem waiting to happen.

Tokenisation solves this by substituting your real card number with a random stand-in. The real number goes into a secure vault once. Everything outside the vault (merchants, AI agents, payment processors) only ever sees the token. The token looks like a card number but it is not one. On its own it is useless.

4111 1111 1111 1111
your real card
🔒 secure vault
PCI-DSS vaulted
9847 3621 0054 7823
token (worthless alone)

Think of it like a valet key. You hand the valet a key that starts the car and opens the door, but not the boot and not the glove box. If the valet loses it, you deactivate that key without touching anything else. Your master key never left your pocket.

In agentic commerce this matters a lot. An AI agent shopping on your behalf never sees your card number. If the agent is compromised, or a merchant's database is breached, the attacker gets a token that cannot be used anywhere else. Modern network tokens go further: each transaction gets its own short-lived cryptogram, so a stolen token from one purchase is useless for another. You can revoke a token at any time, cutting off an agent's spending authority without cancelling your card.


What actually happens when a token is used

A token alone cannot complete a purchase. Each transaction also needs a cryptogram: a one-time code, generated fresh for that specific payment and valid for a matter of seconds. The agent (or your phone) sends both together. Here is what happens next:

1
Agent or device
Sends token + cryptogram to the merchant's payment form or API. Your real card number is never involved.
2
Merchant
Passes the token and cryptogram straight to their payment processor. They store nothing sensitive.
3
Payment processor / acquirer
Routes the transaction to the card network (Visa or Mastercard) just as they would any card payment.
4
Visa or Mastercard ← key step
This is where detokenisation happens. Visa and Mastercard are the ones who hold the vault. They look up the real card number, verify the cryptogram is valid, and only then forward the real PAN to your bank. Nobody else in the chain ever sees it.
5
Your bank (issuer)
Sees a completely normal card transaction. Approves or declines based on your balance, fraud rules, and spending limits.
6
Response travels back
Approval or decline goes back through the same path in milliseconds. The merchant and agent see the outcome, never the card details.

Is this the same as Apple Pay or Google Pay?

Yes, exactly the same. When you add a card to Apple Pay, Visa or Mastercard generate a Device Account Number (DAN) specifically for your phone and store it in the Secure Enclave chip. When you tap to pay, Face ID or Touch ID triggers the generation of a transaction cryptogram. The terminal receives the DAN and cryptogram, not your card. The network flow above runs identically.

With an AI agent the mechanics are the same. The difference is what unlocks the cryptogram. On a phone it is your fingerprint or face. With an agent it is the spending mandate you granted ("up to £50 per transaction on groceries"), stored in the payment infrastructure (PayOS, VGS, Skyfire). The card network processes it exactly as it would an Apple Pay tap. Your bank cannot tell the difference.

The products below are all variations on this pattern: they differ mainly in where the token lives (agent-side or merchant-side) and who generates the cryptogram. Tokenisation answers the credential security question. It does not answer a separate one: is the agent presenting the token actually authorised to spend? That is what agent identity networks like Know Your Agent address.

nekuda (nekuda.ai)
Backed by Visa Ventures & Amex Ventures
Live · Merchant SDK

Merchant-side agentic payment infrastructure. Merchants embed a hosted iframe from collect.nekuda.ai for PCI-compliant card collection, which the nekuda wallet then stores and makes available to authorised AI agents at checkout.

nekuda implements the ACP checkout gateway pattern: merchants expose a /checkout_sessions endpoint that agents call to initiate a purchase. The checkout.directory registry currently lists over 50 participating merchants, including Allbirds, Gymshark, Glossier, Everlane, Away, and Brooklinen. Presence in that registry is the primary signal an agent can use to confirm a merchant supports agentic checkout via nekuda.

Because the integration requires a merchant-side SDK (@nekuda/wallet for React frontends, @nekuda/nekuda-js or the nekuda Python package on the backend), the integration is detectable by scanning for the iframe origin, public keys, or well-known paths. Aidō Lighthouse checks for these signals as part of its agentic readiness assessment.

Key Features
  • Hosted iframe for PCI-compliant card collection
  • ACP /checkout_sessions gateway pattern
  • checkout.directory merchant registry
  • React, Node.js & Python SDKs
PayOS (payos.ai)
Partners: Mastercard & Visa, VGS vault
Live · No Merchant Changes

Agent-side payment infrastructure that requires no changes on the merchant. PayOS provisions an AI agent with a virtual card (an "agentic token") backed by Mastercard's Agentic Tokens programme and Visa Intelligent Commerce. From the merchant's perspective, the transaction arrives as a normal card payment; there is no SDK to install, no checkout session endpoint to expose, and no registry to join.

PayOS uses Visa's Trusted Agent Protocol (TAP) to sign agent requests with RFC 9421 HTTP Message Signatures, giving merchants a cryptographic way to verify the agent's identity without any pre-integration. VGS (Very Good Security) handles PCI vaulting of the underlying card credentials. Mastercard completed its first live agentic token transaction in September 2025, marking a significant milestone for card-native agentic payments.

The split between nekuda and PayOS represents a broader architectural choice facing the industry: merchant-side readiness (where the merchant opts in and gains richer agent integration) versus agent-side infrastructure (where the agent operates independently of merchant support). In practice, both approaches are likely to coexist, and an agent may prefer nekuda on merchants that support it while falling back to PayOS elsewhere.

Key Features
  • No merchant SDK or integration required
  • Mastercard Agentic Tokens + Visa IC
  • TAP RFC 9421 request signing
  • VGS PCI vaulting
Machine Payments Protocol (MPP)
by Stripe + Tempo (18 March 2026)
Active · Open Standard

Stripe and Tempo's open protocol for AI agents to authorise and settle payments via a structured API message, independent of any particular checkout session. Where ACP defines the full checkout lifecycle (cart, address, review, pay), MPP handles just the payment authorisation step — a single structured request that Stripe routes and settles through its existing network.

MPP is designed to be composable: an agent running ACP on a participating merchant uses ACP end-to-end; on a merchant without ACP support, the agent can use MPP for the payment step alone. The protocol includes agent spending mandates (per-transaction and daily limits), revocation, and an audit log endpoint so consumers can review what an agent spent on their behalf.

Key Features
  • Structured payment authorisation API
  • Composable with ACP checkout sessions
  • Agent spending mandates + revocation
  • Consumer audit log endpoint
x402 Protocol
by Coinbase + Cloudflare (open spec)
Emerging · Open Spec

Repurposes the HTTP 402 Payment Required status code for machine-to-machine stablecoin micropayments. When an agent requests a resource or API endpoint, the server responds with 402 and a payment URI; the agent pays in USDC (or another stablecoin) on-chain and retries the request with a payment proof header. The server verifies the on-chain transaction and fulfils the request.

Designed for pay-per-call AI APIs and autonomous agent economies where traditional subscription billing is impractical. An agent researching products could pay fractions of a cent for each data request without a pre-existing account. Cloudflare has added native x402 support to its edge network, making it trivially deployable for any site behind Cloudflare.

Key Features
  • HTTP 402 payment flow, no pre-registration
  • USDC + stablecoin settlement on-chain
  • Cloudflare edge-native support
  • Pay-per-call AI API access
VGS (Very Good Security)
verygoodsecurity.com · Visa Preferred Partner
Live · PCI-DSS Vault

VGS is the world's largest payment tokenisation provider and the PCI vaulting layer behind PayOS and Visa Intelligent Commerce. Its core role is simple: raw card numbers go in, tokens come out. Merchants and agents only ever handle those tokens, so a data breach exposes nothing sensitive. VGS estimates that agentic AI spending will reach $155 billion by 2030, with $250 billion in payments exposed to disruption from the shift to agent-driven commerce.

For agentic commerce specifically, VGS offers four capabilities that matter. Agentic Autofill lets AI agents securely fill payment fields using a pre-authorised token, with VGS inserting the raw credentials server-side before the transaction reaches the card network. Collect MCP UI embeds a VGS-hosted iframe directly inside an agentic prompt, capturing card details without the agent or merchant ever touching the raw PAN — keeping both firmly out of PCI scope. Network Token Management provisions Visa and Mastercard network tokens on behalf of agents, so each transaction uses a short-lived cryptogram that is useless to replay. API Pass-Through proxies payment API calls transparently, applying data security transforms at the edge so merchants can send and receive payment data without storing it themselves.

Because VGS sits behind several major agentic payment products (including PayOS and Visa's own token infrastructure), a merchant that has never heard of VGS may already be using it indirectly. Aidō Lighthouse scans for VGS signals including the vgs-collect.js SDK, cross-frame card-created events, and references to the VGS agent toolkit.

Key Features
  • Collect MCP UI: iframe card capture inside agent prompts
  • Network token provisioning for Visa & Mastercard
  • Agentic Autofill via server-side credential injection
  • Merchant and agent both stay out of PCI scope
Know Your Agent (KYA)
knowyouragent.xyz · Social Protocol Labs, San Jose
Beta · Pre-credentialing Network

A pre-credentialing and reputation network for autonomous AI agents, addressing the trust problem that tokenisation alone does not solve: even a valid payment token says nothing about whether the agent presenting it has permission to spend. KYA verifies operator identity, spending authorisation, and transaction history in under 100ms, returning a trust score (accept, review, or decline) that the merchant can act on before any payment is attempted.

An agent registers with KYA before it starts transacting. At checkout, it presents a KYA credential alongside its payment token, analogous to a CVV but for agent identity. The merchant queries KYA's API; if a consumer later contests a charge, the record of the agent's authorisation is already there. IDC and Microsoft project 1.3 billion AI agents in active use by 2028; McKinsey estimates $3–5 trillion in agentic commerce by 2030. A Shopify integration is in development.

KYA and VGS solve complementary problems. VGS handles credential security: the card number never leaves the vault. KYA handles identity trust: the agent presenting the token is who it claims to be. Together they cover both halves of agentic payment security.

Key Features
  • Agent identity + reputation verified in <100ms
  • Trust score: accept / review / decline
  • Pre-dispute system catches fraud before chargebacks
  • Shopify integration in development
Skyfire KYA/PAY
skyfire.xyz · Know Your Agent + Payments
Live · Header-based

Skyfire collapses two problems into one: proving who an agent is (KYA, Know Your Agent) and authorising it to spend (PAY). Before an agent starts shopping, the user pre-authorises a Skyfire spending wallet with configurable limits — per-merchant caps, daily totals, per-transaction maximums. The agent then attaches a single signed x-kyapay JWT to its request headers.

From the merchant's side, verifying the token is a single call to Skyfire's JWKS endpoint, taking milliseconds. There is no redirect to a payment page, no SMS one-time password, no 3DS popup, and no account creation. The token encodes the agent's identity, the spending mandate, and a cryptographic proof that the user granted it — all in one place. Merchants who verify it get a payment they know is authorised; merchants who do not verify it can still receive the payment through normal card rails with the spending wallet acting like a standard virtual card.

This makes Skyfire particularly attractive for high-frequency agent commerce, where traditional authentication flows would make autonomous purchasing impractical. Aidō Lighthouse scans for Skyfire signals including x-kyapay header references in HTML and JavaScript, and the /.well-known/skyfire discovery endpoint.

Key Features
  • Single x-kyapay header: identity + spend authorisation
  • Pre-authorised wallet with user-defined spend limits
  • JWKS-based merchant verification, no redirect
  • Falls back to virtual card on non-Skyfire merchants

How They Work Together

These protocols are not competing; they serve different purposes and can work together:

Discovery
UCP + Schema.org
How agents find and identify merchants
Interaction
MCP + WebMCP + A2A
How agents communicate with your site and each other
Verification
Visa TAP
How merchants verify agents are who they claim to be
Transaction
UCP + ACP
How agents complete purchases securely

Security First

A major focus of these protocols is ensuring AI commerce is secure. Key principles:

Delegated Payments
AI agents never see card numbers. Payments are tokenized.
User Consent
Agents act with explicit permission. Users approve transactions.
OAuth Authentication
Secure, scoped access. Only needed permissions.
Signed Webhooks
All communications cryptographically signed.

What to Expect

2024 Foundation Year

AI assistants become mainstream. Early adopters start optimising for AI discovery.

2025 Standards Emerge

UCP, MCP, ACP, A2A, and WebMCP draft published. Mastercard completes first live agentic token transaction. First wave of AI-native commerce.

2026 Standards Consolidate

A2A v1.0 stable (March), Mastercard Verifiable Intent launched (March), MPP open spec (March), x402 Cloudflare-native. First wave of autonomous agent purchases at scale.

2030 AI Commerce Era

AI agents handle majority of routine purchases. Human browsing becomes discovery-focused.

What This Means For You

Early Adopters Win

Businesses that prepare now will capture AI-driven traffic while competitors scramble to catch up.

Start with Basics

You don't need to implement every protocol. Start with Schema.org, robots.txt, and good APIs; these form the foundation.

Stay Informed

These standards are evolving. Follow developments and be ready to adopt as they mature.

Learn More

Future-Proof Your Business Today

See where you stand and get personalised recommendations for improving your AI readiness.

Join the Beta
What is Agentic Commerce?