Agentic Commerce Enablement | ForkPoint

MCP 2026 Release Candidate Explained

Fri, 22 May 2026 09:00:00 GMT

On May 21, 2026, the Model Context Protocol (MCP) maintainers locked the release candidate for the largest specification update since the protocol launched. The final spec ships July 28, 2026, with a ten-week validation window for SDK and client teams.

If your business has invested in MCP — or is evaluating it — this release is the one that takes MCP from a fast-moving early standard to a stable foundation enterprises can commit to. This article explains what changed, why it matters commercially, and what your team should do next.

A One-Paragraph Refresher

MCP is the standard interface AI assistants use to connect to business software. Before MCP, every AI vendor needed a custom integration with every system — your CRM, catalog, ticketing tool, data warehouse. MCP collapses that into a single protocol, the same way USB-C collapsed a dozen device cables into one.

<div className="not-prose my-10 rounded-2xl border border-border bg-light p-6 sm:p-8"> <div className="flex flex-col items-center"> <div className="rounded-xl bg-primary px-6 py-4 text-center text-white shadow-lg"> <div className="text-xs font-bold uppercase tracking-wider opacity-80">Client</div> <div className="mt-1 text-lg font-bold">AI assistant</div> <div className="text-xs opacity-80">Claude · Copilot · agents</div> </div> <div className="my-3 flex flex-col items-center text-xs text-text-light"> <div className="h-6 w-px bg-primary/40"></div> <div className="rounded-full border border-primary/30 bg-white px-3 py-1 font-mono">speaks MCP</div> <div className="h-6 w-px bg-primary/40"></div> </div> <div className="grid w-full grid-cols-2 gap-3 sm:grid-cols-4"> {[ { name: "CRM", sub: "Salesforce" }, { name: "Slack", sub: "messaging" }, { name: "Catalog", sub: "product data" }, { name: "GitHub", sub: "code · issues" }, ].map((s) => ( <div className="rounded-lg border border-border bg-white p-4 text-center shadow-sm"> <div className="text-xs font-bold uppercase tracking-wider text-text-light">Server</div> <div className="mt-1 text-base font-semibold text-text-dark">{s.name}</div> <div className="text-xs text-text-light">{s.sub}</div> </div> ))} </div> <p className="mt-4 text-center text-sm italic text-text-light">Each system exposes an MCP server. One protocol, every integration.</p> </div> </div>

The AI is the client. Your system is the server. They communicate over MCP.

Why This Release Is Different

MCP's first version shipped quickly and gained adoption faster than its authors expected. Several design choices that worked for prototypes and single-server deployments became friction at production scale. This release rewrites those choices for the realities of enterprise infrastructure: load balancers, multi-region deployments, security audits, long-running jobs, and a 12-month deprecation contract that lets buyers plan.

In short: MCP moved from an early standard worth experimenting with to a stable platform worth standardizing on.

1. Stateless Protocol Core

What changed. The previous spec required a session handshake: the client opened a session, the server issued a session ID, and every subsequent request had to return to that specific server instance. The new spec removes the handshake entirely. Each request carries the metadata the server needs in a small _meta envelope. Any server instance can handle any request.

<div className="not-prose my-10 grid gap-4 md:grid-cols-2"> <div className="rounded-2xl border-2 border-red-200 bg-red-50 p-6"> <div className="mb-4 flex items-center gap-2"> <span className="rounded-full bg-red-500 px-3 py-1 text-xs font-bold uppercase tracking-wider text-white">Before</span> <span className="text-sm font-semibold text-red-700">Stateful sessions</span> </div> <div className="space-y-2 font-mono text-sm"> <div className="flex items-center justify-between gap-3 rounded-md bg-white px-3 py-2 shadow-sm"><span className="text-text-dark">Client</span><span className="text-text-light">→ initialize</span><span className="text-text-dark">Server #1</span></div> <div className="flex items-center justify-between gap-3 rounded-md bg-white px-3 py-2 shadow-sm"><span className="text-text-dark">Client</span><span className="text-text-light">← session_id</span><span className="text-text-dark">Server #1</span></div> <div className="flex items-center justify-between gap-3 rounded-md bg-white px-3 py-2 shadow-sm"><span className="text-text-dark">Client</span><span className="text-text-light">→ request (sid)</span><span className="text-text-dark">Server #1</span></div> <div className="flex items-center justify-between gap-3 rounded-md bg-white px-3 py-2 shadow-sm"><span className="text-text-dark">Client</span><span className="text-text-light">← response</span><span className="text-text-dark">Server #1</span></div> </div> <p className="mt-4 text-sm font-medium text-red-700">⚠ Traffic locked to one server. Sticky session infrastructure required.</p> </div>

<div className="rounded-2xl border-2 border-emerald-200 bg-emerald-50 p-6"> <div className="mb-4 flex items-center gap-2"> <span className="rounded-full bg-emerald-600 px-3 py-1 text-xs font-bold uppercase tracking-wider text-white">After</span> <span className="text-sm font-semibold text-emerald-700">Stateless</span> </div> <div className="space-y-2 font-mono text-sm"> <div className="flex items-center justify-between gap-3 rounded-md bg-white px-3 py-2 shadow-sm"><span className="text-text-dark">Client</span><span className="text-text-light">→ request + _meta</span><span className="text-text-dark">Server A</span></div> <div className="flex items-center justify-between gap-3 rounded-md bg-white px-3 py-2 shadow-sm"><span className="text-text-dark">Client</span><span className="text-text-light">→ request + _meta</span><span className="text-text-dark">Server B</span></div> <div className="flex items-center justify-between gap-3 rounded-md bg-white px-3 py-2 shadow-sm"><span className="text-text-dark">Client</span><span className="text-text-light">→ request + _meta</span><span className="text-text-dark">Server N</span></div> <div className="flex items-center justify-between gap-3 rounded-md bg-white px-3 py-2 shadow-sm"><span className="text-text-dark">Client</span><span className="text-text-light">← response</span><span className="text-text-dark">any</span></div> </div> <p className="mt-4 text-sm font-medium text-emerald-700">✓ Load balancer routes anywhere. Horizontal scaling. Failover by default.</p> </div> </div>

Business impact. Sticky sessions are expensive. They constrain how you deploy, complicate failover, and limit horizontal scaling. Removing them means MCP servers can run behind standard load balancers, deploy across regions, and scale the way the rest of your web infrastructure already does. Lower hosting cost, simpler operations, faster failure recovery.

For workloads that genuinely need continuity (a multi-step checkout, a long-running analysis), the spec defines an explicit-handle pattern: the server returns an opaque identifier the client passes back on subsequent calls. State lives in your database — where it should — rather than in server memory.

2. First-Class Extensions Framework

What changed. Extensions are now part of the protocol, not a workaround. Each extension has a reverse-DNS identifier (com.acme.feature), an independent version, and its own maintainers. Two official extensions ship alongside the core:

MCP Apps — servers can render real HTML interfaces inside the AI client (sandboxed, prefetched, cached). The AI is no longer limited to chat-style responses.
Tasks — a standard for long-running work (large report generation, codebase scans, batch operations) that no longer requires holding an open connection.

<div className="not-prose my-10 rounded-2xl border border-border bg-light p-6 sm:p-8"> <div className="rounded-xl bg-gradient-to-r from-primary to-cyan-500 p-6 text-white shadow-lg"> <div className="text-xs font-bold uppercase tracking-widest opacity-80">Stable Foundation</div> <div className="mt-1 text-2xl font-bold">MCP Core Specification</div> <div className="mt-2 text-sm opacity-90">request/response · auth · schema · errors</div> <div className="mt-3 inline-block rounded-full bg-white/20 px-3 py-1 text-xs font-medium">12-month deprecation policy</div> </div>

<div className="my-4 flex justify-center"> <div className="text-xs font-semibold uppercase tracking-wider text-text-light">— extends —</div> </div>

<div className="grid gap-4 md:grid-cols-3"> <div className="rounded-xl border-2 border-cyan-400 bg-white p-5"> <div className="mb-2 inline-block rounded-full bg-cyan-100 px-2 py-0.5 text-xs font-bold uppercase text-cyan-700">Official</div> <div className="text-lg font-bold text-text-dark">MCP Apps</div> <p className="mt-1 text-sm text-text-light">Server-rendered UI inside the AI client (sandboxed iframe, prefetched, cached).</p> </div> <div className="rounded-xl border-2 border-cyan-400 bg-white p-5"> <div className="mb-2 inline-block rounded-full bg-cyan-100 px-2 py-0.5 text-xs font-bold uppercase text-cyan-700">Official</div> <div className="text-lg font-bold text-text-dark">Tasks</div> <p className="mt-1 text-sm text-text-light">Long-running jobs with an async lifecycle — no held-open connections.</p> </div> <div className="rounded-xl border-2 border-dashed border-purple-400 bg-white p-5"> <div className="mb-2 inline-block rounded-full bg-purple-100 px-2 py-0.5 text-xs font-bold uppercase text-purple-700">Custom</div> <div className="text-lg font-bold text-text-dark">com.acme.x</div> <p className="mt-1 text-sm text-text-light">Your vertical extension. Independently versioned. Can graduate into core.</p> </div> </div> </div>

Business impact. You are no longer blocked on the core working group to add capabilities your industry needs. Verticals — commerce, healthcare, financial services — can ship extensions that codify their workflows, gather adoption, and graduate into the core spec if successful. This is how mature standards (HTTP, OAuth, USB) evolve, and it is the mechanism that lets MCP grow without breaking what already works.

3. Hardened Authorization

What changed. Six Security Enhancement Proposals (SEPs) tighten alignment with OAuth 2.0 and OpenID Connect. The most consequential:

Servers must validate the iss (issuer) parameter per RFC 9207, closing a known token-substitution attack class.
Clients must declare their application_type during Dynamic Client Registration so servers apply the correct security policy.
Clarified rules for issuer binding, refresh tokens, scope accumulation, and .well-known discovery.

<div className="not-prose my-10 rounded-2xl border border-border bg-light p-6 sm:p-8"> <div className="mb-4 grid grid-cols-3 gap-3 text-center"> <div className="rounded-lg bg-primary px-3 py-2 text-sm font-bold text-white">Client</div> <div className="rounded-lg bg-primary px-3 py-2 text-sm font-bold text-white">Auth Server</div> <div className="rounded-lg bg-primary px-3 py-2 text-sm font-bold text-white">MCP Server</div> </div> <div className="space-y-2 font-mono text-xs sm:text-sm"> <div className="rounded-md bg-white px-4 py-2 shadow-sm"><span className="text-text-light">1.</span> Client <span className="text-primary">→</span> Auth Server: <span className="text-text-dark">register (application_type)</span></div> <div className="rounded-md bg-white px-4 py-2 shadow-sm"><span className="text-text-light">2.</span> Auth Server <span className="text-primary">→</span> Client: <span className="text-text-dark">client_id</span></div> <div className="rounded-md bg-white px-4 py-2 shadow-sm"><span className="text-text-light">3.</span> Client <span className="text-primary">→</span> Auth Server: <span className="text-text-dark">authorization request</span></div> <div className="rounded-md bg-white px-4 py-2 shadow-sm"><span className="text-text-light">4.</span> Auth Server <span className="text-primary">→</span> Client: <span className="text-text-dark">code + iss</span></div> <div className="rounded-md bg-white px-4 py-2 shadow-sm"><span className="text-text-light">5.</span> Client <span className="text-primary">→</span> Auth Server: <span className="text-text-dark">exchange code → access_token</span></div> <div className="rounded-md bg-white px-4 py-2 shadow-sm"><span className="text-text-light">6.</span> Client <span className="text-primary">→</span> MCP Server: <span className="text-text-dark">request + access_token</span></div> </div> <div className="mt-4 rounded-xl border-2 border-amber-400 bg-amber-50 p-4"> <div className="mb-2 text-sm font-bold uppercase tracking-wider text-amber-800">MCP Server validates</div> <ul className="grid gap-1 text-sm text-amber-900 sm:grid-cols-2"> <li>✓ token signature</li> <li>✓ audience</li> <li>✓ scope sufficient</li> <li className="font-bold">✓ iss matches expected <span className="ml-2 rounded-full bg-amber-600 px-2 py-0.5 text-xs uppercase text-white">new · RFC 9207</span></li> </ul> </div> </div>

Business impact. Enterprise security reviews are where AI integrations go to die. By aligning with the same OAuth and OIDC standards already approved by most enterprise security teams, MCP integrations now clear procurement faster. If you sell to regulated industries — finance, healthcare, government — this is the change that makes deals close.

4. Deprecation Policy and Removed Features

Three core features enter formal deprecation with a guaranteed twelve-month transition window before removal.

Feature	What it did	Replacement
Roots	Indicated which "folders" the client cared about	Tool parameters, resource URIs, or server configuration
Sampling	Let the server request LLM generations from the client	Direct LLM provider API integration
Logging	Streamed log messages over the protocol	`stderr` for local processes; OpenTelemetry for observability

Business impact. A published deprecation policy is what separates a research project from an industry standard. Procurement teams, CTOs, and architecture review boards need a multi-quarter horizon before they commit. The 12-month minimum gives every downstream team room to plan migrations on their own roadmap rather than scrambling against a surprise breaking change.

5. Schema and Standards Updates

A set of focused improvements that compound into a meaningfully better protocol:

Tool schemas now support full JSON Schema 2020-12, including conditionals (if/then/else) and composition (allOf, oneOf). Tool authors can finally express rules like "if shipping option A is selected, a phone number is required."
Error code for missing resources moved from custom -32002 to the standard JSON-RPC -32602 — generic tooling now works without MCP-specific patches.
Trace Context propagation is formally documented with fixed _meta keys. Distributed failures are now debuggable across long chains of MCP servers.
New Mcp-Method and Mcp-Name headers let load balancers and API gateways route requests without parsing the body — lower latency, lower infrastructure cost.
New response fields ttlMs and cacheScope let CDNs and proxies cache MCP responses correctly, with explicit lifetime and sharing semantics.

Business impact. Each of these closes a small gap that previously required custom workarounds. Collectively, they remove most of the "MCP-specific tooling" overhead — your existing API gateway, CDN, observability platform, and JSON-RPC libraries now work without adaptation. That is a real, recurring cost reduction.

6. Multi Round-Trip Requests

What changed. When a server needs additional input mid-request (a confirmation, a missing parameter, a credential), it previously held the connection open with Server-Sent Events. That pattern fails under stateless load balancing because the second message might land on a different server. The new pattern returns an InputRequiredResult containing the requests and an opaque requestState. The client gathers the responses and re-issues the call with the echoed state — any server can resume.

<div className="not-prose my-10 space-y-4"> <div className="rounded-2xl border border-border bg-white p-5 shadow-sm"> <div className="mb-3 flex items-center gap-3"> <span className="rounded-full bg-primary px-3 py-1 text-xs font-bold uppercase tracking-wider text-white">Step 1</span> <span className="text-sm font-semibold text-text-dark">Initial request → Server A responds with checkpoint</span> </div> <div className="space-y-2 font-mono text-sm"> <div className="rounded-md bg-light px-4 py-2"><span className="text-primary">Client</span> → <span className="text-text-dark">Server A</span>: <span className="text-text-light">"delete record X"</span></div> <div className="rounded-md bg-amber-50 px-4 py-2"><span className="text-primary">Client</span> ← <span className="text-text-dark">Server A</span>: <span className="text-amber-700">"need confirmation + requestState"</span></div> </div> </div>

<div className="rounded-2xl border-2 border-dashed border-amber-300 bg-amber-50 p-5"> <div className="flex items-center gap-3"> <span className="rounded-full bg-amber-600 px-3 py-1 text-xs font-bold uppercase tracking-wider text-white">Step 2</span> <span className="text-sm font-semibold text-amber-800">Client gathers user confirmation — minutes, hours, or days</span> </div> </div>

<div className="rounded-2xl border border-border bg-white p-5 shadow-sm"> <div className="mb-3 flex items-center gap-3"> <span className="rounded-full bg-emerald-600 px-3 py-1 text-xs font-bold uppercase tracking-wider text-white">Step 3</span> <span className="text-sm font-semibold text-text-dark">Resume on any server — state travels with the request</span> </div> <div className="space-y-2 font-mono text-sm"> <div className="rounded-md bg-light px-4 py-2"><span className="text-primary">Client</span> → <span className="text-text-dark">Server B</span>: <span className="text-text-light">"resume: inputResponses + requestState"</span></div> <div className="rounded-md bg-emerald-50 px-4 py-2"><span className="text-primary">Client</span> ← <span className="text-text-dark">Server B</span>: <span className="text-emerald-700">"deleted ✓"</span></div> </div> <p className="mt-3 text-sm italic text-text-light">Server B completes work Server A started. All state in the echoed blob.</p> </div> </div>

Business impact. Long-running, multi-step interactions (approvals, escalations, human-in-the-loop workflows) no longer require expensive session affinity infrastructure. Combined with the Tasks extension, this is the foundation for production-grade agentic workflows that span minutes, hours, or days.

Governance: How MCP Now Evolves

The release introduces three governance mechanisms that determine how the protocol changes going forward:

Feature Lifecycle Policy — every feature moves through Active → Deprecated → Removed, with a minimum 12-month deprecation window. Predictable for buyers, fair to implementers.
Extensions framework as the official on-ramp — new capabilities ship as opt-in extensions first, prove themselves, then graduate into core.
Conformance requirements — Standards Track proposals must ship with matching scenarios in the conformance suite. The spec is now testable, not just describable.

This is the governance maturity that distinguishes a long-lived industry standard from a fast-moving project. It is the precondition for serious enterprise commitment.

