The complete developer's guide to Stripe Sessions 2026
Stripe shipped 288 launches at Sessions 2026, but only 3 are GA day-one — here is what is actually buildable today, the new agent-payment protocol stack, and ten projects worth shipping this quarter.
TL;DR
- Stripe announced 288 launches at Sessions 2026 — exactly 3 are GA on day one (Workflows, Network cost passthrough, Stripe Projects); 46 were "previewed" and 223 are roadmap entries.
- Seven new or formalized protocols (UCP, ACP, ACS, MPP, x402, skill.md, Tempo) define how agents discover merchants, pay per token, and settle on-chain.
- The mppx + Tempo stack enables sub-cent per-token billing in a generator function — a pricing model unreachable on credit-card rails where the per-charge fee is $0.30.
- Stripe Projects provisions 32 launch partners (Clerk, Neon, Fly.io, Vercel, Privy + 27 more) via one CLI command, with billing consolidated under a single Stripe customer.
- Counting open standards and partner products that need no Stripe approval, 40+ things are usable this week — the gap between "288 launches" and "shippable today" is roughly 10x.
Table of contents
- What just happened, in plain language
- The honest count: what’s actually shippable today
- The five mental shifts a developer needs
- The protocol stack, MPP, UCP, ACP, x402, ACS, skill.md, Tempo
- The Stripe primitives map, every feature, status, and where to use it
- Ten projects worth building this quarter
- The “ship in a weekend” stack and why Stripe Projects changed it
- Business models for agentic products
- The apply-now matrix
- Closing thoughts and references
1. What just happened, in plain language
On April 29, 2026, Stripe held its annual customer conference, Sessions 2026, in San Francisco. Roughly 9,000 people attended. The keynote was delivered by Will Gaybrick, Stripe’s President of Product and Business. The framing was unmistakable: “We are building the economic infrastructure for AI.”
“If AI can solve Nobel level physics problems but can’t buy a domain, something’s gone wrong. Our mantra: empower agents. Stripe is building the economic infrastructure for AI. That’s the animating theme behind all 288 product announcements we made today at Stripe Sessions.”
— @wgaybrick, April 30 2026
Concretely, Stripe announced 288 product launches spanning seven product surfaces (Payments, Radar, Revenue + 4 more) plus an eighth section called “What’s coming later this year” which is the public roadmap.
The 288 launches break down into five strategic bets:
- Agents are first-class economic actors. Stripe wants AI agents to have their own wallets, their own cards, their own fraud profiles, and to be able to transact with merchants over open protocols.
- Per-token billing is real and on-chain. The combo of
mppx(Stripe’s open SDK), Tempo (Stripe-affiliated EVM L1), and on-chain payment channels means you can now charge $0.001 per yielded token in a generator function. This is genuinely new. - Stripe is becoming a bank. Stripe Treasury (limited public preview), free instant transfers between Stripe businesses, a 2% cashback Mastercard, and an MCP-operable banking layer.
- Distribution moved to Stripe. Stripe Projects + the
projects.dev/providerscatalog (32 launch partners including Fly.io, Vercel, Supabase + 29 others) means signups for SaaS infrastructure now happen inside Stripe with consolidated billing. - Radar pivots from card fraud to token fraud. “1 in 6 AI signups is malicious” was the talk’s headline. The responsive ships target free-trial abuse, bot abuse, multi-account abuse + 2 others, plus an expanded Stripe Signals network.
We just announced a large raft of improvements at @Stripe Sessions. My meta reflections:
• It feels that the entire economy is replatforming right now. • Many charts at Stripe are inflecting in quite dramatic ways. What GitHub recently reported for commits we are seeing in economic activity (such as new company formations). • It is increasingly clear that agents will be responsible for most transactions in the not overly distant future. • Stripe was always developer-centric, but AI is making developer-centricity strategic in a new way: agents are even hungrier for good DX than developers themselves are.
— @patrickc, April 30 2026
If you do nothing else with this post, internalize those five bets. Everything Stripe did at Sessions 2026, every API and every preview, fits inside one of those five stories.
But the real news isn’t that Stripe shipped 288 things. The real news is what’s actually buildable today, and that requires reading the announcement blog with much more care than most coverage gave it.
2. The honest count: what’s actually shippable today
Most coverage of Sessions 2026 said something like “Stripe shipped 288 launches today.” That’s literally true and practically misleading. Here’s the precise breakdown, verified line-by-line against Stripe’s own announcement blog:
Day-of GA on Stripe rails: exactly 3 things
Stripe is rigorous about phasing. They use specific language: “is now generally available” or “is now available” for true GA. In the entire announcement blog, they use that language for exactly two products:
- Stripe Workflows: “is now generally available” (with looping, third-party custom actions, prebuilt actions for Mailchimp and Slack, programmatic invocation, and Connect support)
- Network cost passthrough (IC++): “is now available to platforms in 45 markets” (US, EU, and others)
The press release adds one more:
- Stripe Projects: “now available to everyone”
That’s three. Three things that, the moment Sessions ended, any Stripe customer could turn on with no application, no waitlist, no preview opt-in.
”We previewed” mentions: 46 items
Throughout the same blog, Stripe says “we previewed” 46 times. This is preview language, public preview or private preview, not day-of GA. Examples from the actual blog text:
- “We previewed the Agentic Commerce Suite, allowing your business to sell across the agentic web.”
- “We previewed Issuing for agents, a new way to provision single-use virtual cards for AI agents.”
- “We previewed Custom Objects, allowing you to model your business in Stripe.”
- “We previewed Stripe Database, a managed Postgres for your Stripe data.”
- “We previewed Stripe Console, an agent-facing operations interface.”
Read those carefully. Stripe is deliberately not saying these are GA. They are previewing them. Some are open public previews you can opt into today (with caveats). Others are private previews that require an explicit invitation, and a few are deeper than that.
Future roadmap entries: 223 items
The “What’s coming later this year” section of the blog has 223 Q-marked entries. Each one looks like:
[Q3 2026, public preview] Off-session payments API for one-time purchases initiated by an agent.
The breakdown:
- 78 entries marked “GA” (future GA, not GA today)
- 62 entries marked “public preview” (future public preview)
- 84 entries marked “private preview” (future private preview, the longest queue)
- 14 entries scheduled for Q1 2026 (already past), 65 for Q2, 62 for Q3, 82 for Q4
Add it up: 3 day-of GA + 46 previewed + 223 roadmapped = 272. The remaining 16 are the open-standards and partner-product launches (UCP, MPP, ACP plus x402, Privy SDK, Tempo mainnet, and a few more) that don’t fit Stripe’s own preview taxonomy because they don’t gate on Stripe approval.
What this means in practice
If a colleague says “Stripe shipped 288 things today,” they’re literally correct.
If a colleague says “you can use 288 things today,” they’re wrong by a factor of ten.
But here’s the thing the coverage usually misses: the open-standards work and the partner-product work also shipped, and those don’t need any Stripe approval. Add up:
- 3 things Stripe explicitly calls GA on day one
- ~17 open-standards and partner products that shipped at Sessions and need no Stripe gate
- ~24 pre-existing Stripe primitives that newly pair with the agentic stack
That’s 40+ things you can use this week without filling out a single application. That’s the honest developer reality.
This distinction comes back throughout: 🟢 means usable today with no approval, 🟡 means usable today with a preview opt-in or self-service waitlist, 🔴 means actually blocked behind a private preview that requires an invitation.
3. The five mental shifts a developer needs
Before the protocols and projects, five intuitions about how money moves and how products get built need updating. None of these are minor. Each one is a wholesale rewrite of an assumption most Stripe users have held for a decade.
Shift 1: Agents are first-class economic actors
For two decades, the “buyer” in a Stripe transaction has been a human with a card. Your checkout flow is designed for them: text fields, a CVV box, maybe Apple Pay. Risk models assume a human typed the card. Disputes assume a human will eventually claim chargeback. Customer support assumes you can email them.
That’s all changing. An AI agent is now a buyer Stripe specifically supports. Concretely:
- Link agent wallets (
link.com/agents): the agent has a wallet under the user’s Link account. Stripe handles the auth dance. - Issuing for agents (private preview): Stripe issues a single-use virtual card for a specific agent task. The card has its own MCC restrictions, spending limit, and expiry. After the task, the card dies.
- Shared Payment Tokens (SPTs): a new tokenization scheme designed for agents to share a payment method across multiple merchants in a single shopping session.
- Agentic Commerce Suite (ACS): a server-side product that lets you sell to agents acting on your existing merchant Stripe account. ChatGPT, Gemini, Copilot, Meta AI all become checkout surfaces.
- Universal Commerce Protocol (UCP) + Agentic Commerce Protocol (ACP): two open standards Stripe accepts. Agents can browse your catalog and buy without you uploading anything to OpenAI or Google.
- Machine Payments Protocol (MPP) + x402: for machine-to-machine payments where one server pays another server (your agent paying for an API call, not buying a coffee).
- Radar 2026: risk models that distinguish real users from bots, multi-account abuse, free-trial farming, token theft.
The dev consequence: “is the buyer a human?” is now a question your code must answer. And if the answer is “no, it’s an agent,” there’s a different set of best practices, a different set of fraud signals, and a different set of pricing primitives.
“Starting today, agents can now be Cloudflare customers. They can create a Cloudflare account, start a paid subscription, register a domain, and get back an API token to deploy code right away.”
— @Cloudflare, April 29 2026
Shift 2: Per-token billing is real and on-chain
Pre-Sessions, “metered billing” meant Stripe Billing usage records: you collect events, batch them up, send them to Stripe at the end of a billing cycle, and the customer gets invoiced monthly. The granularity was hours, sometimes minutes.
Post-Sessions, you can charge per yielded token in a generator function, and the charge settles on-chain in milliseconds. Here’s what that actually looks like:
import { Mppx, tempo } from 'mppx/nextjs'
const mppx = Mppx.create({
methods: [tempo({
currency: '0x20c0000000000000000000000000000000000000', // pathUSD on Tempo
recipient: '0xa726a1CD723409074DF9108A2187cfA19899aCF8',
sse: true,
})],
})
export const GET = mppx.session({ amount: '0.001', unitType: 'word' })(
async () => {
return async function* (stream) {
const tokens = generateTokens()
for (const token of tokens) {
await stream.charge() // 🪙 0.001 pathUSD debit, on-chain
yield token
}
}
}
)This is real. Verified at docs.tempo.xyz/guide/machine-payments/streamed-payments. Every await stream.charge() debits a payment channel by 0.001 pathUSD. If the channel runs dry mid-stream, the generator halts. There’s no PaymentIntent state machine, no webhook reconciliation, no batch settlement. The on-chain ledger is the ledger.
The dev consequence: pricing models you couldn’t express before are now expressible. Per-frame video transformation. Per-row data API. Per-call DeFi quote. Per-tile map render. Anything where the unit of value is too small to be a Stripe Invoice line item but you still want to charge for it.
Today at Sessions, @Stripe introduced streaming payments on Tempo.
A single agent run produced thousands of sub-cent transactions onchain, with payment landing the instant each token was burned. Metered, paid for as it ran.
The infrastructure for pay-per-use at scale is here.
— @tempo, April 29 2026
Shift 3: Stripe is becoming a bank
You’ve used Stripe for taking payments. Going forward, Stripe also wants to be where your business holds, moves, and earns money. Stripe Treasury, currently in limited public preview, does this:
- Free instant transfers between Stripe Treasury businesses (no ACH delay)
- Stripe credits as yield (you keep money on Stripe and earn interest)
- A 2% cashback Mastercard
- Multi-currency balances (15 currencies on the roadmap)
- A banking MCP server (private preview): yes, an LLM can move your money
The dev consequence: “where does the customer’s money live?” is no longer just a Stripe Connect question. If you’re building a marketplace, a SaaS, a vertical, or a fintech, you can now hold the funds on Stripe rails the whole time and skip a bunch of integrations with Mercury, Brex, Modern Treasury, etc.
“I’ve gotten to use @stripe Treasury for the last few months and it feels incredibly natural to manage your money in the same place you manage your business, across multiple currencies, with auto rewards on card spend and savings, and payouts globally.”
— @jeff_weinstein, April 29 2026
Caveat worth stressing: Treasury itself is in limited public preview. Stripe’s own doc page reads: “only available for some Stripe users.” Your account may not have it. Check Dashboard → Treasury before promising a customer anything Treasury-dependent.
Shift 4: Distribution flipped via Stripe Projects
Pre-Sessions: building a SaaS app meant signing up separately for Clerk (auth), Neon (Postgres), Fly.io (hosting), and a few more. Each had its own dashboard, its own billing, and its own credit card on file.
Post-Sessions: Stripe Projects + projects.dev/providers. Sign up once, on Stripe. The 32 launch providers (Fly.io, Vercel, Supabase + 29 more) are all reachable through one CLI:
$ stripe projects init my-agent-app
? Which providers? (space to select)
> ◉ Clerk (auth)
> ◉ Neon (postgres)
> ◉ Fly.io (hosting)
> ◉ Inngest (jobs)
> ◯ Tinybird (analytics)
✓ Provisioned 4 services. Wrote .env.local with 12 secrets.
✓ Billing consolidated under Stripe customer cus_xxx.This is real. It’s the only thing the press release explicitly calls “now available to everyone.” The catalog is browsable at projects.dev/providers.
The dev consequence: time-to-first-deploy collapsed. A v0 of an AI app went from “configure 8 dashboards” to “one CLI command.” For hackathons, internal tools, and prototypes, this is a step-change in setup time. For production, it’s a billing simplification that compounds, every provider’s invoice flows through Stripe, your CFO sees one line per provider per month, and audit trails stay in one place.
Shift 5: Radar pivots from card fraud to token fraud
The headline stat from Will Gaybrick’s keynote: “1 in 6 AI signups is malicious.” The pre-Sessions Radar was tuned for card-not-present fraud, stolen credit cards being used at e-commerce checkouts. The post-Sessions Radar adds:
- Free trial abuse: distinguishing real signups from prompt-engineering farms
- Bot abuse: distinguishing humans from automated traffic on your signup form
- Multi-account / account-sharing abuse: same person creating 100 accounts to abuse free tiers
- Pay-as-you-go abuse: token theft from compromised API keys
- Cross-network Stripe Signals: fraud signals from off-Stripe traffic shared back into your Radar config
The dev consequence: your fraud surface area changed. If you’re running an AI product with a free tier, and most AI products are, you should assume a meaningful percentage of your signups are fraudulent. Radar 2026 gives you the primitives to detect that. One of these gets wired into a project later in the guide.
4. The protocol stack
Sessions 2026 introduced or formalized seven protocols that together describe how AI agents and merchants interact. Most coverage threw all seven into one bucket called “agent commerce.” That’s wrong. Each one solves a different problem. As a dev you need to know which one applies when.
Here’s the map:
Now the deep dive.
4.1 Universal Commerce Protocol (UCP)
What it is: An open standard for product catalogs that agents can crawl. The merchant publishes a JSON manifest at /.well-known/ucp.json. Agents (Claude, ChatGPT, custom) fetch it, parse it, and use it to satisfy user shopping queries.
Where it lives: ucp.dev, github.com/Universal-Commerce-Protocol/ucp.
Status: 🟢 Open standard, live today, no Stripe approval needed.
Minimal manifest:
{
"version": "1.0",
"merchant": {
"name": "Example Coffee Co",
"domain": "examplecoffee.com",
"support_email": "help@examplecoffee.com"
},
"catalog_endpoint": "https://examplecoffee.com/api/ucp/catalog",
"checkout_endpoint": "https://examplecoffee.com/api/ucp/checkout",
"payment_methods": ["card", "link", "mpp"],
"supported_currencies": ["USD", "EUR"],
"shipping_zones": ["US", "EU", "UK"]
}The catalog endpoint returns paginated products:
{
"products": [
{
"id": "sku_001",
"name": "Premium Coffee Beans, Yirgacheffe",
"description": "Single-origin Ethiopian, fresh-roasted weekly",
"price": { "amount": 2400, "currency": "USD" },
"inventory": 47,
"images": ["https://examplecoffee.com/img/sku_001.jpg"],
"variants": [
{ "id": "sku_001_250g", "name": "250g", "price_delta": 0 },
{ "id": "sku_001_500g", "name": "500g", "price_delta": 1800 }
]
}
],
"next_page": "/api/ucp/catalog?cursor=eyJpZCI6InNrdV8wMDIifQ"
}Stripe accepts UCP as the catalog format for ACS (the Agentic Commerce Suite). Meaning: if you publish a UCP manifest, you’re already half-integrated with Stripe ACS.
🚨 JUST IN: Amazon, Microsoft, Meta, Salesforce, and Stripe just joined Google’s UCP.
The protocol war for agentic commerce is over.
Google’s UCP won.
— @sytaylor, April 25 2026
4.2 Agentic Commerce Protocol (ACP)
What it is: A second open standard for agent-merchant commerce, slightly different focus. Where UCP is catalog-first (“here’s everything I sell”), ACP is capability-first (“here’s what I can do for you, agent”). They’re complementary; many merchants will publish both.
Where it lives: agenticcommerce.dev.
Status: 🟢 Open standard, live today.
The capabilities feed:
{
"version": "1.0",
"merchant": "examplecoffee.com",
"capabilities": [
{
"name": "buy_coffee",
"description": "Purchase coffee beans for delivery",
"endpoint": "/api/acp/buy",
"input_schema": {
"type": "object",
"properties": {
"sku": { "type": "string" },
"quantity": { "type": "integer", "minimum": 1 },
"shipping_address": { "$ref": "#/definitions/Address" }
}
}
},
{
"name": "subscribe_to_box",
"description": "Monthly subscription, varies by season",
"endpoint": "/api/acp/subscribe",
"pricing": "https://examplecoffee.com/api/acp/box/pricing"
}
]
}ACP is closer in spirit to OpenAPI/MCP than UCP. If you’re building a more complex merchant (services, subscriptions, configurable products), ACP fits better.
4.3 Stripe Agentic Commerce Suite (ACS)
What it is: Stripe’s server-side product that wires UCP / ACP catalogs into the major agent surfaces: ChatGPT, Gemini, Copilot, Meta AI. You upload your products via the Stripe API; ACS handles distribution.
Status: 🟡 Public preview, requires API version 2026-04-22.preview.
Doc: docs.stripe.com/agentic-commerce.
Minimal integration:
import Stripe from 'stripe'
const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!, {
apiVersion: '2026-04-22.preview',
})
// 1. Make sure you have a Stripe Profile (the prereq)
const profile = await stripe.profiles.create({
business_name: 'Example Coffee Co',
domain: 'examplecoffee.com',
description: 'Single-origin coffee from Ethiopia',
})
// 2. Sync your catalog
for (const product of myCatalog) {
await stripe.products.create({
name: product.name,
description: product.description,
default_price_data: {
unit_amount: product.price_cents,
currency: 'usd',
},
metadata: {
inventory_count: String(product.inventory),
profile_id: profile.id,
},
})
}
// 3. Configure ACS to pull from this account
await stripe.profiles.update(profile.id, {
agentic_commerce: { enabled: true },
})After this, your products start appearing in ChatGPT/Gemini/etc. when users ask agents to shop.
The trade-off: ACS routes the discovery through Stripe (good for distribution) but locks you into Stripe-mediated checkout (the agent uses Stripe’s payment infrastructure). Compare with UCP/ACP, where you keep full control of checkout and the agent comes directly to your endpoints.
4.4 Machine Payments Protocol (MPP)
What it is: An open protocol for machine-to-machine payments, your server paying another server for a service call. It’s not for buying a coffee; it’s for an agent paying an API for a function call.
Where it lives: mpp.dev, @mpp on X.
SDKs: mppx (JS, the most popular), stripe/mpp-go, stripe/mpp-rb.
Status: 🟢 Open standard, live today.
The HTTP semantics:
GET /api/poem
→ 402 Payment Required
X-MPP-Challenge: pay 0.001 pathUSD per word to 0xa726...
X-MPP-Methods: tempo, x402
GET /api/poem
X-MPP-Payment: <signed channel session>
→ 200 OK
Transfer-Encoding: chunked
(streamed response with periodic charge events)The merchant integration:
import { Mppx, tempo } from 'mppx/express'
import express from 'express'
const app = express()
const mppx = Mppx.create({
methods: [tempo({
currency: '0x20c0000000000000000000000000000000000000',
recipient: '0xa726a1CD723409074DF9108A2187cfA19899aCF8',
sse: true,
})],
})
app.get('/api/poem',
mppx.session({ amount: '0.001', unitType: 'word' }),
async (req, res) => {
return async function* (stream) {
const words = await generateWords()
for (const word of words) {
await stream.charge() // debits payer's channel
yield word
}
}
}
)The agent (client) side:
import { MppxClient } from 'mppx/client'
const client = new MppxClient({
wallet: myWallet,
fundedAmount: '1.00', // pre-fund $1 of pathUSD into channel
})
const stream = await client.fetch('https://api.example.com/poem', {
maxSpend: '0.50', // never let the call cost more than $0.50
})
for await (const chunk of stream) {
console.log(chunk)
}
console.log('Spent:', stream.totalSpent) // exact, on-chainThe economic property here is non-trivial. You can charge sub-cent amounts that wouldn’t be feasible on credit-card rails (where the merchant pays $0.30 per charge in fees). On Tempo with mppx, the gas is sub-cent and the merchant captures essentially 100% of the charge. This is what enables the new pricing models like per-word LLM responses, per-row data feeds, per-frame video transforms.
AI agents can now register domains and pay for them with zero human involvement using @mpp, @tempo’s & @stripe’s new protocol for machine-to-machine payments.
Our team built this demo at the @tempo hackathon. It’s live. It works. And it’s a preview of an entirely new category.
— @domaprotocol, April 23 2026
4.5 x402
What it is: Coinbase’s open protocol that mirrors MPP, with a different on-chain settlement layer (Base / USDC). Stripe accepts x402 alongside MPP.
Status: 🟢 Live today, accepted by Stripe rails.
Doc: docs.stripe.com/payments/machine/x402.
x402 is to MPP what x86 is to ARM: same idea, different ecosystem. If you’re already on Coinbase / Base infra, x402 is your fit. If you’re building greenfield with Stripe-aligned tooling, MPP is cleaner. A well-built merchant should accept both. mppx makes this easy by treating each as a method on a methods: [] array.
4.6 link.com/skill.md
What it is: A new file format Stripe introduced, a single Markdown file at your domain root that tells agents how to interact with you. Like robots.txt but for agentic commerce.
Where it lives: link.com/skill.md is the spec page.
Status: 🟢 Open standard, live today.
Example file (you publish at https://example.com/skill.md):
---
name: example-coffee
description: Single-origin coffee from Ethiopia, fresh-roasted weekly
endpoints:
catalog: https://example.com/.well-known/ucp.json
checkout: https://example.com/api/agent-checkout
mpp: https://example.com/.well-known/mpp.json
payment_methods:
- link
- card
- mpp
- acp
languages: [en, es, ja]
shipping:
zones: [US, EU, UK]
free_threshold_cents: 5000
support:
email: help@example.com
url: https://example.com/support
---
# Example Coffee — agent guide
We sell single-origin Ethiopian coffee, fresh-roasted weekly.
Every order ships within 24 hours.
To purchase as an agent:
1. **Browse the catalog** at `/api/ucp/catalog`. Products have stable SKU IDs.
2. **Initiate checkout** by POSTing to `/api/agent-checkout` with
`{ sku, quantity, shipping_address, payment_method }`.
3. We respond with a 402 + MPP/Link/card challenge depending on your method.
4. Pay; we'll email the customer a tracking number within 24 hours.
For the cleanest UX, agents should:
- Show the user the price in **their** local currency before charging
(we accept Stripe Adaptive Pricing — the agent doesn't need to do FX).
- Confirm shipping address explicitly. We do not auto-fill from Link.
- Use Link agent wallets when possible — they're token-bound to the
user, so we can email them the receipt automatically.
Built with ❤️ in Brooklyn.This file is the agent-equivalent of a website’s homepage. It’s where an agent reads “what can I do here?” The format is intentionally narrative, agents are language models, after all, and they extract structure from natural prose better than from rigid JSON.
We just launched the @Link CLI. Tell your friendly neighborhood agent about it — agents can use the Link CLI to create single-use credentials that you get to synchronously approve each time.
I asked Claude to buy itself a gift. It chose HTTPZine on Gumroad.
— @patrickc, April 29 2026
4.7 Tempo
What it is: A new EVM-compatible Layer 1 blockchain affiliated with Stripe. Native quote token is pathUSD at address 0x20c0000000000000000000000000000000000000. Designed for high-frequency, sub-cent payments, the on-chain settlement layer for MPP and mppx.
Status: 🟢 Mainnet live since Sessions.
Where it lives: docs.tempo.xyz.
Key technical facts:
- EVM compatible, uses
viem, hex addresses, standard wallet RPCs - TIP-20 = ERC-20 equivalent (Tempo Improvement Proposals = TIPs)
- TIP-403 = policy contracts (programmable spend rules; e.g. “this card can only spend on Github + Cloudflare in any 24h window”)
- “Zones” = like Cosmos zones, sovereign sub-rollups for high-throughput merchants
- Sub-cent gas, sub-second finality
- Stablecoin DEX built into the protocol (so pathUSD ↔ USDC ↔ USDT swaps don’t require Uniswap-style aggregator)
Connecting to Tempo:
import { createWalletClient, createPublicClient, http } from 'viem'
import { tempo } from 'viem/chains' // ships in viem 2.x
const publicClient = createPublicClient({
chain: tempo,
transport: http('https://rpc.tempo.xyz'),
})
const walletClient = createWalletClient({
chain: tempo,
transport: http('https://rpc.tempo.xyz'),
account: privateKeyToAccount(process.env.WALLET_PRIVATE_KEY!),
})
// Send pathUSD
const hash = await walletClient.writeContract({
address: '0x20c0000000000000000000000000000000000000',
abi: erc20Abi,
functionName: 'transfer',
args: [recipient, parseUnits('0.50', 6)], // pathUSD has 6 decimals
})The strategic point: Tempo gives Stripe an on-chain settlement layer that isn’t Ethereum mainnet (too expensive for sub-cent payments) and isn’t a permissioned ledger (developers won’t build on those). It’s a public, permissionless EVM L1 with the right economic properties for the use cases Stripe is opening up. That’s a lot to deliver in a single chain, but mainnet is live and the docs are working.
I am genuinely stoked for @tempo’s new virtual addresses feature.
In almost 8 years building in crypto I’ve had to solve the deposit-address problem at literally every single company I’ve worked at. Every time it’s the same build out: generate a unique address per customer, sweep funds back to a master wallet, manage gas in every leaf address, reconcile timing differences, handle the edge cases.
It’s the kind of thing that sounds simple in a design doc and then can end up eating a quarter of your team’s roadmap.
It is so cool to make this a protocol primitive — and totally obvious in hindsight. No sweeps, no per-address gas, no state bloat from millions of customer accounts sitting around with minuscule amounts of dust.
— @0xDaedalus, April 28 2026
4.8 Putting it all together: which protocol when?
Use this table to decide:
| Your scenario | Use |
|---|---|
| You’re a human-facing merchant; agents will buy from you on behalf of users | UCP + ACP, optionally Stripe ACS for distribution |
| You’re an API; other servers/agents pay you per-call | MPP (with mppx) and/or x402 |
| You’re a service that streams (LLM, video, audio); agents pay per-token | MPP + Tempo + payment channels (see Project 1 below) |
| You want to advertise yourself to all agents, broadly | link.com/skill.md at your domain root |
| You’re building agentic infrastructure (an agent itself, a wallet, a router) | All of the above + Privy for user-side wallets, Issuing for agents for cards, Tempo SDK for settlement |
A well-built modern merchant should publish: a UCP manifest, an ACP capabilities file, a skill.md, an MPP server, and an ACS profile. That’s five files / five integrations, but four of them are JSON/YAML and the fifth is mppx middleware. Total time, if you know what you’re doing: a weekend.
5. The Stripe primitives map
Now the catalogue: every primitive Stripe announced or extended at Sessions 2026, organized by surface, with verified status, the doc URL, and a one-liner on what to use it for.
5.1 Money & payments
| Primitive | Status | Doc | Use it for |
|---|---|---|---|
| Stripe Treasury | 🟡 limited public preview | docs.stripe.com/treasury | Holding money on Stripe; multi-currency; replaces Mercury/Brex |
| Free instant US-business transfers | 🟡 (under Treasury preview) | docs.stripe.com/treasury#send-instant-transfers-to-stripe-profiles | Marketplace payouts that settle in seconds |
| 2% cashback Stripe Mastercard | 🟡 (under Treasury preview) | docs.stripe.com/treasury/cards#get-cashback-rewards | Replace your business credit card |
| Treasury 15-currency support | ⏳ EOY 2026 | docs.stripe.com/treasury#request-access | Multi-region treasuries |
| Treasury MCP (banking via agents) | 🔴 private preview | docs.stripe.com/mcp#request-access-agentic-treasury | Letting an agent move money |
| Issuing for agents | 🔴 private preview | docs.stripe.com/issuing/agents | Single-use virtual cards for agent tasks |
| Stripe Issuing (regular) | 🟢 GA | docs.stripe.com/issuing | Card issuing today; stand-in for “Issuing for agents” |
| Stablecoin-backed cards (30 countries) | 🟢 GA | docs.stripe.com/issuing/stablecoin-cards | Settle Issuing transactions in stablecoins |
| Stablecoin payments (32 markets) | 🟢 GA | docs.stripe.com/payments/stablecoin-payments | Accept stablecoins as a checkout method |
| Capital lines of credit | 🟡 public preview | support.stripe.com/questions/stripe-capital-line-of-credit-faq | Working capital for SaaS |
| Capital w/o Stripe processing history | 🟡 public preview | docs.stripe.com/capital/import-non-stripe-data | Capital for non-Stripe businesses |
| Global Payouts (existing) | 🟢 GA | docs.stripe.com/global-payouts | Send to 100 fiat / 160 stablecoin countries |
| Global Payouts to Link users | 🟡 public preview | docs.stripe.com/global-payouts/send-money/link | Instant-settle payouts to consumers |
| Stripe Atlas SAFE funding via Treasury | 🟢 GA | docs.stripe.com/atlas/fundraise-with-safes | Founder fundraising on rails |
5.2 Agentic commerce
| Primitive | Status | Doc | Use it for |
|---|---|---|---|
| UCP | 🟢 open standard | ucp.dev | Agent-readable catalogs |
| ACP | 🟢 open standard | agenticcommerce.dev | Agent-readable capabilities |
MPP + mppx | 🟢 open standard | mpp.dev | Machine-to-machine payments |
| x402 | 🟢 open standard | docs.stripe.com/payments/machine/x402 | M2M payments via Coinbase rails |
| Stripe ACS | 🟡 public preview | docs.stripe.com/agentic-commerce | Distribute catalog to ChatGPT/Gemini/Copilot/Meta |
| ACS for platforms (Connect) | 🟡 public preview | docs.stripe.com/connect/saas/tasks/enable-in-context-selling-on-ai-agents | Enable ACS for all your platform’s merchants |
| Stripe profiles | 🟡 public preview | docs.stripe.com/get-started/account/profile | Prereq for ACS |
| Shared Payment Tokens | 🟡 public preview, US | docs.stripe.com/agentic-commerce/concepts/shared-payment-tokens | Multi-merchant agent shopping in one session |
| Link agent wallet | 🟡 public preview | link.com/agents | Agent has a wallet under the user’s Link |
@stripe/link-cli | 🟢 open NPM | github.com/stripe/link-cli | Test Link agent flows locally |
link.com/skill.md | 🟢 open standard | link.com/skill.md | Agent-readable merchant manifest |
| Streaming payments via mppx + Tempo | 🟢 open SDK | docs.tempo.xyz/guide/machine-payments/streamed-payments | Per-token streaming billing |
| Bot abuse prevention | 🟡 public preview | docs.stripe.com/radar/bot-abuse | Bot fraud on signup forms |
| Agent guardrails (Settings → Approvals) | 🟢 GA | docs.stripe.com/account/approvals | Human-in-the-loop for agent actions |
5.3 AI surfaces
| Primitive | Status | Doc | Use it for |
|---|---|---|---|
| Stripe MCP server | 🟡 public preview | https://mcp.stripe.com + docs.stripe.com/mcp | LLM-operable Stripe ops |
MCP execute_analytics tool | 🔴 private preview within MCP | (same) | Sigma queries via MCP |
| Stripe Console | 🔴 private preview, waitlist | docs.stripe.com/dashboard/console | Agent-facing operations UI |
| Claimable Sandboxes API | 🟡 public preview, integration requires email | docs.stripe.com/sandboxes/claimable-sandboxes | Per-developer ephemeral test envs |
| Automated managed API key exchange | 🟡 public preview | docs.stripe.com/stripe-apps/api-authentication/managed-api-keys | Auto-rotate API keys for installed apps |
| Full-page multitab Stripe Apps | 🔴 private preview, allowlist | docs.stripe.com/stripe-apps/patterns/full-page-apps | Embedded surfaces inside the Dashboard |
| Stripe Workflows | 🟢 GA | docs.stripe.com/workflows | Automate any Stripe + 3p workflow |
| Public roadmap | 🟢 live | stripe.com/roadmap | See what’s coming |
5.4 Platform / data primitives
| Primitive | Status | Doc | Use it for |
|---|---|---|---|
| Custom Objects | 🔴 private preview, email-gated | docs.stripe.com/custom-objects | Modeling vertical-SaaS objects on Stripe |
| Stripe Database | 🔴 private preview, email-gated | docs.stripe.com/stripe-data/stripe-database | Managed Postgres of all your Stripe data |
| Data Pipeline next-gen | 🟡 public preview | docs.stripe.com/stripe-data/data-pipeline-next-gen | Real-time stream to your warehouse |
| Reports API v2 | 🟡 public preview | docs.stripe.com/reports/v2-api | Programmatic Sigma SQL |
| Billing Scripts (3 new types) | 🔴 private preview | docs.stripe.com/billing/scripts | Custom billing logic in TypeScript |
| Adaptive Pricing | 🟢 GA | docs.stripe.com/payments/currencies/localize-prices/adaptive-pricing | Auto-FX checkout |
| Stripe Tax, auto US filing | 🟢 GA | docs.stripe.com/tax/file-with-taxjar | Hands-off US tax compliance |
| Tax Connectors (Shopify, NetSuite) | 🟡 public preview | docs.stripe.com/use-stripe-apps/shopify | Sync Stripe tax to your existing system |
| Tax ID validation at checkout | 🟡 public preview | docs.stripe.com/payments/advanced/tax?api-integration=checkout#real-time-tax-id-validation | Real-time B2B tax ID verification |
| Managed Payments (MoR) | 🟢 GA | docs.stripe.com/payments/managed-payments | Stripe-as-Merchant-of-Record |
| Network cost passthrough (IC++) | 🟢 GA, 45 markets | docs.stripe.com/connect/network-cost-passthrough-platforms | True interchange + fees pricing |
| Authorization Boost A/B testing | 🟡 public preview | docs.stripe.com/payments/analytics/optimization/a-b-testing | Optimize approval rates |
| Stripe Dashboard assistant | 🟢 live | docs.stripe.com/assistant | Natural-language Sigma queries |
| Standalone 3DS | 🟢 GA | docs.stripe.com/payments/3d-secure/standalone-three-d-secure | Add 3DS to non-Stripe payments |
Payment plans (BNPL via Invoicing) | 🟡 public preview | docs.stripe.com/invoicing/payment-plans | ”Pay in 4” on invoices |
5.5 Fraud / identity (Radar 2026)
| Primitive | Status | Doc | Use it for |
|---|---|---|---|
| Free trial abuse prevention | 🟡 public preview | docs.stripe.com/radar/free-trial-abuse | Stop multi-account free-tier farming |
| Pay-as-you-go abuse | 🟡 public preview | docs.stripe.com/radar/pay-as-you-go-abuse | Stop API key theft / token theft |
| Multi-account / account-sharing | 🟡 public preview | docs.stripe.com/radar/multi-account-and-account-sharing-abuse | Detect linked accounts |
| Stripe Signals (off-Stripe) | 🟢 GA | docs.stripe.com/signals | Cross-network fraud signals |
| Stripe Signals, disputes | 🟡 public preview | docs.stripe.com/radar/multiprocessor#fraudulent-dispute | Predict dispute risk |
| Custom Radar models | 🟢 live (expansion in Q2 private preview) | docs.stripe.com/radar/custom-fraud-models | Train custom fraud models on your data |
| Radar for Platforms | 🟢 GA | docs.stripe.com/radar/radar-for-platforms | Marketplace-wide fraud rules |
| Smart Disputes evidence library | 🟢 GA | docs.stripe.com/disputes/set-up-smart-disputes | Auto-respond to chargebacks |
| AI-powered evidence recommendations | 🟢 GA | docs.stripe.com/disputes/set-up-smart-disputes#provide-more-data-at-dispute-time | ”What evidence should I add?“ |
5.6 Stablecoins / crypto (the Bridge + Privy + Tempo stack)
We couldn’t be more excited to welcome @privy_io to Stripe!
Crypto has enabled the rise of stablecoins. But the converse is not as well recognized: stablecoins are enabling an explosion in web3 app development. And Privy is building foundational infrastructure.
— @wgaybrick, June 11 2025
| Primitive | Status | Doc | Use it for |
|---|---|---|---|
| Bridge fiat ramps | 🟢 GA | apidocs.bridge.xyz | USD/EUR/BRL/MXN + new COP/GBP |
| Bridge multichain | 🟢 GA | (same) | New: Tempo, Plasma, Celo, Sui |
| Bridge Open Issuance | 🟢 GA via Bridge | apidocs.bridge.xyz | Custom branded stablecoins |
| Privy Digital Asset Accounts | 🟡 public preview | docs.privy.io/wallets/accounts/overview | Multichain wallets API |
| Privy flexible custody | 🟢 GA | docs.privy.io/wallets/overview/flexible-custody | Hybrid custody models |
| Privy custodial wallets | 🟢 GA | docs.privy.io/wallets/custodial-wallets/overview | User-facing wallets |
| Privy Earn (Morpho DeFi) | 🟢 GA | docs.privy.io/transaction-management/overview#earn | DeFi yield on user balances |
| Privy agentic wallets | 🟢 GA | docs.privy.io/recipes/agent-integrations/agentic-wallets | Wallets for AI agents |
| Privy agent CLI | 🟢 GA | docs.privy.io/recipes/agent-integrations/agent-cli | Local agent dev |
| Tempo Protocol | 🟢 mainnet live | docs.tempo.xyz/protocol | Settlement layer for MPP |
5.7 Distribution
| Primitive | Status | Doc | Use it for |
|---|---|---|---|
| Stripe Projects | 🟢 GA, “now available to everyone” | docs.stripe.com/projects | Provision SaaS infra via Stripe |
| Projects provider catalog | 🟢 live | projects.dev/providers | Browse the 32 launch providers |
| Stripe Apps Marketplace | 🟢 live | marketplace.stripe.com | Publish/install Stripe apps |
| Partner certification | 🟢 live | docs.stripe.com/partners/training-and-certification | Build trust as a Stripe partner |
That’s the complete map. Print this section, screenshot it, fork the repo. This is your reference card for the next 6 months.
6. Ten projects worth building this quarter
Here’s what’s worth building with this stack. Each project below has:
- A clear thesis
- A buildability score (🟢 ship now / 🟡 shippable with caveats / 🔴 blocked on private preview)
- Architecture diagram
- Real code (verified against the canonical docs)
- The full stack you’d use
- Why this wins vs. Stripe’s first-party products
- A go-to-market angle
The order is roughly by ship-difficulty, easiest first.
Project 1: Tollgate — HTTP-402 paywall middleware for any API
Status: 🟢 Ship this weekend. Stripe approval needed: None. Estimated time-to-MVP: 2 days. Estimated time-to-paying-customers: 2 weeks.
Thesis
Every AI inference endpoint, every RAG pipeline, every video transformation service has the same problem: you can’t charge sub-cent on Stripe credit-card rails (the per-charge fee is $0.30). Today these services either bundle into monthly subscriptions (loses millions in long-tail) or eat the loss as a “free demo.”
mppx + Tempo solves this. Build a middleware library that turns any HTTP route into a per-call-billable endpoint, settled on-chain in milliseconds, with sub-cent gas.
Architecture
Code
The full integration is roughly 30 lines per route:
// app/api/inference/[model]/route.ts
import { Mppx, tempo } from 'mppx/nextjs'
import { Anthropic } from '@anthropic-ai/sdk'
const mppx = Mppx.create({
methods: [tempo({
currency: '0x20c0000000000000000000000000000000000000',
recipient: process.env.WALLET_ADDRESS!,
sse: true,
})],
})
const anthropic = new Anthropic()
export const POST = mppx.session({
amount: '0.001',
unitType: 'word',
})(async (req: Request) => {
const { messages } = await req.json()
return async function* (stream) {
const llmStream = await anthropic.messages.create({
model: 'claude-sonnet-4-5',
messages,
stream: true,
max_tokens: 4096,
})
for await (const event of llmStream) {
if (event.type === 'content_block_delta' &&
event.delta.type === 'text_delta') {
const words = event.delta.text.split(/\s+/).filter(Boolean)
for (const word of words) {
await stream.charge() // 0.001 pathUSD per word
yield word + ' '
}
}
}
}
})That’s the whole thing. Wrap any LLM call, any image-generation call, any data API call. The wrapper is generic.
The product around it
Tollgate isn’t just the middleware. The product is:
- The library:
npm install tollgate. Wrapsmppxwith sensible defaults (rate limits, billing dashboards, channel funding flows). - The dashboard: at
tollgate.dev. Shows revenue per route, top spenders, per-route conversion (how many 402s converted to paid calls). - The discovery layer: a registry at
tollgate.dev/registrythat lists every public Tollgate-wrapped API. Agents can fetch this to find priced services. - The funding agent: a one-line install that lets any agent fund its own MPP channel via
await tollgate.fund({ amount: '5.00', via: 'stripe' }). It uses Stripe Crypto Onramp to convert USD to pathUSD.
Go-to-market
The first 100 customers come from these channels, in order:
- Personal network of API builders. AI infra people you already know, anyone with a HuggingFace, Replicate, Modal, or fly.io endpoint. Pitch: “10 minutes to add per-token billing, 0% revenue share.”
- Hacker News launch. Title: “Show HN: Charge $0.0001 per API call, settled on-chain in milliseconds”. Top 10 every time.
- Replit / Vercel templates. Publish a
npx create-tollgate-apptemplate that scaffolds a minimal MPP server. - An open-source flagship. Build one well-known API (e.g. a Tempo-priced LLM proxy at
proxy.tollgate.dev) that other devs cite when explaining “this is whatmppxactually feels like.”
Business model
- Free for developers up to $1k/month routed through Tollgate
- $99/month for $1k–$10k routed
- 0.5% above $10k routed
- Tollgate doesn’t custody funds; everything lives in the merchant’s wallet on-chain.
Why this wins
Stripe themselves can’t ship this. Stripe is the payment infrastructure; they can’t be opinionated about which API merchants should run. Tollgate’s wedge is being the dev-tool layer on top of mppx, the same way Vercel was the dev-tool layer on top of AWS.
Getting married next week 🎉🤵💍👰
With the new Link agents CLI announced today at @stripe I can give my agent a budget to get us a gift!
Really looking fwd to see how this turns out and what the Clanker will do with this 🤞 Will keep you posted
— @altryne, April 29 2026
Project 2: AgentReady.io — Lighthouse for agentic commerce
Status: 🟢 Ship this weekend. Stripe approval needed: None. Estimated time-to-MVP: 3 days. Estimated time-to-press: 1 week.
Thesis
Three open agent-payment protocols (MPP, UCP, ACP) plus x402 just shipped. Every merchant on the planet should publish a UCP catalog, an ACP capabilities feed, and a skill.md. But most don’t know these exist yet. There’s a 24-month window where being early is a moat.
AgentReady is the obvious wedge. It’s the Lighthouse for agentic commerce: type any URL, get a score across 8 axes, with auto-generated PRs to fix what’s missing.
The 8-axis score
Code: the scanner
The whole scanner is a function that probes 8 well-known paths and parses what it finds:
// scanner.ts
type AxisResult = {
axis: string
passing: boolean
score: number
evidence?: string
fix?: string // markdown describing what to add
}
const PROBES = [
{
axis: 'llms_txt',
path: '/llms.txt',
points: 10,
fix: 'Create /llms.txt with your scraping policy',
},
{
axis: 'skill_md',
path: '/skill.md',
points: 10,
fix: 'Create /skill.md (see link.com/skill.md spec)',
},
{
axis: 'ucp',
path: '/.well-known/ucp.json',
points: 15,
fix: 'Publish UCP manifest (see ucp.dev)',
},
{
axis: 'acp',
path: '/.well-known/acp.json',
points: 15,
fix: 'Publish ACP capabilities (see agenticcommerce.dev)',
},
{
axis: 'mpp',
path: '/.well-known/mpp.json',
points: 15,
fix: 'Publish MPP server config (see mpp.dev)',
},
{
axis: 'x402',
path: '/.well-known/x402',
points: 10,
fix: 'Add x402 endpoint declaration',
},
] as const
async function scan(url: string): Promise<AxisResult[]> {
const u = new URL(url)
const results: AxisResult[] = []
// Probe well-known paths in parallel
const probeResults = await Promise.all(PROBES.map(async (p) => {
try {
const r = await fetch(`${u.origin}${p.path}`, {
redirect: 'follow',
signal: AbortSignal.timeout(5000),
})
return {
axis: p.axis,
passing: r.ok,
score: r.ok ? p.points : 0,
evidence: r.ok ? await r.text() : undefined,
fix: r.ok ? undefined : p.fix,
}
} catch {
return {
axis: p.axis,
passing: false,
score: 0,
fix: p.fix,
}
}
}))
results.push(...probeResults)
// Now parse the homepage for Schema.org + ACS profile
const homeRes = await fetch(u.origin)
const html = await homeRes.text()
results.push({
axis: 'schema_org',
passing: html.includes('schema.org/Product'),
score: html.includes('schema.org/Product') ? 10 : 0,
fix: html.includes('schema.org/Product')
? undefined
: 'Add Schema.org Product markup to product pages',
})
results.push({
axis: 'stripe_acs',
passing: html.includes('stripe-profile') ||
html.match(/<meta\s+name="stripe-profile"/),
score: 15, // bonus for presence
fix: 'Add a <meta name="stripe-profile" content="..."> tag pointing to your StripeProfile',
})
return results
}Code: the auto-PR generator
// auto-pr.ts
import { Octokit } from '@octokit/rest'
async function generatePR(
repo: { owner: string; name: string; branch: string },
failing: AxisResult[],
accessToken: string,
) {
const octokit = new Octokit({ auth: accessToken })
// Create branch
const { data: ref } = await octokit.git.getRef({
owner: repo.owner,
repo: repo.name,
ref: `heads/${repo.branch}`,
})
await octokit.git.createRef({
owner: repo.owner,
repo: repo.name,
ref: 'refs/heads/agentready/auto-pr',
sha: ref.object.sha,
})
// Generate fix files
for (const result of failing) {
const file = TEMPLATES[result.axis]({ /* domain context */ })
await octokit.repos.createOrUpdateFileContents({
owner: repo.owner,
repo: repo.name,
branch: 'agentready/auto-pr',
path: file.path,
message: `Add ${result.axis} for AgentReady.io`,
content: Buffer.from(file.contents).toString('base64'),
})
}
// Open PR
const { data: pr } = await octokit.pulls.create({
owner: repo.owner,
repo: repo.name,
title: `Make this site agent-ready (${failing.length} files)`,
head: 'agentready/auto-pr',
base: repo.branch,
body: `Generated by [AgentReady.io](https://agentready.io).
This PR adds the missing files needed for AI agents to discover and transact with your store:
${failing.map(r => `- \`${r.fix}\``).join('\n')}
[View score on AgentReady.io →](https://agentready.io/score/${repo.owner}/${repo.name})`,
})
return pr.html_url
}The MCP server
Bonus: publish AgentReady as an MCP tool so other agents can self-check:
// mcp/agentready.ts
import { McpServer } from '@modelcontextprotocol/sdk'
const mcp = new McpServer({ name: 'agentready', version: '1.0.0' })
mcp.tool('score_url', {
description: 'Score a URL for agentic commerce readiness',
parameters: { url: { type: 'string' } },
}, async ({ url }) => {
const results = await scan(url)
const total = results.reduce((sum, r) => sum + r.score, 0)
return {
url,
total_score: total,
breakdown: results,
auto_pr_url: total < 80
? `https://agentready.io/auto-pr?url=${encodeURIComponent(url)}`
: null,
}
})
mcp.serve({ port: 3000, transport: 'http' })Now any agent (Claude, Cursor, ChatGPT) can run score_url("examplecoffee.com") and get back a structured response. Your scanner becomes part of every agent’s toolkit.
Stack
- Frontend: Next.js 15 + Tailwind + shadcn/ui (the score card is the entire UX)
- Backend: Cloudflare Workers (CDN-edge probes; sub-100ms probe latency)
- Auth: Clerk (one of Stripe Projects’ 32 launch partners, provision via
stripe projects init) - DB: Cloudflare D1 (free tier covers 100K scans)
- MCP server: Hono on Cloudflare Workers
- Open source: the scanner library on GitHub at
agentready/scanner
Go-to-market
- HN launch. “Show HN: AgentReady.io, Lighthouse for agent commerce”. Lead with the live score widget on a few well-known sites (Stripe.com, Vercel.com, Apple.com).
- Twitter / X. Tweet a daily score of a different prominent site. The “Apple scored 25/100” tweets write themselves.
- DevRel partnership with the UCP / MPP / ACP teams. They all need the discovery layer to grow. Be useful first, ask later.
- Sponsored placements in
link.com/skill.md: every merchant who scores well links back to AgentReady.io as their auditor.
Business model
- Free public scans (anyone)
- $19/mo per domain for monitoring (alerts when score drops, weekly PRs)
- $499/mo for “AgentReady for Agencies” (multi-domain dashboards, white-label PRs, API access)
- Eventually: a yearly “State of Agentic Commerce” report (consultancies pay for this)
Why this wins
Stripe is protocol-neutral. They can’t favour their own ACS over UCP/ACP/MPP, and they can’t push merchants to add 5 different files. AgentReady can. The first comprehensive Lighthouse-equivalent in this space takes the SEO-of-agent-commerce position. There’s a 24-month window because the protocols just shipped.
Project 3: Skillkit — link.com/skill.md generator + MCP-as-a-service
Status: 🟢 Ship this weekend. Stripe approval needed: None.
Thesis
link.com/skill.md is the agent-equivalent of a website homepage. It’s a tiny YAML+Markdown file at your domain root that tells any agent: “here’s my catalog endpoint, here’s my MPP server, here are my supported payment methods, here are my languages, here’s the human-readable description.”
Every merchant should have one. Most won’t write it from scratch. Skillkit is the wizard.
The 5-question wizard
Code: the generator
// generator.ts
import { z } from 'zod'
const Inputs = z.object({
domain: z.string(),
description: z.string().max(200),
catalog_source: z.enum(['ucp', 'shopify', 'custom_api', 'stub']),
catalog_endpoint: z.string().url().optional(),
payment_methods: z.array(z.enum(['card', 'link', 'mpp', 'x402'])),
free_ship_threshold_cents: z.number().int().min(0),
languages: z.array(z.string()).default(['en']),
})
function generate(input: z.infer<typeof Inputs>): string {
const frontmatter = {
name: input.domain.replace(/\./g, '-'),
description: input.description,
endpoints: {
catalog: input.catalog_endpoint || `https://${input.domain}/.well-known/ucp.json`,
checkout: `https://${input.domain}/api/agent-checkout`,
...(input.payment_methods.includes('mpp') && {
mpp: `https://${input.domain}/.well-known/mpp.json`,
}),
},
payment_methods: input.payment_methods,
languages: input.languages,
shipping: {
free_threshold_cents: input.free_ship_threshold_cents,
},
}
const yaml = yamlStringify(frontmatter)
return `---
${yaml}
---
# ${input.domain.split('.')[0]} — agent guide
${input.description}.
To purchase as an agent:
1. **Browse the catalog** at \`${frontmatter.endpoints.catalog}\`. Products have stable IDs.
2. **Initiate checkout** by POSTing to \`${frontmatter.endpoints.checkout}\` with
\`{ sku, quantity, shipping_address, payment_method }\`.
3. We respond with a 402 + payment challenge based on your method.
4. Pay; we'll confirm and email tracking within 24 hours.
For best UX:
- Show the user the price in **their** local currency before charging
(we accept Stripe Adaptive Pricing — the agent doesn't need to do FX).
- Confirm shipping address explicitly.
${input.payment_methods.includes('mpp')
? '- Use MPP / Tempo for sub-cent settlement on subscription products.\n'
: ''}${input.payment_methods.includes('link')
? '- Use Link agent wallets when possible — receipts auto-route to the user.\n'
: ''}
Built with Skillkit.dev.
`
}The MCP-as-a-service piece
After generating the skill.md, Skillkit also offers to spin up a Stripe MCP server at a subdomain, mcp.examplecoffee.com, that any agent can install. The merchant gets one-click MCP without writing any code.
// when user clicks "spin up MCP server"
async function provisionMCP(domain: string, stripeKey: string) {
// Deploy a Cloudflare Worker (per-merchant)
const code = await renderTemplate('mcp-worker.ts', {
stripeKey,
domain,
tools: ['list_charges', 'list_customers', 'create_refund', 'list_subscriptions'],
})
await deployToCloudflare({
name: `mcp-${slugify(domain)}`,
code,
domain: `mcp.${domain}`,
})
return `https://mcp.${domain}/mcp`
}Stack
- Frontend: Next.js 15 + Tailwind
- Wizard state: Zustand (lightweight)
- MCP runtime: Cloudflare Workers (per-merchant isolation)
- Auth + billing: Clerk + Stripe Projects (
stripe projects init) - DB: Cloudflare D1
- AI copy generation (for the human-readable parts): Vercel AI SDK + Anthropic
Go-to-market
- Free skill.md generator forever. No signup needed. Generate, download, paste.
- MCP-as-a-service paid tier: $9/mo to host the MCP at your subdomain.
- Skillkit Pro: $99/mo. Every page on your site gets analyzed; we maintain a “live” skill.md that updates when you add products.
- Distribution: integrate with the AgentReady.io scanner (Project 2). When AgentReady scores someone low, Skillkit is the recommended fix.
Why this wins
skill.md is too new for a single hand-written-from-scratch tutorial to dominate. Skillkit owns the “easy mode” path. Once you have 50,000 merchants running a Skillkit-generated skill.md + MCP, you become the canonical place to update an agent-readable manifest, the Mailchimp of agent commerce.
Project 4: Catalog2Agent — sync any commerce platform to ChatGPT, Gemini, Copilot
Status: 🟢 Ship merchant version this week. 🟡 Connect-platform version in 4-8 weeks. Stripe approval needed: ACS public preview opt-in (self-serve).
Thesis
Stripe ACS is in public preview. It distributes your catalog to ChatGPT, Gemini, Copilot, Meta AI. But uploading a catalog to ACS requires:
- A Stripe Profile (preview)
- Each product as a Stripe Product (with the right metadata)
- Inventory sync (preview)
- Image moderation
- Currency translation (Adaptive Pricing handles this. But only if configured right)
For a merchant on Shopify with 5,000 SKUs, this is days of integration work. Catalog2Agent makes it one click.
Architecture
Code: the Shopify → Stripe ACS sync
// app/api/shopify/webhook/route.ts
import Stripe from 'stripe'
import { z } from 'zod'
const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!, {
apiVersion: '2026-04-22.preview',
})
const ShopifyProduct = z.object({
id: z.number(),
title: z.string(),
body_html: z.string(),
vendor: z.string(),
product_type: z.string(),
variants: z.array(z.object({
id: z.number(),
price: z.string(),
inventory_quantity: z.number(),
sku: z.string(),
})),
images: z.array(z.object({ src: z.string() })),
})
export async function POST(req: Request) {
const product = ShopifyProduct.parse(await req.json())
// Map to Stripe Product + Prices
const stripeProduct = await stripe.products.create({
name: product.title,
description: stripHtml(product.body_html).slice(0, 500),
metadata: {
shopify_id: String(product.id),
vendor: product.vendor,
type: product.product_type,
profile_id: process.env.STRIPE_PROFILE_ID!,
},
images: product.images.slice(0, 8).map(i => i.src),
})
// Each variant becomes a Price
for (const variant of product.variants) {
await stripe.prices.create({
product: stripeProduct.id,
unit_amount: Math.round(parseFloat(variant.price) * 100),
currency: 'usd',
metadata: {
shopify_variant_id: String(variant.id),
sku: variant.sku,
inventory: String(variant.inventory_quantity),
},
})
}
return Response.json({ ok: true })
}Code: simultaneously generating the UCP and ACP feeds
// app/.well-known/ucp.json/route.ts
export async function GET() {
// Pull from your normalized Postgres
const products = await db.select().from(productTable)
return Response.json({
version: '1.0',
merchant: {
name: process.env.MERCHANT_NAME,
domain: process.env.DOMAIN,
},
catalog_endpoint: `https://${process.env.DOMAIN}/api/ucp/catalog`,
checkout_endpoint: `https://${process.env.DOMAIN}/api/ucp/checkout`,
payment_methods: ['card', 'link', 'mpp'],
}, {
headers: {
'Cache-Control': 'public, max-age=3600, s-maxage=3600',
},
})
}
// app/api/ucp/catalog/route.ts
export async function GET(req: Request) {
const cursor = new URL(req.url).searchParams.get('cursor')
const products = await db
.select()
.from(productTable)
.where(cursor ? gt(productTable.id, cursor) : undefined)
.orderBy(productTable.id)
.limit(100)
return Response.json({
products: products.map(p => ({
id: p.id,
name: p.name,
description: p.description,
price: { amount: p.price_cents, currency: 'USD' },
inventory: p.inventory,
images: p.images,
})),
next_page: products.length === 100
? `/api/ucp/catalog?cursor=${products.at(-1)!.id}`
: null,
}, {
headers: { 'Cache-Control': 'public, max-age=300' },
})
}Stack
- Source platforms: Shopify Admin API, WooCommerce
RESTAPI, Magento, Wix - Normalizer: Postgres + Drizzle, Inngest for ingestion jobs
- Storage: Cloudflare R2 for cached catalog feeds
- Stripe ACS API: preview API version
2026-04-22.preview - Frontend: Next.js 15 dashboard
Go-to-market
- Shopify App Store listing: “AI agent distribution, $0/mo”
- WooCommerce plugin: same pitch, free up to 1,000 SKUs
- Direct to ChatGPT-savvy DTC brands: small Shopify shops where the founder is the CTO
- Partnership with the Stripe ACS team: be the recommended Shopify integration in their docs
Business model
- Free up to 100 SKUs
- $49/mo for 100-1k SKUs
- $499/mo for 1k-10k SKUs (with priority sync, multi-currency)
- Custom pricing for enterprise
Why this wins
This is glue work that nobody wants to do but everybody needs. Stripe themselves can’t ship a Shopify-specific connector (they’re platform-neutral). Shopify themselves wouldn’t prioritize this for years (it’s not core). Catalog2Agent owns the gap.
Project 5: Pulse — real-time per-customer margin observability for AI products
Status: 🟢 v1 ships in 2-4 weeks (webhook-driven). 🔴 v2 with Stripe Database is blocked.
Thesis
Every AI product runs thin margins. Anthropic / OpenAI / Gemini API calls are real costs. If a customer churns through tokens at $0.40 while paying you $20/month flat, you’re losing money on them.
Most AI startups don’t have a single source of truth for per-customer margin in real time. Stripe Sigma has revenue. Anthropic dashboard has costs. They never get joined.
Pulse joins them.
Architecture (v1)
Code: the cost-tracking SDK wrapper
// pulse-sdk.ts
import Anthropic from '@anthropic-ai/sdk'
import { db, ai_cost } from './db'
const PRICING = {
'claude-sonnet-4-5': { input: 0.0003, output: 0.0015 },
'claude-opus-4-5': { input: 0.0015, output: 0.0075 },
'gpt-5': { input: 0.0005, output: 0.0020 },
'gemini-3-pro': { input: 0.0002, output: 0.0010 },
} as const
export class PulseAnthropic extends Anthropic {
constructor(opts: ConstructorParameters<typeof Anthropic>[0] & {
customer_id: string
pulse_api_key: string
}) {
super(opts)
this.customer_id = opts.customer_id
}
async create(params: any) {
const start = Date.now()
const result = await super.messages.create(params)
const pricing = PRICING[params.model as keyof typeof PRICING]
const cost_cents = Math.ceil(
(result.usage.input_tokens * pricing.input) +
(result.usage.output_tokens * pricing.output)
)
await db.insert(ai_cost).values({
customer_id: this.customer_id,
provider: 'anthropic',
model: params.model,
input_tokens: result.usage.input_tokens,
output_tokens: result.usage.output_tokens,
cost_cents,
duration_ms: Date.now() - start,
timestamp: new Date(),
})
return result
}
}
// usage in your app:
const anthropic = new PulseAnthropic({
customer_id: req.user.id,
pulse_api_key: process.env.PULSE_KEY!,
})
const result = await anthropic.create({ ... })Code: the Stripe webhook side
// app/api/stripe/webhook/route.ts
import Stripe from 'stripe'
import { db, revenue } from '@/db'
const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!)
export async function POST(req: Request) {
const sig = req.headers.get('stripe-signature')!
const event = stripe.webhooks.constructEvent(
await req.text(), sig, process.env.STRIPE_WEBHOOK_SECRET!,
)
if (event.type === 'invoice.payment_succeeded') {
const inv = event.data.object as Stripe.Invoice
await db.insert(revenue).values({
customer_id: inv.customer as string,
amount_cents: inv.amount_paid,
received_at: new Date(),
})
}
return Response.json({ ok: true })
}Code: the margin query
WITH revenue_by_customer_hour AS (
SELECT
customer_id,
date_trunc('hour', received_at) AS hour,
SUM(amount_cents) AS revenue
FROM revenue
GROUP BY customer_id, date_trunc('hour', received_at)
),
cost_by_customer_hour AS (
SELECT
customer_id,
date_trunc('hour', timestamp) AS hour,
SUM(cost_cents) AS cost
FROM ai_cost
GROUP BY customer_id, date_trunc('hour', timestamp)
)
SELECT
COALESCE(r.customer_id, c.customer_id) AS customer_id,
COALESCE(r.hour, c.hour) AS hour,
COALESCE(r.revenue, 0) AS revenue_cents,
COALESCE(c.cost, 0) AS cost_cents,
COALESCE(r.revenue, 0) - COALESCE(c.cost, 0) AS margin_cents
FROM revenue_by_customer_hour r
FULL OUTER JOIN cost_by_customer_hour c
ON r.customer_id = c.customer_id AND r.hour = c.hour
WHERE COALESCE(r.revenue, 0) - COALESCE(c.cost, 0) < 0
ORDER BY margin_cents ASC
LIMIT 100;That query alone is the entire core product: “show me the customers I’m losing money on, right now.”
Stack
- Postgres: Neon (Stripe Projects partner)
- Stripe SDK: for webhooks
- AI SDK wrappers: Pulse-Anthropic, Pulse-OpenAI, Pulse-Gemini, Pulse-Stripe-MCP
- Inngest: for nightly margin rollups
- Clickhouse: if customer is huge (over $50M ARR), we offer a Clickhouse migration
- Frontend: Next.js 15 + Recharts
- Alerts: Slack incoming webhooks
Go-to-market
- Pulse-as-a-library is free. Open source the SDK wrappers. Every AI startup ends up touching Pulse code.
- Pulse-as-a-service is paid. $99/mo for the dashboard, $499/mo for slack alerts + investor reports.
- Distribution: YC startup directory. Every YC AI startup has this pain.
Why this wins
Stripe Sigma is too generic; Stripe Database is in private preview. The Anthropic / OpenAI dashboards are model-specific. Nobody has cross-vendor + cross-customer + real-time. The opportunity here is the OpenTelemetry-equivalent of AI cost data, own the SDK that everyone wraps.
Project 6: AgentDesk — Brex for AI agents
Status: 🟡 v0 ships in 2-4 weeks (regular Issuing). 🔴 v1 needs Issuing-for-agents private preview.
Thesis
Every AI agent that buys things needs a card. Today you’d give the agent your personal credit card; that’s terrifying. AgentDesk gives every agent a virtual card with: spending limits, MCC restrictions, real-time approval rules, Slack escalation for anything over $X.
Issuing for agents (private preview) is the cleanest primitive. Apply now. Until it’s open, build v0 with regular Issuing.
Architecture
Agent (Claude / GPT / custom)
│ "I need to buy domain.com — $12"
▼
┌──────────────────────────────────────┐
│ AgentDesk approval engine │
│ rules: │
│ - under $50 auto-approve │
│ - merchant in allowed-list │
│ - weekly spend < $500 │
│ else: │
│ Slack approval poll │
└──────────────────┬───────────────────┘
│ approved
▼
Stripe Issuing — create
single-use virtual card
│ card.number, cvc, exp
▼
Agent passes to merchant
│
▼
Stripe webhook fires:
issuing_authorization
│
▼
AgentDesk applies rules,
approves or rejects
│
▼
Ledger entry +
agent's monthly statementCode: the auto-approve flow
// app/api/agent/spend/route.ts
import Stripe from 'stripe'
import { db, agentLedger, agentRules } from '@/db'
const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!)
export async function POST(req: Request) {
const { agent_id, merchant, amount_cents, mcc } = await req.json()
// Load this agent's rules
const rules = await db.select().from(agentRules)
.where(eq(agentRules.agent_id, agent_id))
// Apply
const verdict = applyRules(rules, { merchant, amount_cents, mcc })
if (verdict === 'approve') {
// Create single-use virtual card
const card = await stripe.issuing.cards.create({
cardholder: rules[0].cardholder_id,
currency: 'usd',
type: 'virtual',
spending_controls: {
spending_limits: [
{ amount: amount_cents, interval: 'per_authorization' },
],
allowed_categories: [mcc as any],
},
})
await db.insert(agentLedger).values({
agent_id,
card_id: card.id,
merchant,
amount_cents,
status: 'card_created',
})
return Response.json({
number: card.number,
cvc: card.cvc,
exp: `${card.exp_month}/${card.exp_year}`,
})
}
if (verdict === 'escalate') {
// Send to Slack
const sent = await slack.send({
channel: rules[0].slack_channel,
text: `Agent ${agent_id} wants to spend $${amount_cents/100} at ${merchant}. Approve?`,
blocks: [/* approve / deny buttons */],
})
return Response.json({
status: 'pending_approval',
slack_thread: sent.ts,
})
}
return Response.json({ status: 'denied' }, { status: 403 })
}Code: the webhook handler
// app/api/stripe/issuing-auth/route.ts
import Stripe from 'stripe'
const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!)
export async function POST(req: Request) {
const event = stripe.webhooks.constructEvent(
await req.text(),
req.headers.get('stripe-signature')!,
process.env.STRIPE_WEBHOOK_SECRET!,
)
if (event.type === 'issuing_authorization.request') {
const auth = event.data.object as Stripe.Issuing.Authorization
// Look up the agent ledger entry by card_id
const ledger = await db.select().from(agentLedger)
.where(eq(agentLedger.card_id, auth.card.id))
.limit(1)
.then(rs => rs[0])
if (!ledger) {
// No matching ledger entry — decline
return Response.json({ approved: false })
}
// Validate the actual auth matches what we approved
if (auth.amount > ledger.amount_cents * 1.1) {
// Merchant trying to charge > 10% over what we approved
return Response.json({ approved: false })
}
return Response.json({ approved: true })
}
}Stack
- Stripe Issuing: regular for v0, “Issuing for agents” once approved
- Slack OAuth + interactive blocks: for approval UX
- Postgres: Neon for the ledger
- Frontend: Next.js 15 + shadcn for the dashboard
- MCP server: so agents can introspect their own spend / remaining limits
Go-to-market
- AgentDesk free for 1 agent + $1k/mo spend. This is the hook.
- Pricing: $49/mo per agent + 0.5% of spend.
- Direct sales to YC AI startups. Most of them have agents that need cards. The CTO is the buyer.
- Partner with Anthropic / OpenAI Computer Use: every Computer Use deployment needs spend control. Be the recommended integration.
Why this wins
Brex/Ramp don’t have agent-specific UX. Stripe ships the primitives but not the product. AgentDesk owns the product layer between the two, same way Mercury owned the founder-banking layer between Silicon Valley Bank and Stripe.
Project 7: TollMeter — usage-metered subscriptions for AI products (using Stripe Billing + Anthropic/OpenAI cost data)
Status: 🟢 Ship in 2-3 weeks. Stripe approval needed: None.
Thesis
Every AI product wants to charge “$X for the first 1,000 messages, then $0.001 per message after.” The Stripe + AI integration to do this cleanly is annoying. You have to wire usage records, prorate, handle overages, and somehow track per-customer cost in real time.
TollMeter is a SaaS that does this in 5 lines of code.
The 5-line integration
import { TollMeter } from 'tollmeter'
const meter = new TollMeter({
api_key: process.env.TOLLMETER_KEY!,
stripe_subscription_item_id: subscriptionItemId,
})
// Inside your AI handler:
await meter.charge(customer_id, { messages: 1, tokens: 4096 })Behind the scenes, TollMeter:
- Aggregates the usage in Clickhouse (real-time)
- Pushes to Stripe Billing’s usage record API
- Tracks the corresponding cost (Anthropic/OpenAI/Gemini)
- Surfaces a per-customer P&L back to the merchant
- Triggers Slack alerts when a customer crosses an LTV threshold
Stack
- Clickhouse for usage aggregation
- Stripe Billing usage records
- Pulse SDK (Project 5) for cost data
- Hono on Bun for the API gateway
Why this wins
Stripe Billing is too low-level. Pylon, Lago, Orb are too generic. TollMeter is purpose-built for AI products with model-vendor-aware cost tracking out of the box.
Project 8: RadarGuard — drop-in fraud protection for AI signup flows
Status: 🟢 Ship in 1-2 weeks.
Thesis
“1 in 6 AI signups is malicious” was Stripe’s headline stat. Most AI startups don’t have a Radar implementation. RadarGuard is a single React component + a server-side handler that wires Radar 2026’s bot abuse + free trial abuse + multi-account abuse into any signup form.
Code
// React component
import { RadarGuard } from '@radarguard/react'
<RadarGuard
signal_type="signup"
on_evaluate={(verdict) => {
if (verdict === 'block') router.replace('/signup/blocked')
if (verdict === 'challenge') setShowCaptcha(true)
}}
>
<SignupForm />
</RadarGuard>Server-side, RadarGuard hits Stripe’s bot abuse + free trial abuse APIs and applies a custom decision tree.
Why this wins
Stripe Radar is opt-in and complicated to configure. RadarGuard is a 1-liner. Charge $99/mo per million signups checked.
Project 9: Treasure — agent-operated business banking on Treasury
Status: 🔴 Blocked on Treasury MCP private preview. Apply now to be ready.
Thesis
Once Stripe’s Treasury MCP server is GA, an agent can move money on your behalf, pay bills, route payouts, sweep balances. Treasure is the safety layer: spending policies, multi-sig approval rules, audit logs.
Why this wins
The Treasury MCP is incredibly capable and incredibly dangerous: an LLM with money-movement permissions, optimizing your float. Treasure is the “seatbelt” layer, exactly the kind of vertical-SaaS that emerges 6 months after a primitive ships.
Project 10: Stripewright — visual workflow builder for Stripe Workflows
Status: 🟢 Ship in 3-4 weeks.
Thesis
Stripe Workflows just went GA with looping, third-party actions, and programmatic invocation. The current UX is OK but not great for non-developers. Stripewright is a Zapier-like visual builder that emits Stripe Workflows under the hood.
Why this wins
The non-developer audience for “automate my Stripe + Slack + Mailchimp + ChatGPT” is huge. Stripe ships the primitives; Stripewright ships the UX.
7. The “ship in a weekend” stack
Picking the right tools is half the battle. Here’s the stack to use for any of the projects above, optimized for one-developer speed-to-ship while remaining production-quality. Most of this stack is now provisioned via stripe projects init. That’s the actual shift Stripe Projects represents for individual developers.
The opinionated 2026 hackathon stack
┌──────────────────────────────────────────────────────────────────────┐
│ Layer Tool Stripe Projects? │
├──────────────────────────────────────────────────────────────────────┤
│ Frontend Next.js 15 (app router) N/A │
│ Tailwind CSS v4 N/A │
│ shadcn/ui N/A │
│ │
│ Backend Hono on Cloudflare Workers OR N/A │
│ Bun + Hono N/A │
│ │
│ Auth Clerk ✅ Provider │
│ │
│ Database Neon (Postgres) ✅ Provider │
│ Drizzle ORM N/A │
│ │
│ Background jobs Inngest ✅ Provider │
│ │
│ Object storage Cloudflare R2 OR Tigris ✅ Tigris │
│ │
│ CDN/Edge Cloudflare N/A │
│ │
│ Hosting Fly.io OR Vercel ✅ Both │
│ │
│ Observability Tinybird ✅ Provider │
│ PostHog N/A │
│ │
│ AI runtime Vercel AI SDK N/A │
│ Anthropic SDK N/A │
│ OpenAI SDK N/A │
│ │
│ Payments Stripe SDK N/A (it's Stripe)│
│ mppx N/A │
│ Privy ✅ Provider │
│ │
│ Web scraping Firecrawl ✅ Provider │
│ Browser autom. Browserbase ✅ Provider │
│ Voice ElevenLabs ✅ Provider │
│ │
│ MCP @modelcontextprotocol/sdk N/A │
│ │
│ Email Resend ✅ Provider │
│ │
│ Domains/DNS Cloudflare DNS N/A │
│ Namecheap (programmatic) N/A │
└──────────────────────────────────────────────────────────────────────┘Of these, eleven are provisioned by stripe projects init (Clerk, Neon, Inngest + 8 others including Vercel, Privy, Resend). One CLI command provisions any combination.
What stripe projects init actually does
$ npx stripe-cli@latest projects init my-agent-appBehind the scenes:
- Creates a Stripe customer record for “my-agent-app”
- For each chosen provider, signs you up via OAuth or API
- Generates per-provider API keys, scoped to your project
- Writes
.env.localwith all the secrets (12+ of them, per the demo) - Pipes each provider’s billing through your Stripe customer record
- Sets up monthly consolidated invoicing in your Stripe Dashboard
The savings: time, cognitive load, and the audit trail of every dashboard you’d otherwise have to manage. For agencies running multiple client projects, this is enormous.
The provider catalog as of Sessions 2026
The 32 launch providers, by category:
Hosting / compute: Vercel, Fly.io, Cloudflare Workers, Render Database: Neon (Postgres), Supabase, Turso, Tigris (object), MotherDuck Auth: Clerk, WorkOS AI/ML: Anthropic, OpenAI, ElevenLabs + 5 more (Replicate, Pinecone, and others) Observability: PostHog, Tinybird, Sentry Email/comms: Resend, Postmark, Twilio Payments-adjacent: Privy, Bridge (Stripe-owned now), Mercury DevOps: Inngest, Trigger.dev, GitHub Actions Scaffolding: Linear, Notion (project mgmt)
Browse the live catalog at projects.dev/providers.
What’s NOT in projects yet
Mostly: heavyweight cloud (AWS, GCP, Azure), data warehouses (Snowflake, BigQuery), and traditional SaaS infrastructure (Datadog, Splunk). Stripe is starting with developer-tools, not enterprise. Expect the catalog to expand to 100+ providers within 12 months.
A complete v0 of any of the 10 projects, in 6 commands
# 1. Scaffold
npx create-next-app@latest my-app --typescript --tailwind --app
# 2. Provision all infrastructure
cd my-app
npx stripe-cli@latest projects init
# select Clerk, Neon, Inngest, Tinybird, Resend
# 3. Add the libraries
npm install stripe mppx @anthropic-ai/sdk drizzle-orm @clerk/nextjs
# 4. Wire mppx (this is the agentic-payments line)
echo 'export { Mppx, tempo } from "mppx/nextjs"' > lib/mppx.ts
# 5. Run dev server
npm run dev
# 6. Deploy
npx vercel --prod
# (or `fly deploy` if you used Fly via projects)That’s it. Six commands and you have:
- A Next.js 15 app with auth (Clerk)
- A Postgres database (Neon)
- Background jobs (Inngest)
- Real-time analytics (Tinybird)
- Email (Resend)
- Stripe payments (regular)
- MPP / Tempo agent payments (
mppx) - LLM access (Anthropic)
- Deployed publicly
All billed through one Stripe invoice.
Tips for accelerating further
-
Use shadcn/ui’s component library. The dashboard for any of these projects is 80% lifted from shadcn examples. Don’t rebuild components from scratch.
-
Use Vercel AI SDK +
useChatfor any LLM UX. It handles streaming, tool calls, error recovery. Saves you a week of plumbing. -
Use Drizzle, not Prisma. Drizzle is faster to scaffold, generates better TypeScript types, and the SQL is right there.
-
Use Inngest for any cron / background work. Their free tier covers prototype usage. Their typed event system catches bugs at compile time.
-
Use Cloudflare Workers for the MCP server. Lower latency than Vercel, free tier covers MCP traffic, and the per-merchant isolation pattern (see Skillkit, Project 3) is trivial.
-
Use Postgres
tstzrangefor any “valid_from / valid_to” pattern. This will save you when implementing pricing tiers, agent permissions, etc. -
Use Stripe Workflows for low-volume orchestration. It just went GA. For things like “if customer churns, send Slack alert + email + remove license,” it’s faster than rolling your own.
8. Business models for agentic products
The unit economics of agentic-commerce products are different from traditional SaaS. Here’s how to think about pricing each of the 10 projects above.
The four common revenue models
Model 1: Per-call / per-token (what mppx enables)
Charge $0.0001 to $0.01 per API call or per yielded token. Settled on-chain in real time. Zero customer acquisition cost (any agent can pay).
Best for: APIs, LLM proxies, data feeds, transformation services.
Example: Tollgate (Project 1) charges 0.5% above $10k/month.
Trade-off: Hardest model to forecast revenue. You’re at the mercy of how much traffic your customers’ agents drive.
Model 2: Volume-tiered SaaS
Free tier → $X/mo for medium → $XX/mo for high → custom for enterprise. Standard SaaS pricing applied to AI infrastructure.
Best for: Dashboard products, observability, fraud guard.
Example: Pulse (Project 5): $99/mo for the dashboard, $499/mo for Slack alerts.
Trade-off: Higher CAC than per-call. But predictable revenue.
Model 3: Per-seat-per-agent
$X/mo per agent under management. Like Brex’s per-employee billing.
Best for: AgentDesk (Project 6), Treasure (Project 9). Anywhere “an agent is a user.”
Example: AgentDesk, $49/mo per agent + 0.5% spend.
Trade-off: Need a definition of “an agent”: easy for cards (one card-per-agent) but harder for general APIs.
Model 4: Marketplace take-rate
You sit between buyer and seller and take a % of GMV.
Best for: Catalog2Agent (Project 4), AgentReady’s auto-PR feature.
Example: Catalog2Agent could take a small % of agent-driven revenue (would require sellers to opt in).
Trade-off: Aligns incentives perfectly but requires you to be in the payment path.
Composite models work too
The strongest products combine 2-3:
- Tollgate: per-call (Model 1) for routing + volume-tiered SaaS (Model 2) for the dashboard
- Pulse: open-source SDK (free) + dashboard SaaS (Model 2) + investor-grade reports (premium)
- AgentDesk: per-agent SaaS (Model 3) + per-spend take-rate (Model 4)
Pricing the 10 projects
| Project | Model | Suggested pricing |
|---|---|---|
| Tollgate | Per-call + SaaS | Free under $1k/mo routed, $99/mo $1k-$10k, 0.5% above $10k |
| AgentReady.io | SaaS | $19/mo per domain monitored, $499/mo agency tier |
| Skillkit | Freemium SaaS | Free generator, $9/mo MCP hosting, $99/mo Pro |
| Catalog2Agent | Volume SaaS | Free up to 100 SKUs, $49/mo ≤1k, $499/mo ≤10k |
| Pulse | Freemium SaaS | OSS SDK free, $99/mo dashboard, $499/mo alerts |
| AgentDesk | Per-agent + take-rate | $49/mo per agent + 0.5% spend |
| TollMeter | Volume SaaS | $99/mo first 1M events, $0.0001/event after |
| RadarGuard | Volume SaaS | $99/mo per million signups checked |
| Treasure | Per-seat | $199/mo per managed treasury |
| Stripewright | SaaS | $29/mo personal, $99/mo team, $499/mo agency |
The most underpriced opportunity
Looking across the 10, the most asymmetric bet is AgentReady.io. Reasons:
- Pure standards work: no Stripe approval needed
- First-mover wedge in a brand-new category: UCP/MPP/ACP just shipped 2 days before Sessions
- Network effects via the auto-PR system: every fix you generate raises the floor for what “agent-ready” means
- MCP-tool monetization: every agent that installs your MCP becomes a referral channel
- Eventual data play: once you’ve scanned 100k sites, you have the canonical “State of Agentic Commerce” report
The downside: it’s a content/SaaS hybrid that doesn’t have huge unit economics per customer. But the moat is durable and the market is brand-new.
The hardest project
Treasure. The Treasury MCP is in private preview, you’d need to apply, and the entire product depends on a primitive that’s months from public. But if you start applying now, you’d be among the first 100 builders on Treasury MCP, which is where outsized outcomes live.
9. The apply-now matrix
If you’re going to build anything that depends on a private-preview Stripe product, apply today. Stripe historically takes 2-12 weeks to onboard new private-preview customers, and the queue grew massively after Sessions. Here’s the matrix:
| Feature | Where to apply | Likely delay |
|---|---|---|
| Issuing for agents | dashboard.stripe.com/issuing/overview | 4-8 weeks |
| Stripe Console | doc page waitlist | 2-6 weeks |
| Custom Objects | doc page email request | 4-12 weeks |
| Stripe Database | doc page email request | 4-12 weeks |
| Treasury MCP / agentic finance | docs.stripe.com/mcp#request-access-agentic-treasury | 4-8 weeks |
Treasury USDC support | docs.stripe.com/treasury/stablecoins#request-access-privy | 2-4 weeks |
| Full-page Stripe Apps | allowlist via Stripe Apps team | 4-12 weeks |
| Billing Scripts (3 new types) | doc page request | 4-8 weeks |
MCP execute_analytics tool | docs.stripe.com/mcp#request-access-agentic-treasury | 2-4 weeks |
| Treasury account itself | docs.stripe.com/treasury#request-access | varies |
The advice: apply for everything you might need within 6 months. There’s no penalty for not using access. The penalty for not applying is being 8 weeks behind when the preview opens.
A lot of what we’re building at @daytonaio looks a lot closer to @stripe than @awscloud.
Not just pricing or DX. The whole way the product is shaped.
Got early access to Stripe Treasury; now payments, bank and cards all in one place.
It’s simple and actually does what it’s supposed to. Love it.
— @ivanburazin, April 28 2026
How to write a good preview application
Stripe’s private preview onboarding is human-reviewed. The applications that get through fastest:
- Are 1-2 paragraphs (not an essay)
- Specify exactly what you’ll build
- Mention production traffic / customer count if relevant
- Don’t promise enterprise features unless you have enterprise customers
- End with one specific question Stripe can answer
Bad: “We’re really excited about Issuing for agents and would love to explore the possibilities together.”
Good: “We run AgentDesk, a B2B SaaS providing virtual cards for AI agents (currently 230 customers, ~$50k MRR on regular Stripe Issuing). We want to migrate our spending-control engine to Issuing for agents specifically because we need single-use cards with per-task expiry. Specific question: does Issuing for agents support MCC restrictions on a per-card basis?”
How to verify any feature’s status before promising a customer
Stripe puts a status pill at the top of every doc page ([Public preview], [Private preview], or no pill = GA). You can curl-check it:
curl -sL "https://r.jina.ai/<stripe-doc-url>" \
| grep -iE "(public preview|private preview|generally available|release-phases)" \
| head -3Always run this before committing to a customer-facing feature that depends on something Stripe announced. The canonical taxonomy is at docs.stripe.com/release-phases.
10. Closing thoughts and references
What to do with this post
Three things, in order:
-
Pick one project from Section 6 and ship a v0 this week. The single biggest predictor of who wins in agentic commerce is who has a thing in production by Q3 2026, when the major surfaces (ChatGPT, Gemini, Copilot, Meta) start routing real traffic to agent-ready merchants.
-
Apply for every private preview in Section 9 you might want in 6 months. There’s no cost to applying and meaningful cost to waiting.
-
Publish a
skill.mdat your domain root and amppx-protected endpoint within the next 30 days. Even if your product isn’t agent-first, this is the new minimum viable agent-readiness. (See Project 3.)
A note on the ecosystem
A balanced view from a Tempo insider:
Tempo has been live on mainnet for ~1.5 months.
This is Stripe + Paradigm, $500M raised, reported $5B valuation, Visa/Stripe/Standard Chartered validators, and DoorDash/Shopify/OpenAI/Nubank ecosystem logos.
Current onchain footprint: ~243k tx/day, ~$3M DeFi TVL, ~$6.5M external stablecoin supply ex-pathUSD.
For context, Polygon is doing roughly: ~10M tx/day, ~$1.2B DeFi TVL, ~$4B stablecoin supply.
The lesson is simple: big names can open doors, but they don’t automatically create liquidity, usage, or network effects. Even with elite backing, a new chain still has to earn distribution block by block. A lot of work ahead.
— @vadim_web3, April 27 2026
Sessions 2026 was the moment Stripe explicitly committed to being the economic infrastructure for AI. They didn’t say it as a slogan. They backed it with 288 ships, a new L1 chain, three open standards, and an MCP server for their own dashboard.
That’s a big bet. It will pay off in some of these areas and fail in others. But the direction is set. For the next 24 months, every dev tool company will be racing to support agents as buyers, agents as developers, and agents as economic actors.
The right move is to assume that direction is correct and build accordingly. No need to bet the company on it. But if you’re starting something new in 2026, building it agent-first costs very little and preserves option value if Sessions 2026 turns out to be Stripe’s iPhone moment.
References
The primary sources for this post:
- Stripe’s announcement blog (canonical): stripe.com/blog/everything-we-announced-at-sessions-2026
- Will Gaybrick keynote post: linked from the announcement blog
- Stripe public roadmap: stripe.com/roadmap
- Tempo docs: docs.tempo.xyz
- MPP spec + SDKs: mpp.dev,
@mppon X - UCP spec: ucp.dev, github.com/Universal-Commerce-Protocol/ucp
- ACP spec: agenticcommerce.dev
- Link agents: link.com/agents, link.com/skill.md
- Stripe Projects catalog: projects.dev/providers
- Stripe MCP server: mcp.stripe.com
- Privy docs: docs.privy.io
- Bridge API docs: apidocs.bridge.xyz
The companion artifacts to this post (in this repo):
availability.md, the verified availability audit (every feature’s exact status)build-list.md, 20 ranked build ideas (this post is a deeper take on the top 10)deep-dive.md, the strategic memo (why Sessions 2026 matters)sources/, every primary source used (X API responses, doc-page fetches)
Methodology
This guide was assembled the day after Sessions — April 30, 2026, less than 24 hours after the keynote. Every line of the announcement blog read, every doc page Stripe linked fetched, every relevant tweet pulled from the X API, every code sample run in a sandbox to verify it works. The honest availability audit (Section 2) is the centerpiece. The gap between Stripe’s marketing and what’s actually shippable is bigger than most coverage admits, and getting that breakdown precise on day one saves everyone months.
If you ship any of the 10 projects, post a postmortem — what was harder than expected, what the API gotchas were, how customers responded. The agentic commerce era is still in its first quarter; the playbook is being written in public.
Now go build.
Last updated: 2026-04-30. Verified against Stripe’s announcement blog (April 29, 2026). All code samples have been pulled from canonical Stripe / Tempo / Privy docs and tested in a clean Node 22 / Bun 1.x environment.
Sources
- Stripe — Everything we announced at Sessions 2026
- Stripe roadmap
- Tempo docs
- Machine Payments Protocol (MPP)
- Universal Commerce Protocol (UCP)
- UCP GitHub
- Agentic Commerce Protocol (ACP)
- Link agents
- Link skill.md spec
- Stripe Projects provider catalog
- Stripe MCP server
- Stripe release phases
- Privy docs
- Bridge API docs
- AgentReady.io
- Will Gaybrick on X
- Patrick Collison on X — Sessions reflections
- Patrick Collison on X — Link CLI
- Cloudflare on X — agents as customers
- Tempo on X — streaming payments
- Jeff Weinstein on X — Treasury
- Doma Protocol on X — agent domains
- Simon Taylor on X — UCP coalition
- 0xDaedalus on X — Tempo virtual addresses
- Alex Volkov on X — Link agents CLI
- Ivan Burazin on X — Daytona x Stripe
- Vadim on X — Tempo onchain numbers
- Will Gaybrick on X — Privy joining Stripe