Google UCP Checkout: Complete Zero-Click Store Guide

TL;DR

What changed: Google UCP checkout lets a shopper complete a purchase inside Search or an AI agent without ever landing on your product page, which means the storefront you spent years optimizing is no longer the only place a sale can happen.
Why it matters now: Agentic buyers read your structured feed, not your hero image, so a conformant manifest, accurate inventory, and clean fulfillment signals now determine whether you win the order or get skipped silently.
What to do first: Validate your UCP manifest, confirm real-time price and stock accuracy, and run an end-to-end test checkout through an agent before you touch anything cosmetic, because a passing manifest does not guarantee a completable purchase.

A merchant we work with noticed something strange three weeks after Google UCP checkout went live in their category. Traffic to their best-selling product page dropped 14 percent, yet orders held steady and, for that one SKU, actually ticked up. For three days they thought it was a tracking bug. It was not. Shoppers were buying the product straight out of Search results through the new Google UCP checkout flow, completing the transaction without ever clicking through to the site. The sale was real, the revenue landed, but the funnel they had instrumented for a decade no longer described how the money moved. That is the shift this guide is about, and in our experience it catches almost every merchant off guard the first time they see it in their own analytics.

This is a complete, step-by-step guide to Google UCP checkout and what zero-click purchases mean for your store. We build Universal Commerce Protocol infrastructure for real merchants, so we are going to skip the encyclopedia tour and give you the sequence we actually run: how to get started, how to set up correctly, the exact implementation steps, how to optimize, the mistakes we see weekly, and how to measure whether any of it is working. If you want the conceptual grounding first, our Google Universal Commerce Protocol explained breakdown is the companion piece. This guide assumes you want to ship.

What Google UCP Checkout Actually Is, and Why Zero-Click Changes Your Store

Google UCP checkout is the point where the Universal Commerce Protocol stops being a discovery layer and becomes a transaction layer. UCP is the open standard that lets agents and search surfaces read a structured, machine-readable description of your catalog: products, variants, prices, inventory, shipping, returns, and the actions a buyer can take. Checkout is the action that matters most, because it is the one that moves money. When Google UCP checkout is live, a shopper can see your product in a Search result or ask an AI assistant to buy it, and the entire transaction, payment, address, confirmation, can complete inside that surface.

Zero-click purchase: a sale that closes without the customer ever loading your product detail page or your cart. The agent reads your UCP feed, confirms price and availability, collects payment through the surface’s own secure flow, and sends you a structured order. In our experience the first reaction merchants have is fear about losing control, and the second, once they see the conversion math, is relief that the highest-friction step in ecommerce just got shorter.

Here is the honest framing we give every client. According to UCP Checker, which independently monitors more than 23,253 storefronts, roughly 70 percent pass full UCP validation, which works out to around 16,376 verified stores. That number skews heavily toward Shopify, so it is not a claim that 70 percent of all ecommerce stores have UCP, and more importantly a conformant manifest is not the same thing as an agent being able to complete a real checkout. We have watched stores pass validation and still fail a live transaction because their inventory feed was stale or a shipping rule returned an error at the wrong moment. Passing is the floor, not the finish line.

What this achieves for your store: it decouples the sale from the page. You no longer need a shopper to navigate your UI to earn the order. That is a profound change, and it rewards stores whose data is accurate and punishes stores whose data is merely decorative.

Checklist for grasping the shift before you build:

Transaction, not just discovery: Understand that Google UCP checkout completes payment, it does not only surface listings.
Feed over funnel: Accept that your structured data now does the selling your landing page used to do.
Validation is the floor: Treat a passing manifest as a prerequisite, never as proof the checkout works end to end.
Revenue can rise while sessions fall: Prepare your reporting for orders that arrive with no matching page view.
Accuracy is the moat: Recognize that price and inventory correctness, not design, decides whether you win the agent’s order.

Getting Started: The Prerequisites Before You Touch Checkout

Before Google UCP checkout can work for you, three things have to be true, and we audit them in this order every single time. Skipping ahead to the exciting part, the live transaction, is the most common way merchants waste a month.

Merchant Center foundation: Google’s UCP checkout rides on your Google Merchant Center product data, so the first prerequisite is a clean, complete, actively syncing Merchant Center feed. We have found that stores with chronic feed disapprovals, more than 5 percent of SKUs disapproved, are not ready, because those same data gaps will surface as failed or skipped checkouts. Our guide to activating AI shopping agents via Google Merchant Center walks the specifics of that setup.

