Chat-Commerce Brain — Build vs. Buy

Build (Webflow · Xano · Shopify · Cloudflare · MCP) alongside the Buy SaaS most Shopify stores already run — Klaviyo, Sprinklr, Salesforce, Gorgias, Braze, Attentive. Coexistence-first — lower cost, easier org-wide, optional non-destructive migration · June 13, 2026
Live chatbot demo: omenphase1-1.webflow.io · CRM Sync: crm-sync.webflow.io · PIM Sync on Shopify: apps.shopify.com/pim-sync

Executive Summary

The benefit, up front: an organization adds an omni-channel, AI/API-first commerce layer that lowers cost — flat infrastructure (~$100–150/mo) instead of per-seat, per-ticket or per-conversation metering — and is easier for the whole organization to use (one identity, one tool surface, one place to manage consent and access). It is additive: it runs alongside the tools you already use, so adding it also offsets fee, security and risk-dependency exposure with nothing ripped out. Under the hood it is the Chat-Commerce Brain — the MCP Chatbot stack (Botpress chat runtime · Xano identity · Shopify commerce · Cloudflare worker) — a multi-tenant MCP server (9 tools) that drives search → add-to-cart → checkout, orders and returns, and AP2 autonomous purchase under a consented mandate. Xano holds identity, consent and entitlement as the source of truth; Webflow hosts the site and FAQ source; any MCP-client agent runtime can drive it, with Botpress as the reference implementation.