Release Timeline

<div className="not-prose my-10 rounded-2xl border border-border bg-light p-6 sm:p-8"> <div className="grid gap-4 md:grid-cols-3"> <div className="rounded-xl border-l-4 border-emerald-500 bg-white p-5 shadow-sm"> <div className="text-xs font-bold uppercase tracking-wider text-emerald-600">2026-05-21</div> <div className="mt-1 text-lg font-bold text-text-dark">Release candidate locked</div> <p className="mt-2 text-sm text-text-light">10-week validation window begins. SDK and client teams ship updates.</p> </div> <div className="rounded-xl border-l-4 border-primary bg-white p-5 shadow-sm"> <div className="text-xs font-bold uppercase tracking-wider text-primary">2026-07-28</div> <div className="mt-1 text-lg font-bold text-text-dark">Final specification</div> <p className="mt-2 text-sm text-text-light">Spec frozen. Tier-1 SDKs (Python, TypeScript) ship support.</p> </div> <div className="rounded-xl border-l-4 border-red-500 bg-white p-5 shadow-sm"> <div className="text-xs font-bold uppercase tracking-wider text-red-600">2027-07-28</div> <div className="mt-1 text-lg font-bold text-text-dark">Deprecated features removed</div> <p className="mt-2 text-sm text-text-light">Roots, Sampling, Logging exit the core spec. 12-month window closes.</p> </div> </div> </div>

Anthropic's Tier 1 SDKs (Python, TypeScript, and others) are expected to ship support within the validation window. Most businesses building on those SDKs will receive the upgrade as part of a routine dependency bump.

What to Do Now

If you operate an MCP server today (product catalog, CRM connector, internal data access):

Migrate off initialize / Mcp-Session-Id to the new _meta envelope.
Move per-session state into your database using the explicit-handle pattern.
Add Roots, Sampling, and Logging to your deprecation roadmap.
Audit your OAuth implementation against the six new SEPs before your next security review.
Upside: drop sticky-session infrastructure, scale horizontally, clear enterprise security reviews faster.

If you consume MCP servers (you build AI assistants, agents, or internal copilots):

Upgrade to the SDK release that adopts the new spec; most migration work is handled there.
Evaluate the new capabilities — MCP Apps for rich UI surfaces, Tasks for long-running jobs, full JSON Schema for richer tool definitions.
Expect lower infrastructure cost and better debuggability from the new tracing and caching primitives.

If you are a commerce or enterprise leader evaluating protocols:

MCP has crossed the line from interesting standard to production-grade infrastructure.
The full agentic stack is now clear: MCP for tool access, A2A for agent-to-agent workflows, UCP for consumer commerce. Each layer is independently maturing. (We covered the full landscape in our executive guide to MCP and A2A.)
The "wait and see" window has effectively closed. Competitors who began adoption during the experimental phase now have a 12-to-18-month head start on tooling, internal expertise, and integration partnerships.

Bottom Line

The 2026-07-28 release candidate is MCP's transition from early standard to durable platform. It trades the convenience of stateful sessions for the economics of stateless infrastructure, opens the protocol to vertical extensions, hardens security to enterprise standards, and commits to a deprecation policy that allows multi-year planning.

For builders, the migration is well-scoped: upgrade the SDK, retire deprecated features over twelve months, audit OAuth. For business leaders, the signal is clearer: the protocol is no longer a moving target, and the cost of waiting now exceeds the cost of acting.

If your team is scoping MCP adoption — or revisiting an earlier implementation in light of these changes — our team can help you plan the migration, evaluate the new extension capabilities, and avoid the common pitfalls.

Top 5 E-Commerce Platforms for AI Shopping Agents

Sun, 05 Apr 2026 09:00:00 GMT

Not all e-commerce platforms are created equal in the age of AI. Some are still trapped in the "eyeball economy," optimizing for clicks and page views. Others have recognized that the future of commerce is autonomous.

We’ve evaluated the major players based on their readiness for Agentic Commerce—specifically their support for structured discovery, real-time inventory for bots, and standardized checkout protocols like UCP.

Here are the top 5 platforms for AI shopping agents in 2026.

1. Shopify Plus (Native Ready)

Shopify has moved the fastest. By integrating native support for AI-driven commerce early, they’ve made it easy for their merchants to show up in "Google AI Mode" and ChatGPT's shopping features.

Grade: A
Why: Lower barrier to entry; "it just works."

2. Salesforce Commerce Cloud (Enterprise Lead)

SFCC doesn't have native UCP support yet, but it holds the #2 spot because of the ecosystem. With the availability of the ForkPoint UCP Cartridge, enterprise brands on SFCC can transform their powerful backends into Agentic Storefronts faster than almost any other legacy platform.

Grade: A- (with Cartridge)
Why: Robustness and the ability to handle complex, high-volume agentic traffic.

3. BigCommerce (The Follower)

BigCommerce has announced intent to support open commerce protocols, but the implementation is still rolling out. It remains a strong contender for mid-market brands who want more flexibility than Shopify but less complexity than SFCC.

Grade: B
Why: Strong API-first approach, though native agentic features are still maturing.

4. Custom Headless (Vercel / Next.js)

Headless stacks are theoretically the most "ready" because they are pure APIs. However, being headless isn't the same as being agentic. You still have to map your custom APIs to the UCP standard.

Grade: B-
Why: High flexibility, but requires significant engineering to build the Agentic layer manually.

5. Adobe Commerce (The Laggard)

Adobe is currently focused on its proprietary "LLM Optimizer." While powerful, its focus on a closed ecosystem makes it harder for merchants to reach all agents compared to platforms embracing open standards.

Grade: C+
Why: High "visibility" potential within Adobe's partners, but limited transaction autonomy across the broader AI landscape.

Summary: How to Choose

The best platform isn't necessarily the one with the most features; it’s the one that lets you be transactable wherever the buyer is—whether that's a browser, a voice assistant, or a shopping agent.

Curious where your platform stands? Take our Agentic Readiness Assessment.

Agentic Storefront vs. Salesforce Einstein Service Agent: Which handles commerce better?

Thu, 02 Apr 2026 09:00:00 GMT

Salesforce has gone all-in on "Agentforce," positioning Einstein Service Agent as the future of customer interaction. It’s a powerful, conversational AI designed to handle support tickets, answer product questions, and guide users through a site.

But is a smarter chatbot the same as an Agentic Storefront?

Not quite. While Salesforce focuses on the conversation, the Agentic Storefront narrative (powered by UCP) focuses on the transaction. Here is the breakdown of how they differ and which one your business actually needs.

Salesforce Einstein: The Conversational Layer

Einstein is a "Copilot." It lives on your website and waits for a human to show up and ask a question. It’s designed to improve the User Experience (UX).

Strength: Excellent for high-touch customer service and guiding a human shopper who is already on your site.
Weakness: It doesn't solve the "Zero-Click" problem. If the user is on ChatGPT or Gemini and never visits your site, Einstein never gets the chance to speak to them.

Agentic Storefront: The Transaction Layer

An Agentic Storefront is designed for Agent Experience (AX). It doesn't wait for a human to visit your site. It exposes your store to the AI agents that humans use off-site.

Strength: It enables autonomous agents (external to your site) to discover your inventory and complete a purchase without human intervention.
Weakness: It is a protocol, not a personality. It doesn't "chat"; it transacts.

The Core Difference: Bot vs. Agent

The industry often confuses "Bots" with "Agents."

A Bot (Einstein) helps a human do a task on a website.
An Agent (Agentic Storefront/UCP) does the task for the human, wherever that human happens to be.

Can they work together?

Absolutely. In fact, for a Salesforce Commerce Cloud merchant, the ideal stack looks like this:

Einstein handles the onsite human shoppers (UX).
UCP Cartridge handles the off-site AI shopping agents (AX).

The UCP Cartridge acts as the "translator" that lets external AI agents speak the same commerce language as your Salesforce backend, effectively turning your SFCC instance into a true Agentic Storefront.

Verdict

If you want to reduce support tickets and help people find products on your site, use Einstein.

If you want to capture the 60% of searchers who aren't clicking through to your site anymore and want to delegate their shopping to AI, you need an Agentic Storefront.

The Best Adobe LLM Optimizer Alternatives in 2026

Mon, 30 Mar 2026 09:00:00 GMT

If you are an Adobe Commerce merchant, you’ve likely heard the whispers about the Adobe LLM Optimizer. Rumored to be a proprietary bridge between your catalog and search models, it promises to restore the visibility lost to zero-click search.

But for many, the "Adobe-only" constraint is a non-starter. Merchants today are rarely on just one platform; they are multi-channel, headless, and increasingly wary of vendor lock-in.

If you’re looking to optimize your storefront for the age of AI without being tied to a single tech stack, here are the best Adobe LLM Optimizer alternatives in 2026.

1. Universal Commerce Protocol (UCP) / Agentic Storefront

The most robust alternative isn't a single tool, but an open standard. While Adobe’s optimizer is likely built to feed specific partner LLMs, an Agentic Storefront built on UCP is platform-agnostic.

Why it’s better: It works on Adobe Commerce today but can move with you if you go headless or switch to Salesforce. It doesn't just "optimize" for viewability; it enables end-to-end transactions via standardized checkout APIs.
Best for: Enterprise brands looking for a future-proof, protocol-based solution.

2. LLM Pulse (Now Agentic Storefront)

LLM Pulse began as the industry standard for AI visibility tracking (the "SEMrush of AI"). It has since evolved into the Agentic Storefront suite, which includes both the tracking layer and the implementation layer.

Key Advantage: Unlike Adobe’s "black box" optimizer, Agentic Storefront gives you a dashboard to see exactly why an agent recommended your competitor over you, then gives you the UCP tools to fix it.

3. Vertex AI Multi-Channel Connect

For those heavily invested in the Google Cloud ecosystem, Vertex AI offers powerful distillation tools to create machine-readable catalog versions.

Cons: It requires significant engineering overhead to build the bridge between the AI model and your commerce checkout. It provides the "Discovery" but lacks the standardized "Checkout" layer that UCP provides natively.

Comparison: Adobe vs. Open Standards

Feature	Adobe LLM Optimizer	Agentic Storefront (UCP)
Platform	Adobe Commerce Only	Cross-Platform (Any)
Data Standard	Proprietary	Open (UCP)
Checkout Support	Limited / TBA	Full (Native UCP)
Visibility Tracking	Integrated	Integrated + Competitor Labs

Conclusion: Don't Get Locked In

The "AI Visibility" problem is not an Adobe problem—it is a commerce industry problem. Solving it with a proprietary Adobe tool is like solving the internet's search problem with an AOL-only index.

To truly win the zero-click era, you need an open, protocol-driven architecture that makes your store readable and transactable by every AI agent, not just the ones in Adobe's ecosystem.

Ready to explore the open alternative? Download the UCP Technical Primer or talk to our team.

Traditional SEO vs. Agentic Storefronts: Winning the Zero-Click Search

Sat, 28 Mar 2026 09:00:00 GMT

For fifteen years, the e-commerce playbook has remained unchanged: optimize your product pages, generate backlinks, manipulate technical architecture, and fight for the top organic spot on Google.

But what do you do when the user never clicks that #1 spot?

Welcome to the era of zero-click search. Today, shoppers are asking AI assistants like Perplexity or Google’s Gemini to do the heavy lifting. The AI summarizes reviews, compares specs, and outputs a clean answer directly in the chat interface. Your website traffic drops, but the searches are still happening.

Here is why your Traditional SEO strategy is failing, and why transitioning to an Agentic Storefront is the only viable path forward.

The Death of the Eyeball Economy

Traditional SEO relies on human eyeballs. It requires a consumer to physically visit your domain, look at your branding, navigate your menus, and organically stumble across upsells.

Because of this, SEO strategy dictates that you create vast arrays of "Top of Funnel" content—blogs, buying guides, and comparison pages—hoping to catch a user in the research phase and slowly nurture them.

Agentic Commerce destroys the funnel. When an AI bot enters your ecosystem, it doesn't need nurturing. It doesn't read your brand story. It has explicit instructions from a human buyer ($150 budget, black, water-resistant, fast shipping), and it operates with ruthless efficiency.

How Agentic Optimization Differs from SEO

If SEO is about getting a human to click a blue link, Agentic Optimization is about getting a machine to execute an API call.

1. Keywords vs. Data Precision

SEO: You obsess over long-tail keywords ("best running shoes for flat feet 2026").
Agentic: You obsess over precise, structured attribute mapping. If your JSON feed doesn't definitively list "arch support" as an attribute, the LLM will skip your product entirely.

2. Dwell Time vs. Latency

SEO: You want users to stay on your page as long as possible (dwell time) to prove to Google your content is valuable.
Agentic: Agents despise latency. If your UCP payload takes more than 500ms to return an inventory count, the agent assumes a timeout and moves to your competitor instantly.

3. Links vs. Transactability

SEO: Your authority is judged by how many referring domains link to your site.
Agentic: Your authority is increasingly judged by your verifiable transactability. Can the agent complete a checkout securely? AI platforms penalize storefronts that offer broken or highly frictional bot-checkout flows because it ruins the user experience in the chat window.

Stop Optimizing for Clicks

We are entering a phase where the metric "Monthly Unique Visitors" is decoupling from "Monthly Revenue."

You will soon see highly profitable merchants with incredibly low website traffic, simply because an Agentic Storefront handles the majority of its volume via API calls from AI assistants.

To survive the zero-click era, you have to stop fighting for human clicks and start building the infrastructure for machine transactions.

How to Transform Your E-Commerce Site into an Agentic Storefront

Thu, 26 Mar 2026 09:00:00 GMT

We know the theory: AI shopping agents are responsible for the fastest-growing segment of e-commerce traffic. They don't want your beautiful CSS; they want your structured data and your checkout APIs.

But how do you actually turn your massive, complex legacy platform into a sleek, AI-readable Agentic Storefront?

Whether you are running Salesforce Commerce Cloud, Adobe Commerce, or a custom headless stack, the transition requires three distinct phases.

Phase 1: Solving the Visibility Gap

Before an AI agent can buy from you, it has to know what you sell. Traditional HTML tags aren't enough.

Action Steps:

Audit Your Structured Data: Ensure every product page implements comprehensive Schema.org JSON-LD. Agents still pull from search indices as a fallback.
Expose Real-Time Feeds: Build high-performance, paginated JSON feeds of your catalog.
Establish Your Manifest: Create a /.well-known/ucp document. This simple JSON file is the front door for AI agents. It tells them your store's name, capabilities, and where to find your catalog endpoints.

Even if you don't enable AI checkout right away, completing Phase 1 ensures agents can at least recommend your products and link back to your human checkout flow.

Phase 2: Implementing the Universal Commerce Protocol (UCP)

To become a true Agentic Storefront, you must authorize AI to transact on the buyer's behalf. This is where the Universal Commerce Protocol (UCP) comes into play.

UCP is an open standard that gives agents a predictable set of actions: creating a cart, calculating taxes, adding shipping details, and processing payments.

Action Steps:

Build the Session API: Develop an endpoint that allows an agent to create a checkout_session. The session must hold cart state securely.
Handle Dynamic Calculations: Agents need immediate feedback on tax and shipping before they can confirm the purchase. Your UCP layer must calculate this on the fly without human interaction.
Map the Payment Flow: UCP defines standard contracts for passing payment tokens from the AI environment securely to your PSP (Payment Service Provider).

Phase 3: Platform Upgrades & Cartridges

Building UCP from scratch is a heavy lift for enterprise merchants. The smartest engineering teams aren't reinventing the wheel; they are leveraging pre-built translation layers.

If you are on Shopify Plus: You are sitting on native support. Your primary job is configuration and auditing your inventory feeds.

If you are on Salesforce Commerce Cloud (SFCC): ForkPoint has open-sourced the first UCP Cartridge for SFCC. Rather than building custom middleware, you can install the cartridge to map SFCC's native checkout pipelines to the UCP standard.

If you are on Adobe Commerce: Similar architectural patterns apply. You will need an extension that exposes GraphQL or REST API wrappers translating Adobe's cart logic into UCP JSON responses.

The Payoff

Upgrading to an Agentic Storefront is less about "re-platforming" and more about "re-wiring."

By exposing the heavy lifting your backend already does (pricing, inventory, tax, checkout) via a standardized protocol, you instantly open your business to the most revolutionary commerce channel of the decade.

What is an Agentic Storefront? The Future of AI-Driven E-Commerce

Tue, 24 Mar 2026 09:00:00 GMT

Traditional e-commerce was built for clicks. Product pages, category navigation, high-res image galleries—all designed to guide a human being down a funnel.

But what happens when the buyer isn't human?

As Google AI Overviews, Perplexity, and ChatGPT evolve from search engines into action engines, the commerce landscape is shifting. AI agents are no longer just summarizing reviews; they are actively researching products, comparing inventory, and completing transactions on behalf of consumers.

To capture this new wave of zero-click buyers, you can't rely on a traditional web store. You need an Agentic Storefront.

What is an Agentic Storefront?

An Agentic Storefront is an e-commerce infrastructure explicitly designed to be read, navigated, and transacted on by Artificial Intelligence agents.

While a traditional storefront optimizes for human user experience (UX), an Agentic Storefront optimizes for Agent Experience (AX). It provides structured, deterministic data and deterministic checkout APIs that an LLM can parse and interact with flawlessly.

If a customer asks an AI shopping assistant, "Find me size 10 running shoes in blue, under $150, that can be shipped by Tuesday," an Agentic Storefront can directly supply that data and allow the bot to purchase it without the human ever opening a browser tab.

The Three Pillars of an Agentic Storefront

