# Stripe MPP x M39 Commerce x Chat SDK

Deep Research Brainstorm — 3 Protocol Comparison, Israeli Compliance, Architecture Design
21 March 2026 | yonatan-hq

## The Landscape Shift (March 18, 2026)

Three days ago, Stripe and Paradigm launched Tempo (a payments-focused L1 blockchain) alongside MPP (Machine Payments Protocol). Simultaneously, Coinbase's x402 crossed 75M transactions. Google launched UCP. This is the agent payments Big Bang.

Core Question: How should yonatan-hq's M39 commerce milestone adapt to a world where AI agents are autonomous economic actors?

## MPP Stripe + Tempo

- Sessions model (auth once, spend within limit)
- Fiat + crypto (cards, BNPL, USDC)
- Existing Stripe Dashboard
- SPTs for secure credential passing
- Private Preview
- US businesses only (stablecoin acceptance)

## x402 Coinbase

- HTTP 402 native (1-line middleware)
- Crypto only (USDC on Base/Solana)
- Zero protocol fees
- 75M+ transactions, $24M volume
- Live
- Avg tx: $0.20 (mostly testing)

## ACP OpenAI + Stripe

- Open-source commerce protocol
- Checkout API + catalog sync
- MCP server: `@stripe/acp-mcp-server`
- SPTs for agent credential delegation
- Beta
- URBN, Etsy, Coach already integrated

## Your Existing Stack (What You Have)

Ingestion
Chat SDK
ChatIngestEvent
WA/Slack/Telegram
AI
GenUI
14 component types
SSE streaming
Commerce
Registry
Product config
Order service
Fulfillment
Prodigi
POD integration
Webhooks
+ what's missing
M39 #613
Payment
PayPlus/Grow
+ Stripe MPP?
M39 #614
Invoice
GreenInvoice
SHAAM allocation
M39 #1102
Chat Commerce
Intent detection
Product browse
Future
Stripe MCP
Agent toolkit
ACP integration

## Three-Protocol Comparison

Aspect | Detail
--- | ---
Launch | March 18, 2026 (3 days ago)
Status | Private Preview — requires API version `2026-03-04.preview`
Flow | Agent requests resource -> HTTP 402 -> Agent pays -> Resource delivered
Networks | Tempo (USDC), Stripe card networks (all Stripe currencies)
Auth | Sessions model — authenticate once, spend within budget limit, batch settle
Credentials | SharedPaymentTokens (SPTs) — single-use, time-limited, scoped to one tx
Settlement | Into existing Stripe balance, standard payout schedule
Min payment | $0.01 USDC
Tooling | Stripe Agent Toolkit (Python/TS), MCP server at `mcp.stripe.com`
Geo restriction | US businesses only for stablecoin acceptance. Cards: 46 countries (Israel NOT listed)
Partners | Visa, Anthropic, OpenAI, Mastercard, Shopify, Lightspark (Bitcoin/Lightning)
Key advantage | Fiat + crypto hybrid, sessions for throughput, existing Stripe ecosystem

### Code Example

// Server: accept MPP payments import Stripe from 'stripe'; import { Credential } from 'mppx'; const stripe = new Stripe(process.env.STRIPE_SECRET_KEY, { apiVersion: '2026-03-04.preview', }); // Create PaymentIntent for crypto const pi = await stripe.paymentIntents.create({ amount: 1, // $0.01 currency: 'usd', payment_method_types: ['crypto'], payment_method_data: { type: 'crypto' }, payment_method_options: { crypto: { mode: 'deposit', deposit_options: { networks: ['tempo'] }, }, }, confirm: true, });

Aspect | Detail
--- | ---
Launch | Mid-2025 (Coinbase + Cloudflare)
Status | Live — 75M+ transactions, $24M volume
Flow | HTTP request -> 402 + PAYMENT-REQUIRED header -> Client pays -> Retry with PAYMENT-SIGNATURE
Networks | Base (EVM), Solana — token-agnostic across EVM chains
Auth | Per-request (pay, get resource, repeat). "upto" scheme planned but not shipped
Settlement | On-chain (<2 sec on Solana)
Fees | Zero protocol fees — only nominal network fees
Min payment | No minimum. $0.001 viable.
Tooling | `@x402/fetch`, `@x402/express`, Python/Go clients
Geo restriction | None — permissionless, no accounts needed
Partners | Coinbase, Cloudflare, Vercel, AWS, Nansen, Alchemy
Key advantage | Zero fees, truly open, 1-line server middleware, no accounts
Key weakness | Crypto only — no fiat rails. Avg tx $0.20 (mostly testing/gamified)