Real-time inventory and price sync: An agent that quotes a price or confirms stock to a buyer, then discovers at payment that you were wrong, creates a failed transaction and, worse, a surface that deprioritizes you going forward. We tell clients to confirm their price and stock data is never more than 5 to 15 minutes stale before they even attempt a checkout integration. Batch updates once a day do not survive agentic commerce.

Payment and fulfillment readiness: You need a payment path the surface can invoke, and you need the ability to receive and acknowledge a structured order programmatically. If your order intake is a human reading an email, you are not ready for zero-click volume.

What this achieves: it guarantees that when an agent commits a buyer to purchase, your store can actually honor that commitment without a human in the loop. That reliability is what earns you repeat placement in agentic results.

Getting-started checklist:

Feed health above 95 percent: Confirm fewer than 5 percent of SKUs are disapproved in Merchant Center.
Sync latency under 15 minutes: Verify price and inventory updates propagate in minutes, not hours.
Programmatic order intake: Ensure orders can arrive and be acknowledged through an API, not a mailbox.
Payment path exposed: Confirm the surface can invoke a supported, secure payment flow.
Returns policy published: Make sure your returns and shipping terms are structured and machine-readable, not buried in a PDF.

Core Setup: Building a Google UCP Checkout Manifest That Agents Trust

With prerequisites met, the core setup is the UCP manifest and the checkout endpoints it points to. This is where the protocol work actually lives. The manifest is the contract between your store and every agent that reads it, and the single biggest lesson we have learned is that agents trust specificity and distrust ambiguity.

Describe actions, not just products: A basic feed lists what you sell. A checkout-ready manifest describes what a buyer can do: add to cart, select a variant, confirm shipping, complete payment. Each action needs explicit inputs and outputs so the agent never has to guess. Ambiguity is where zero-click purchases quietly fail.

Variant and option fidelity: We have seen more failed checkouts come from variant mismatch than from any other single cause. If your size, color, or bundle options are not represented one to one with what an agent can select, the agent will either pick wrong or bail. Map every purchasable variant explicitly.

Shipping and tax as structured logic: Shipping cost and tax cannot be a note that says “calculated at checkout.” For Google UCP checkout to complete inside Search, the surface needs to compute the final total before showing it to the buyer. Expose your shipping rules and tax logic in a form the agent can evaluate deterministically.

Error semantics: Decide, before you launch, exactly what your endpoints return when something is out of stock, when a price has changed, or when a shipping region is unsupported. Clean, specific error responses let the agent recover gracefully instead of abandoning the buyer. Our rundown of common UCP protocol errors and how to fix them covers the failure modes we see most.

What this achieves: a manifest that an agent can act on confidently without a fallback to your website, which is the entire point of zero-click.

Core setup checklist:

Actions fully specified: Define cart, variant, shipping, and payment actions with explicit inputs and outputs.
One-to-one variant mapping: Represent every purchasable option exactly as a buyer would select it.
Deterministic totals: Expose shipping and tax logic so the final price is computable before purchase.
Named error responses: Return specific, recoverable errors for stock, price, and region failures.
Idempotent order creation: Guarantee a retried request never creates a duplicate order.

The Implementation Steps: From Validation to Live Transaction

Here is the exact sequence we run to take a store from zero to a completed Google UCP checkout. Treat these as ordered steps, not a menu.

Step 1, validate the manifest. What this achieves: it confirms your structured data is syntactically and semantically correct before any agent tries to transact against it. Run your manifest through UCP validation and resolve every error and warning. Remember the caveat we keep repeating: passing validation gets you to the starting line, nothing more.

Step 2, wire real-time price and inventory checks into the checkout path. What this achieves: it ensures the number an agent quotes is the number you will honor. We require a live price-and-stock confirmation call at the moment of purchase intent, not a cached value, because the gap between discovery and checkout in agentic flows can be seconds or hours.

Step 3, implement the order creation endpoint with idempotency. What this achieves: it lets agents submit orders safely, including retries, without ever double-charging a buyer or duplicating an order in your system. Use an idempotency key on every order request and store it.

Step 4, build and test error recovery. What this achieves: it turns edge cases into graceful outcomes instead of silent abandonment. Deliberately trigger out-of-stock, price-change, and unsupported-region conditions in a sandbox and confirm the agent receives a response it can act on.