Building an Agentic Storefront doesn't mean deleting your React or Astro frontend. It means adding an invisible, AI-first layer beneath it.

1. The Discovery Manifest

Agents don't have time to crawl your sitemap and infer what you sell. An Agentic Storefront publishes a standard manifest (often at /.well-known/ucp) that declares its existence, its catalog endpoints, and its checkout capabilities.

2. Machine-Readable Inventory

HTML product pages are notoriously difficult for LLMs to scrape reliably. Instead, an Agentic Storefront exposes clean JSON feeds detailing exact SKUs, real-time inventory levels, pricing, and shipping policies.

3. Agentic Checkout APIs

This is the holy grail. While your traditional site uses a visual shopping cart, an Agentic Storefront supports checkout sessions generated via API. Using standards like the Universal Commerce Protocol (UCP), the AI agent can securely pass shipping details and payment tokens to complete the transaction autonomously.

Why Traditional "Headless" Isn't Enough

Many brands mistakenly believe that a headless architecture automatically makes them AI-ready. This is completely false.

Headless separates the frontend from the backend, but your REST or GraphQL APIs are still entirely custom. An AI agent from Google does not know how your specific cart endpoint is structured. It doesn't have the custom API documentation for your brand.

An Agentic Storefront relies on universally adopted protocols (like UCP). Instead of expecting every AI agent on the planet to learn your custom APIs, you implement a standard protocol that every AI agent already understands.

The Future is Autonomous

60-70% of searches now end without a click. If your store relies entirely on human traffic, you are fighting over a shrinking pie.

Transforming into an Agentic Storefront ensures that when a consumer delegates their buying power to an AI, your brand is not just visible—it's ready to transact.

Your Store Is Invisible to AI Shopping Agents — Here's Why That Matters

Thu, 19 Mar 2026 09:00:00 GMT

You're ranking on page one. Your product pages are optimized. Your schema markup is correct. And your traffic is dropping anyway.

You're not doing anything wrong. The infrastructure changed.

The Zero-Click Problem

60-70% of Google searches now end without a click. The searcher gets their answer directly in the results — an AI-generated summary, a featured snippet, a knowledge panel — and never visits a website.

For e-commerce, this is devastating. According to a Kellogg School of Business analysis, retailers saw traffic drops of 20-40% in 2025, with most of that decline coming from lost organic search traffic. Not because their rankings fell, but because rankings stopped mattering the way they used to.

Google's AI Overviews scrape your product content, summarize it, and present it to the searcher — without sending them to your store. You're still "visible" in the technical sense. You're just not getting the visit, the session, or the sale.

One merchant put it bluntly: they asked 10 SEO experts what to do, got 10 different answers, implemented them all, and have been waiting for tangible results since 2023.

What the Old Playbook Gets Wrong

If the traffic decline were a temporary algorithm fluctuation, the standard response — optimize harder, spend more on ads, diversify content — would work. But this isn't a fluctuation. It's a structural shift in how buyers find and purchase products.

Here's what merchants have been trying, and why it's not working:

Doubling down on SEO — You can't out-optimize a system that's designed to keep users on Google's property. The rules of the game changed, and the new rules don't reward the same plays.

Increasing ad spend — CPCs rise year over year while conversion rates flatline. One merchant spent $200 on Google Ads, got 900 clicks, and made zero sales. Paid acquisition without organic discovery is, as one store owner described it, "not building a brand — building a time bomb."

Content marketing — Google's AI Overviews summarize your content without sending traffic. You're effectively training Google's answer engine at your own expense.

CRO and conversion optimization — Valuable, but it optimizes a shrinking denominator. Improving conversion rate on declining traffic is arithmetic, not strategy.

Social media — Drives awareness, but average e-commerce conversion from social channels sits at 0.91%. You can't run a business on likes.

None of these approaches are wrong. They're just insufficient for a world where the primary discovery mechanism no longer sends people to your store.

Where Buyers Are Actually Going

While organic search traffic declines, a different channel is growing at a rate that's hard to ignore.

AI-driven retail traffic grew 4,700% year-over-year according to Adobe. Traffic referred by large language models converts at 4.4x the rate of traditional organic search visitors. Over 700 million people use ChatGPT every week — and as of September 2025, they can complete purchases directly inside the conversation.

Google is rolling out native shopping in AI Mode. Microsoft Copilot is integrating product recommendations. Perplexity is building commerce features. Gartner projects that by end of 2026, more than 50% of consumers will use AI shopping assistants regularly.

This isn't speculative. It's measurable today.

The critical difference: these AI agents don't browse websites. They query structured data, evaluate product attributes, assess merchant trust signals, and make recommendations — all without visiting a traditional product page. If your store can't respond to those queries, you don't exist in this channel.

The Visibility Gap

Traditional e-commerce visibility works like this: you optimize your store, search engines index it, shoppers find you through queries, and they visit your site to buy.

AI agent commerce works differently: a shopper tells an AI assistant what they want, the agent searches for products that match across structured data sources, evaluates trust and fulfillment signals, and either recommends or completes the purchase — often without the shopper ever seeing your website.

The gap between these two models is where revenue disappears without a trace. You never see the "lost visit" in your analytics because the shopper never intended to visit a website. They intended to buy through a conversation.

Every day your store isn't visible to AI shopping agents, you're losing sales to competitors who are. Not in theory. In the analytics of merchants who've already connected.

Why This Isn't "The New SEO"

E-commerce operators have been promised "the new SEO" every 18 months for a decade. Voice search was supposed to change everything. Social commerce was the future. Web3 would revolutionize retail.

Agentic commerce is structurally different for one reason: it enables transactions, not just discovery.

SEO gets you found. Ads get you clicked. Social gets you followed. Agentic commerce gets you sold — inside the conversation where the buying decision happens, with checkout completed before the shopper ever opens a browser tab.

This is possible because of the Universal Commerce Protocol (UCP) — an open standard that lets AI agents discover products, check availability, and complete purchases programmatically. UCP gives agents everything they need to act on behalf of a buyer: product data, pricing, inventory, shipping options, return policies, and a secure checkout flow.

Without UCP, your store is a black box to AI agents. They can't see your products, can't verify your inventory, and can't offer your checkout to shoppers.

The Platform Gap

Here's the uncomfortable part: Shopify merchants are getting agentic storefronts natively. When Steve Madden's VP of e-commerce says they can "automatically be wherever our customers are shopping — including inside AI conversations," that's not aspirational. It's live.

If you're on Salesforce Commerce Cloud, Adobe Commerce, WooCommerce, or a custom platform, you don't have that. UCP is an open protocol — any platform can implement it — but your platform vendor hasn't shipped it yet, and they haven't committed to a timeline.

This mirrors what happened with mobile commerce. Merchants on platforms that adapted early captured the channel. Everyone else spent years catching up.

The difference this time: the adoption curve is steeper. AI agent traffic is growing exponentially, not linearly. The window between "early mover advantage" and "table stakes" is measured in months, not years.

What You Can Do Now

You don't need to re-platform. You don't need to understand the UCP spec, MCP, A2A, or any of the protocol alphabet soup. You need your store to be findable and transactable when AI agents look for products in your category.

1. Understand Your Exposure

Check your analytics for AI-referred traffic. Look at your Search Console for impression-to-click ratios over the past 12 months. Quantify how much of your discovery funnel depends on channels that are structurally declining.

2. Assess Your Agent Readiness

Can an AI agent today find your products, understand your pricing, verify your inventory, and complete a checkout? If the answer is no to any of those, you have a gap that's costing you revenue in the fastest-growing commerce channel.

3. Prioritize Structured Data

Even before UCP implementation, making your product data comprehensive, consistent, and machine-readable improves your position everywhere — traditional SEO, marketplace listings, and agent discovery. This is the highest-ROI investment regardless of timeline.

4. Don't Wait for Your Platform Vendor

Salesforce, Adobe, and BigCommerce will eventually ship native UCP support. Eventually. The merchants who are live on agentic channels when that happens will have months of transaction history, trust signals, and optimization data that latecomers won't.

Early movers in AI commerce are building compounding advantages. Recommendation algorithms favor stores with transaction history. The longer you wait, the harder the gap is to close.

Not sure where you stand? Run the Agent Commerce Simulation to see exactly where AI agents get stuck trying to buy from your store, or talk to us about getting your catalog live on agentic channels.

The 7 Dimensions of Agentic Commerce Readiness: A Complete Framework

Tue, 24 Feb 2026 09:00:00 GMT

The 7-Dimension Agentic Commerce Readiness framework is ForkPoint's methodology for evaluating and achieving full readiness for AI agent-driven commerce. The seven dimensions are: AI Discoverability, Protocol Readiness, Data Quality, Transaction Enablement, Trust & Verification, Post-Purchase Experience, and Measurement & Optimization. A brand must score adequately across all seven to capture AI-agent-driven revenue — deficiency in any single dimension can block the entire channel.

This document defines each dimension, explains why it matters, and describes what adequate readiness looks like in practice.

Why a Framework?

Most agentic commerce guidance focuses on a single layer: "implement UCP" or "optimize your schema markup." That's necessary but insufficient. AI agents that interact with your commerce infrastructure encounter every dimension simultaneously.

A shopper's AI agent might:

Search for a product → AI Discoverability
Call your UCP manifest to check capabilities → Protocol Readiness
Query your product feed for attributes and pricing → Data Quality
Create a checkout session and initiate payment → Transaction Enablement
Validate your return policy and merchant reputation → Trust & Verification
Query order status post-purchase → Post-Purchase Experience
Generate attribution data in your analytics → Measurement & Optimization

That's the full sequence. A failure at step 3 (incomplete product data) means the agent never reaches step 4. A failure at step 5 (unclear return policy) means the agent recommends a competitor instead. All seven dimensions are in the critical path.

Dimension 1: AI Discoverability

The question: Can AI agents find your products in the first place?

AI discoverability is the practice of making your brand, products, and content visible to AI-powered recommendation systems — Google AI Mode, ChatGPT Shopping, Perplexity, and similar platforms. It is distinct from traditional SEO because these systems don't crawl and rank pages the same way search engines do.

What discoverability requires

Structured data (Schema.org) Product markup must be comprehensive — not just name and price, but category hierarchy, attributes, availability by region, shipping policies, and review aggregates. Agents parse structured data before page content.

UCP discovery manifest The /.well-known/ucp endpoint is the formal entry point for UCP-compliant agents. Even if checkout isn't enabled, having a valid manifest with product feed URL signals to agents that you're a participatory merchant.

Content entity recognition AI models build a knowledge graph of entities — brands, products, categories, merchants. Appearing in structured references (product databases, review platforms, knowledge bases) increases the probability that a model associates your brand with relevant queries.

GEO-optimized content Blog posts, guides, and product descriptions should open with direct-answer paragraphs that state the key fact or answer the primary question immediately. Language models trained on web content have been shown to cite pages with direct-answer openings at significantly higher rates.

llms.txt and AI crawler access The llms.txt standard (llmstxt.org) provides AI crawlers with a structured map of your site's most relevant content. Paired with a correctly configured robots.txt that allows AI crawlers, this ensures models can index your content for recommendation training.

Readiness indicators

Valid /.well-known/ucp manifest
Schema.org Product markup with 15+ attributes per product
llms.txt and llms-full.txt published
AI crawlers (GPTBot, ClaudeBot, PerplexityBot) allowed in robots.txt
Google Merchant Center listing active and verified

Dimension 2: Protocol Readiness

The question: Are agent protocols implemented so AI systems can transact, not just discover?

Protocol readiness refers to the implementation of the technical standards that govern how AI agents interact with commerce infrastructure. The three protocols that matter for enterprise commerce are UCP, MCP, and A2A.

Universal Commerce Protocol (UCP)

Developed by Google, Shopify, and 20+ partners, UCP is the open standard enabling consumer-facing AI agents to discover products, manage carts, and complete checkout. It's the protocol behind Google AI Mode purchases.

UCP implementation requires:

Discovery manifest at /.well-known/ucp
Product feed API (paginated, filterable)
Checkout session API (create, update, expire)
Payment handler integration
Order status and tracking API

Platform status: Native on Shopify Plus. Custom implementation required on SFCC (use ucp-sfcc), Adobe Commerce, BigCommerce, and headless platforms.

Model Context Protocol (MCP)

Developed by Anthropic, MCP enables tool-using AI systems to query structured data sources through standardized tool definitions. Enterprise B2B buyers' AI assistants increasingly use MCP to interact with vendor systems.

MCP implementation for commerce exposes tools for:

Catalog search with semantic filters
Account-specific pricing and availability
Order history and account status
Quote generation

Relevant for: B2B sellers, wholesale, brands with corporate account programs.

Agent-to-Agent Protocol (A2A)

Developed by Google, A2A enables autonomous agent-to-agent communication — allowing buyer AI agents to interact directly with supplier AI agents without human involvement in each transaction.

Relevant for: High-frequency B2B relationships, automated replenishment, enterprise procurement workflows.

Readiness indicators

UCP manifest validated and live
Checkout sessions tested with agent simulation
MCP server operational (if B2B segment exists)
A2A capability card published at /.well-known/agent.json

Dimension 3: Data Quality

The question: Is your product data complete, accurate, and structured for machine consumption?

Data quality is frequently the largest gap in agentic commerce readiness — and the most underestimated. Most product catalogs are built for human browsing, not machine querying. AI agents need different data than human shoppers.

What agents need that humans don't

Attribute completeness. A human shopper can look at a product image and infer dimensions. An AI agent cannot. Every attribute an agent might need to answer a shopper's question must be explicit in the product data: dimensions, weight, material composition, compatibility, care instructions, certifications.

Attribute consistency. "Color: Navy" in one product and "Color: Dark Blue" in another causes recommendation failures when agents try to filter by color. Attribute values must be standardized across the catalog.

Real-time inventory. Agents recommending out-of-stock products destroy trust in both the agent and the merchant. Inventory data that's even an hour stale is a problem for high-velocity SKUs.

Pricing accuracy. If your UCP product feed shows $79 and your checkout session returns $89 (due to a promotion that expired), the agent sees a discrepancy it can't explain to the shopper. Price consistency across all data layers is mandatory.

Variant completeness. Every purchasable combination (size × color × configuration) must be represented in the product feed with its own inventory and pricing. Agents can't guess at availability — they need explicit variant data.

Common catalog failures

Missing attributes for 30–50% of SKUs (common in legacy catalogs)
Promotional copy in description fields instead of factual specifications
Images without alt text or structured metadata
Category taxonomy inconsistent across catalog sections
No machine-readable shipping or returns data at the product level

Readiness indicators

Catalog attribute completeness audit score > 85%
Inventory data freshness < 15 minutes
Pricing consistent between catalog feed and checkout session API
All product images have descriptive alt text
Variant grid complete for every product

Dimension 4: Transaction Enablement

The question: Can AI agents actually complete a purchase on your store?

Discoverability gets agents to your products. Protocol readiness gives them the interface. Transaction enablement is whether that interface actually works end-to-end for a purchase.

The checkout session lifecycle

UCP checkout follows a stateful session model:

Session creation — Agent creates a session with cart items and shipping address estimate
Session population — Agent adds items, applies promotions, selects shipping method
Tax calculation — Merchant returns calculated totals
Payment initiation — Agent submits payment token
Order confirmation — Merchant returns order ID and confirmation

Every step must work reliably, including edge cases: out-of-stock items added mid-session, promotion expiry during checkout, address validation failures, payment declines.

Payment handler requirements

UCP doesn't process payments — it defines a handoff to your existing payment processor. Your payment handler must:

Accept UCP-standard payment tokens (card, Google Pay, Shop Pay, Apple Pay)
Return structured error responses agents can interpret and relay to the shopper
Handle 3DS and additional verification flows
Process refunds and returns initiated by post-purchase agent queries

Session management

Agents don't always complete purchases linearly. They may pause for shopper confirmation, compare alternatives, or hand off to a different agent in a multi-agent workflow. Your session management must:

Support sessions lasting 30+ minutes without forced expiry
Return clear 410 Gone responses with instructions when sessions expire
Allow session state to be transferred between agent contexts where applicable

Readiness indicators

Checkout session API tested for all common edge cases
Payment handler accepts all major UCP-compatible methods
Session expiry handled with clear agent-readable error responses
Successful end-to-end transaction test with agent simulator

Dimension 5: Trust & Verification

The question: Will AI agents confidently recommend your brand, or route shoppers to competitors?

AI recommendation systems are trained to protect users from bad experiences. Merchants with ambiguous trust signals get lower recommendation rates — or get filtered out entirely.

What agents use as trust signals

Return and refund policy clarity. Agents need to answer: "What happens if this doesn't work out?" Vague policies ("we'll work with you") score lower than specific, structured policies ("free returns within 60 days, no questions asked"). Structured return policy markup in Schema.org and your UCP manifest is the machine-readable version.

Merchant verification. Google Merchant Center verification, BBB accreditation, and similar third-party verifications are signals that agents can programmatically check. Unverified merchants are treated with more caution.

Review aggregation. Verified purchase reviews on major platforms (Google, Trustpilot, platform-native) signal real transaction history. Review recency and response rate both matter. Agents trained on review data have higher confidence in merchants with consistent, recent review activity.

Security and compliance signals. SSL/TLS configuration, PCI DSS compliance indicators, and privacy policy accessibility are baseline requirements. These don't earn recommendation priority, but their absence can trigger filtering.

Contact and support availability. Merchants with clear, accessible contact information and responsive support are rated higher. Agents can verify whether support channels exist and are responsive before recommending a high-value purchase.

Readiness indicators