### Code Example

// Server: 1-line middleware import { paymentMiddleware } from '@x402/express'; app.use(paymentMiddleware({ "GET /api/data": { price: 0.01, // $0.01 USDC network: "base", description: "Data access" } })); // Client: agent pays import { x402Fetch } from '@x402/fetch'; const response = await x402Fetch( "https://api.example.com/data", { wallet: agentWallet } );

Aspect | Detail
--- | ---
Launch | December 2025 (Stripe Sessions), spec v2026-01-30
Status | Beta — open-source spec on GitHub
Purpose | Full commerce protocol (not just payments) — discovery, checkout, fulfillment
Flow | Agent discovers merchant -> Creates checkout -> Shares SPT -> Completes -> Gets order events
Spec | 4 REST endpoints: create_checkout, update_checkout, complete_checkout + events
MCP | `@stripe/acp-mcp-server` — exposes ACP as MCP tools for any LLM agent
Catalog | Merchants sync product catalog to Stripe -> agents discover via ACP
Payments | Uses SPTs (SharedPaymentTokens) — wraps any Stripe payment method
Merchants | URBN (Anthropologie, Free People, Urban Outfitters), Etsy, Coach, Kate Spade
Platforms | Wix, WooCommerce, BigCommerce, Squarespace, commercetools integrated
AI Agents | ChatGPT "Instant Checkout" powered by ACP
Key advantage | Full commerce lifecycle, not just payment — discovery through fulfillment

### MCP Tool Example

// ACP MCP tools available to agents: { name: "acp_discover_merchants", description: "Find merchants that can fulfill a purchase intent", parameters: { intent: { type: "string" }, // "photo puzzle gift" constraints: { type: "object" }, // { currency: "ILS", ships_to: "IL" } location: { type: "object" } // optional } } // Stripe MCP server tools (mcp.stripe.com): create_payment_link // Generate payment link create_payment_intent // Direct payment create_invoice // Issue invoice create_product // Manage catalog list_customers // Customer lookup create_refund // Process refund

## Head-to-Head Comparison

Dimension | MPP | x402 | ACP
--- | --- | --- | ---
Scope | Payments only | Payments only | Full commerce lifecycle
Fiat support | Yes Cards/BNPL | No | Yes via SPTs
Crypto support | Yes USDC/Tempo | Yes USDC/Base/Sol | Yes via MPP/x402
Israel support | No (US only for stablecoin) | Permissionless | Depends on Stripe IL
ILS currency | No | No (USDC only) | If Stripe supports IL
Micropayments | $0.01+ | $0.001+ | Standard pricing
Setup complexity | Medium (Stripe account) | Low (1 line) | High (catalog sync)
MCP integration | Via Stripe MCP | Custom | Native
Maturity | 3 days old | ~9 months | ~3 months

## Israeli Payment Reality Check

Critical: Israel is NOT in Stripe's 46 supported countries for direct merchant accounts. Stripe has a "payments in Israel" guide but positions itself for international businesses selling TO Israel, not Israeli businesses.

Implication: MPP and ACP are not directly usable by an Israeli Osek Morsheh. PayPlus/Grow remain mandatory for ILS transactions. Stripe MPP is relevant only for USD international sales or as an outbound payment method (your agents paying foreign services).

## Required Israeli Gateways

### PayPlus

- Leading Israeli payment gateway
- Full REST API: charges, refunds, payment links, payment pages
- IPN (Instant Payment Notification) webhooks
- Sandbox environment for testing
- ILS native, Israeli card networks (Visa CAL, Isracard, etc.)
- API docs: `docs.payplus.co.il`

### Grow (Meshulam)

- Already configured in Commerce Registry: `payment_provider: "grow"`
- Used for CoupleSnap currently
- ILS native

## Required Israeli Invoicing

### E-Invoicing Mandate (2026)

- Jan 2026: Invoices > NIS 10,000 require SHAAM allocation number
- Jun 2026: Threshold drops to NIS 5,000
- ITA requires real-time allocation number from Tax Authority
- Customers can only deduct input VAT with valid allocation number

### GreenInvoice vs iCount

| GreenInvoice | iCount
--- | --- | ---
API | REST API | REST API
SHAAM | Integrated | Integrated
Webhooks | Yes | Limited
Developer DX | Better docs | Older API
Recommendation | GreenInvoice — better API, SHAAM-ready

## The Two-Track Payment Reality