• The thesis. Enterprise organizations running omni-channel applications and omni-channel e-commerce need a strong agentic middleware layer — one that scales by Function (composable MCP tools / skills) and Loop (dynamic, self-correcting data loops: SWR caches, event-driven content-drain, export→ingest→publish), and is token- and function-flexible (runtime-agnostic, model-agnostic, driven by a portable per-tenant token). The Chat-Commerce Brain is that layer: it sits between the agent runtimes and the commerce/identity systems, and everything below the MCP line is the product — not another single-purpose application to license per channel.
• Coexistence-first, non-destructive. These are mature, well-supported tools most Shopify stores already run — nothing here calls them obsolete. The Brain is built to sit alongside them: it reads the same Shopify store, moves no customer or order data, and adds capability at the edge. Any consolidation later is optional, phased and reversible — a merchant turns over only the pieces they choose, when they choose, with nothing ripped out.
• Build alongside Buy. A Webflow + Xano build complements the single-tenant Buy applications — Klaviyo, Sprinklr, Salesforce — and can, where a merchant chooses, incrementally take over the pieces they’d otherwise license per seat, per store, or per conversation. Owning that layer adds the optionality fee-based plans withhold: scale freely (one deployment, marginal infra), test freely (no per-environment metering), and provision ad-hoc language versions on demand (enable a locale in the data layer — no per-market SKU, no services engagement). Many of these Shopify apps were built before today’s requirements — GA4 server-side events, Consent Mode v2 mandates, and the AI / agent era — so they retrofit them onto older architectures; the Build stack is native to all three (GA4 ucp_* events, versioned consent, AP2 + MCP).
• The pain point this audit prices throughout: every incumbent bills per Shopify instance — a separate subscription per store (a Gorgias plan, a Klaviyo agent add-on, Attentive minimums, an enterprise contract). The Brain is multi-tenant: one Cloudflare deployment serves every store at ~$1–5 marginal infra each, and single-tenant isolation is an optional priced tier ($499+/mo), never a forced cost.
• Global-First, one coupled suite. PIM (catalog + localization), CRM (identity/consent) and the chatbot run on one multi-tenant deployment and are multilingual by construction — English + APAC via a bge-m3 vector index with a locale-gated answer fallback. The incumbent model is the inverse: a fee per application bolted to a single-tenant, English-first, single-stream account (Klaviyo’s K:AI is the type case), with its Language-Based AI seamed off from the Shopify catalog (gid://) and Google/Shopify GID identity. The Brain binds language, catalog and identity into one omni-global segment across applications.
• Only Klaviyo (K:AI Customer Agent) matches in-conversation checkout. No vendor in this set matches mandate-based autonomous purchase (AP2).
• Running cost is roughly $100–150/month flat, against per-ticket (Gorgias), per-conversation (Klaviyo, Attentive) or per-seat enterprise (Sprinklr, Braze) vendor metering.
• Because the Brain speaks open protocols (MCP, plus a REST facade), it is runtime-agnostic: the same endpoint and tenant token serve Botpress, Claude-based agents, ChatGPT apps, or a helpdesk widget.

Landscape Matrix

The Buy options at a glance — what each single-tenant SaaS does in chat and what it costs per Shopify instance — with the Build row (MCP Brain) at the top.

Sources: vendor docs and 2026 pricing reports (Lindy, Chatarmin, Vendr, StackScored, Retainful, vendor press releases).

Key-Feature Comparison

Four capabilities that decide a chat-commerce deal — agentic checkout (delegated purchase under mandate), RMA (conversational returns/exchanges), a customer-service knowledge base grounding answers, and globalized vectorized search (multilingual semantic retrieval across catalog and KB). The RMA specialists join the matrix here. Read it as Build (the MCP Brain row) versus Buy (every row below it).

• The Brain is the only row pairing agentic checkout with native RMA: every chat agent that “does returns” (Siena, Gorgias, Klaviyo) fronts a Loop/AfterShip portal; the Brain’s orders/returns tools act on Shopify return objects directly — and can chain return → exchange → re-checkout in one conversation under one identity.
• Globalized vector search is the axis enterprise vendors led on — and the Brain now matches it. Catalog, KB and product-manual PDFs embed with bge-m3 (1024-d, 100+ languages incl. APAC) into Cloudflare Vectorize, and the chatbot answer cascade is locale-gated (en-US + fr-CA live; APAC additive on the same index). Where Klaviyo breaks is the seam: its Language-Based AI is a separate system from the Shopify catalog (gid://) and Google/Shopify GID identity. The Brain has no seam — the multilingual agent, the gid-addressed catalog and the GID identity are one omni-global segment across applications. See Global-First Language Architecture below; the only piece still finishing is search_products’ keyword→semantic upgrade.
• DigitalGenius’s photo-based damage assessment is the one genuine RMA capability gap — an image input on the returns tool is the feasible answer if RMA-heavy merchants become a target segment.

Reference Architecture — Botpress · MCP · Cloudflare · Xano

The Brain separates the conversation surface from commerce execution. The chat runtime is swappable; everything below the MCP line is the product — this is the Build stack (Webflow · Xano · Shopify · Cloudflare, wired by MCP) that you own — designed to run alongside your existing tools, not in place of them.

Agentic Checkout (AP2) sequence

1. The shopper signs in (Google or Shopify as login provider; Xano /auth/me is the canonical identity) and grants consent. create_mandate issues a standing authorization with an amount cap.
2. The mandate is stored in Xano beside the user’s entitlement; the entitlement must actively grant AP2 (caps.ap2) and bounds the mandate amount. A signed offline token is projected so revocation also works without a live Xano call.
3. An agent — the Botpress Autonomous Node, or any external MCP client — invokes agentic_checkout under the mandate. The shopper does not need to be present.
4. The worker double-gates the call (consent and an active entitlement granting AP2), enforces the cap, then executes the Shopify checkout via Admin GraphQL.
5. ucp_mandate_used and ucp_checkout_completed events are emitted to GA4 under the canonical identity; revoking the entitlement drops the projection and kills the agent’s purchase authority — including offline.

The same tool handlers also back the REST facade, so a helpdesk platform (e.g., Gorgias custom Actions) can drive the identical flow with the consent step hosted on a worker-rendered, signed confirmation page — purchase authority never leaves the merchant’s stack.

Challenges → MCP Brain Solutions

Three structural problems the Buy SaaS apps inherit by design — protocol fragmentation, the identity/signals gap, and the purchase-authority ceiling — that Building on Shopify/Google open rails resolves rather than meters around.

Challenge 1 — Protocol fragmentation: REST vs GraphQL vs agent rails

Every chat/CX vendor in this audit (Gorgias, Sprinklr, Klaviyo, Braze, Attentive) exposes classic REST/JSON APIs with flat IDs. Shopify, meanwhile, is GraphQL-only for new apps, addressing every object with a global ID (gid://shopify/Product/…, gid://shopify/ProductVariant/…). And the emerging agent-payment rails — Google’s AP2 mandate exchange, OpenAI/Stripe’s Agentic Commerce Protocol — are JSON-over-HTTP message protocols that are neither REST-resource-shaped nor GraphQL. No chat vendor natively bridges all three worlds; merchants are left gluing them together per integration.

Solution: the Brain is the translation layer. Its tools accept flat JSON arguments (a query, a variant ID, a quantity); internally the worker composes Shopify GraphQL and handles gid addressing; externally it speaks standard MCP (JSON-RPC over Streamable HTTP) plus an optional REST facade for platforms like Gorgias Actions. Shopify’s gid complexity and AP2’s mandate handshake never leak to the chat platform — the runtime sees one simple, stable tool surface.

Challenge 2 — The identity and signals gap

Each vendor traps identity and behavioral signals in its own CDP: Klaviyo profiles, Braze user data, Attentive phone-number identity. A Google or Shopify sign-in is just a login event to them, conversation signals never join commerce outcomes under one identity, and switching vendors forfeits the graph. The result is a signals gap — the moment a shopper converses, researches and then purchases is split across systems that do not share a key.

Solution: the Brain anchors identity in merchant-owned Xano — Google and Shopify act as login providers, but Xano /auth/me is the canonical identity, with consent and entitlement stored beside it. Every commerce event the Brain executes (ucp_checkout_created, ucp_checkout_completed, ucp_mandate_created, ucp_mandate_used) is emitted to GA4 keyed to that identity, and the same event stream can feed Klaviyo, Braze or Attentive journeys. The merchant keeps the identity graph; vendors become consumers of it, not owners.

Challenge 3 — Purchase authority: assistants can recommend, none may buy

Even the strongest competitor capability (Klaviyo’s in-chat checkout) is consumer-driven — the shopper must be present and tapping. No vendor offers delegated purchase: a standing, revocable authorization under which an agent may complete a transaction on the customer’s behalf.

Solution: the Brain’s AP2 layer. A consented mandate (create_mandate) carries an amount cap and is gated twice — user consent in Xano, and a tenant/user entitlement that must actively grant AP2. agentic_checkout then executes within those bounds, every use is logged and signaled, and revoking the entitlement kills the authority offline. This is the capability gap none of the five vendors closes, and the basis for replenishment partnerships with Braze and Attentive.

Vendor Profiles

The Buy options, profiled — what each does well, what it costs, and how the Build stack coexists with and complements it — with optional, gradual hand-off only where a merchant chooses.

Gorgias — Shopify-native helpdesk

Ticketing, macros, and order actions inside a shared inbox; AI Agent answers and deflects but cannot build a cart or complete checkout. Pricing is per ticket ($10–900/mo tiers) plus $0.90–1.00 per AI interaction, which also bills as a ticket — automated conversations are effectively double-billed. Its AI Agent supports custom HTTP Actions, so the Brain can plug in via a REST facade; the cleaner end-state is the Brain owning storefront chat with escalations creating Gorgias tickets.

Sprinklr — enterprise CX suite

Omnichannel contact center: voice, social listening, workforce management, Digital Twin bots. Self-serve plans (formerly ~$249/seat) were discontinued April 30, 2026; new customers face ~$50k+/yr enterprise contracts with year-one costs typically 15–30% higher. Not commerce-native; no in-chat checkout. The Brain coexists beside it — integrating into Digital Twin would route every change through Sprinklr enterprise services and strengthen their renewal story, not yours.

Klaviyo — the closest functional overlap

K:AI Customer Agent (launched 2025, expanded March 2026) recommends products, adds to cart, applies promotions and completes purchases in chat, SMS, email and soon WhatsApp — the Brain’s core loop, shipped by a vendor most target merchants already pay. It is an add-on: ~$140/mo introductory ($200 regular) plus $0.70 per resolved conversation, on top of a profile-scaled Klaviyo plan. Differentiation: the Brain is cheaper at volume, runtime-open via MCP, merchant-owned on identity, resellable per tenant, and uniquely offers AP2 autonomous purchase. Klaviyo’s edge: zero-infrastructure packaging and multi-channel reach.

• Case study · Happy Wax (wax melts, Shopify): Customer Agent handled 50%+ of support conversations with zero service-team involvement in its first 90 days; 10%+ total-cost reduction from channel consolidation onto Klaviyo.
• Case study · LifeStraw (water filtration, Shopify): 111% jump in AI-driven sales — the agent reads purchase history and converts service questions into upgrade recommendations.

Read of the references: both headline numbers are service deflection and recommendation-driven sales. Neither showcases completed in-chat checkout at scale, and nothing resembles autonomous purchase — a year after launch the reference base is two flagship studies, which marks an early-adopter window. A demo that completes a purchase in the conversation (and shows the mandate flow) outweighs a deflection-percentage slide.

Braze — pure complement

Cross-channel engagement orchestration (push, in-app, email, SMS, WhatsApp) with RL-driven optimization from the $325M OfferFit acquisition and Project Catalyst. No conversational surface, no checkout, no shopper-facing agent — its “agentic” AI optimizes campaigns. MAU-priced enterprise contracts from ~$30–60k/yr. The play is integration: Braze decides when and what to say; the Brain is the execution layer that completes the purchase (replenishment journey → AP2 reorder → conversion event back).

Attentive — channel complement

SMS-first marketing for DTC brands; Concierge is a genuine conversational AI personal shopper over SMS, but SMS cannot host a checkout — Concierge converts by linking out to the site. Thread 2026 announcements (Brand Voice 2.0, Reporting Agent) target marketing operations, not transactions. Custom pricing with quarterly minimums (~$8–12k+/yr effective) plus per-message and carrier fees. Same partnership shape as Braze, with an RCS angle: as rich in-thread interactions arrive, Attentive will want a checkout-execution endpoint behind its messages.

Cost Scenario — 1,000 AI Conversations / Month

The Build vs. Buy math at one month of volume: Buy meters per conversation, per ticket or per seat; Build is flat — LLM tokens plus marginal infra.

Botpress fees and requirements to run the Brain

What the Brain requires from its chat runtime — five things, all met by Botpress and by any comparable MCP-capable platform: (1) an MCP client over Streamable HTTP (Botpress’s Autonomous Node); (2) the ability to attach the crm_t_ tenant token as a Bearer header on tool calls; (3) a tool-calling LLM strong enough for multi-step loops (search → cart → checkout in one conversation); (4) a webchat embed for the host site; (5) secret hygiene — the token lives in bot configuration and is never rendered into the conversation (the JWT-shield rule).

The binding limit is AI quota, not message count: one commerce conversation’s Autonomous-Node loop burns 20–50k tokens carrying 9 tool schemas plus product-JSON results — budget roughly 3–10× the AI spend of a FAQ bot per conversation. When the quota runs out mid-month the bot silently stops responding, which from the outside resembles an auth failure; triage order is Botpress quota → worker 401s → Shopify token health. In the BYO model these fees sit on the customer’s bill and the Brain is licensed per tenant with the revocable, shop-scoped crm_t_ token as the license key; in managed models they are pass-through costs to price in.

Deployment Fees — Single-Tenant vs Multi-Tenant

Why infrastructure is never the cost driver: a Cloudflare Workers paid plan is $5/month with ~10M requests included; a tenant doing 1,000 conversations generates tens of thousands of worker requests — pennies. Per-tenant state in KV (config, tokens, mandates) is negligible. The real marginal costs are LLM tokens (externalized to the customer in the BYO model) and operations: in single-tenant, each instance carries its own ADMIN_KEY, KV namespace, deploy cadence and monitoring, which is what the higher tier prices in. Multi-tenant isolation rides crm_t_ tenant tokens plus per-shop config on one worker — hundreds of tenants fit on a single deployment.

Global knowledge scaling

Knowledge splits into two layers with very different economics. Tenant-scoped knowledge (the merchant’s FAQ, policies, catalog behavior) lives in per-shop config, Xano and the runtime’s knowledge base — it grows linearly with tenants but each increment is small. Global knowledge (commerce reasoning, returns logic, AP2/consent explainers, tool-use patterns) is authored once in the worker and the shared skill layer and serves every tenant at zero marginal cost — this is the margin engine of the multi-tenant model. The constraint to watch sits in managed-Botpress variants: vector-DB storage (1–2GB per workspace tier) and pooled AI quotas mean that at scale, clean isolation forces workspace-per-client — i.e., a Botpress subscription per customer. The BYO model externalizes both the quota and the storage ceiling, which is why it is the default recommendation.

Omni-tenant scaling — Shopify/Google GraphQL instances vs vendor REST

One worker deployment serves every tenant (“omni-tenant”); what actually scales — or throttles — is the upstream APIs. GraphQL’s economics compound in the Brain’s favor:

Shopify Admin GraphQL meters a calculated-cost leaky bucket per app per store. Because every tenant is its own store, an omni-tenant Brain inherits a fresh quota with each merchant onboarded — throughput scales with the tenant count instead of against a global ceiling. Per-tenant admin tokens live in KV with the self-heal / client-credentials fallback, so a dead token degrades one tenant, never the fleet. Google services behave the same way: OAuth sign-in and GA4 events are scoped per project and per property, with per-tenant properties available where merchants want their own analytics.

Vendor REST APIs invert this. Integrate Gorgias, Klaviyo or Attentive at platform level and their per-account rate limits pool across all of your tenants — the busiest merchant throttles the rest unless you hold one vendor account per tenant. That is the architectural reason the Brain keeps vendor REST integrations at the edge (event sinks, ticket handoffs) and keeps the transaction path on per-tenant GraphQL instances. The Cloudflare Worker itself is stateless and horizontally scaled at the edge — it is never the bottleneck; single-tenant dedicated workers are a compliance choice, not a throughput one.

GraphQL’s single shaped round-trip also matters inside the agent loop: fewer upstream calls per tool invocation means lower latency per Autonomous-Node step and smaller tool-result payloads — which directly cuts the LLM token burn that dominates per-conversation cost.

Global-First Language Architecture — English + APAC, Omni-Tenant

The one axis the enterprise vendors led on — globalized multilingual search — is now the Brain’s, and it arrives coupled to the multi-tenant suite rather than sold as a separate localization SKU. Klaviyo’s K:AI — the closest functional overlap — is effectively single-tenant, English, single-stream: one brand-trained RAG per account, one language model per conversation. The Brain is Global-First by construction: localization is a property of the data layer, and the answer path falls back across languages instead of dead-ending in English.

Locale-gated fallback, not English-only

Every chatbot answer resolves through a tiered cascade whose vector tiers are filtered by the conversation’s resolved content locale (market → geo → Accept-Language → persona). The retrieval index is multilingual: catalog, KB articles and product-manual PDFs embed with BAAI bge-m3 (1024-d, 100+ languages) into Cloudflare Vectorize, so an English query and a Japanese, Korean, Thai or Vietnamese one hit the same semantic space and return locale-correct passages. A script-level language guard drops cross-lingual bleed (a passage in a script the locale never uses is rejected), and the open-pool fallback fires only when the locale-correct tiers miss — so the shopper never gets a foreign-language answer, and never a hard “no result.”

PIM Sync = Global-First, with dynamic ISO-detection publishing

PIM Sync is the localization spine. Market variants, translations, prices and currencies live in the Xano PIM layer, and publishing is driven by dynamic ISO detection — ISO 639 language + ISO 3166 country/market resolved per request (country TLD / host map, market param, Accept-Language, geo) → the matching locale build, hreflang trio, currency and persona. New markets are additive: enable a locale in the PIM layer and the catalog, KB and chatbot inherit it — ad-hoc language versions provisioned on demand, no per-market re-platform. That is the core tenet of an Enterprise Omni-Tenant strategy: one deployment serves every tenant and every market, with localization owned by the data layer instead of bought as a separate product. By contrast, a single-tenant app pinned to a single-tenant Shopify store only works as an isolated, single-market build — each additional market means another app instance, another store and another contract, so markets multiply cost instead of inheriting it. Global-First makes markets additive; the single-tenant pairing makes them duplicative.

One coupled suite vs. fee-per-application

The Brain couples three planes the incumbents sell — and meter — separately: PIM (catalog + localization), CRM (identity, consent, entitlement) and the chatbot (agent runtime). Because they share one identity and one deployment, the suite scales across both SaaS and e-commerce tenants on the same rails. The competitor model is a fee per application — a Klaviyo agent add-on, a Gorgias plan, an Attentive minimum — bolted to a single-tenant account with single-stream, English-first language modeling. Coupling the suite is the differentiator: globalization, identity and commerce arrive together at one marginal cost, not as three contracts in one language.

Where Klaviyo breaks — the seam. Klaviyo’s Language-Based AI sits on one side of a seam and the commerce graph sits on the other: its RAG is trained per brand and in English, while the catalog and identity it would act on live in Shopify (GraphQL gid://) and Google/Shopify sign-in. The two never share a key, so a multilingual conversation cannot resolve to the same catalog object or the same customer segment across applications. The Brain removes the seam: the multilingual agent, the gid-addressed Shopify catalog and the Google/Shopify GID identity are bound under one Xano-canonical identity — one omni-global segment that spans applications (SaaS and e-commerce), in any language. Language is an attribute of that segment, not a separate AI product bolted alongside it.

Where Sprinklr breaks — static KB, unpaired from Shopify. Sprinklr leads on raw language coverage (100+ languages, semantic), but its knowledge base is enterprise-static: per-locale content changes route through Sprinklr professional services and custom workflows, not a self-serve update, so a new market’s KB is a project, not a config change. And it does not pair with Shopify’s native LLM modeling tools — the gid-addressed catalog and Shopify’s own Knowledge Base (its built-in search_shop_policies_and_faqs MCP tool). Incumbents re-train a separate brand KB that is decoupled from Shopify; the Brain instead rides Shopify’s own KB and layers a locale KB on top. The Brain inverts both Sprinklr limits: the layered KB is dynamically updated per locale through the data-layer loops (Webflow → Xano → locale-tagged Vectorize; event-driven content-drain refresh), and it is paired directly with Shopify’s LLM tools in the answer cascade (Shopify’s own Knowledge Base first, then the locale-filtered bge-m3 KB). A new locale goes live by editing the data layer, and every answer grounds on the live Shopify catalog — no services engagement, no stale translation.

SLA and Resilience Posture

An SLA binds only the vendor who issues it — no layer of the stack underwrites the composite, and Xano’s SLA covers the Xano instance alone. What each layer actually offers:

Composite math works against any paper promise: serial dependencies multiply, so three honest 99.9% layers chained together yield ~99.7% — roughly 26 hours per year of theoretical exposure — regardless of any single vendor’s commitment. Shopify is the unfixable hole: it offers no contractual SLA at any tier, which means no competitor in this audit can do better on the checkout layer either.

Why the architecture matters more than the paper

• AP2 survives a Xano outage: the signed offline entitlement-token projection keeps mandate validation and revocation working without a live Xano call.
• Per-tenant config and tokens are cached in KV at the Cloudflare edge; the Shopify token self-heal recovers dead admin credentials per tenant without fleet impact.
• A Botpress outage kills only the chat surface — the host site, data layer and worker stay up. In the BYO model the runtime SLA is the customer’s own Botpress contract.
• Identity and consent gates fail closed: an outage degrades to “cannot purchase right now,” never to “purchased without consent.”

Commercial posture

Offer an SLO on the worker layer you control, with the standard carve-out for third-party service interruptions (which covers the Shopify hole no vendor can close). When a tenant contractually requires a credit-backed SLA, that is precisely what the single-tenant tier ($499+/mo, annual) funds: the upstream enterprise contracts — Xano dedicated instance, Cloudflare Enterprise, Botpress Enterprise — that make a real commitment possible. SLA demand is therefore a pricing signal, not a blocker: it routes the prospect to the tier built for it.

Migration Playbooks

Coexistence is the default; migration is optional, phased and reversible. If a merchant chooses to consolidate, here is the gentle cutover sequencing per incumbent — coexist paths first, at the merchant’s pace, with identity and order data staying on Shopify the whole way (nothing moves that can’t be rolled back).

For Gorgias users (self-serve billing — cutover any month)

• Path 1 · Coexist: Brain takes storefront commerce chat; escalations create Gorgias tickets via REST API. Disable Gorgias “AI Agent for Sales” to avoid paying for overlap. Days to deploy.
• Path 2 · Brain inside the Gorgias widget: REST facade wired to AI Agent custom Actions; agentic checkout stays on a worker-hosted signed confirmation page. A bridge, not a destination — Gorgias AI and ticket fees still apply.
• Path 3 · Swap the widget, keep the inbox: Brain owns chat; Gorgias remains the email inbox. Only real migration is Help-Center/macro content into the Webflow CMS FAQ source. No customer or order data ever moves — both read the same Shopify store.
• Path 4 · Downgrade, don’t exit: deflected ticket volume slides the merchant down Gorgias’s pricing ladder; full cancellation only makes sense with near-zero email support.

For Sprinklr users (enterprise contracts drive sequencing)

• Path 1 · Coexist (the wedge): Brain added as the storefront commerce agent; support issues create Sprinklr cases with transcript attached. No Sprinklr decision required — sells to revenue leadership, not CX procurement.
• Path 2 · Hand off web chat only, at renewal: widget swap, KB articles exported to the FAQ source, intents the Sprinklr bot handled now resolve via Shopify tools. Identity and history deliberately do not move.
• Path 3 · Full exit — only for orphaned self-serve customers forced into enterprise contracts after April 30, 2026: Brain for commerce chat plus a low-cost helpdesk (Gorgias/Zendesk) for the inbox.

Differentiators and Honest Gaps

• Moat: AP2 mandate-based autonomous purchase · open MCP runtime surface · merchant-owned identity and consent (Xano) · multi-tenant, white-label resellable · flat-cost Cloudflare infrastructure · Global-First localization (PIM-driven dynamic ISO detection, bge-m3 English+APAC, locale-gated fallback) coupled into the suite — language, gid-addressed catalog and GID identity as one omni-global segment built on Shopify + Google’s native omni-channel tools, not a fee-based single-tenant silo.
• Gaps to disclose: no ticketing/shared inbox · webchat-only channel today (no SMS/email/voice) · no SOC2/SLA · the ~9,500-line worker is self-maintained. In fairness, Klaviyo is a complete, packaged solution — multi-channel, zero-infrastructure, supported — and that completeness is genuine; the deliberate tradeoff here is open, merchant-owned rails over a turnkey-but-locked-in suite.

Net positioning: coexistence first. These are mature, well-supported tools most Shopify stores already run — the Brain is built to sit alongside them, not to declare them obsolete. It reads the same Shopify store and moves no customer or order data, so adding it is non-destructive and reversible from day one. Where a merchant later wants to consolidate, migration is gentle, phased and optional: by building on Shopify and Google’s native, free, Global-out-of-the-box rails (GraphQL gid catalog, GID identity, GA4, MCP), identity, catalog and language stay one merchant-owned omni-global segment — and the merchant turns over only the pieces, and only when, they choose. Concretely: Braze and Attentive are integration partners whose journeys need an execution layer; Gorgias coexists, with optional gradual hand-off of storefront chat at the merchant’s pace; Klaviyo is the closest functional overlap — coexist, and consolidate only if the economics and ownership goals call for it; Sprinklr is a different buyer — coexist beside it. The throughline is added optionality and ownership, never a forced rip-and-replace.