Step 5, run an end-to-end live test checkout. What this achieves: it proves the entire loop works with real payment and real fulfillment, which is the only evidence that actually counts. Place a real low-value order through an agent, confirm it lands in your system correctly, confirm payment settles, and confirm you can fulfill and, if needed, refund it. We do not consider a store live until this passes.

Step 6, enable gradually and monitor. What this achieves: it limits blast radius while you build confidence. Start with a subset of your catalog or a single product category, watch the first wave of real orders, and expand once your failure rate on completed checkouts is under 1 percent.

Implementation checklist:

Manifest validated and clean: Resolve all errors and warnings, not just the blocking ones.
Live price confirmation: Confirm stock and price at purchase intent, never from cache.
Idempotency enforced: Protect against duplicate orders with stored keys.
Error paths tested: Trigger and verify stock, price, and region failures in sandbox.
End-to-end order proven: Complete one real transaction through payment and fulfillment before launch.
Phased rollout: Start narrow and expand only when completion failures fall below 1 percent.

The TRUST Framework for Winning Zero-Click Purchases

We package the strategic side of Google UCP checkout into a framework we call TRUST, because every element of winning agentic orders comes down to whether the surface and the buyer can trust your data to be true. Each step has a one-line purpose.

T, Timeliness of data. What this achieves: it keeps your price and inventory correct in the window when agents actually transact. We hold clients to sub-15-minute sync and, for high-velocity SKUs, sub-5-minute. Stale data is the fastest way to get demoted.

R, Representation completeness. What this achieves: it ensures every variant, bundle, and option an agent might select is explicitly present, so the agent never has to improvise. Incomplete representation is the single most common cause of failed variant checkouts we diagnose.

U, Unambiguous actions. What this achieves: it removes guesswork from the checkout flow by specifying every input and output of every purchasable action. Agents reward manifests they can execute without inference.

S, Settlement reliability. What this achieves: it guarantees payment and order creation succeed deterministically, including on retries, so a committed buyer always becomes a fulfilled order. This is where idempotency and clean error semantics pay off.

T, Transparency of terms. What this achieves: it exposes shipping, tax, and returns as structured, computable logic so the buyer sees a real, final total and the surface trusts you enough to complete the sale in place.

A conformant manifest gets you discovered, but it is the reliability of your live checkout, not the prettiness of your feed, that decides whether an agent ever sends you a buyer twice.

In our experience, stores that score well on all five TRUST elements see agents return to them for repeat placement, while stores that pass validation but fail on timeliness or settlement get quietly rotated out of results. The protocol does not announce this. It just stops sending you orders. We saw exactly this pattern with the merchant from the introduction: once we tightened their inventory sync and variant mapping, their zero-click order share for that category kept climbing rather than plateauing.

Win the Agentic Shopping Era With UCPhub

If you are serious about capturing zero-click purchases instead of watching them accrue to better-prepared competitors, this is the moment to build on infrastructure made for it. At UCPhub we build the Universal Commerce Protocol layer that keeps your feed timely, your manifest complete, and your checkout reliable enough that agents come back for the next order and the one after that. We have taken stores from stale daily feeds to sub-15-minute sync and proven end-to-end agentic checkouts, and we would rather do that with you before your category fills up than help you catch up after.

Talk to our team about getting your store ready for Google UCP checkout, and see our deeper take on how retailers can win the agentic shopping era in 2026. When you are ready to move, contact UCPhub and we will map your path from validation to live transaction.

Optimization: Turning a Working Checkout Into a Preferred One

A functioning Google UCP checkout earns you orders. An optimized one earns you preference, meaning agents and surfaces choose your store over an equivalent competitor. This is where most of the ongoing value lives, and it is the part merchants neglect once the basics work.

Tighten the latency budget: We have found that stores quoting from real-time inventory with sub-5-minute freshness on their fastest-moving SKUs experience measurably fewer checkout failures than stores on a 15-minute cycle. Every stale quote that leads to a failed purchase is a signal to the surface that you are less reliable. Invest your optimization time where velocity is highest.

Enrich structured attributes: Agents filter and rank on structured attributes, not marketing copy. The more precise and complete your material, dimensions, compatibility, and use-case attributes, the more queries you qualify for. We treat attribute enrichment as an ongoing program, not a one-time feed build.