TRACK 1: Israeli Commerce (ILS) TRACK 2: Agent Economy (USD) Required for legal compliance Optional / future opportunity Customer (IL) Your Agent (outbound) | | v v PayPlus / Grow Stripe MPP / x402 | ILS transaction | USD/USDC v v GreenInvoice Stripe Dashboard | Tax invoice + SHAAM allocation | Auto-settled v v Order Service Prodigi / APIs / MCP tools | | v v Prodigi fulfillment Resources acquired KEY INSIGHT: These are SEPARATE payment rails. The PaymentProvider protocol must abstract BOTH. M39 #613 = Track 1. Stripe MPP = Track 2. Track 1 is legally required. Track 2 is strategic.

## Israeli E-Invoicing Timeline

May 2024
Pilot Phase: > NIS 25,000
E-invoicing mandate launched for high-value invoices
Jan 2025
Threshold: > NIS 20,000
VAT increased to 18%
Jan 2026 (NOW)
Threshold: > NIS 10,000
SHAAM allocation numbers required for qualifying invoices
Jun 2026
Threshold: > NIS 5,000
Most B2B invoices will require allocation numbers

## PaymentProvider Protocol (Protocol DI)

class PaymentProvider(Protocol): """Abstract payment provider — same pattern as voice-core providers.""" async def create_payment_link( self, amount_cents: int, currency: str, # "ILS" | "USD" order_id: str, customer_email: str | None, description: str, redirect_url: str | None, ) -> PaymentLinkResult: ... async def create_payment_intent( self, amount_cents: int, currency: str, metadata: dict, ) -> PaymentIntentResult: ... async def verify_webhook( self, payload: bytes, signature: str, ) -> WebhookEvent: ... async def refund( self, transaction_id: str, amount_cents: int | None, # None = full refund ) -> RefundResult: ... # ─── Implementations ─── class PayPlusProvider(PaymentProvider): # ILS, Israeli cards class GrowProvider(PaymentProvider): # ILS, Israeli cards (existing) class StripeProvider(PaymentProvider): # USD, international cards class StripeMPPProvider(PaymentProvider): # USD/USDC, agent-to-agent (FUTURE) # ─── Registry (extends existing CommerceProduct) ─── "couplesnap": CommerceProduct( payment_provider="grow", # resolves to GrowProvider currency="ILS", ) "international-product": CommerceProduct( payment_provider="stripe", # resolves to StripeProvider currency="USD", )

## InvoiceProvider Protocol

class InvoiceProvider(Protocol): """Israeli tax invoice generation with SHAAM allocation.""" async def create_invoice( self, customer_name: str, customer_id_number: str | None, # Israeli ID / company number items: list[InvoiceItem], currency: str, vat_rate: float = 0.18, # 18% as of Jan 2025 payment_method: str | None, # "credit_card", "bank_transfer" ) -> InvoiceResult: ... # includes SHAAM allocation_number async def send_invoice( self, invoice_id: str, email: str | None, whatsapp: str | None, # send PDF via WhatsApp! ) -> bool: ... # ─── Implementations ─── class GreenInvoiceProvider(InvoiceProvider): # Recommended class ICountProvider(InvoiceProvider): # Alternative class NoOpInvoiceProvider(InvoiceProvider): # For non-IL transactions # ─── Trigger: payment.completed webhook ─── @observe(name="post_payment_invoice") async def on_payment_completed(event: WebhookEvent): order = await order_service.get(event.order_id) invoice_provider = resolve_invoice_provider(order.currency) if order.total_cents >= 500_00: # > NIS 5,000 after Jun 2026 result = await invoice_provider.create_invoice(...) # SHAAM allocation number automatically obtained

## Chat SDK Commerce Extension

┌─────────────────────────────────────────────────────────────────┐ │ EXISTING PIPELINE NEW COMMERCE LAYER │ │ │ │ WhatsApp msg │ │ │ │ │ v │ │ ChatIngestEvent │ │ │ │ │ v │ │ whatsapp_processor │ │ │ │ │ ├──> spam detection │ │ ├──> media download │ │ ├──> audio transcription │ │ │ │ │ ├──> commerce_intent_detection() NEW SIDE EFFECT │ │ │ │ │ │ │ ├─ "order" ──> commerce_dispatch() │ │ │ ├─ "browse" ─> product_catalog_reply() │ │ │ ├─ "track" ──> order_status_reply() │ │ │ └─ "receipt" ─> invoice_resend() │ │ │ │ │ ├──> question detection │ │ └──> agent dispatch (existing) │ │ │ │ AllowedChats.assistant_mode: │ │ "off" | "codebase" | "project_assistant" | "commerce" │ │ │ │ GenUI Commerce Components: │ │ render_product_card — browseable product with image │ │ render_order_summary — cart review before payment │ │ render_payment_link — pay button (web) / URL (WhatsApp) │ │ render_order_tracker — status timeline │ │ render_invoice_card — downloadable tax invoice │ └─────────────────────────────────────────────────────────────────┘

## Three Payment Flows — When to Use Each

## Flow A Human Pays via Agent

Use case: Customer orders via WhatsApp/Portal

Payment: PayPlus/Grow (ILS)

Customer: "I want a puzzle" │ v Intent: ORDER │ v Agent builds order │ v Payment link (PayPlus) │ sent via WA/Portal v Human clicks & pays │ v Webhook: payment.completed │ v GreenInvoice (SHAAM) │ v Prodigi fulfillment

Status: M39 #613 + #614 + #1102. Must build. Legally required for IL.

## Flow B Agent Pays Service (MPP)

Use case: Your agent pays Prodigi, APIs, MCP tools

Payment: Stripe MPP / x402 (USD)

Order.status = PROCESSING │ v Agent initiates payment │ v MPP: HTTP 402 from service │ v Agent authorizes (SPT/wallet) │ v Service delivers resource │ v Stripe Dashboard: settled │ v No IL invoice needed (outbound, not revenue)

Status: Future opportunity. MPP is 3 days old, private preview, US-only for stablecoin. Build the protocol interface now, wire MPP later.

## Flow C ACP Commerce (Agent Shop)

Use case: AI agents discover & buy your products

Payment: ACP + SPTs

ChatGPT user: "Find me a custom photo puzzle gift" │ v ACP: discover_merchants() │ finds CoupleSnap v ACP: create_checkout() │ v User confirms in ChatGPT │ v SPT → your Stripe account │ v Order created via ACP event │ v Prodigi fulfillment

Status: Strategic future. Requires Stripe account (IL issue) + catalog sync. URBN/Etsy already live. Could be transformative if Stripe opens IL.

## Stripe MCP Server — Already Available Tools

Category | Tool | Description
--- | --- | ---
Account | `get_stripe_account_info` | Retrieve account details
Balance | `retrieve_balance` | Current + pending balance
Customer | `create_customer`, `list_customers` | Manage customers
Product | `create_product`, `list_products` | Product catalog
Price | `create_price`, `list_prices` | Pricing management
Payment | `create_payment_link`, `create_payment_intent` | Accept payments
Invoice | `create_invoice`, `list_invoices` | Invoice management
Subscription | `list_subscriptions`, `cancel_subscription` | Recurring billing
Refund | `create_refund` | Process refunds
Dispute | `list_disputes` | Handle chargebacks
Search | `search_stripe_documentation` | Knowledge base search

Remote MCP: `mcp.stripe.com` (OAuth2 via Stripe Connect) | Local: `npx @stripe/mcp --tools=all`

## Decision: M39 Redesign Strategy

Click to select your preferred approach:

#### A. Israel-First + MPP-Ready

Recommended

Build PayPlus/Grow + GreenInvoice now (legal requirement). Design PaymentProvider protocol with MPP adapter slot. Wire Stripe MCP as hq-platform tool. Add MPP when Israel is supported.

- Ship #613 with PayPlus + Grow
- Ship #614 with GreenInvoice
- Ship #1102 on Chat SDK (channel-agnostic)
- Add Stripe MCP to hq-platform now
- Add StripeMPPProvider when available

#### B. Stripe-First

Blocked

Wait for Stripe Israel support, build entirely on Stripe + MPP + ACP. Skip Israeli gateways.

- Stripe doesn't support IL merchants
- MPP is private preview, US-only
- No ILS support
- No timeline for IL availability
- Would violate Osek Morsheh requirements

#### C. Dual Track from Day 1

Over-engineered

Build both Israeli gateways AND Stripe MPP simultaneously. Full ACP catalog sync. Full x402 support.

- 4 payment providers at once
- 2 invoice providers
- ACP catalog sync infrastructure
- MPP not usable yet
- Solo-dev complexity explosion

## Scoring: What to Build When

PayPlus/Grow (#613)
9.5
GreenInvoice (#614)
9.0
Chat Commerce (#1102)
8.5
Stripe MCP (hq-platform)
7.0
PaymentProvider Protocol
8.0
ACP Catalog Sync
4.0
MPP Provider
2.5
x402 Provider
2.0

Scoring criteria: Legal requirement (3x weight) + Revenue impact + Technical feasibility + Solo-dev effort + Time-to-value

## Recommended Phased Roadmap

Phase 1 — Now (Q1 2026)
PaymentProvider Protocol + Israeli Gateways

- Design `PaymentProvider` + `InvoiceProvider` protocols (Protocol DI)
- Implement `GrowProvider` (already have integration) + `PayPlusProvider`
- Implement `GreenInvoiceProvider` with SHAAM allocation
- Add Stripe MCP server to `.mcp.json` (free, immediate value for dashboard ops)
- Issues: #613, #614

Phase 2 — Q2 2026
Chat Commerce on Chat SDK

- Commerce intent detection in WhatsApp pipeline (ORDER, BROWSE, TRACK)
- `assistant_mode="commerce"` for AllowedChats
- 5 GenUI commerce components (product_card, order_summary, payment_link, order_tracker, invoice_card)
- Channel-adaptive rendering (web=cards, WA=text+URL, portal=embedded)
- Issue: #1102 (reframed as Chat SDK native)

Phase 3 — Q3 2026
Stripe Integration + MPP Readiness

- Add `StripeProvider` for USD international payments (if Stripe opens IL, or via US entity)
- ACP catalog sync for CoupleSnap (expose to ChatGPT/Claude agent shoppers)
- Add `StripeMPPProvider` stub with feature flag
- Enable agent-outbound payments (your agents pay Prodigi/APIs via MPP)

Phase 4 — Q4 2026+
Full Agent Economy

- MPP GA + Israel support (when available)
- x402 for MCP tool monetization (charge per API call)
- ACP multi-product catalog (CoupleSnap + future products)
- Agent-to-agent commerce via Chat SDK

### The Verdict

Build Israeli rails NOW, design for agent economy TOMORROW.

PayPlus + GreenInvoice are legally required and revenue-generating today. MPP/ACP/x402 are 3 days old, US-only, and have ~$28K daily volume. The PaymentProvider protocol abstraction costs zero extra effort and makes you MPP-ready the day Stripe opens Israel.

Meanwhile: add Stripe MCP to your hq-platform tools TODAY (free, instant value for ops).

## Implementation Prompt

## M39 Commerce Implementation Plan — Post-MPP Brainstorm (21 March 2026) ### Context Stripe launched MPP (Machine Payments Protocol) on March 18, 2026 — agent-to-agent autonomous payments. However: Israel is NOT in Stripe's 46 supported countries. MPP is private preview, US-only for stablecoin. Israeli Osek Morsheh requires PayPlus/Grow (ILS gateway) + GreenInvoice (SHAAM e-invoicing). ### Phase 1: #613 + #614 — Israeli Payment + Invoicing 1. Create `apps/api/app/services/commerce/payment_provider.py`: - `PaymentProvider` Protocol (Protocol DI pattern like voice-core) - Methods: create_payment_link(), create_payment_intent(), verify_webhook(), refund() - `GrowProvider` implementation (existing integration) - `PayPlusProvider` implementation (REST API at docs.payplus.co.il) 2. Create `apps/api/app/services/commerce/invoice_provider.py`: - `InvoiceProvider` Protocol - Methods: create_invoice(), send_invoice(), get_status() - `GreenInvoiceProvider` with SHAAM allocation number support - Triggered by payment.completed webhook (any provider) - SHAAM threshold: > NIS 5,000 after June 2026 3. Update `CommerceProduct` in commerce_registry.py: - payment_provider field resolves to Provider instance - Add invoice_provider field ### Phase 2: #1102 — Chat Commerce (Chat SDK Native) 4. Add commerce intent detection to whatsapp_processor.py: - New side effect: commerce_intent_detection() - Intents: ORDER, BROWSE, TRACK, RECEIPT - Insert AFTER spam detection, BEFORE agent dispatch 5. Add assistant_mode="commerce" to AllowedChats: - Config: product_slug, default_currency 6. Add 5 GenUI commerce components to packages/generative-ui/: - render_product_card, render_order_summary, render_payment_link - render_order_tracker, render_invoice_card - Channel-adaptive: web=interactive cards, WA=text+URL ### Future: Stripe MPP/ACP Readiness 7. Add Stripe MCP server to .mcp.json (hq-platform): ```json "stripe": { "url": "https://mcp.stripe.com" } ``` 8. Design StripeMPPProvider stub (feature-flagged): - Same PaymentProvider protocol - Uses PaymentIntents API with payment_method_types: ['crypto'] - Activate when Stripe supports Israel ### Cross-Stack Types - PaymentLinkResult, InvoiceResult -> Pydantic schemas + TypeScript interfaces - GenUI commerce component props -> Zod schemas (Tier 1)