Return policy structured in Schema.org and UCP manifest
Google Merchant Center listing verified
BBB accreditation active (if applicable)
Review aggregate score ≥ 4.0 on major platforms with recent reviews
Privacy policy, terms, and contact accessible at standard URLs

Dimension 6: Post-Purchase Experience

The question: Can agents support the shopper after the order is placed?

The AI agent relationship with a shopper doesn't end at checkout. Agents that facilitate purchases are increasingly expected to answer "where's my order?", handle return requests, and manage exception cases — without the shopper needing to contact the merchant directly.

Order status APIs

Your UCP order management endpoints must return structured, agent-parseable status information:

Current order status (processing, shipped, delivered, exception)
Carrier and tracking number
Estimated delivery date (not a static range — a calculated estimate based on current carrier data)
Line item status for partial shipments

Agents that can't answer "where's my order?" in natural language will lose the shopper's trust — and that trust loss gets attributed to the merchant, not the agent.

Return initiation

Agents handling returns need programmatic access to:

Return eligibility check (within window, non-restricted item)
Return label generation or drop-off location lookup
Refund status after return receipt

This doesn't require full returns automation from day one. Even a structured deep link to the returns portal, returned from the order status API, is a meaningful improvement over "contact us."

Communication hooks

Agents may proactively notify shoppers of order updates — shipping confirmations, delivery exceptions, return processing. To support this, your post-purchase APIs should include webhook registration so agents can subscribe to status change events rather than polling.

Readiness indicators

Order status API returns structured carrier and tracking data
Estimated delivery date is dynamic, not a static range
Return eligibility checkable via API
Agent-initiated return label generation or structured deep-link fallback

Dimension 7: Measurement & Optimization

The question: Can you measure agent-driven performance and improve it over time?

Without measurement, you can't distinguish between "agents aren't finding us" and "agents are finding us but not converting" — and you can't improve what you can't measure.

Agent session identification

AI agents send identifiable user-agent strings. Known agent crawlers and shopping agents include:

GPTBot (OpenAI)
ClaudeBot (Anthropic)
PerplexityBot (Perplexity)
Googlebot-Image, Google-InspectionTool, GoogleOther

Your analytics must segment traffic by these identifiers to create an agent-specific funnel separate from human browse traffic.

The agent commerce funnel

Traditional e-commerce funnels (impression → product view → add to cart → checkout → purchase) don't map cleanly to agent traffic because agents don't generate pageviews. The agent-specific funnel is:

Agent crawl — Agent indexes your product feed (server-side, no pageview)
Recommendation event — Agent includes your product in a response to a shopper (typically untrackable directly)
Agent session creation — Agent creates a UCP checkout session (server-side, trackable)
Payment initiation — Agent submits payment (trackable)
Order placed — Order confirmed (trackable)

You can instrument steps 3–5 directly. Step 2 is the black box — but you can infer recommendation rate from the ratio of agent sessions to known crawler visits.

Key KPIs for agent commerce

Agent session rate — UCP checkout sessions per day / week
Agent conversion rate — Completed orders ÷ checkout sessions initiated
Agent revenue attribution — Revenue from agent-initiated sessions
Protocol error rate — 4xx/5xx responses on UCP endpoints per 1,000 requests
Recommendation rate by platform — Where measurable, track which AI platforms are driving sessions

Readiness indicators

Agent user-agent strings segmented in analytics
UCP endpoint logging capturing session creation, payment initiation, order confirmation
Agent-specific funnel report built and reviewed weekly
Protocol error rate monitored with alerting

Using the Framework

Assessment

ForkPoint's free Agent Commerce Simulation lets you experience what an AI agent encounters when trying to buy from your store across all 7 dimensions. Most teams discover 3–5 critical gaps they weren't aware of. Want the full picture? The 70-point professional assessment delivers a scored report with a prioritized remediation roadmap.

Implementation sequencing

The dimensions have dependencies. The typical implementation sequence is:

Data Quality — Foundation. Everything else depends on it.
AI Discoverability — Get indexed. Agents can start recommending you before checkout is live.
Protocol Readiness (UCP) — Enable transactions.
Transaction Enablement — Validate end-to-end checkout works.
Trust & Verification — Improve recommendation rate.
Post-Purchase Experience — Extend the agent relationship past checkout.
Measurement & Optimization — Instrument, measure, and compound.
Protocol Readiness (MCP/A2A) — Layer on B2B and enterprise coverage.

Timeline expectations

On modern platforms (Shopify Plus), a full 7-dimension implementation from assessment to live typically runs 8–16 weeks. On SFCC, Adobe Commerce, or headless architectures, 12–24 weeks is realistic depending on current data quality and API readiness.

The data quality dimension is the most variable. Brands with clean, complete catalogs move faster. Brands with legacy catalog debt should plan the remediation effort before starting protocol work.

Start with a readiness score. Our 70-point assessment evaluates your brand across all 7 dimensions and identifies which gaps to address first. Or talk to us directly about your platform and business model.

Markdown for Agents: Cloudflare's New Standard for AI Discovery

Tue, 24 Feb 2026 09:00:00 GMT

Markdown has quickly become the lingua franca for autonomous agents and AI systems. Unlike humans who browse fully rendered HTML pages with CSS and heavy Javascript payloads, AI agents struggle to parse complex DOM trees efficiently. The explicit, clean structure of Markdown makes it ideal for AI processing—providing better extraction results while simultaneously minimizing costly token waste.

Recognizing this shift in how the web is consumed, Cloudflare has introduced Markdown for Agents. This feature allows AI systems to request website content directly formatted as Markdown, converting HTML on the fly at the edge.

How Markdown for Agents Works

Cloudflare’s global network supports real-time content conversion using standard HTTP content negotiation.

When an AI system requests a page from a Cloudflare-enabled website that has this feature turned on, the agent simply needs to express its preference by adding an Accept header to the request:

Accept: text/markdown

Cloudflare intercepts this request, fetches the original HTML version from the origin server, and efficiently converts it to Markdown before serving the clean response back to the client.

Key Technical Features

If you are building an AI agent or optimizing your site for AI discoverability, there are two crucial headers Cloudflare includes in these Markdown responses:

1. Token Estimation (`x-markdown-tokens`)

Cloudflare automatically calculates and injects an x-markdown-tokens header into the response. This indicates the estimated number of tokens in the converted markdown document.

Engineering teams building AI agents can use this value dynamically in their flows—for instance, to calculate context window usage on the fly or to decide whether a chunking and embedding strategy is necessary before passing the content to an LLM.

2. Usage Permissions (`Content-Signal`)

By default, converted responses include a Content Signals policy framework header. It looks like this:

Content-Signal: ai-train=yes, search=yes, ai-input=yes

This acts as a transparent contract detailing how the content may be used, specifically signaling that the content is permitted for AI Training, traditional indexing for Search, and processing as AI Input (including agentic use cases).

Why This Matters for Agentic Commerce

As we transition into the era of the agent economy, ensuring your storefront's products and catalog data are easily readable by AI is paramount—a strategy known as GEO (Generative Engine Optimization).

Traditionally, agents scraping e-commerce sites have to download massive HTML files, parse through nested <div> tags, strip out navigation headers and footers, and attempt to isolate the core product details. This process is brittle; a simple UI update can easily break an agent's scraping logic.

By serving structured Markdown directly from the CDN edge:

You eliminate parsing errors. The agent gets the exact product title, description, and specifications formatted perfectly with clear heading tags (#) and lists (-).
You reduce bandwidth and token costs. Markdown strips away styling and scripts. Smaller payloads mean faster agent ingestion and significantly cheaper API calls to LLMs.
You improve AI discovery. Agents are more likely to successfully index and recommend products that are easy for them to "read" accurately.

Availability

Markdown for Agents is currently available at no additional cost for Cloudflare customers on Pro, Business, and Enterprise plans, as well as SSL for SaaS customers. It can easily be toggled on inside the Cloudflare dashboard under the "AI Crawl Control" section.

At ForkPoint, we help brands optimize their infrastructure for the Agent Economy. Want to learn how prepared your storefront is for AI shoppers? Take our Readiness Assessment.

Agentic Commerce: Visual Insights and Commentaries

Sun, 22 Feb 2026 10:00:00 GMT

Agentic commerce is reshaping digital retail in three fundamental ways: AI agents are replacing search as the primary discovery mechanism, human intent is being delegated to autonomous agents, and merchants must now optimize for machine recommendation rather than human browsing. The following visual analysis — featuring infographics from Björn Ognibeni's excellent series — breaks down each shift.

Google's Agentic Shopping Platform

Credit: Infographic by Björn Ognibeni

The transition toward an agent-mediated shopping ecosystem fundamentally changes where product discovery happens. As Google and other major tech platforms transition into "Shopping Platforms," merchants have to ask themselves: are we optimizing our catalogs for humans or for AI agents? In this agentic model, the search engine takes on an active role as a personal shopper, executing transactions right from the AI surface via emerging frameworks like the Universal Commerce Protocol (UCP). Brands must ensure their APIs and structured data readiness are prioritized to remain visible when AI makes the purchasing recommendations.

The Missing Element in Agentic Commerce: the Human

Credit: Infographic by Björn Ognibeni

While the automation of intent-to-checkout is powerful, e-commerce cannot become a purely synthetic interaction. The human element—curation, emotion, nuanced taste, and trust—remains paramount. Agentic commerce doesn't eliminate the need for human touch; rather, it elevates the human role to that of a creative director or specialized consultant. The systems process the enormous volumes of catalog matching, while humans provide the strategic oversight and the emotional brand connection that prevents shopping from becoming overly commoditized and robotic.

More than just Search - The 4 Modes of E-Commerce

Credit: Infographic by Björn Ognibeni

E-commerce is no longer a monolith. The traditional "Search and Display" grid is merely one mode in an expanding matrix of digital shopping. We are moving toward complex environments where algorithmic discovery (like TikTok grids) meets agentic facilitation (where an AI does the research for you based on a loose brief, like planning an entire living room aesthetic). Retailers must map their current digital offerings against these four distinct modes: Direct Search, Browsing Inspiration, Algorithmic Discovery, and Agent-assisted Action, ensuring they offer journeys tailored to distinct types of buyer intent.

What These Shifts Mean for Merchant Strategy

The three shifts illustrated above — toward agent mediation, toward autonomous intent, toward multi-mode commerce — have concrete operational implications. Here's how to translate each visual insight into action.

From the Agentic Shopping Platform graphic

The key insight is who controls discovery. In traditional e-commerce, merchants optimize for search engines that rank their own pages. In agentic commerce, a platform intermediary (Google AI Mode, ChatGPT, Perplexity) makes the recommendation — and the merchant's product data is the input to that decision.

The operational shift: You can no longer rely on a URL in a search result as the primary discovery mechanism. Merchants must ensure their catalog is directly legible to AI systems through structured product data, UCP manifests, and schema markup — before the agent ever considers linking to their storefront.

From the Missing Human graphic

Automation handles the mechanics of matching and transaction. Human judgment remains essential for brand positioning, curation, and emotional resonance — the things that make one product preferable to a technically equivalent alternative.

The operational shift: Content and brand investment doesn't disappear in agentic commerce — it shifts upstream. The work is now in how products are described, attributed, and positioned in the data that agents read, not in the marketing copy on a product page that agents don't read.

From the 4 Modes graphic

Different shoppers are in different modes simultaneously. A shopper might discover a brand through algorithmic discovery (TikTok, Instagram), do detailed comparison research via an AI assistant (agentic mode), and complete the purchase through a UCP checkout session — all in one decision journey.

The operational shift: Readiness for agentic commerce doesn't replace investment in direct search or inspiration channels. It adds a new mode. Brands must be discoverable and transactable across all four modes, because shoppers move between them fluidly within a single purchase decision.

The Quantitative Case

To ground the visual narrative in numbers:

AI-driven retail traffic grew 4,700% year-over-year (Adobe Analytics, 2025)
65% of retailers have taken no steps to prepare for agentic commerce (Optimizely, 2025)
Agent-referred shoppers convert at 3–5x the rate of organic search traffic — because they arrive having already decided to buy
Agentic commerce is projected to influence $390 billion in global retail sales by 2028 (Salesforce)

The visual shifts illustrated above aren't speculative. They're already in the data. The question for merchants is which mode of the four-mode framework they're optimized for — and whether "agent-assisted action" is one of them.

Further reading: For a technical breakdown of what agentic readiness requires, see our 7-Dimension Agentic Commerce Readiness Framework. To understand the protocol stack behind these shifts, start with What is Universal Commerce Protocol?

Salesforce B2C Commerce Embraces Agentic Commerce: Spring '26 Innovations

Sat, 21 Feb 2026 10:00:00 GMT

Salesforce Spring '26 introduces native agentic commerce support in Agentforce Commerce, including Universal Commerce Protocol (UCP) integration, AI-powered shopping agents, and autonomous checkout capabilities. For B2C merchants on Salesforce Commerce Cloud, this is the most significant platform shift since the move to headless commerce.

Here is a breakdown of the most significant announcements and what they mean for B2C merchants.

Agentic Shopping Takes Center Stage

Shoppers no longer want to hunt through static websites using rigid keyword searches. They expect highly contextual, conversational experiences. Salesforce’s new agentic shopping features are designed to meet this expectation:

Google's Universal Commerce Protocol (UCP) Integration: This is perhaps the most significant structural update. Salesforce is enabling native checkout and direct buying experiences on Google AI commerce surfaces. This validates the importance of UCP as the emerging standard for agentic discovery and transaction.

ChatGPT Catalog Integration: Merchants can now publish structured product feeds directly to OpenAI without writing custom code. This allows ChatGPT to accurately recommend and display products, turning the AI assistant into a highly qualified traffic and discovery engine.

Guided Shopping Agent: On-site, the Guided Shopper Agent uses store context to help shoppers refine results intelligently, offering smart alternatives for zero-result queries to prevent dead ends.

Empowering Merchandisers with Agentic Actions

The shift to agentic commerce isn't just about the shopper; it's also about dramatically improving backend efficiency.

Agentic Boost and Bury: Merchandisers can now deploy AI agents to instantly promote high-margin or trending items, while automatically burying slow-moving or out-of-stock products. This replaces manual, rule-based merchandising with dynamic, intent-driven catalog management.

Embedded Analytics and Workspaces: Business Manager now offers highly personalized workspaces where merchandisers can leverage agents with a single click, instantly understanding the context and impact of visual merchandising or campaign performance.

Contextual Search

The keyword era is ending. Salesforce is introducing Contextual Search, which moves beyond literal word matching to semantic understanding.

This means the search engine understands natural language, intent, and shopper context (like location or season). For example, a search for a "lightweight jacket" can intelligently return windbreakers and mild weather accessories based on the shopper's recent history, rather than just returning items explicitly tagged as "jackets."

The Takeaway: Agentic Readiness is Non-Negotiable

Salesforce's robust roadmap for Agentforce Commerce sends a clear signal to the market: agentic commerce is not a future concept; it is the current battleground for customer acquisition and conversion.

The native integration of Google's Universal Commerce Protocol and direct feed connections to ChatGPT mean that the platforms themselves are preparing for a world where AI agents do the shopping on behalf of the consumer.

For brands on Salesforce B2C Commerce, these tools will provide a powerful advantage. However, the foundational requirement remains the same: your product data, catalog structure, and backend APIs must be ready to interface with these agents.

The competitive window is open. Brands that prepare their data and embrace these agentic capabilities early will capture the initial wave of AI-driven commerce.

Want to prepare your storefront for the agentic era? Speak with our team about an implementation roadmap and how to get your catalog ready for AI discovery.

Adobe Commerce and Agentic Commerce: What Magento Merchants Need to Know in 2026

Sat, 14 Feb 2026 09:00:00 GMT

Adobe Commerce does not have native UCP support, and Adobe has not committed to a public timeline for adding it. For the 8,000+ enterprise brands running on Adobe Commerce, this creates an immediate strategic decision: wait for platform support, or build agent readiness now through Magento's proven extension architecture.

Adobe is investing heavily in AI — Adobe Sensei, AI-powered personalization, the Commerce Optimizer suite. The platform is evolving fast. But Universal Commerce Protocol, the open standard that lets AI shopping agents discover and transact with your store, is not on Adobe's official roadmap, at least not publicly.

Why Adobe Commerce Is Actually Well-Positioned

Before addressing the gap, it's worth naming the advantages.

GraphQL-first architecture. Adobe Commerce's comprehensive GraphQL API is one of the most complete in enterprise commerce. Every product, category, pricing rule, inventory signal, and cart operation is queryable via a well-documented schema. AI agents need clean, structured API access — and Adobe Commerce's GraphQL layer is already structured for programmatic consumption.

PWA Studio and headless patterns. Many Adobe Commerce merchants have already adopted headless or composable architectures through PWA Studio or custom frontends. This decoupled pattern makes it significantly easier to add agent-facing endpoints without disturbing the storefront.

Extension ecosystem maturity. The Magento marketplace has 3,000+ extensions, and the extension architecture is deeply understood by the developer community. Adding protocol support through extensions is a proven pattern — not an architectural experiment.

Multi-store, multi-brand, multi-region. Adobe Commerce's multi-store capabilities are enterprise-grade. For brands operating multiple storefronts — different brands, different regions, different B2B catalogs — the platform's native architecture supports deploying per-store agent configuration with shared infrastructure.

The platform can support agentic commerce. It just needs the protocol layer that Adobe hasn't shipped yet.

The Waiting Risk

The temptation is to wait for Adobe to ship native UCP support. After all, platform-native implementations are typically lower-maintenance than extension-based approaches.

But "waiting for the platform" carries real costs.

Timeline uncertainty. Adobe hasn't announced UCP support, and enterprise platform roadmaps move slowly. "Next year" can mean 18 months. That's 18 months of Google AI Mode, ChatGPT Shopping, and enterprise procurement agents surfacing competitors — not you.

Optimization lag. Even when Adobe ships native UCP, turning it on is a starting point, not a destination. GEO optimization, product data enrichment, discovery manifest configuration, and protocol testing all take time. Brands that start now will be 12–18 months ahead on the optimization curve when native support arrives.

Competitive compounding. AI agent recommendation systems learn from performance data. Brands that are recommended now and convert well get recommended more. The recommendation advantage compounds with time in the market. Every month of delay is a month of compounding your competitors are doing without you.

The math is clear: waiting for native support is the more expensive option.

What Extension-Based Implementation Actually Looks Like

Adobe Commerce's extension architecture supports adding protocol capabilities without core code modifications. A well-designed implementation:

Protocol Extensions

UCP, MCP, and A2A can be delivered as Composer-managed modules that:

Add new API endpoints for agent discovery and transaction
Implement the session lifecycle (discovery → selection → checkout → fulfillment)
Handle protocol-specific authentication and trust verification
Log agent interactions separately from storefront traffic for measurement

These modules hook into Adobe Commerce's existing catalog, pricing, inventory, and checkout layers — they don't replace them. Your existing catalog management, pricing rules, and order processing continue to work exactly as they do today.

GEO and Structured Data

Adobe Commerce's built-in schema generation and meta management can be extended to produce the richer, more complete structured data that GEO requires:

Full Product schema with all attributes, not just name/price/SKU
ShippingDetails and MerchantReturnPolicy schema
AggregateRating markup properly formatted for AI consumption
Availability by store/region for multi-store deployments

This is primarily a configuration and data quality problem, not an architectural one. If your product data is complete, the structured data layer can be built quickly.

Discovery Manifest

A UCP discovery manifest is the entry point for agent protocols — the document that tells AI systems what you sell, how to query it, and what capabilities you support for agent transactions.

For Adobe Commerce, the manifest is generated dynamically from your catalog configuration and exposed at a predictable URL. It requires no storefront changes and no customer-facing UI work.

The B2B Opportunity Is Bigger Than Most Teams Realize

Many Adobe Commerce deployments run B2B storefronts — wholesale portals, account-based pricing, contract catalogs. This is where the MCP and A2A protocol opportunity is particularly significant.

Enterprise buyers are deploying AI procurement systems right now. These systems use MCP to access supplier catalogs, query pricing for their account tier, check availability, and initiate orders against pre-approved purchasing policies — autonomously, without human involvement in each transaction.

If your B2B catalog isn't MCP-accessible, you're invisible to those systems. Your competitors who implement MCP first will receive automated orders from enterprise AI procurement tools that never visit your portal.

For high-frequency B2B relationships, A2A enables fully automated order workflows: the buyer's agent and your supplier agent negotiate terms, validate against purchasing policy, and complete the transaction without a human approving each order.

This is not science fiction. It's in production at select enterprise suppliers today.

The Product Data Problem You Need to Solve First

Here's the honest assessment: for most Adobe Commerce merchants, the protocol implementation is not the hardest part. The product data is.

AI agents can only recommend products they can evaluate. If your catalog has:

Attributes named inconsistently across categories
Missing specifications on a significant portion of SKUs
Pricing that's stale or inconsistent between systems
Images without proper alt text or structured metadata
Product descriptions that are marketing copy, not structured attribute data

...then adding UCP to your platform doesn't solve your agent invisibility problem. It just makes a structurally incomplete catalog accessible via a protocol.

The right approach is to audit and fix your product data in parallel with protocol implementation — or even first. For a typical mid-size Adobe Commerce deployment, a data quality audit surfaces gaps on 20–40% of active SKUs. Fixing those gaps delivers GEO improvements immediately, before a single line of protocol code ships.

How to Sequence an Adobe Commerce Agentic Implementation

Given the above, here's the sequencing we recommend:

Phase 1 (Weeks 1–4): Audit and Prioritize

Product data quality audit across top catalog segments
Structured data and schema gap analysis
API readiness assessment (GraphQL coverage, rate limiting, authentication)
B2B buyer analysis: which accounts could benefit from MCP/A2A?

Phase 2 (Weeks 5–10): Foundation

Fix critical product data gaps in priority categories
Implement comprehensive Schema.org markup
Deploy updated Google Merchant Center feeds
Set up agent traffic measurement

Phase 3 (Weeks 8–14): Protocol Layer

Install and configure UCP extension
Configure discovery manifest for primary catalog
Test agent discovery and checkout flows
Launch to production with monitoring

Phase 4 (Ongoing): B2B Protocols and Optimization

MCP server for enterprise buyer access
A2A for qualified high-frequency accounts
Continuous GEO optimization based on performance data

The timeline for a typical Adobe Commerce implementation is 8–14 weeks to full protocol readiness, assuming product data and API infrastructure are in reasonable shape.

What to Do This Quarter

If you're an Adobe Commerce merchant evaluating this space, the decision framework is simple:

Don't wait for Adobe. The competitive window is open now. Extension-based implementation is proven and production-ready.
Start with data. Run an honest audit of your product data quality before investing in protocol infrastructure. Data gaps are the most common reason implementations underdeliver.
Prioritize by business model. B2C with high-frequency repeat products → UCP first. B2B with enterprise accounts → MCP alongside UCP. High-volume wholesale relationships → A2A.
Measure from day one. Instrument agent traffic separately, track recommendation rates, and set conversion baselines before you optimize.

The brands building agentic infrastructure on Adobe Commerce in the next two quarters will have a head start that's difficult to overcome once the mainstream catches up.

Running Adobe Commerce and want to know your agentic readiness score? Take the free assessment or speak with our team about an Adobe Commerce implementation roadmap.

Beyond UCP: Why MCP and A2A Are the Protocols Your Enterprise Needs to Know

Thu, 12 Feb 2026 09:00:00 GMT

MCP (Model Context Protocol) and A2A (Agent-to-Agent) are two open protocols that operate alongside UCP in enterprise agentic commerce. MCP, developed by Anthropic, enables AI systems to query structured data sources — including product catalogs and inventory — through standardized tool definitions. A2A, developed by Google, enables AI agents to delegate tasks to other specialized agents. Together, UCP + MCP + A2A form the full protocol stack required for end-to-end agentic commerce readiness.

Update (May 2026): MCP shipped its largest revision since launch — the 2026-07-28 release candidate — introducing a stateless protocol core, an extensions framework, and a formal deprecation policy. The strategic guidance in this post still holds; some implementation details (sessions, sampling, logging) are changing. Read the explainer for what's new and what to migrate.

Most commerce teams have heard of UCP by now. If you haven't — it's the Universal Commerce Protocol, the open standard that lets AI shopping agents like Google's find, evaluate, and purchase products on behalf of consumers.

UCP is important. But it's only one layer of the agent economy your brand needs to be ready for.

Two other protocols — MCP (Model Context Protocol) and A2A (Agent-to-Agent) — are already powering enterprise AI workflows, B2B procurement automation, and the infrastructure behind AI shopping assistants. And most enterprise commerce teams have no plan for either.

Why Three Protocols?

The agent economy isn't monolithic. Different AI systems have different access patterns, different trust models, and different use cases. The protocol landscape reflects that.

Think of it this way:

UCP is for consumer-facing AI agents — the AI that helps your customer find and buy products
MCP is for tool-using AI systems — agents that integrate with enterprise software and need structured access to your product and order data
A2A is for agent-to-agent communication — automated workflows between AI systems, especially in B2B and supply chain contexts

A consumer shopping agent, an enterprise procurement bot, and a supply chain optimization system all need to interact with your commerce infrastructure — but they interact differently, with different security requirements and data access patterns.

MCP: The Enterprise Access Layer

Anthropic's Model Context Protocol has been widely adopted as the standard way AI assistants integrate with enterprise software. Slack, Notion, Salesforce, GitHub — they all expose MCP servers. Enterprise AI tools like Claude for Work and Copilot agents use MCP to access data and take actions inside corporate systems.

For commerce, the MCP opportunity is this: enterprise buyers' AI assistants are already using MCP to interact with ERP systems, procurement platforms, and CRM tools. If your commerce infrastructure exposes an MCP server, enterprise AI systems can query your catalog, check pricing, validate availability, and trigger orders — all without a human in the loop.

Who this matters for:

B2B and wholesale sellers with enterprise buyers
Brands with corporate gift, bulk order, or account-based programs
Any business where enterprise procurement decisions influence revenue

The B2B procurement case is particularly compelling. Large enterprises are deploying AI procurement systems that autonomously source, evaluate, and purchase goods within pre-approved policies. If your product data and pricing API aren't MCP-accessible, you're invisible to those systems.

What MCP Implementation Looks Like

An MCP server for commerce exposes capabilities that AI clients can call:

Product search and catalog access
Pricing by account, quantity, or relationship tier
Stock availability and lead times
Order history and account information
Quote generation and approval workflows

The implementation hooks into your existing commerce APIs — it doesn't replace them. For SFCC and Adobe Commerce platforms, this means building on top of OCAPI, SCAPI, or REST/GraphQL layers with an MCP compatibility wrapper.

A2A: The Automation Protocol

Where MCP is about AI tools accessing your data, A2A is about AI agents talking to each other — autonomously, without human involvement in each transaction.

Google's Agent-to-Agent protocol defines how AI agents across different organizations can discover each other, negotiate capabilities, and execute multi-step workflows. The canonical use case is B2B procurement: a buyer's procurement agent autonomously queries a supplier's commerce agent, negotiates terms, validates against purchasing policy, and places an order.

This is already happening in enterprise supply chain. The early deployments are in manufacturing, wholesale distribution, and B2B SaaS procurement.

The commerce implications:

Repeat orders on established terms can be fully automated
Supplier agents can proactively notify buyer agents of price changes, stock alerts, or contract renewals
Multi-supplier comparison shopping can happen at machine speed
Procurement approval workflows can include AI agents as participants

The A2A Security Model

A2A introduces a trust and identity layer that UCP and MCP don't need for consumer contexts. When agents negotiate autonomously, the system needs to verify:

Is this agent authorized to place orders?
What spending limits and approval thresholds apply?
How are disputes and returns handled between agents?
What audit trail is required for compliance?

A2A defines a capability negotiation model where agents exchange what they can do, what permissions they have, and what limits apply — before any transaction begins. For enterprise commerce implementations, this means architecting your agent infrastructure with identity, authorization, and audit logging from day one.

The Multi-Protocol Reality

The brands that win in agentic commerce aren't choosing one protocol — they're implementing the full stack.

A typical enterprise implementation looks like:

UCP for consumer-facing AI agent discovery and purchase
MCP for enterprise buyer tools, B2B account access, and integration with procurement systems
A2A for automated B2B transactions, repeat order workflows, and supply chain integration

These aren't competing choices. They serve different surfaces and different buyer types. A manufacturing brand might drive 70% of revenue through A2A-enabled procurement automation and 30% through UCP-enabled consumer discovery — and those percentages will vary by category and business model.

What the Competitive Window Looks Like

UCP adoption is accelerating — Shopify has native support, Google AI Mode is live, and enterprise implementations are compounding. The consumer agent channel is moving fast.

MCP and A2A adoption is earlier-stage, which means the competitive window is larger. Brands that implement B2B agent infrastructure in 2026 are building the kind of early-mover advantage that compounds over years.

The analogy: brands that built EDI capability in the 1990s to serve big-box retail buyers had a structural advantage for 20 years. Brands that implemented early e-commerce APIs in 2010 captured B2B platform integrations their competitors spent years catching up to.

The protocol stack is the new EDI. And the window to build it before your competitors is open right now.

Assessing Your Protocol Readiness

Before mapping an implementation roadmap, you need to know where you actually stand. Key questions:

For MCP:

Do you have B2B or enterprise buyer segments?
Are your product and pricing APIs comprehensive enough to power automated queries?
Do you have account-based pricing or tiered access that agents would need to handle?

For A2A:

Do you have high-frequency repeat order relationships that could be automated?
Is your order processing infrastructure capable of handling agent-initiated transactions without human review for approved buyers?
Do you have the identity and authorization infrastructure to grant agents appropriate access levels?

For all protocols:

Is your product data complete enough to serve agent queries without human interpretation?
Do you have API rate limiting and authentication that can handle automated traffic?
Is your fulfillment infrastructure capable of handling AI-initiated orders at volume?

These questions surface the gaps that determine how long an implementation actually takes — and why "turn it on" underestimates the work.

The Right Sequencing

For most enterprise brands, the right sequencing is:

Foundation first — Get your product data and APIs to agent-ready quality
UCP — Consumer discovery is the highest-volume opportunity in the near term
MCP — If you have B2B buyers, this can run in parallel with UCP
A2A — Layer on automation for qualified repeat-order relationships

Each layer builds on the one before it. The data quality work for UCP makes MCP cheaper to implement. The API infrastructure for MCP creates the foundation for A2A.

This isn't a three-year project. Brands on modern platforms can complete the full stack in 12–18 months. The question is whether you start now or start when your competitors are already live.

Frequently Asked Questions (FAQ)

What is the difference between UCP, MCP, and A2A?

UCP (Universal Commerce Protocol) facilitates consumer-facing AI shopping agents. MCP (Model Context Protocol) is an enterprise access layer allowing AI tools to securely query backend data. A2A (Agent-to-Agent) enables autonomous multi-agent workflows, specifically for B2B procurement automation.

Why is MCP important for B2B commerce?

MCP allows enterprise buyers' AI assistants to directly query your catalog, check account-specific pricing, and trigger orders without a human continuously driving the interface.

How does the A2A security model work?

Unlike consumer contexts, A2A requires robust identity and authorization layers. Agents must securely negotiate their capabilities, permissions, and spending limits before executing autonomous multi-step transactions.

Not sure which protocols your business actually needs? Get your readiness score across all 7 dimensions including protocol readiness, or talk to us about mapping your specific business model to the right protocol stack.

The Executive's Guide to GEO: Why Your SEO Budget Isn't Protecting You Anymore

Tue, 10 Feb 2026 09:00:00 GMT

SEO rankings no longer protect your brand's AI visibility. As shoppers shift from Google Search to ChatGPT, Perplexity, and Google AI Mode, brands with excellent SEO are being omitted from AI recommendations — because AI models select products based on structured data quality, entity recognition, and content authority, not keyword rankings.

Your SEO team may be doing everything right. Rankings are up. Organic traffic is solid. And yet, when a shopper asks an AI assistant to find the product you sell, your brand doesn't come up. This is the GEO problem — and it's hiding in plain sight on your analytics reports.

What GEO Is (And Isn't)

Generative Engine Optimization is the practice of making your products, brand, and content visible to AI-powered discovery systems — the language models behind Google AI Mode, ChatGPT Shopping, Perplexity, and enterprise shopping agents.

It is not a new name for SEO. The signals that determine AI recommendations are fundamentally different from the signals that determine search rankings.

SEO is about keywords, backlinks, and crawlability. GEO is about structured data completeness, product attribute specificity, and machine-readable policy signals.

A brand can rank #1 for "running shoes" on Google while being completely invisible to an AI agent processing the same query through a language model.

The Business Case You Can Actually Take to the CFO

Here's why this matters in revenue terms.

Adobe reported that AI-driven retail traffic grew 4,700% year-over-year. Salesforce projects that agentic commerce will influence $390 billion in global retail sales by 2028. Early data from UCP implementations shows agent-referred traffic converting at 3–5x the rate of organic search traffic — because shoppers arrive having already made the decision to buy.

The math changes fast when conversion rates triple.

The question isn't whether to invest in GEO. It's whether your competitors get there first and build the trust signals and recommendation history that compound over time.

Why Your Current Stack Doesn't Solve This

The instinct is to assume that existing investments will cover it:

"Our CDN and page speed will help." Page speed is a search ranking factor. AI agents don't load your pages to evaluate products — they parse structured data feeds, schema markup, and API responses.

"Our product content team handles discoverability." Marketing copy optimized for human readers is not the same as machine-readable product attributes. An agent evaluating "ergonomic office chairs for back pain" needs structured fields for lumbar support type, seat height range, and weight capacity — not a paragraph about comfort.

"Our PIM will feed this." Product Information Management systems store your data. Whether that data is structured in ways that AI agents can parse — with complete attributes, consistent naming, and standardized schemas — is a separate problem that most PIMs don't solve out of the box.

The Four Layers of GEO Readiness

Getting your brand in front of AI agents requires investment across four layers:

1. Product Data Quality

This is the foundation. AI agents make recommendations based on what they can read and interpret. If your product data is incomplete, inconsistently structured, or conflicting across systems, agents simply can't make confident recommendations.

Start here:

Every product should have complete, structured attribute data — not just name and price
Attributes should be standardized across categories (not "size" in one place and "dimensions" in another)
Stock levels and pricing must be accurate and real-time
Product descriptions should be factual and specific, not just promotional

Most enterprise catalogs fail this audit on 30–50% of SKUs. Fixing it is not glamorous, but it is the highest-ROI GEO investment.

2. Schema Markup and Structured Data

Schema.org is the vocabulary that AI systems understand. If your products are marked up with comprehensive schema — including attributes, reviews, availability, shipping terms, and return policies — AI agents can read and evaluate them reliably.

Going beyond basic Product schema to include Offer, AggregateRating, ShippingDetails, and MerchantReturnPolicy adds the machine-readable context that drives recommendation probability up.

3. Discovery Infrastructure

AI agents need a way to find your product catalog systematically. This means:

A UCP discovery manifest that exposes your catalog to agent protocols
Comprehensive, accurate Google Merchant Center listings
Product feeds optimized for AI consumption, not just comparison shopping engines
Sitemap and crawlability standards for structured product data

4. Trust Signals

Agents are trained to recommend trustworthy merchants. Trust signals that matter:

Verified reviews on major platforms
Clear, specific return and refund policies at predictable URLs
BBB accreditation and rating
Accurate business information and contact details
Secure checkout certification

These aren't new investments — but ensuring they're in place, current, and machine-readable is part of GEO readiness.

Where to Start: The 90-Day GEO Foundation

You don't need to solve everything at once. Here's a sequenced approach:

Days 1–30: Audit and Baseline

Run a structured data audit against your top 500 SKUs
Identify attribute gaps and inconsistencies
Benchmark your current Schema.org coverage
Check Google Merchant Center health and completeness

Days 31–60: Data and Schema

Fix critical attribute gaps in high-priority categories
Implement or upgrade Product schema to include the full attribute set
Add ShippingDetails and MerchantReturnPolicy schema
Submit updated feeds to Merchant Center

Days 61–90: Discovery and Measurement

Deploy a UCP discovery manifest for your catalog
Set up tracking for AI-referred sessions (user-agent detection)
Establish baseline conversion rates for agent traffic
Report to leadership on early signals

A 90-day foundation gives you measurable progress, a clear ROI story, and the infrastructure to layer protocols and optimization on top.

The Compounding Advantage

The brands that invest in GEO now are building something that compounds.

AI systems learn from performance. Merchants whose products consistently convert when recommended build recommendation history that makes future recommendations more likely. Trust signals accumulate. Attribute completeness improves. The gap between early movers and late movers widens every quarter.

This is structurally similar to what happened with SEO in 2005–2010. The brands that invested early built domain authority that took late movers years to catch up to.

Being recommended by AI agents isn't just a traffic channel. It's a trust asset that appreciates over time.

The Conversation to Have This Week

If you're a VP of eCommerce or a CTO reading this, the conversation to have this week is with your head of SEO or digital marketing: "Are we measuring AI-referred traffic separately? Do we have a GEO plan?"

If the answer is no — you're not behind yet, but the window is closing.

Want to know exactly where you stand? Run the free Agent Commerce Simulation to see how an AI agent experiences your store across all 7 dimensions, including GEO. Or talk to our team about a full GEO audit.

Introducing the First Open-Source UCP Cartridge for SFCC

Tue, 20 Jan 2026 09:00:00 GMT

The ucp-sfcc cartridge is the first open-source, MIT-licensed implementation of Universal Commerce Protocol (UCP) for Salesforce Commerce Cloud. It enables SFCC merchants to expose a UCP discovery manifest, accept agent-initiated checkout sessions, and process payments through the standard UCP payment handler — without waiting for native Salesforce support.

Today, we're excited to announce the release of ucp-sfcc—the first open-source Universal Commerce Protocol cartridge for Salesforce Commerce Cloud. It's free, MIT-licensed, and ready for production use.

Why This Matters

Google's AI Mode is live. Shoppers are already using Gemini to find, compare, and purchase products without ever visiting a traditional storefront. Universal Commerce Protocol (UCP) is the open standard that makes this possible—enabling AI agents to discover products, manage carts, and complete checkouts on behalf of shoppers.

The problem? Salesforce hasn't announced when native UCP support will come to Commerce Cloud. For SFCC merchants, that means waiting indefinitely while competitors capture this new channel.

We built the solution.

What's in the Cartridge

The ucp-sfcc cartridge provides core UCP capabilities for any SFCC storefront:

Discovery Manifest (/.well-known/ucp) — Makes your products visible to AI agents across Google's ecosystem
Checkout Sessions — Full cart management, pricing, tax, and shipping calculations
Payment Handler Integration — Secure payment processing via your existing PSP
Order Management — Real-time order status and tracking
SFRA 6.x+ Compatible — Drop-in architecture that follows SFRA conventions

// Example: Discovery Manifest
{
  "name": "Your Store",
  "description": "Your store description",
  "logo": "https://yourstore.com/logo.png",
  "capabilities": {
    "product_discovery": true,
    "checkout": true,
    "payment": true,
    "order_tracking": true
  }
}

Why Open Source?

We believe UCP adoption benefits the entire commerce ecosystem. By open sourcing our SFCC cartridge, we:

Lower the barrier to entry for agentic commerce
Build trust through transparent, reviewable code
Enable the community to contribute improvements
Establish a standard before fragmentation occurs

The cartridge is free. Our expertise is the product.

Getting Started

Clone the repository and follow the installation guide:

git clone https://github.com/ForkPoint/ucp-sfcc.git

The documentation covers everything from initial setup to production deployment. For enterprise deployments requiring customization, performance tuning, or integration with existing systems, contact our team.

What's Next

This is just the beginning. We're actively developing:

Multi-site and multi-brand configuration support
Advanced capability extensions
Performance optimization tools
Integration accelerators for common PSPs

Star the repo, submit issues, contribute PRs. Let's build the future of commerce together.

Ready to implement UCP? Get your readiness score or view the cartridge on GitHub.

What is Universal Commerce Protocol? A Technical Primer

Sun, 18 Jan 2026 09:00:00 GMT

Universal Commerce Protocol (UCP) is an open standard developed by Google, Shopify, and 20+ partners that enables AI agents to discover products, compare options, and complete purchases on behalf of shoppers. It's the protocol powering checkout in Google AI Mode and Gemini.

This primer covers the technical architecture, core capabilities, and implementation considerations for engineering teams evaluating UCP.

The Problem UCP Solves

Traditional e-commerce was built for humans. Product pages, shopping carts, checkout flows—all designed for people clicking through websites. But AI agents don't browse. They need structured data, programmatic interfaces, and standardized protocols.

Before UCP, each AI agent had to:

Scrape websites (unreliable, brittle)
Integrate custom APIs per merchant (doesn't scale)
Guess at checkout flows (poor conversion)

UCP provides a universal contract between merchants and AI agents.

Architecture Overview

UCP operates through four primary capabilities:

1. Discovery Manifest

The entry point. Located at /.well-known/ucp, this JSON document tells agents what your store offers and how to interact with it.

{
  "schema_version": "1.0",
  "merchant": {
    "name": "Example Store",
    "id": "merchant_12345",
    "description": "Premium outdoor gear",
    "logo_url": "https://store.com/logo.png"
  },
  "capabilities": {
    "product_discovery": {
      "enabled": true,
      "feed_url": "https://store.com/api/ucp/products"
    },
    "checkout": {
      "enabled": true,
      "session_url": "https://store.com/api/ucp/checkout"
    },
    "payment": {
      "enabled": true,
      "methods": ["card", "google_pay", "shop_pay"]
    },
    "order_tracking": {
      "enabled": true,
      "status_url": "https://store.com/api/ucp/orders/{order_id}"
    }
  },
  "policies": {
    "returns": "https://store.com/returns",
    "shipping": "https://store.com/shipping",
    "privacy": "https://store.com/privacy"
  }
}

2. Checkout Sessions

When an agent wants to purchase, it creates a checkout session. This is a stateful object that tracks:

Cart contents (products, quantities, variants)
Shipping address and method
Tax calculations
Applied discounts
Session expiration

// POST /api/ucp/checkout/sessions
{
  "items": [
    {
      "product_id": "SKU-12345",
      "quantity": 2,
      "variant_id": "size-large-color-blue"
    }
  ],
  "shipping_address": {
    "country": "US",
    "postal_code": "94105",
    "region": "CA"
  }
}

// Response
{
  "session_id": "cs_abc123",
  "status": "open",
  "expires_at": "2026-01-18T10:00:00Z",
  "totals": {
    "subtotal": 15999,
    "shipping": 999,
    "tax": 1440,
    "total": 18438
  },
  "currency": "USD"
}

3. Payment Handlers

UCP doesn't process payments directly. It defines a contract for initiating payment through the merchant's existing PSP:

// POST /api/ucp/checkout/sessions/{session_id}/pay
{
  "payment_method": "card",
  "payment_token": "tok_visa_4242",
  "billing_address": {
    "country": "US",
    "postal_code": "94105"
  }
}

The response includes confirmation or required actions (3DS, additional verification).

4. Order Management

Post-purchase, agents can query order status:

// GET /api/ucp/orders/{order_id}
{
  "order_id": "ORD-789456",
  "status": "shipped",
  "tracking": {
    "carrier": "UPS",
    "number": "1Z999AA10123456784",
    "url": "https://ups.com/track?num=..."
  },
  "estimated_delivery": "2026-01-22"
}

Transport Bindings

UCP is transport-agnostic. The protocol can be exposed via:

REST APIs (most common)
MCP (Model Context Protocol) for direct LLM integration
A2A (Agent-to-Agent) for multi-agent workflows

This flexibility means the same UCP implementation can serve Google's agents, Perplexity, and future AI shopping assistants.

Security Considerations

Authentication

UCP supports multiple auth patterns:

Anonymous sessions — Guest checkout, no account required
OAuth 2.0 — Link existing customer accounts for personalized pricing, saved addresses, loyalty points
API keys — For trusted agent partners with pre-negotiated terms

Rate Limiting

Agents can be aggressive. Your implementation should:

Implement rate limiting per agent/IP
Cache product data at the discovery layer
Use async processing for order creation

Data Validation

Never trust agent input. Validate:

Product IDs exist and are available
Quantities don't exceed inventory
Prices match current catalog (agents may cache stale data)
Shipping addresses are deliverable

Platform Implementation Status

Platform	Status	Notes
Shopify Plus	Native	Built-in, requires enablement
SFCC	Custom	No native support; use ucp-sfcc cartridge
BigCommerce	Custom	Announced support, timeline TBD
commercetools	Custom	REST API compatible
Headless/Custom	Custom	Full flexibility

Performance Requirements

Agents expect fast responses. Target latencies:

Discovery manifest: < 100ms
Checkout session create: < 500ms
Payment initiation: < 1000ms
Order status: < 200ms

Cache aggressively. Pre-compute where possible.

Common Implementation Mistakes

1. Skipping the discovery manifest

Teams often jump straight to checkout session implementation because it feels like the "real" work. But agents can't reach your checkout if they can't discover your store. The manifest at /.well-known/ucp is the entry point — get it live first, even with minimal capabilities enabled.

2. Stale product data in the feed

UCP product feeds are often cached aggressively. If your inventory or pricing changes aren't propagating within minutes, agents will recommend products that are out of stock or mispriced. Set short cache TTLs on inventory and pricing fields specifically; longer TTLs on stable attributes like descriptions and images are fine.

3. Session expiry not handled gracefully

Checkout sessions expire. Agents don't always complete purchases in one shot — they may pause for user confirmation, additional queries, or multi-agent handoffs. If your session expiry is 15 minutes and the agent doesn't handle 410 Gone responses correctly, the shopper gets a broken experience. Design for session resumption and expose clear expiry timestamps.

4. No rate limiting strategy

AI agents can generate significant traffic spikes during product comparison workflows. A single agent query might fan out into hundreds of product detail requests. Implement per-agent-identifier rate limiting at the discovery and product feed layers before you go live.

5. Authentication as an afterthought

Anonymous checkout (guest) is the simplest path to launch, but it gives up personalized pricing, loyalty, and saved preferences. Plan your OAuth 2.0 account linking flow from the start — retrofitting it after launch is more disruptive than building it in.

UCP vs. Direct API Integration

Some teams ask: why UCP? We already have REST APIs. Can't agents just use those?

Technically yes — a determined agent developer can reverse-engineer your checkout flow and call your existing APIs. But UCP provides three things a custom integration can't:

Discoverability — Agents don't know your custom API exists. UCP's /.well-known/ucp manifest is how they find you without any prior knowledge of your store.
Standardization — Google's agents, Perplexity's agents, and third-party shopping assistants all speak the same UCP protocol. One implementation serves all of them.
Trust — UCP-compliant merchants are verified participants in the ecosystem. Agents are more likely to recommend merchants with a valid UCP manifest than those without.

Relationship to MCP and A2A

UCP doesn't operate in isolation. The full agentic commerce protocol stack is:

UCP — The consumer-facing commerce layer: discovery, cart, checkout, payment, order tracking
MCP (Model Context Protocol) — The data access layer: lets AI tools query your catalog, inventory, and orders through standardized tool definitions. Primarily relevant for B2B and enterprise buyer scenarios.
A2A (Agent-to-Agent) — The automation layer: lets AI agents from different organizations communicate directly. Enables fully automated B2B procurement workflows.

UCP is typically the first protocol to implement because it has the highest near-term consumer traffic impact. MCP and A2A add incremental B2B and enterprise buyer coverage on top.

Platform Implementation Status

Platform	Status	Notes
Shopify Plus	Native	Built-in, requires enablement
SFCC	Custom	No native support; use ucp-sfcc cartridge
BigCommerce	Custom	Announced support, timeline TBD
Adobe Commerce	Custom	Extension-based; no native support announced
commercetools	Custom	REST API compatible
Headless/Custom	Custom	Full flexibility via direct API implementation

Performance Requirements

Agents expect fast responses. Target latencies:

Discovery manifest: < 100ms
Product feed: < 300ms (paginated)
Checkout session create: < 500ms
Payment initiation: < 1000ms
Order status: < 200ms

Cache aggressively. Pre-compute where possible. Agents that encounter timeouts will move to a competitor in the same session.

Frequently Asked Questions (FAQ)

What is the Universal Commerce Protocol (UCP)?

UCP is an open standard that enables AI agents (like Google AI or Gemini) to discover products, compare options, and complete purchases natively on storefronts without human intervention.

How does UCP differ from traditional APIs?

Unlike custom REST APIs that require one-off integrations, UCP provides a standardized /.well-known/ucp manifest. This makes your storefront instantly discoverable and interoperable with any UCP-compliant shopping agent.

Is UCP available on Salesforce Commerce Cloud (SFCC)?

Yes, ForkPoint created the first open-source UCP cartridge for SFCC, allowing enterprise brands to enable agentic checkout flows on the platform.

What is the role of the Discovery Manifest in UCP?

The Discovery Manifest is the entry point for AI agents. It tells the agent what your store offers, where your product feeds are located, and which checkout and payment capabilities are currently enabled.

Getting Started

Audit your current APIs — Do you have the data UCP needs? Inventory, pricing, and fulfillment data must be real-time or near-real-time.
Evaluate platform options — Native support (Shopify Plus) vs. cartridge (SFCC) vs. custom implementation (headless, Adobe, BigCommerce).
Start with discovery — Get your manifest and product feed live. Agents can start recommending your products even before checkout is enabled.
Add checkout in phase 2 — Sessions, payment handling, and order management.
Test with agent simulators — Validate your implementation against real agent traffic patterns before production.

Ready to implement? Get your readiness score or explore our open-source SFCC cartridge on GitHub.

Why We Open Sourced Our UCP Cartridge

Thu, 15 Jan 2026 09:00:00 GMT

We open-sourced our UCP cartridge for Salesforce Commerce Cloud because agentic commerce adoption requires the whole ecosystem to move — not just well-resourced enterprises. An MIT-licensed, production-ready implementation lowers the barrier for every SFCC merchant to become agent-ready, which grows the channel we've built our business around.

Here's the full reasoning behind that decision.

The DWithEase Precedent

Eight years ago, we faced a similar decision. Business Manager sessions in SFCC expired every 15 minutes, and it was driving developers insane. We built a browser extension to fix it.

We could have charged for it. Instead, we made it free.

Today, DWithEase has 25,000+ active users. It's become essential infrastructure for SFCC developers worldwide. That user base—those relationships—became the foundation of everything we've built since.

The lesson: infrastructure wants to be free.

Network Effects in Standards Adoption

UCP is a protocol, not a product. Its value comes from network effects:

More merchants implementing UCP → More agents supporting it
More agents supporting UCP → More merchants implementing it
More participants → Better standard → Faster innovation

By keeping our cartridge proprietary, we'd be optimizing for short-term revenue at the cost of long-term ecosystem growth. A fragmented market with multiple incompatible implementations helps no one.

Open sourcing accelerates the flywheel.

The Real Business Model

Here's what we've learned from eight years in this space: the cartridge isn't the product—expertise is.

The open-source cartridge handles core UCP capabilities. It's enough for a developer to get started, experiment, build a proof of concept. That's exactly what we want.

But enterprise deployments? Those require:

Multi-site configuration across brand portfolios
Performance optimization at scale
Custom capability extensions for unique business requirements
Integration with existing OMS, ERP, and PSP systems
24/7 support and SLA guarantees
Ongoing optimization as UCP evolves

That's where we add value. The cartridge gets you in the door. We help you win.

Building Trust Through Transparency

When we talk to CTOs and VPs of Engineering, they have legitimate concerns:

"How do I know your implementation is secure?"
"What happens if you go out of business?"
"Are we locked into your ecosystem?"

Open source answers all three:

Security through transparency — Review the code yourself. Run your own audits. We welcome scrutiny.
No vendor lock-in — The cartridge is MIT licensed. Fork it, modify it, run it forever without us. Your implementation isn't hostage to our business.
Community continuity — Even if we disappeared tomorrow, the code remains. Other developers can maintain it. The ecosystem survives.

Trust is earned, not claimed. Open source is how we earn it.

The Strategic Bet

We're betting on three things:

1. UCP Will Be Big

Google doesn't launch protocols lightly. Shopify doesn't join initiatives without conviction. The consortium behind UCP includes the biggest names in commerce.

AI-driven shopping isn't a fad. It's a fundamental shift in how commerce works. Merchants who optimize for agents will win; those who don't will become invisible.

The TAM is massive. We want to be the experts.

2. SFCC Will Be Slow

Salesforce is a large organization. Their roadmap is packed. Native UCP support will come eventually, but "eventually" means 12-24 months at minimum.

That gap is our window. Every merchant who implements UCP using our cartridge is a merchant we've helped, built a relationship with, proven value to.

When Salesforce does release native support, guess who they'll call to migrate?

3. The Best Marketing Is Shipping

We could spend $500K on paid acquisition. Or we could build something useful and give it away.

The cartridge markets itself:

Developers share it
Conference speakers reference it
Blog posts link to it
Competitors have to acknowledge it

That's the kind of mindshare money can't buy.

What We're Not Open Sourcing

To be clear: not everything is free.

Our proprietary services include:

Readiness assessments and gap analysis
Enterprise implementation and customization
Performance optimization and tuning
Managed services and 24/7 support
Strategic consulting on agentic commerce

The cartridge is the foundation. Services are the business.

Join Us

Star the repo. Submit issues. Contribute PRs. Build on top of it.

Let's make agentic commerce accessible to every merchant, not just those with seven-figure budgets.

The code is at github.com/ForkPoint/ucp-sfcc.

Questions? Reach out. We're happy to discuss the cartridge, our roadmap, or anything else.

The 65% Problem: Why Most Retailers Aren't Ready for Agentic Commerce

Mon, 12 Jan 2026 09:00:00 GMT

A recent Optimizely study found that 65% of retailers have taken no steps to prepare for agentic commerce. Not "made limited progress." Not "exploring options." No steps at all.

Meanwhile, AI-driven retail traffic grew 4,700% year-over-year according to Adobe.

Something doesn't add up.

The Awareness Gap

When we talk to e-commerce leaders, we hear three consistent themes:

1. "It's Not Urgent Yet"

Many executives believe agentic commerce is a 2027 or 2028 problem. They're watching the space, waiting for clearer signals before investing.

The data says otherwise. Google AI Mode is live today. Shoppers are already asking Gemini to find and purchase products. The early adopters are capturing traffic that late movers will never see.

First-mover advantage in new channels is real. Ask anyone who optimized for mobile in 2010 vs. 2015.

2. "Our Platform Will Handle It"

There's an assumption that Salesforce, Adobe, or whoever provides your commerce platform will ship native UCP support, and you'll just turn it on.

This thinking has two problems:

Timing — Platform vendors haven't committed to timelines. Salesforce hasn't even announced UCP support for Commerce Cloud. Adobe hasn't either. You could be waiting 12-24 months while competitors capture the channel.

Optimization — Even when native support arrives, "turning it on" is just the beginning. UCP implementation is like SEO implementation—technically you can do the basics, but winning requires strategy, optimization, and continuous improvement.

3. "We Don't Have Budget"

Some teams correctly identify that UCP implementation requires investment. But without clear ROI projections, they can't secure funding.

This is a measurement problem disguised as a budget problem. You can't measure ROI on a channel you're not participating in. Early movers are building attribution models that will define how this channel gets valued for years.

The Real Reasons Retailers Aren't Ready

Beyond the stated objections, we see structural issues:

Product Data Isn't Agent-Ready

AI agents need structured, consistent, comprehensive product data to make good recommendations. Most product catalogs are optimized for human browsing, not machine consumption.

Common issues:

Inconsistent attribute naming across categories
Missing or sparse product descriptions
Images without proper alt text or structured metadata
Pricing discrepancies between systems
Inventory data that's stale or inaccurate

Fixing product data isn't glamorous, but it's the foundation of agent visibility.

Tech Teams Are Overloaded

E-commerce engineering teams are already stretched thin. Between platform upgrades, new feature requests, integration maintenance, and security patches, there's no slack in the system.

UCP feels like "one more thing" rather than a strategic priority. Without executive sponsorship and dedicated resources, it never makes the sprint.

Organizational Silos

Agentic commerce touches everything:

Engineering owns the technical implementation
Marketing owns product content and discovery
Operations owns fulfillment and inventory
Finance owns pricing and payment

No single team has authority to drive a cross-functional initiative. Projects without clear ownership don't ship.

What the 35% Are Doing

The minority of retailers who are preparing share common characteristics:

Executive Sponsorship

Someone at VP level or above has claimed agentic commerce as a strategic priority. They've allocated budget, assigned resources, and are tracking progress in executive reviews.

Dedicated Resources

Whether internal team members or external partners, specific humans are accountable for UCP implementation. It's not a "when we have time" initiative.

Phased Approach

Smart teams aren't trying to boil the ocean. They're starting with:

Discovery only — Get the UCP manifest live, even before checkout is ready
Limited catalog — Enable agentic commerce for top SKUs first
Single market — Launch in one region before global rollout

Progress beats perfection.

Measurement Framework

They're instrumenting from day one:

How many agent sessions are hitting the site?
What products are agents recommending?
What's the conversion rate for agent-initiated checkouts?
How does agent traffic compare to organic?

You can't optimize what you can't measure.

The Window Is Closing

Here's the uncomfortable truth: the 65% aren't going to stay unprepared forever. Eventually, they'll catch up. Platform vendors will ship native support. Consultants will productize implementation.

But by then, the early movers will have:

Established trust signals with AI agents
Built historical data for optimization
Captured brand association in the "AI recommends" space
Developed institutional knowledge that's hard to replicate

Being in the 35% today is a competitive advantage. Being in the 35% in 2028 is table stakes.

What You Should Do Monday

If you're in the 65%, here's your action plan:

Week 1: Assess Your Position

Audit your product data quality
Inventory your current API infrastructure
Identify your UCP readiness gaps

Week 2: Build the Business Case

Model the traffic opportunity (we can help)
Calculate implementation investment
Compare to cost of waiting

Week 3: Secure Sponsorship

Present findings to executive leadership
Request dedicated resources
Define success metrics

Week 4: Start Building

Choose implementation path (native, partner, or custom)
Allocate engineering resources
Set a launch target

You don't need a perfect plan. You need momentum.

Not sure where to start? Run the Agent Commerce Simulation to see where an AI agent gets stuck in your store, or book a call to discuss your specific situation.

GEO vs. SEO: Optimizing for AI Agent Discovery

Thu, 08 Jan 2026 09:00:00 GMT

Generative Engine Optimization (GEO) is the practice of making your brand and products discoverable to AI systems like ChatGPT, Google AI Mode, and Perplexity — which surface recommendations through language models rather than keyword rankings. Where SEO targets search engine algorithms, GEO targets the structured data, content clarity, and authority signals that AI models use to decide what to recommend.

For 25 years, SEO has been the discipline of getting found in search. Keywords, backlinks, page speed, mobile optimization—a mature playbook that every e-commerce team knows. But AI agents don't use Google Search. They use language models that process information differently, prioritize different signals, and surface results through entirely different mechanisms.

How AI Agents "Search"

When a traditional search engine ranks results, it's evaluating:

Keyword relevance
Domain authority
Backlink profile
Page speed and Core Web Vitals
User engagement signals

When an AI agent selects products to recommend, it's evaluating:

Structured data completeness
Product attribute specificity
Price competitiveness
Availability confidence
Policy clarity (returns, shipping)
Trust signals from merchant reputation

The overlap is smaller than you'd think.

Key Differences

1. Keywords vs. Attributes

SEO mindset: "What keywords should we target on our product pages?"

GEO mindset: "Do our product attributes answer every question an agent might have?"

AI agents don't match keywords—they understand intent. A shopper asking for "comfortable running shoes for marathon training" triggers the agent to look for:

Product category (running shoes)
Comfort indicators (cushioning type, weight)
Use case suitability (long-distance, training)

If your product data says "Running Shoe - Black - Size 10" and nothing else, the agent has no signal to work with. You're invisible.

2. Page Content vs. Structured Data

SEO mindset: "We need 1,500 words of optimized content on each product page."

GEO mindset: "We need comprehensive, machine-readable product data in standardized schemas."

Agents don't read your marketing copy. They parse structured data. Schema.org markup, UCP manifests, product feeds—that's the content that matters.

// What agents want to see
{
  "@type": "Product",
  "name": "CloudRunner Pro Marathon Shoe",
  "category": "Running Shoes > Marathon",
  "attributes": {
    "cushioning": "maximum",
    "weight": "8.5oz",
    "drop": "10mm",
    "support": "neutral",
    "surface": ["road", "track"],
    "distance": ["marathon", "ultra"]
  },
  "price": 179.99,
  "availability": "in_stock",
  "shipping": {
    "free_threshold": 50,
    "estimated_days": "2-4"
  },
  "returns": {
    "window_days": 60,
    "free_returns": true
  }
}

3. Traffic Volume vs. Conversion Quality

SEO mindset: "We need more traffic to our site."

GEO mindset: "We need agents to recommend us to the right shoppers."

Agent-driven traffic is fundamentally different:

Shoppers arrive with high purchase intent
Product already pre-selected by agent
Comparison shopping already complete
Price expectations already set

Conversion rates for agent-referred traffic can be 3-5x higher than organic search. But you can't measure success in pageviews—you measure it in recommendation rate and checkout completion.

4. Backlinks vs. Trust Signals

SEO mindset: "We need more high-authority backlinks."

GEO mindset: "We need trust signals that agents can verify."

Agents are trained to recommend trustworthy merchants. Trust signals include:

BBB accreditation and rating
Verified reviews from trusted platforms
Clear return and refund policies
Secure payment options
Physical business address
Customer service availability

These aren't new—but the importance weighting is different than traditional SEO.

5. SERP Position vs. Recommendation Probability

SEO mindset: "We need to rank #1 for 'running shoes'"

GEO mindset: "We need to maximize probability of recommendation for relevant queries"

There's no "page 1" in agentic commerce. There's only: recommended or not recommended.

And the recommendation algorithm isn't a single ranking—it's a complex model that considers:

Query match (does this product fit what the shopper asked for?)
Competitive positioning (is this the best option available?)
Merchant trust (can we confidently send a shopper here?)
Historical performance (have previous recommendations converted well?)

You can't reverse-engineer it like a search algorithm. You can only optimize for fundamentals.

The GEO Playbook

1. Audit Your Product Data

Start with these questions:

Do all products have complete attributes (not just required fields)?
Are attributes standardized across categories?
Is pricing consistent between systems?
Is inventory data real-time?
Are product descriptions factual, not just promotional?

Most catalogs fail this audit. Fixing data quality is the highest-ROI GEO investment.

2. Implement Comprehensive Schema

Go beyond basic Schema.org Product markup:

Add detailed specifications
Include shipping and returns information
Mark up reviews and ratings
Specify availability by region
Include price drop history (agents may prioritize deals)

3. Make Policies Machine-Readable

Agents need to answer: "Can I confidently recommend this merchant?"

That means your policies need to be:

Clear and specific (not vague legalese)
Accessible at predictable URLs
Structured in a parseable format
Consistent with actual practice

A 14-day return policy clearly stated beats a "generous return policy" vaguely implied.

4. Build Trust Infrastructure

Claim and optimize your Google Merchant Center listing
Gather verified reviews on major platforms
Ensure contact information is accurate and accessible
Display security badges and certifications
Maintain BBB accreditation

5. Instrument and Iterate

GEO is nascent. The playbook will evolve as we learn more about how agents rank recommendations.

Set up tracking for:

Agent-initiated sessions (user agent detection)
Product recommendation rates (if measurable)
Agent-referred conversion rates
Post-purchase satisfaction for agent traffic

The teams that build measurement frameworks now will have the data to optimize later.

SEO Isn't Dead

To be clear: traditional SEO still matters. Organic search isn't going away. The majority of commerce traffic still comes through traditional channels.

But the mix is shifting. Agent-driven traffic is growing exponentially while search traffic grows linearly. The teams that master both disciplines will win.

GEO isn't replacing SEO. It's joining it.

Ready to optimize for agents? Learn about our agentic commerce strategy services or get your readiness score.

UCP Checkout Sessions: A Deep Dive

Mon, 05 Jan 2026 09:00:00 GMT

Checkout sessions are the core transactional mechanism in Universal Commerce Protocol. They represent the stateful journey from "add to cart" to "order confirmed"—but designed for AI agents rather than human shoppers.

This deep dive covers the complete lifecycle, implementation patterns, and edge cases you'll encounter in production.

Session Lifecycle Overview

Sessions move through discrete states:

created — Session initialized with cart items
address_set — Shipping address provided, rates calculated
shipping_selected — Shipping method chosen
payment_pending — Ready for payment initiation
payment_processing — Payment in progress
completed — Order placed successfully
expired — Session timed out without completion
abandoned — Explicitly cancelled

Creating a Session

Sessions begin when an agent adds items to cart:

POST /api/ucp/checkout/sessions
Content-Type: application/json

{
  "items": [
    {
      "product_id": "SKU-RUNNER-PRO-001",
      "variant_id": "size-10-color-black",
      "quantity": 1
    },
    {
      "product_id": "SKU-SOCKS-CUSHION-003",
      "quantity": 2
    }
  ],
  "locale": "en-US",
  "currency": "USD"
}

Response Structure

{
  "session_id": "cs_live_a1b2c3d4e5f6",
  "status": "created",
  "created_at": "2026-01-05T14:30:00Z",
  "expires_at": "2026-01-05T15:30:00Z",
  "items": [
    {
      "line_id": "li_001",
      "product_id": "SKU-RUNNER-PRO-001",
      "variant_id": "size-10-color-black",
      "name": "CloudRunner Pro Marathon Shoe",
      "quantity": 1,
      "unit_price": 17999,
      "line_total": 17999,
      "available": true,
      "image_url": "https://store.com/images/runner-pro.jpg"
    },
    {
      "line_id": "li_002",
      "product_id": "SKU-SOCKS-CUSHION-003",
      "name": "Performance Cushion Socks (3-pack)",
      "quantity": 2,
      "unit_price": 1599,
      "line_total": 3198,
      "available": true,
      "image_url": "https://store.com/images/socks.jpg"
    }
  ],
  "totals": {
    "subtotal": 21197,
    "discount": 0,
    "shipping": null,
    "tax": null,
    "total": 21197
  },
  "currency": "USD",
  "requires": ["shipping_address"]
}

Key Implementation Notes

Pricing should be authoritative. Don't trust prices sent by the agent. Always look up current catalog prices at session creation.

Inventory validation is critical. Check availability before confirming items. Return clear errors if products are out of stock or discontinued.

Session expiration prevents stale carts. 60 minutes is typical, but adjust based on your checkout complexity.

Updating Sessions

Sessions are modified through PATCH requests. Each update recalculates totals.

Adding Shipping Address

PATCH /api/ucp/checkout/sessions/cs_live_a1b2c3d4e5f6
Content-Type: application/json

{
  "shipping_address": {
    "recipient": "John Smith",
    "line1": "123 Market Street",
    "line2": "Apt 4B",
    "city": "San Francisco",
    "region": "CA",
    "postal_code": "94105",
    "country": "US",
    "phone": "+14155551234"
  }
}

Response now includes shipping options:

{
  "session_id": "cs_live_a1b2c3d4e5f6",
  "status": "address_set",
  "shipping_address": { /* address object */ },
  "shipping_options": [
    {
      "id": "standard",
      "name": "Standard Shipping",
      "description": "5-7 business days",
      "price": 799,
      "estimated_delivery": {
        "min_days": 5,
        "max_days": 7
      }
    },
    {
      "id": "express",
      "name": "Express Shipping",
      "description": "2-3 business days",
      "price": 1499,
      "estimated_delivery": {
        "min_days": 2,
        "max_days": 3
      }
    },
    {
      "id": "overnight",
      "name": "Overnight Shipping",
      "description": "Next business day",
      "price": 2999,
      "estimated_delivery": {
        "min_days": 1,
        "max_days": 1
      }
    }
  ],
  "totals": {
    "subtotal": 21197,
    "discount": 0,
    "shipping": null,
    "tax": null,
    "total": 21197
  },
  "requires": ["shipping_selection"]
}

Selecting Shipping Method

PATCH /api/ucp/checkout/sessions/cs_live_a1b2c3d4e5f6
Content-Type: application/json

{
  "shipping_selection": "express"
}

Response now includes calculated taxes:

{
  "session_id": "cs_live_a1b2c3d4e5f6",
  "status": "shipping_selected",
  "shipping_selection": {
    "id": "express",
    "name": "Express Shipping",
    "price": 1499
  },
  "totals": {
    "subtotal": 21197,
    "discount": 0,
    "shipping": 1499,
    "tax": 1872,
    "total": 24568
  },
  "requires": ["payment"]
}

Applying Discount Codes

PATCH /api/ucp/checkout/sessions/cs_live_a1b2c3d4e5f6
Content-Type: application/json

{
  "discount_code": "WELCOME20"
}

Validation response if invalid:

{
  "error": {
    "code": "invalid_discount",
    "message": "Code WELCOME20 has expired",
    "field": "discount_code"
  }
}

Payment Initiation

When all requirements are satisfied, agents can initiate payment:

POST /api/ucp/checkout/sessions/cs_live_a1b2c3d4e5f6/pay
Content-Type: application/json

{
  "payment_method": "card",
  "payment_token": "tok_visa_4242424242424242",
  "billing_address": {
    "line1": "123 Market Street",
    "city": "San Francisco",
    "region": "CA",
    "postal_code": "94105",
    "country": "US"
  }
}

Successful Payment Response

{
  "session_id": "cs_live_a1b2c3d4e5f6",
  "status": "completed",
  "order": {
    "order_id": "ORD-2026-01-05-789456",
    "order_number": "FP-789456",
    "status": "confirmed",
    "created_at": "2026-01-05T14:45:00Z",
    "totals": {
      "subtotal": 21197,
      "discount": 0,
      "shipping": 1499,
      "tax": 1872,
      "total": 24568
    },
    "items": [ /* line items */ ],
    "shipping_address": { /* address */ },
    "tracking_url": "https://store.com/orders/FP-789456/track",
    "estimated_delivery": "2026-01-08"
  },
  "payment": {
    "id": "pay_a1b2c3d4",
    "status": "captured",
    "amount": 24568,
    "method": "card",
    "last_four": "4242"
  }
}

Handling 3D Secure

If the payment requires additional authentication:

{
  "session_id": "cs_live_a1b2c3d4e5f6",
  "status": "payment_action_required",
  "payment": {
    "id": "pay_a1b2c3d4",
    "status": "requires_action",
    "action": {
      "type": "three_d_secure",
      "redirect_url": "https://acs.bank.com/3ds/challenge/...",
      "return_url": "https://store.com/api/ucp/checkout/sessions/cs_live_a1b2c3d4e5f6/3ds-return"
    }
  }
}

Agents handle 3DS by directing the user to complete authentication, then polling the session for status updates.

Error Handling

Inventory Changes During Checkout

{
  "error": {
    "code": "item_unavailable",
    "message": "One or more items are no longer available",
    "details": [
      {
        "line_id": "li_001",
        "product_id": "SKU-RUNNER-PRO-001",
        "issue": "out_of_stock",
        "available_quantity": 0
      }
    ]
  }
}

Price Changes During Checkout

{
  "error": {
    "code": "price_changed",
    "message": "Prices have changed since session creation",
    "details": [
      {
        "line_id": "li_002",
        "previous_price": 1599,
        "current_price": 1799
      }
    ],
    "action_required": "confirm_price_change"
  }
}

Payment Failures

{
  "error": {
    "code": "payment_declined",
    "message": "Your card was declined",
    "decline_code": "insufficient_funds",
    "retry_allowed": true
  }
}

Session Management Best Practices

1. Idempotency

Use idempotency keys to prevent duplicate operations:

POST /api/ucp/checkout/sessions/cs_live_a1b2c3d4e5f6/pay
Idempotency-Key: pay_attempt_abc123

If the same key is sent twice, return the original response instead of processing again.

2. Optimistic Locking

Include version numbers to detect concurrent modifications:

{
  "session_id": "cs_live_a1b2c3d4e5f6",
  "version": 4,
  // ... rest of session
}

Reject updates where the provided version doesn't match:

PATCH /api/ucp/checkout/sessions/cs_live_a1b2c3d4e5f6
If-Match: "4"

3. Session Recovery

Store enough state to recover from failures:

{
  "recovery": {
    "can_retry_payment": true,
    "items_reservable": true,
    "original_session_id": "cs_live_a1b2c3d4e5f6",
    "recovery_expires_at": "2026-01-05T16:30:00Z"
  }
}

4. Rate Limiting

Implement per-session rate limits to prevent abuse:

Session creation: 100/hour per IP
Session updates: 30/minute per session
Payment attempts: 5/hour per session

Testing Checkout Sessions

Test Card Numbers

Number	Behavior
4242424242424242	Succeeds
4000000000000002	Declines
4000000000003220	Requires 3DS
4000000000009995	Insufficient funds

Test Scenarios Checklist

[ ] Successful checkout end-to-end
[ ] Inventory changes mid-checkout
[ ] Price changes mid-checkout
[ ] Session expiration handling
[ ] Payment decline and retry
[ ] 3D Secure flow completion
[ ] Discount code validation
[ ] International shipping address
[ ] Multi-item cart modifications

Implementing checkout sessions? Our open-source SFCC cartridge includes a complete reference implementation. Questions? Get in touch.

Agentic Commerce KPIs: What to Measure and Why

Fri, 02 Jan 2026 09:00:00 GMT

Agentic commerce requires a new measurement framework because traditional e-commerce metrics — sessions, bounce rates, click-through rates — assume a human is browsing. The five core KPIs for agent-driven commerce are: agent session rate, recommendation rate by AI platform, add-to-cart conversion from agent sessions, agent-initiated revenue attribution, and protocol error rate.

This guide explains each metric, how to track it, and what benchmarks to target based on early implementation data.

Why Traditional E-commerce Metrics Fall Short

Traditional e-commerce analytics assumes humans are browsing:

Pageviews — Agents don't view pages, they call APIs
Time on site — A 200ms API call vs. a 5-minute browsing session
Bounce rate — There's no "bouncing" from an API endpoint
Cart abandonment — Session expiration ≠ abandonment intent

We need metrics designed for programmatic commerce.

The Agentic Commerce Metrics Stack

Layer 1: Discovery Metrics

These measure whether agents can find your products.

Manifest Health Score

Is your UCP manifest accessible?
Does it validate against the spec?
How often is it requested?

manifest_health = (successful_requests / total_requests) × schema_compliance_score

Discovery Request Volume

Total discovery API calls per period
Unique agents calling discovery
Product categories being queried

Catalog Coverage

% of catalog exposed via UCP
% of SKUs with complete attributes
Attribute completeness by category

Layer 2: Recommendation Metrics

These measure whether agents are selecting your products.

Recommendation Rate

How often are your products recommended when relevant queries occur?
This is hard to measure directly—you typically infer from checkout session creation

Query-to-Session Conversion

For discovery queries that match your products, how many result in checkout sessions?

query_to_session = checkout_sessions_created / relevant_discovery_queries

Competitive Win Rate

When shoppers ask for products you carry, do they end up at your store or a competitor?
Measure through market research and shopper surveys

Layer 3: Transaction Metrics

These measure checkout performance.

Session Creation Rate

Checkout sessions created per day/week
Growth rate over time
Sessions by agent source (Google, Perplexity, etc.)

Session Completion Rate

Sessions that reach payment / sessions created

completion_rate = completed_sessions / created_sessions

Session Abandonment Analysis

Where do sessions drop off?
Address entry, shipping selection, payment?
Error codes causing abandonment

Average Order Value (Agent)

AOV for agent-initiated orders vs. traditional
Product mix differences

Layer 4: Revenue Metrics

These measure business impact.

Agent-Attributed Revenue

Total revenue from agent-initiated checkouts
% of total revenue from agent channel

Agent Revenue Growth Rate

MoM and YoY growth of agent revenue
Compare to overall e-commerce growth

Customer Acquisition Cost (Agent)

Cost to acquire a customer through agent channel
Should be lower than paid acquisition

Agent Customer Lifetime Value

Do agent-acquired customers have higher or lower LTV?
Track repeat purchases by acquisition channel

Building Your Measurement Framework

Step 1: Instrument Your UCP Layer

Add logging to every UCP endpoint:

// Example logging structure
{
  timestamp: "2026-01-02T10:30:00Z",
  event_type: "ucp_checkout_session_created",
  session_id: "cs_abc123",
  agent_identifier: "google-shopping-agent/1.0",
  ip_address: "hashed_or_anonymized",
  items: [
    { product_id: "SKU-123", quantity: 1 }
  ],
  locale: "en-US",
  currency: "USD"
}

Step 2: Track Session State Changes

Every state transition should be logged:

{
  timestamp: "2026-01-02T10:32:00Z",
  event_type: "ucp_session_state_change",
  session_id: "cs_abc123",
  previous_state: "created",
  new_state: "address_set",
  duration_in_previous_state_ms: 120000
}

Step 3: Connect to Your Analytics Stack

Feed UCP events into your existing analytics:

Step 4: Build Dashboards

Executive Dashboard

Agent revenue (absolute and % of total)
Week-over-week growth
Session completion rate
Top products by agent sales

Operations Dashboard

Session creation by hour/day
Error rates by type
Average session duration
Geographic distribution

Product Dashboard

Products most recommended by agents
Products with high discovery but low conversion
Attribute completeness scores
Price competitiveness signals

Metrics to Watch Early

When you're just getting started, focus on:

1. Is Anyone Knocking?

Before worrying about conversion, confirm agents are finding you:

Discovery endpoint request volume
Unique agent user-agents
Geographic distribution of requests

2. Are Sessions Starting?

Session creation events
Session creation by agent source
Errors during session creation

3. Where Do Sessions Break?

Map the funnel:

Session Created: 1000
Address Set:      800 (80%)
Shipping Selected: 750 (75%)
Payment Started:   600 (60%)
Payment Completed: 500 (50%)

Identify your biggest drop-off and fix it first.

Benchmarks (Early Estimates)

These are rough benchmarks based on limited early data. Your mileage will vary.

Metric	Early Adopter	Mature Implementation
Session Completion Rate	30-40%	50-70%
Agent AOV vs. Traditional	0.8-1.0x	1.2-1.5x
Agent % of Revenue	0.1-1%	5-15% (projected)
Agent CAC vs. Paid	0.3-0.5x	0.1-0.3x

Common Measurement Mistakes

1. Treating Agent Traffic Like Human Traffic

Don't pour agent events into your standard web analytics. They'll pollute human behavior metrics and create confusing dashboards.

Solution: Separate data streams from the start.

2. Obsessing Over Session Volume

Early on, session volume is vanity. A hundred sessions that don't convert teach you nothing.

Solution: Focus on completion rate first, volume second.

3. Ignoring Error Analysis

When sessions fail, you get error codes. Those codes are a goldmine.

Solution: Log every error, categorize by type, fix systematically.

4. Not Tracking by Agent

Different agents may have different behaviors. Google's agent might convert well; another might send garbage traffic.

Solution: Segment all metrics by agent identifier.

Setting Targets

For your first 90 days:

Month 1: Establish Baselines

Instrument everything
No optimization, just measurement
Document current state

Month 2: Identify Opportunities

Where are the biggest drop-offs?
Which products get discovered but not purchased?
What errors occur most frequently?

Month 3: Targeted Improvements

Fix top 3 issues identified
Measure impact
Set ongoing targets

Need help building your measurement framework? Our agentic commerce strategy service includes measurement setup and optimization. Get in touch.

Build vs. Buy: UCP Implementation Decision Framework

Sun, 28 Dec 2025 09:00:00 GMT

The decision to build UCP implementation in-house versus partnering with specialists comes down to three factors: your team's existing protocol experience, your target go-live timeline, and your platform's current state of native UCP support. For most enterprise teams on SFCC or Adobe Commerce, partnering is 3–6x faster to production; for Shopify Plus teams with strong developer capacity, in-house is often viable.

"We'll just build it ourselves."

It's a reasonable instinct. Your team knows your platform. You have developers. UCP is an open protocol with public documentation. How hard can it be?

Sometimes building in-house is the right call. Sometimes it's a costly mistake that delays your time to market by 6-12 months. This framework helps you decide.

The Decision Matrix

Four factors determine whether build or buy makes sense:

	Build In-House	Partner/Buy
Team Expertise	Deep platform + protocol knowledge	Limited UCP experience
Timeline	6+ months acceptable	Need to launch <3 months
Scope	Basic capabilities sufficient	Enterprise requirements
Strategic Priority	UCP is a side project	UCP is critical to strategy

Let's examine each factor.

Factor 1: Team Expertise

Build If:

Your team has:

Architects who've implemented complex protocol integrations before
Developers with 2+ years on your specific commerce platform
Experience with similar projects (payment gateway integrations, marketplace connectors)
Available capacity (not just "we'll find time")

Partner If:

Your team hasn't implemented a protocol-level integration before
Platform expertise is good but not deep
Available developers are already at capacity
You'd need to hire to staff the project

Reality Check Questions:

Have we built something of similar complexity in the last 2 years?
Can the team articulate UCP's technical requirements without referencing documentation?
If we estimated 8 weeks, what's our historical accuracy on similar estimates?

Most teams overestimate their ability to deliver unfamiliar work on time.

Factor 2: Timeline

Build If:

You're planning for 2027+ launch
Agentic commerce is a "nice to have," not competitive necessity
You can afford to iterate through multiple failed attempts
Learning is valued over speed

Partner If:

Competitors are already agent-enabled
You have a specific launch target (holiday 2026, board commitment, etc.)
The market window is closing
Executive patience is limited

Reality Check Questions:

What happens if we're 6 months late?
Are competitors already live with UCP?
How did our last "build it ourselves" project compare to estimate?

In-house builds typically take 2-3x initial estimates. A "3-month build" often becomes 9 months.

Factor 3: Scope

Build If:

You only need basic UCP capabilities
Single site, single region, single brand
Standard payment methods
No complex business rules
Willing to skip optimization initially

Partner If:

Multi-site or multi-brand deployment
Complex pricing rules (B2B, customer-specific, regional)
Custom capabilities beyond spec
Integration with legacy systems
Performance requirements at scale
24/7 support requirements

Reality Check Questions:

Can we launch with just the basics, or do we need full capabilities from day one?
What happens when something breaks at 2 AM on Black Friday?
How will we handle protocol updates and new capabilities?

Scope creep is the silent killer of in-house projects. "Just add one more thing" happens repeatedly.

Factor 4: Strategic Priority

Build If:

UCP is an experiment to evaluate
You're testing market demand before committing
Failure is acceptable
It's not critical to 2026 strategy

Partner If:

Board/exec has committed to agentic commerce
UCP is part of a larger digital transformation
You need to move fast and can't afford mistakes
Success matters more than learning

Reality Check Questions:

What did we tell the board about agentic commerce?
How does our timeline compare to stated strategy?
Who loses their job if this fails?

When UCP is strategic, the cost of delay exceeds the cost of partnership.

The Hidden Costs of Building

When teams calculate "build" costs, they typically undercount:

1. Opportunity Cost

What else could your developers build? If they're building UCP infrastructure, they're not building features that differentiate your store.

2. Learning Curve

Protocol nuances, edge cases, agent behaviors—these take months to learn. Partners have already paid this tuition.

3. Maintenance Burden

UCP will evolve. Google will update the spec. Agents will change behavior. Someone has to keep up.

4. Integration Risk

Your first implementation probably won't work perfectly with your payment provider, OMS, and other systems. Partners have solved these integrations before.

5. Performance Optimization

Making it work is easy. Making it work fast at scale requires experience you don't have yet.

Typical hidden cost multiplier: 2-3x visible costs.

The Hidden Costs of Partnering

To be fair, partnerships have hidden costs too:

1. Knowledge Transfer

You'll depend on the partner initially. Building internal expertise takes intentional effort.

2. Ongoing Fees

Managed services aren't free. Budget for ongoing costs, not just implementation.

3. Vendor Lock-in Risk

If the partner disappears or raises prices, you need a transition plan.

4. Communication Overhead

Working with external teams requires coordination. Decisions take longer.

Typical hidden cost multiplier: 1.3-1.5x visible costs.

A Decision Rubric

Score yourself on each dimension:

Factor	Build (0 pts)	Neutral (1 pt)	Partner (2 pts)
Expertise	Deep platform + protocol	Platform only	Limited
Timeline	12+ months ok	6-12 months	<6 months
Scope	Basic only	Standard enterprise	Complex
Priority	Experiment	Important	Strategic

Scoring:

0-2 points: Likely build in-house
3-5 points: Could go either way—evaluate deeper
6-8 points: Strongly consider partnering

The Hybrid Option

Many teams find success with a hybrid approach:

Phase 1: Partner-led implementation

Partner delivers production UCP
Internal team shadows, learns
Documentation transfer

Phase 2: Internal ownership

Internal team takes over operations
Partner available for escalations
Knowledge fully transferred

Phase 3: Full independence

Internal team owns everything
Partner relationship becomes optional
Future builds done in-house

This captures partner expertise while building internal capability.

Platform-Specific Considerations

Salesforce Commerce Cloud

Build consideration: No native UCP support. Cartridge development requires SFCC expertise. SFRA conventions matter.

Our take: Unless you have senior SFCC architects with protocol experience, partner. The open-source cartridge gives you a head start, but enterprise deployment needs expertise.

Shopify Plus

Build consideration: Native UCP support exists. "Building" is really configuration and optimization.

Our take: You can enable native support yourself. Partner for optimization, GEO strategy, and custom extensions.

BigCommerce

Build consideration: No native support yet. Custom integration via REST APIs.

Our take: API expertise is more common, but timeline matters. Partner if you need to launch before native support arrives.

Headless/Custom

Build consideration: Maximum flexibility, but also maximum work.

Our take: If you built a headless stack, you probably have the skills to build UCP. Partner for acceleration, not capability.

Making the Call

After scoring the rubric and considering hidden costs:

If you decide to build:

Allocate 2x your initial timeline estimate
Plan for 3x budget contingency
Assign a dedicated team (not "spare time")
Accept that v1 will be suboptimal

If you decide to partner:

Evaluate partners on platform expertise, not just UCP knowledge
Check references from similar implementations
Negotiate knowledge transfer into the contract
Plan for eventual internal ownership

If you're still unsure:

Start with a readiness assessment
Get an external estimate for comparison
Make the decision with data, not instinct

Frequently Asked Questions (FAQ)

What are the main factors when deciding to build or buy UCP?

The primary factors are your engineering team's existing protocol integration expertise, your target timeline to market (less than 6 months generally favors buying), the complexity of your scope, and the strategic priority of Agentic Commerce to your board.

Is it cheaper to build UCP in-house?

Visible costs may appear lower, but hidden costs—such as opportunity cost, developer learning curves, ongoing maintenance burden, and performance optimization overhead—typically make building in-house 2-3x more expensive than initial estimates.

Can I implement a hybrid UCP strategy?

Yes. A common hybrid approach involves a specialized partner handling Phase 1 (production implementation and knowledge transfer), followed by the internal team taking over operations in Phase 2, and achieving full independence in Phase 3.

Want an objective evaluation? Our Readiness Assessment includes build vs. buy analysis tailored to your situation. Get started.