Optimize return and shipping transparency: A buyer deciding inside an agent cannot read your charming returns page, so the structured terms are all they get. Clear, generous, machine-readable return terms increase completion because the agent can present confidence. Opacity suppresses the sale.

Reduce time to acknowledgment: The faster your system confirms an order back to the surface, the smoother the buyer’s experience. We target sub-2-second acknowledgment on order creation. Slow acknowledgments do not always fail, but they degrade the experience the surface is trying to protect, and that shows up in placement.

For teams weighing how far to invest in the protocol versus patching things ad hoc, our comparison of UCP adoption versus custom AI integrations lays out the tradeoffs we see across client work.

Optimization checklist:

Velocity-weighted sync: Push fastest-moving SKUs to sub-5-minute freshness.
Attribute enrichment program: Continuously expand structured attributes to qualify for more queries.
Transparent return terms: Make returns and shipping generous and machine-readable to lift completion.
Sub-2-second acknowledgment: Confirm orders back to the surface fast to protect the buyer experience.
Failure-rate monitoring: Track completed-checkout failures per SKU and fix the worst offenders first.

Common Mistakes to Avoid With Google UCP Checkout

These are the failures we diagnose most often, in rough order of how much damage they do. Every one of them is avoidable.

Treating validation as the finish line: The most expensive mistake. A passing manifest feels like done, but we have repeatedly seen validated stores fail live transactions because of stale inventory or a shipping rule that errors at the wrong moment. Validation checks structure, not whether an agent can actually complete a purchase against your live systems.

Caching prices through to checkout: If an agent quotes a buyer a price that your system then contradicts at payment, you create a failed transaction and a reliability black mark. Never serve a checkout-time total from a cache. Confirm it live.

Incomplete variant representation: When a buyer wants the large in navy and your manifest cannot cleanly express that selection, the agent either picks wrong or abandons. We trace a large share of failed checkouts to this one gap.

Human-in-the-loop order intake: Zero-click volume is asynchronous and can spike. If a person has to read and key every order, you will miss fulfillment windows and generate cancellations that damage your standing. Automate intake before you scale.

Ignoring error semantics: Returning a generic failure when a region is unsupported or a SKU is out of stock gives the agent nothing to recover with, so it abandons. Specific, named errors let the agent substitute or explain, which sometimes still saves the sale.

Reporting as if sessions still equal sales: Teams that keep judging performance purely on site sessions will conclude, wrongly, that agentic commerce is hurting them when in fact revenue is holding or growing through zero-click. Fix your reporting before you fix your strategy. For a wider view of these shifts, our breakdown of nine ways UCP reshapes agentic commerce this year is a useful reference.

Mistakes checklist:

Do not stop at validation: Prove a live end-to-end checkout before calling it done.
Do not cache checkout totals: Confirm price and stock live at purchase intent.
Do not under-map variants: Represent every purchasable option one to one.
Do not keep humans in intake: Automate order acknowledgment before scaling volume.
Do not return generic errors: Give agents specific, recoverable failure responses.
Do not report on sessions alone: Attribute zero-click orders explicitly so you see the real picture.

Advanced Tips: Getting Ahead of the Agentic Curve

Once the fundamentals are solid, a few advanced moves separate stores that merely participate from stores that dominate their category in agentic results.

Differentiate by fulfillment signals: Agents weigh delivery speed and reliability heavily because buyers do. If you can expose accurate, SKU-level delivery estimates and consistently hit them, you earn preference over competitors with vaguer promises. We have seen fulfillment transparency function as a genuine ranking advantage, not just a UX nicety.

Build for multiple surfaces and standards: Google UCP checkout is one surface, but the agentic web is not monogamous. Understanding how standards relate, including the questions we address in UCP versus ACP and which standard will rule the agentic web, keeps you from building a dead-end integration. We architect for the protocol layer, not for a single surface, which is also why we counsel against the brittle point solutions we describe in why point solutions will not scale.

Instrument the whole agentic funnel: Build telemetry on manifest reads, action attempts, checkout starts, and completions, segmented by SKU and surface. This is how you find the stale-data or variant-mapping problem that is quietly costing you orders, before it becomes a trend.

Pre-stage inventory buffers for high-velocity SKUs: Because agentic checkout compresses the time between quote and commit, a small safety buffer on your fastest sellers prevents the oversell-then-cancel cycle that erodes reliability scores. We tune this per SKU based on sell-through, not as a blanket rule.

