Executive summary
Agentic Commerce moves the shopping flow into AI assistants (e.g., ChatGPT). Your catalog is discoverable in-agent; checkout is completed via ACP; and payment credentials are delegated using Stripe’s Shared Payment Tokens (SPTs)—scoped, revocable tokens the agent issues for a single seller or transaction window. Salesforce’s Agentforce Commerce is integrating Instant Checkout using ACP, so merchants on Salesforce can surface products in ChatGPT and transact without redirect friction. Stripe Docs+4Salesforce+4Salesforce+4
Amazon
Top picks for "implement agentic commerce"
Open Amazon search results for this keyword.
As an affiliate, we earn on qualifying purchases.
What you need to ship (architecture at a glance)
Core components
- ACP-facing endpoints (merchant): catalog discovery, price/tax/ship calculation, checkout session creation, order confirmation webhooks. Spec is open (Apache 2.0) on GitHub. GitHub
- Payments: accept Shared Payment Tokens from the agent, convert to a PaymentIntent (Stripe) under your account. Stripe Docs+1
- Salesforce: expose product data from Agentforce Commerce to agents; use Salesforce for order/CS/fulfillment lifecycle while ACP handles the agent ↔ merchant handshake. Salesforce+1
- Observability & risk: log all agent-originated actions; tune fraud and SCA flows for delegated credentials. Stripe Docs
Step-by-step implementation
1) Expose a clean, machine-readable catalog
- Create a public, authenticated endpoint the agent can query (e.g.,
/acp/catalog), returning normalized product, price, variant, availability, and policy metadata. - Align field names to ACP draft spec to minimize custom mapping later. (Keep SKU → variant fidelity; include return policy and shipping constraints.) GitHub
Tip (Salesforce): Use Agentforce Commerce’s catalog services, then map to your ACP view. Salesforce says Agentforce will surface catalogs in ChatGPT once integrated. Salesforce
2) Implement a checkout session endpoint
- Create
/acp/checkoutthat accepts line items, shipping address, tax nexus hints, and returns a checkout session with totals, currency, and anorder_reference. - Validate inventory and price at this step; return resolvable errors (e.g., “size 43 out of stock”).
- Persist a pending order with TTL (e.g., 15 minutes) awaiting payment capture via SPT. GitHub
3) Accept and process Shared Payment Tokens (SPTs)
- Agents issue an SPT to you that’s already scoped (merchant-locked, amount-limited, expiry). You never see raw PANs. Stripe Docs+1
- On Stripe:
- Create a
PaymentIntentusing the SPT as the payment method reference. - Pass your
order_referenceand risk signals (IP/UA if applicable). - Handle required actions (3DS) via agent callbacks if prompted. Stripe Docs
- Create a
Why this matters: SPTs materially reduce PCI surface for merchants adopting agentic commerce and match the Delegated Payment Spec ACP references. OpenAI Developers
4) Confirm, fulfill, and notify
- On payment success, update order to confirmed, trigger fulfillment, and notify the agent via webhook (e.g.,
/acp/order/notify). - Include shipment ETA, tracking policy, and return window in the payload for the agent to present to the user. GitHub
5) Handle exceptions conversationally
- Define error classes the agent can act on:
OUT_OF_STOCK,ADDRESS_UNVERIFIED,PAYMENT_ACTION_REQUIRED,PRICE_CHANGED. - Provide structured remedies: alternate variants, re-calculate totals, or re-authorize SPT if expired. GitHub
Minimal payload patterns (illustrative)
Checkout request (agent → merchant)
{
"items": [{"sku":"BOOT-ALP-43","qty":1}],
"destination": {"country":"DE","postal_code":"80331"},
"buyer_intent_id":"bi_9f3...",
"capabilities": ["PROMO_APPLY","ALT_VARIANTS"]
}
Checkout response (merchant → agent)
{
"order_reference":"ord_7b2...",
"currency":"EUR",
"amount_total":12999,
"tax":2079,
"shipping":499,
"expires_at":"2025-10-17T12:05:00Z",
"next_action":"PAYMENT_REQUEST"
}
Payment (merchant → Stripe) with SPT
{
"payment_intent": {
"amount":12999,
"currency":"eur",
"payment_method":"spt_abc123",
"metadata":{"order_reference":"ord_7b2..."}
}
}
(Flows align with Stripe’s agentic commerce docs for SPT usage; exact fields depend on Stripe SDK version.) Stripe Docs+1
(Flows align with Stripe’s agentic commerce docs for SPT usage; exact fields depend on Stripe SDK version.) Stripe Docs+1
Security & trust model (what to insist on)
- Scope & expiry: Reject SPTs that are not merchant-scoped to you, exceed your checkout total + buffer, or are past expiry. Stripe Docs
- Replay protection: Bind SPT usage to
order_referenceand enforce idempotency keys server-side. Stripe Docs - Audit trails: Log each agent action and payment attempt with immutable event IDs; expose read-only traces to CS teams. (Industry best practice; aligned with ACP’s objective of auditability.) GitHub
- Fraud posture: Tune fraud rules for “agent channel” signals; treat agent platform as a distinct channel in your risk engine. (Community security guidance around agentic protocols is emerging.) GitHub
Salesforce integration notes
- Salesforce states Agentforce Commerce will integrate Instant Checkout guided by ACP, enabling catalogs to appear in ChatGPT and transactions to complete via Stripe. That reduces custom plumbing for Salesforce merchants. Salesforce+1
- Expect staged access / previews as the ecosystem rolls out. Keep your ACP endpoints and payment flow ready so you can toggle on once provisioned. Salesforce
Rollout plan (30–60–90 days)
Days 0–30: Foundation
- Data hygiene: normalize variants, stock, tax/ship rules.
- Build
/acp/catalog+/acp/checkout+ order webhooks. - Stripe sandbox: create PaymentIntents with test SPTs; simulate expiry and partial approvals. Stripe Docs
Days 31–60: Pilot
- Limited SKU set; define agent-safe promotions and return windows.
- Observability: dashboards for agent conversions, SPT failures, decline codes.
- CS scripting for “agent channel” disputes.
Days 61–90: Scale
- Expand categories; performance test high QPS catalog queries.
- Add conversational fallbacks for common errors.
- Begin marketing “shop via ChatGPT” with clear consent / confirmation UX.
KPIs to watch
- Agent discovery → add-to-cart rate (vs web)
- Payment success on first SPT (target ≥ web baseline)
- Conversation-resolved exceptions (no human handoff)
- Refund/return rate deltas (are agents picking right variants?)
- Latency: catalog (p95 < 250 ms), checkout calc (p95 < 400 ms)
Competitive map (very brief)
- ACP (OpenAI/Stripe): Open standard; merchant-of-record preserved; first delegated payments impl via Stripe SPTs; Salesforce Agentforce integration announced Oct 14, 2025. GitHub+2Stripe Docs+2
- Google AP2 (Agent Payments Protocol): Google’s effort toward secure agent payments; active code samples, separate governance path. You may see dual-support requests from partners. GitHub
- Ecosystem momentum: Composable platforms and major retailers (e.g., Walmart) are validating in-agent checkout patterns, accelerating user trust and merchant interest. AP News+1
Risk register (and mitigations)
- Spec churn (draft status) → Keep an abstraction layer between internal order objects and ACP payloads; version your endpoints. GitHub
- Token misuse → Strict SPT validation (merchant lock, amount caps, expiry), and real-time revocation on cancellation. Stripe Docs
- Channel cannibalization → Measure incrementality; ring-fence promos to agent channel for testing.
- User trust → Double-confirm high-value orders in-agent; provide an “agent actions history.”
What to build next
- A/B catalog shaping for agents: Provide richer attributes (fit notes, materials, eco labels) that LLMs can reason over.
- Returns via agent: Extend ACP flows for RMAs so the assistant can complete the loop. GitHub
- Promotion intent grammar: Let agents negotiate approved bundles or tiered discounts with strict guardrails.
- Multi-PSP readiness: ACP references a delegated spec; Stripe SPTs are first, but design for multiple PSPs later. OpenAI Developers