Advanced tips checklist:

Expose SKU-level delivery estimates: Turn fulfillment accuracy into a ranking advantage.
Architect for the protocol, not one surface: Avoid dead-end, single-surface integrations.
Instrument the full funnel: Track reads, attempts, starts, and completions by SKU and surface.
Buffer high-velocity inventory: Prevent oversell-and-cancel on your fastest sellers.
Revisit standards quarterly: Stay current as UCP and competing protocols evolve.

Measuring Success: 30, 60, and 90 Day KPIs for Google UCP Checkout

You cannot manage what you do not measure, and agentic commerce breaks the dashboards most merchants rely on. Here is the KPI cadence we hold clients to, written as concrete outcomes by milestone.

At 30 days:

Validation and live checkout proven: Manifest passes validation and at least one real end-to-end order has settled and fulfilled correctly.
Sync latency under 15 minutes: Price and inventory freshness confirmed across the catalog, under 5 minutes on top sellers.
Zero-click orders attributed: Reporting now distinguishes agentic orders from traditional sessions, so no revenue is invisible.
Completion failure baseline captured: You know your current failed-checkout rate per SKU, your starting point for improvement.

At 60 days:

Completion failure under 1 percent: Failed agentic checkouts across live SKUs drop below one in a hundred.
Variant mismatch near zero: No measurable checkout failures traced to variant representation after mapping fixes.
Acknowledgment under 2 seconds: Order confirmation back to the surface consistently fast.
Catalog coverage expanded: Google UCP checkout live across the majority of your eligible SKUs, not just the pilot category.

At 90 days:

Repeat placement growing: Your zero-click order share in key categories is rising, not plateauing, a sign surfaces trust your reliability.
Fulfillment estimates accurate: SKU-level delivery promises met consistently, feeding your preference advantage.
Reliability score stable or improving: No demotion signals from stale data or settlement failures.
Agentic revenue a named line item: Leadership sees zero-click revenue as its own reported channel with its own trend.

A Practitioner’s Wrap-Up Before You Start

If you are just getting started, do not optimize anything yet. Prioritize the foundation in order: clean Merchant Center feed, sub-15-minute price and inventory sync, and one proven end-to-end live checkout through an agent. Those three things, in that sequence, are worth more than any clever attribute enrichment you could layer on top, because without them the enrichment has nothing reliable to stand on. If instead you are auditing something that already exists, start at the other end: pull your completed-checkout failure rate per SKU, segment it by cause, and you will almost always find stale pricing or variant mismatch at the top of the list. Fix the data before you touch the strategy.

Next Steps:

Run validation today: Put your current manifest through UCP validation and log every error and warning.
Place one real test order: Complete a single low-value agentic checkout end to end, including fulfillment and refund, this week.
Separate your reporting: Add a zero-click order line to your analytics so agentic revenue stops hiding inside traffic metrics.

Frequently Asked Questions

What is Google UCP checkout?

Google UCP checkout is the transaction capability built on the Universal Commerce Protocol, the open standard that describes your catalog and purchasable actions in a machine-readable form. Rather than only helping agents and Search surfaces discover your products, checkout lets a buyer complete the entire purchase, including payment and address, inside that surface. The order then arrives at your store as structured data, ready for fulfillment.

In practical terms, it moves the point of sale off your product page and onto whatever surface the buyer is using, whether that is a Google Search result or an AI shopping assistant. The protocol is the contract: your manifest tells the agent what can be bought, at what price, under what shipping and return terms, and how to complete the transaction reliably. If you want the full conceptual foundation, our definitive guide to what UCP is covers it in depth.

The key mental shift for merchants is that your structured data now does the work your storefront UI used to do. Accuracy and completeness in the feed, not design polish on the page, determine whether you win the order.

How does Google UCP checkout work for ecommerce?

It works as a chain of structured interactions. First, an agent or Search surface reads your UCP manifest to understand what you sell and what actions a buyer can take. When a buyer expresses intent, the surface confirms live price and availability against your systems, computes a final total using your exposed shipping and tax logic, and collects payment through its own secure flow. Finally, it sends you a structured order, which your system acknowledges and fulfills.

For ecommerce operators, the critical dependencies are timeliness and determinism. The agent needs your price and stock to be correct at the moment of purchase, not from a cache, and it needs your shipping and tax to be computable so it can show a real total before the buyer commits. If any of those fail, the checkout either errors or the surface quietly stops sending you buyers. This is why we insist on real-time confirmation and idempotent order creation during implementation.

The best way to see the full picture is to walk our implementation guide for the Universal Commerce Protocol, which maps each of these interactions to concrete setup steps.

Is Google UCP checkout live now?

Yes, Google UCP checkout is live and rolling out across categories and surfaces, and merchants are already receiving zero-click orders through it. That said, live does not mean universal or uniform: availability varies by category, region, and the readiness of each merchant’s own data, so your experience depends heavily on whether your store meets the prerequisites we outlined.

We frame it to clients this way: the capability exists and buyers are using it, so the risk is not that it will not arrive, the risk is that it arrives in your category before your store is ready and the orders go to competitors who are. According to UCP Checker, which monitors more than 23,253 storefronts, roughly 70 percent of the stores it tracks pass full UCP validation, though that sample skews toward Shopify and a passing manifest is not the same as a store that can complete a real checkout. Adoption of the structure is ahead of true checkout readiness, which is exactly the gap we help merchants close.

If you want to know which partners and platforms are already in the ecosystem, our UCP partners list and retailer roadmap keeps a current view.

Will zero-click purchases cannibalize my website traffic?

Your product page traffic will likely decline for SKUs that perform well in agentic surfaces, because buyers complete the purchase without clicking through. That is expected and, in the case we opened this guide with, revenue held steady or rose even as page views fell. Zero-click is a shift in where the sale closes, not necessarily a loss of sales.

The real danger is not the traffic drop itself but misreading it. Teams that judge success purely on sessions will conclude agentic commerce is hurting them and may pull back exactly when they should lean in. The fix is reporting: attribute zero-click orders explicitly so you can see that revenue is intact or growing even as session counts change shape.

Does passing UCP validation mean my checkout will work?

No, and this is the single most important caveat in this guide. Validation confirms your manifest is structurally and semantically correct. It does not confirm that an agent can complete a real purchase against your live systems. We have seen validated stores fail live transactions because inventory was stale, a price was cached, or a shipping rule returned an error at the moment of truth.

Treat validation as the floor. The proof that matters is a completed end-to-end checkout with real payment and real fulfillment, followed by a low and stable completion-failure rate across your catalog. If you only do one thing after reading this, make it placing a real test order through an agent rather than trusting a green checkmark.

How accurate does my inventory and pricing need to be?

More accurate than most stores currently operate. We hold clients to under 15 minutes of staleness across the catalog and under 5 minutes on their fastest-moving SKUs, with a mandatory live confirmation of price and stock at the moment of purchase intent. Daily batch updates, which are common and were acceptable in a click-through world, do not survive agentic checkout.

The reason is that the window between an agent discovering your product and a buyer committing can be seconds, and any discrepancy at payment creates a failed transaction and a reliability signal that gets you deprioritized. For fast sellers we also recommend a small inventory buffer to prevent the oversell-then-cancel cycle, tuned per SKU based on sell-through rather than applied as a blanket rule.

What happens if an agent requests a product that is out of stock or in an unsupported region?

That depends entirely on your error semantics, which is why we build and test them before launch. If your endpoint returns a specific, named error, out of stock, price changed, region unsupported, the agent can often recover gracefully by substituting a variant, re-confirming a new price, or explaining the limitation to the buyer. Sometimes that recovery still saves the sale.

If instead your endpoint returns a generic failure, the agent has nothing to work with and abandons the purchase entirely. We deliberately trigger each of these conditions in a sandbox during implementation to confirm the responses are specific and actionable. Clean error handling is one of the least glamorous and most valuable parts of a reliable Google UCP checkout.

Should I build a custom integration or adopt the UCP standard?

In almost every case we recommend adopting the protocol standard rather than hand-building a custom integration for a single surface. Custom point solutions tend to be brittle, expensive to maintain, and locked to one agent or surface, which means they break or need rework as the agentic ecosystem evolves and new surfaces appear. Building on the protocol layer gives you reach across surfaces from one implementation.

We have made this argument at length in our analysis of why point solutions will not scale in 2026, and it is the core reason our own infrastructure targets the protocol rather than any one surface. If you want help deciding for your specific stack and category, that is exactly the conversation our team has with merchants every week.