# What to build on Stripe Sessions 2026: 25 ideas you have not heard yet

URL: https://www.thedeepfeed.ai/posts/2026-05-02-stripe-sessions-2026-25-things-to-build/
Category: Tools
Published: 2026-05-14
Author: the-deep-feed
Tags: stripe, agents, developer-tools, build-ideas, payments, mcp
Kind: deep

> Stripe shipped 288 launches at Sessions 2026 and devtools-Twitter latched onto four — UCP, MPP, Link CLI, Tempo. The other 284 contain at least 25 weekend-buildable products no one is shipping. Here they are, ranked.

## TL;DR

- Stripe announced **288 launches** at Sessions 2026; devtools-Twitter wrote about four. The other 284 contain at least **25 weekend-buildable products** with no incumbents.
- The richest underexploited surface is the dev keynote: **Minions**, the **`?.md` URL pattern**, **agent-tagged API keys**, the **structured-error/approval-request contract**, and **Custom Objects + methods + dashboards** as a Stripe-native Retool replacement.
- Buildability scoring: 11 of 25 ideas score **7/10 or higher** for a 2-person team in 1–2 weekends. The two with the strongest setup are **DocsToMD** (9/10) and **ApprovalKit** (8/10).
- X chatter shows builders already shipping in 12-hour windows — [@FounderWilfred](https://x.com/FounderWilfred/status/2049601371041890490) wired MCP-paid weather data, [@dani_avila7](https://x.com/dani_avila7/status/2049665684146151683) gave up his weekend to Cloudflare + Stripe Projects.
- The dominant risk is not technical. It is the recurring fear in any developer ecosystem near a platform on a tear: *the platform itself will ship this in 18 months.* Every idea below is scored against that probability, and only the ones where the wedge survives are listed.

![25 weekend-buildable ideas from 288 Stripe Sessions launches, with ApprovalKit as the center bet.](/post-images/2026-05-02-stripe-sessions-2026-25-things-to-build/hero-builder-grid.jpg)

The existing TDF Sessions 2026 developer guide named **10 build projects**, Tollgate, AgentReady.io, Skillkit, Catalog2Agent, Pulse, AgentDesk, TollMeter, RadarGuard, Treasure, Stripewright. They cover the obvious territory: HTTP-402 paywalls, agent-readiness scanners, agent banking, agent fraud. They are good projects. But they are also the projects that were obvious from the press release.

This post covers the **other 25**. None overlaps. Every idea is grounded in a Sessions 2026 primitive with a verified status, 🟢 GA, 🟡 public preview, 🔴 private preview, and scored 1–10 on the bar of "a competent solo dev or two-person team ships v1 in one or two weekends." The risk that recurs in every entry is the one that matters most in this ecosystem (*Stripe ships this in 18 months*) and every idea is scored against that probability. The ones where the wedge does not survive are not listed.

The asymmetric-information arbitrage is real. [John Collison's tape](https://x.com/collision/status/2050232889766552027) of Claude Code buying a dataset on Tempo via MPP got 387 likes. [@pejmanjohn's clip](https://x.com/pejmanjohn/status/2049580208966304192) of Link CLI buying coffee beans got 2,078. The 284 launches that are not in those clips have not been read. The richest underexploited surface area sits in the dev keynote, Minions, the `?.md` URL pattern, agent-tagged API keys, the structured-error/approval-request contract, Custom Objects, Checkout Studio's GitHub-PR flow, the Stripe Integration Benchmark, and X coverage of those concepts is approximately zero.

A builder said it directly the morning after the keynote:

> OK Cloudflare just took my weekend. Going to try something, use Claude Managed Agent with this new Cloudflare + Stripe Projects flow and see how far it actually gets on its own. Real end-to-end experiment, no shortcuts.
>
> — [@dani_avila7](https://x.com/dani_avila7/status/2049665684146151683), Apr 30, 2026

214 likes. The window is open. Below is the map.

![The top-five 25-build leaders sorted by payoff × novelty × defensibility, with ApprovalKit at the head.](/post-images/2026-05-02-stripe-sessions-2026-25-things-to-build/top-five-leaders.jpg)

# The 5 highest-payoff opportunities

These are the ideas with the best combination of payoff, novelty, defensibility, and time-window. Full template, *builds on / for / solves / why now / how to start / risk / buildability score*, followed by editorial framing.

# 1. ApprovalKit — drop-in human-in-the-loop middleware for any agent-touching API

**Builds on:** Approval Rules + Approval Request endpoint (🟡 public preview, the `apreq_` flow Bu Wong demoed live); Agent-tagged API keys (🟡 public preview); [Stripe Workflows](https://docs.stripe.com/workflows) (🟢 GA, callouts to Slack and email).
**For:** API companies and agent-platform builders who want Stripe's "agent figured it out from the error message" pattern but for *their own* APIs, Twilio, Resend, Linear, Notion, GitHub, AWS.
**Solves:** Every API company is about to have agents acting on their behalf. None of them have Stripe's approval primitives. They will all reinvent the same wheel: agent submits action → server returns structured error containing an approval-request handle → agent calls `/approvals` → human approves in Slack → action proceeds. ApprovalKit is the open-source library plus hosted SaaS that ships this in 30 lines.
**Why now:** Until Sessions 2026 there was no canonical pattern. Bu's "your agent figured this out from the error message" was the first live demo of a *contractual* error response that an LLM can parse and act on. Within 6 months every B2B SaaS will need this; the design space is now public.
**How to start:**

  1. Define a JSON error contract: `{ "type": "approval_required", "request_id": "apreq_…", "policy": "refund_over_100", "approve_url": "…", "deny_url": "…" }`.
  2. Ship a Hono / Express / Fastify / FastAPI middleware: `app.use(approvalKit({ policies, slackWebhook, persistence: 'redis://…' }))`.
  3. Ship a Shadcn-themed Approvals inbox component, copy-paste into any admin app.
  4. Open an MCP server at `approvalkit.dev/mcp` so agents can request approvals natively.

**Risk:** Stripe will eventually open-source their version. But Stripe's surface is *only* Stripe API objects, ApprovalKit's wedge is the cross-API generalization. The harder problem is distribution: convincing the first 10 API companies to adopt requires a real GTM motion, not just a GitHub repo.
**Buildability:** **8/10.** Library plus landing site plus Slack app is a weekend. The Shadcn inbox is another weekend. Distribution is the moat.

The structured-error contract is the hidden API of Sessions 2026. It only got two minutes in the dev keynote and zero X coverage, but it is the most copyable pattern Stripe has shipped in years. It does for agent error-handling what `application/json` did for HTTP responses: standardizes the part everyone was already inventing badly. The first cross-API library that ships a clean version of it, with a Shadcn admin component and a Slack approval bot, owns the category before the term "agent approvals" has a Wikipedia page.

# 2. AgentBench — integration eval-as-a-service for any API company

**Builds on:** The **Stripe Integration Benchmark** concept (described publicly in the dev keynote, "agents ship `plans` API deprecated 2019"); the [Markdown URL pattern](https://docs.stripe.com/payments) (🟢 GA, every Stripe doc page now serves at `<path>.md`); [Stripe Agent Skills](https://github.com/stripe/ai) (🟢 GA).
**For:** API DevRel, platform PMs, and docs teams at Twilio, Vercel, Cloudflare, Supabase, Linear, MongoDB, Anthropic, OpenAI, ElevenLabs, AWS, anyone whose docs are now read by agents 40% of the time.
**Solves:** Stripe runs an internal benchmark that asks Claude, Codex, GPT-5, and Gemini to complete real Stripe tasks and grades whether they ship deprecated or wrong APIs. Every API company has the same problem. AgentBench runs this as a hosted SaaS: connect your docs → it auto-generates eval suites → runs them daily across leading LLMs → ships you a scorecard plus auto-PRs a `SKILL.md`, `.md` mirror routes, and "Copy for LLM" buttons to fix the gaps.
**Why now:** Sessions 2026 was the first time anyone publicly described the eval-driven DX loop. The dev keynote made it explicit ("evals are the new TDD"). Devtools-Twitter has not caught on yet, coverage was approximately zero. The demand side, captured cleanly:

> It's becoming clear that every product out there needs an MCP server and a solid API, and probably also an AI agent. I didn't even login to Stripe to create the products, Claude Code just created them for me in my account.
>
> — [@joncphillips](https://x.com/joncphillips/status/2050243989865894087), May 1, 2026

If every product needs an MCP server and an agent-readable docs surface, every product needs an eval.
**How to start:**

  1. Build the eval harness: `agentbench scan https://docs.acme.com` → crawls docs → identifies API endpoints → generates "build X with Acme" prompts → runs them against five LLMs → measures which APIs are recommended versus which are deprecated.
  2. Auto-generate the fix kit: a `SKILL.md` with the right idioms, `.md` mirrors of every doc page, and a Stripe-style "Copy for LLM" snippet on each page.
  3. Open-source the harness; charge for the SaaS dashboard, daily runs, and the auto-PR bot.

**Risk:** Customers may build it in-house. Counter: the eval corpus plus cross-LLM normalization is hard, and Stripe explicitly described this as a strategic moat, that signals it is non-trivial and durable.
**Buildability:** **6/10.** The eval harness is a real engineering project (one to two months for v1), but the wedge is large. Sponsor it via launch on a single API, partner with Resend or Cal.com first, for proof.

The fact that Stripe ships a `.md` version of every doc page is the cheapest thing they shipped at Sessions and arguably the most important. It establishes the agent reading layer as a first-class output of every docs site. The companies that ship `.md` mirrors in 2026 will have the same advantage that the companies that shipped mobile-responsive sites had in 2011. AgentBench's wedge is converting that abstract claim into a daily scorecard CFOs can read.

# 3. Minion-in-a-Box — OSS clone of Stripe's internal coding agent

**Builds on:** [Minions](https://stripe.dev/blog/minions-stripes-one-shot-end-to-end-coding-agents), Stripe's internal Slack-driven, codebase-aware, one-shot PR-opener that ships 1,000 PRs/week to Stripe production (architecture is publicly described); Stripe Workflows GA (callouts to Slack); Stripe Agent Skills GA (`SKILL.md` for repo context).
**For:** Engineering managers at companies with >50 engineers who saw the "57,000 PRs in March" stat and want it on their stack.
**Solves:** Stripe's Minions are Slack-driven internal agents. The pattern is: agent reads Slack thread context → walks the codebase via embeddings + AST → opens a PR. The blog post describes it openly. Every other company with a Slack-and-GitHub stack will want it. Minion-in-a-Box is `npx create-minion --slack-channel … --repo … --provider claude|codex|gpt-5` plus a hosted dashboard for accuracy, eval scores, and per-IC token budgets.
**Why now:** The dev keynote *publicly* showed Minions doing real work on stage, and Alistair Gray, the engineer who built them, is doing a [virtual summit talk on May 6–7](https://x.com/ona_hq/status/2050286794789339165) breaking down the architecture. Devtools-Twitter has not yet reverse-engineered it. Anthropic's Claude Code, OpenAI's Codex, Cursor, Cline, Devin, all are point tools or IDE-bound. None ships the **Slack-driven, org-context-aware loop** Minions runs.
**How to start:**

  1. Read the public Minions blog post and Gray's summit talk; design a clean four-stage pipeline (Slack listen → context build → plan → PR open).
  2. Ship as a self-hostable Docker container with one-line `docker compose up`.
  3. Ship the per-IC token budget tracker, this rhymes with Daniel Gross's "every IC is a hedge-fund portfolio manager" framing in the Friedman/Gross/Collisons fireside, and is an instant pitch to ops-savvy CTOs.

**Risk:** GitHub Copilot Workspace, Cursor's background agents, and Devin are all crowding this space. Wedge: Slack-native, repo-aware, open-source, and self-hostable. Do not try to beat Cursor at IDE, beat Cursor at "agent fielding ad-hoc team requests in #eng-help."
**Buildability:** **6/10.** Real engineering project (one to two weeks for v1) but a defensible category if shipped before Cursor extends background agents into Slack.

The opening here is Slack rather than IDE. Cursor owns the cursor; Devin owns the IDE; Copilot Workspace owns the GitHub PR review surface. Nobody owns "the agent that picks up the Slack thread where someone says 'can someone bump this dependency.'" That is where Minions runs at Stripe, and that is where the equivalent fits in any company already on Slack-plus-GitHub. Build it once, run it on every repo.

# 4. SkillForge — Custom Objects → vertical SaaS-in-a-Stripe-Dashboard

**Builds on:** [Custom Objects](https://docs.stripe.com/custom-objects) (🟡 public preview); Custom Object methods (🟡 public preview, server-side functions); Custom Object dashboards (🟡 public preview, auto-rendered); Stripe Workflows (🟢 GA); Stripe Console (🟡 public preview, the agent-operable dashboard).
**For:** Vertical-SaaS founders who would otherwise build a Retool admin panel + Stripe + Postgres + Auth0 stack from scratch. Especially "service-as-software" categories, legal, fitness, property management, schools, healthcare clinics, agencies.
**Solves:** The Bu/Nilifer demo quietly killed the standalone admin panel. Custom Objects + methods + dashboards turn the Stripe Dashboard into Retool, with Workflows as the automation layer. SkillForge ships *opinionated vertical templates*: pick "fitness studio" or "solo legal practice" or "therapy clinic" → it deploys a complete Custom Objects schema, methods, Workflows, Console-discoverable buttons, a `link.com/skill.md`, and an MCP server, all wired to your Stripe account in one CLI command.
**Why now:** Custom Objects landed at Sessions 2026 in public preview. The "Dashboard is your admin app" thesis is brand new — noted the same day Stripe's CRM partner team did:

> The team shipped custom objects, so you can sync anything from your CRM (contracts, subscriptions, etc.) and use them in AI fields and triggers.
>
> — [@advith_c](https://x.com/advith_c/status/2049889025188590041), Apr 30, 2026

Existing Retool / Internal / Appsmith competitors do not ship Stripe-native primitives. The new opportunity is to skip them entirely.
**How to start:**

  1. Ship `npx skillforge init fitness-studio` → calls Stripe API to create custom object schemas (`class_package`, `instructor`, `attendance`), Workflows, and dashboards.
  2. Open-source five starter verticals; charge for the deployment tooling, premium templates, and white-label.
  3. Become a [Stripe Projects](https://projects.dev/providers) provider, free distribution.

**Risk:** Custom Objects is preview; breaking changes are possible. Mitigate by versioning each template against Stripe API version. Stripe Apps Marketplace might also ship templates of its own.
**Buildability:** **7/10.** Each vertical template is a one-to-two-day build once the harness exists. The harness is a long weekend.

This is the idea that most rewards moving fast. Within twelve months Stripe will publish official Custom Objects vertical templates and acquire the most successful third-party SkillForge-clone. Within six the first-mover gets Stripe-paid co-marketing as the canonical reference. The reason it is not 8/10 is that picking the right first vertical is harder than the engineering, and a wrong vertical pick burns the whole bet.

# 5. AgentRouter — multi-protocol payment middleware (UCP / ACP / MPP / x402 in one)

**Builds on:** [UCP](https://ucp.dev) (🟢 GA, Stripe joined the general committee); ACP (🟢 GA, the older ChatGPT-integration protocol Stripe still accepts); [MPP](https://mpp.dev) (🟢 GA, `mppx` SDK); x402 (🟢 GA, Coinbase-led standard); `link.com/skill.md` (🟢 GA, open standard).
**For:** API companies, marketplaces, and agentic merchants who *do not want to pick a protocol*. Stripe is deliberately multi-protocol; most builders have not realized they should be too.
**Solves:** Every protocol launched at Sessions has a different "I want to pay this" handshake. UCP does conversational catalog + checkout. ACP is the legacy ChatGPT integration. MPP does HTTP-402 plus on-chain settlement. x402 does Coinbase-flavored 402. AgentRouter is a single `npm install agentrouter` middleware: incoming agent request → detect what protocol it is speaking → respond in that protocol's grammar → settle via the right rail. The existing TDF dev guide projects (Tollgate, Catalog2Agent) each pick one protocol; AgentRouter is the cross-protocol unifier.
**Why now:** Stripe's *intentional* multi-protocol stance was confirmed at Sessions. Until now nobody knew Stripe accepted UCP + ACP + MPP + x402 simultaneously, that is the asymmetric-information arbitrage. [@FavManCity's framing](https://x.com/FavManCity/status/2050294843159482679) captures the demand side: *"with x402, it's not about humans calling APIs but more about agents doing real work, autonomously, call, pay, and execute, without bothering about managing API keys or creating accounts."* Pick any single protocol and you exclude half the agents.
**How to start:**

  1. Implement protocol detectors as a Hono middleware: `agentrouter({ ucp: {...}, mpp: {...}, x402: {...}, fallback: 'card' })`.
  2. Open-source the detector and ship a Cloudflare Worker version.
  3. Charge for the analytics layer, *"47% of your agent traffic is x402, 31% MPP, 22% UCP, here is where to invest."*

**Risk:** One protocol may win and the rest die. Mitigate by treating detection as plugin-based, if MPP wins, AgentRouter becomes a thin MPP gateway and the wedge collapses, but the code is reusable.
**Buildability:** **7/10.** Detection logic is straightforward; integration with each protocol's SDK is well-documented in their respective specs.

The skeptical case is that one protocol, most likely MPP, given Stripe's backing, eats the others. The contrarian case is that Stripe deliberately did not pick a winner because they want the whole layer to be commoditized so the *settlement* underneath becomes the moat. If that is the strategy (and the Sessions framing strongly suggests it is), the multi-protocol middleware layer is structurally durable. AgentRouter wins either way: in the consolidation case, you exit by selling to the winner; in the commodity case, you become the canonical detector library.

# Top 25 — sorted by buildability × wedge strength

![25 ideas plotted on the buildability × wedge-strength matrix — the top-right cluster of 5 ideas (in editorial red) is where weekend-buildable meets defensible-by-construction. Most ideas land in the middle quadrants.](/post-images/2026-05-02-stripe-sessions-2026-25-things-to-build/buildability-matrix.jpg)

| # | Idea | Builds on (status) | Buildability | Wedge survives Stripe? |
|---|------|---------------------|--------------|------------------------|
| 1 | **DocsToMD** | `?.md` URL pattern (🟢) | **9/10** | 90–180 day window |
| 2 | **ApprovalKit** | Approval Rules (🟡) | **8/10** | Cross-API only |
| 3 | **AgentReady-for-Banking** | Treasury (🟡) | **8/10** | Top-of-funnel only |
| 4 | **Sandbox-as-Onboarding** | Claimable Sandboxes (🟢) | **8/10** | Short window |
| 5 | **SkillForge** | Custom Objects (🟡) | **7/10** | Vertical wedges only |
| 6 | **AgentRouter** | UCP+MPP+x402 (🟢) | **7/10** | Yes if multi-protocol holds |
| 7 | **CheckoutPilot** | Checkout Studio (🟡) | **7/10** | Yes if scope > Checkout |
| 8 | **MCPGate** | Stripe MCP (🟡) | **7/10** | Yes (security wedge) |
| 9 | **ProvisionLayer** | Stripe Projects (🟢) | **7/10** | Yes (partner-side) |
| 10 | **BlueprintCraft** | Blueprints (🟢) | **7/10** | 6–12 month window |
| 11 | **AgentBench** | Integration Benchmark | **6/10** | Yes (cross-LLM moat) |
| 12 | **Minion-in-a-Box** | Minions architecture | **6/10** | Yes if Slack-native |
| 13 | **AgentKey Vault** | Agent-tagged keys (🟡) | **6/10** | Yes (cross-API) |
| 14 | **ConsoleApps Studio** | Stripe Apps (🟡) | **6/10** | Tooling wedge |
| 15 | **TokenFinOps** | Metronome (🟡) | **6/10** | Yes (LLM-judge wedge) |
| 16 | **PaywallProxy** | x402 + MPP (🟢) | **6/10** | Yes (long tail of writers) |
| 17 | **Anti-AgentBlock** | ACS + SPTs + Radar (🟢) | **6/10** | Yes (vendor-side) |
| 18 | **WeddingClerk** | Link agent wallet (🟢) | **5/10** | Vertical wedge holds |
| 19 | **FreelancerCoaster** | mppx streaming (🟢) | **5/10** | Speculative |
| 20 | **Indexr** | Stripe Database (🔴) | **5/10** | Gated on preview access |
| 21 | **RFP-as-a-Service** | UCP + SPTs (🟢) | **5/10** | Vertical wedges only |
| 22 | **CoasePilot** | Sigma + Database (🟡) | **5/10** | Sigma-only v0.5 viable |
| 23 | **PolicyWallet** | SPTs + Issuing (🟡) | **5/10** | Apple/Google may eat |
| 24 | **HydrationCoach** | mppx + vision (🟢) | **4/10** | Privacy risk |
| 25 | **AgentBnB** | Issuing for agents (🔴) | **4/10** | Wait until preview opens |

![Builder velocity since the keynote — the window is open and closing.](/post-images/2026-05-02-stripe-sessions-2026-25-things-to-build/builder-velocity.jpg)

# Ideas 6–25, named and framed

# 6. DocsToMD — Cloudflare Worker that mirrors any docs site as `/path.md`

**Builds on:** the `?.md` / `.md` suffix pattern (🟢 GA, demonstrably copyable). **Buildability: 9/10.**

Bu's most-quoted line at Sessions: *"By appending `.md` to any URL, an agent gets all the content without headers, footers, and UI elements."* Most docs sites cannot ship this in a weekend. DocsToMD is a hosted proxy: point your `*.docs.acme.com` CNAME at it; it serves clean Markdown at every path; it adds the `?.md` URL hint; it injects a "Copy for LLM" button via JS. Free tier under your subdomain, paid for custom domain plus analytics on agent-versus-human traffic. Bonus: emit an `llms.txt` and a `.well-known/agent.json` for free. Vercel, Cloudflare, and Mintlify will ship native versions within months, the window is 90–180 days, but the brand recognition you accrete in that window is portable.

# 7. AgentKey Vault — single-pane observability for every agent-tagged API key

**Builds on:** Agent-tagged API keys (🟡 public preview); the OAuth-for-agents pattern from Link CLI. **Buildability: 6/10.**

Stripe established a new actor type on API keys: agent versus human. No other API has this yet. AgentKey Vault is the cross-platform layer, every key tagged "agent" goes through Vault, which logs every call, scopes credentials, rotates them, and surfaces unified audit. Like Doppler or Infisical, but designed around the agent actor type rather than the human-developer one. The SOC 2 conversation that follows is the moat. Pair it with ApprovalKit (idea #1) and you have a security stack.

# 8. CheckoutPilot — GitHub Action PR-bot for Stripe (and adjacent) config

**Builds on:** Checkout Studio (🟡 public preview, which scans GitHub repos and opens PRs). **Buildability: 7/10.**

[@ned_malki](https://x.com/ned_malki/status/2049815820650635498) described what Stripe shipped: *"Stripe now allows users to customize Checkout for any of their products and hand off a prompt to their agent to embed in any of their projects. It's called Checkout Studio."* The pattern is generalizable. Stripe Studio just opens *Checkout* PRs. Most Stripe integrations are six to twenty-four months out of date and never fixed. CheckoutPilot is the Stripe-side config audit + PR bot covering all 8 surfaces: Adaptive Pricing on, Smart Disputes on, Tax filing on, agent-keys flag, `llms.txt`, `mpp.json`, MD-mirror docs, Apple Pay domain verification, all checked and PR'd as a single GitHub App. Charge per PR or per repo per month.

# 9. Indexr — macro-economic dashboard for vertical SaaS, powered by Sigma + Database

**Builds on:** Stripe Database (🔴 private preview); Sigma (🟢 GA); the "indexing the economy" thesis from the Sands/Collison talk. **Buildability: 5/10** (gated on Database access).

Sands and J. Collison's argument: Stripe's data is a real-time macro index. Most Stripe customers cannot access aggregate data, but they *can* access their own cohort. Indexr packages Sigma queries plus Stripe Database as a "vertical macroeconomics" dashboard: *"show me MRR cohort velocity for AI startups born in Q1 2026 versus Q1 2025"* or *"what % of my customers are international, versus the Stripe Atlas median?"* The macro stats Sands shared (5× class-of-2026 revenue, +130% Atlas YoY, international share moving from 11.6% to 23%) prove there is signal worth selling. Sell as a Sigma/Database power-user tier. Until Stripe lets you into Database, ship a v0.5 with Sigma only.

# 10. Sandbox-as-Onboarding — drop-in `try-before-signup` widget for any Stripe app

**Builds on:** Stripe Claimable Sandboxes (🟢 CLI flow GA); Sandbox API (🟡 preview). **Buildability: 8/10.**

The dev keynote demo showed an agent provisioning a sandbox without an existing Stripe account. The pattern works for *any* user flow: drop a `` React component on your landing page → user enters email → sandbox spawns with your app pre-installed → 24 hours later they "claim" it into their real Stripe account. Cuts the "create a Stripe account first" drop-off that kills half of B2B SaaS signups. Stripe will likely ship this themselves as a Checkout Studio companion within 12 months, the window is short but the technical lift is also short.

# 11. WeddingClerk — the agent that books your whole wedding

**Builds on:** Link agent wallet (🟢 GA); Issuing for agents single-use cards (🟢 GA); UCP / ACS for vendor catalogs. **Buildability: 5/10.**

Reference [@altryne's tweet from the dev keynote dossier](https://x.com/altryne/status/2049639344340873264): "Getting married next week, Link CLI lets me give my agent a budget for a gift." Generalize. Weddings involve 30+ vendor checkouts, all UCP/ACS-discoverable. Chat → it browses florists, photographers, caterers via UCP → returns a comparison → on approval, books each via Link agent wallet with single-use cards and an SPT scoped to a $X budget per vendor. Real-world ops (vendor reliability) is the bottleneck, not payments. App reputation risk if a single vendor flakes, solve with concierge fallback.

# 12. HydrationCoach — agent-vision hardware-OS bridge

**Builds on:** Link agent wallet (🟢); Nat Friedman's hydration-agent demo from the talk; MPP for compute paywalls. **Buildability: 4/10.**

Friedman's stage anecdote: *"Claude told me to walk to the kitchen and drink water on camera. I did. It rated me."* That is the first publicly modeled consumer-agent vision app. Productized: connect home cameras → vision agent monitors hydration, posture, phone use → nudges → charges per-monitoring-second via MPP streaming. [Streaming payments](https://x.com/katiewav/status/2049538960540443043) make per-second compute billing viable for the first time, pre-Sessions you would have had to bundle into a flat subscription. The privacy panic gets ahead of you unless you ship on-device-only mode from day one.

# 13. FreelancerCoaster — agent-paid streaming bounty platform

**Builds on:** mppx streaming payments (🟢); Stripe Connect (🟢); Workflows (🟢). **Buildability: 5/10.**

Pay-per-second of work. A maintainer broadcasts "I'm working on this Issue right now, $0.50/min while I stream" via mppx. Donors stream stablecoin in real time as long as they are watching. Each second of work is a microtransaction settled on Tempo. Twitch Bits but for code review and policy research, with cryptographic proof of work-time. [@Joshuwa Roomsburg](https://x.com/Joshuwa/status/2050029045782544508) summarized the closed-loop economics that make this viable: *"Tempo Shows Agent Commerce Loop. The agent bought data. Used stablecoins. Generated a report. Then listed the output for sale again. That closes the loop."* Demand-side risk is real, test small.

# 14. AgentBnB — Issuing-for-agents-powered short-term-rental subletting

**Builds on:** Issuing for agents (🔴 private preview); Treasury (🟡); Custom Objects (🟡). **Buildability: 4/10.**

Each guest gets a single-use virtual card pre-loaded with the security deposit plus groceries budget; the card is auto-cancelled at checkout. Property manager runs an agent that handles 100% of guest comms via MCP-driven Stripe (refunds, deposits, surcharges) using Approval Rules so the human approves anything > $250. Pre-Sessions you could not programmatically expire a card after one charge. Mark as **🟡 wait** until the Issuing-for-agents preview opens, but the architecture is shippable today against test mode.

# 15. PaywallProxy — replace newsletter paywalls with x402 / MPP

**Builds on:** x402 + MPP (🟢); `link.com/skill.md` (🟢). **Buildability: 6/10.**

Substack and Patreon take 10%. Most readers will not subscribe. PaywallProxy puts every article behind an x402 / MPP wall: humans pay $0.05 / article via Apple Pay through Link; agents pay $0.05 via MPP. Writers get 95% rev share. Article metadata is exposed via `link.com/skill.md` so agents can discover and price articles before paying. [Paul Millerd](https://x.com/p_millerd/status/2050196719045165094), 14k followers and a Stripe-native author: *"agentic purchasing of my books is now live, great feature [@link](https://x.com/link) and [@stripe](https://x.com/stripe)."* That is the leading indicator. Pivot for B2B paid research first if solo-writer adoption is too slow.

# 16. ProvisionLayer — partner-side SDK for any infra company joining Stripe Projects

**Builds on:** Stripe Projects (🟢 GA, 32 providers; the Daytona "Agentic Provisioning Protocol"). **Buildability: 7/10.**

Projects requires each partner to expose a provisioning + billing surface. Daytona named the pattern. ProvisionLayer is the PaaS that handles the Projects partnership intake: a per-tenant provisioning webhook adapter, a usage event emitter, projects.dev-compatible metadata. Stripe Projects went from 0→32 providers in six weeks; the next 100 will not want to spend six weeks each on integration. Open-source the SDK; charge a percentage of provisioned-customer revenue through the hosted control plane; become a Projects provider yourself first as proof.

# 17. ConsoleApps Studio — IDE for full-page Stripe Apps

**Builds on:** Stripe Apps Marketplace full-page experiences (🟡 preview); Stripe Console (🟡). **Buildability: 6/10.**

Full-page Stripe Apps are now possible. The dev experience for them is sparse. ConsoleApps Studio is a `create-stripe-app`-style scaffolder + visual layout tool + Console-discovery wiring + Custom Objects bindings. Distribution: every Stripe customer (1M+) installs apps via Marketplace, and Console surfaces them as agent-discoverable. Ship three reference apps as proof, subscription analytics, dispute war-room, Treasury treasurer, and you become the de-facto template repo before anyone else realizes the surface exists.

# 18. AgentReady-for-Banking — the Stripe-Treasury readiness scanner

**Builds on:** Stripe Treasury (🟡 limited public preview); Treasury MCP; Issuing for agents (🟡). **Buildability: 8/10.**

Treasury was the engagement hit of Sessions ([@PsudoMike caught the energy](https://x.com/PsudoMike/status/2049971933433708808): *"Treasury launch is the interesting one. Embedded banking without Plaid plus a partner bank stack changes the build math for fintech founders. Worth tracking."*). Most Stripe customers do not realize their account already supports it. Build a one-click readiness scanner: connect Stripe → answer five questions → get a scorecard ("you'd save $X/mo on banking by switching, here's the migration plan, here's the 2% cashback Mastercard upside, here's how to wire your AP into Treasury MCP"). Pure top-of-funnel. Distinct from the existing Project 9 (Treasure), Treasure runs the operations *after* migration; this scanner sells the migration *before* it.

# 19. MCPGate — the agent firewall

**Builds on:** Stripe MCP (🟡 public preview); the token-fraud Radar 2026 patterns. **Buildability: 7/10.**

MCP servers are a new attack surface. [DJ_HiKaRu's warning is direct](https://x.com/DJ_HiKaRu/status/2049664181247570409): *"Stripe is fine, but smart criminals will emerge who use Stripe MCP to make AI transfer all kinds of money."* MCPGate is a reverse proxy in front of any MCP server: rate-limit per agent, log every tool call, redact secrets, enforce approval rules on dangerous tools, replay defenses. Cloudflare Access for MCP. Ship pre-built rule packs for `stripe`, `github`, `slack`, `aws` MCPs. The hosted policy admin UI is the SaaS layer; the proxy is the open-source loss leader.

# 20. TokenFinOps — open-source FinOps for tokens

**Builds on:** Metronome real-time metering (🟡 public preview, Stripe acquisition); Daniel Gross's "every IC is a hedge-fund portfolio manager" framing. **Buildability: 6/10.**

Daniel Gross publicly stated Meta is building "FinOps for tokens" with LLMs grading the economic value of generated tokens. Every other org will copy. TokenFinOps is the open-source Datadog-for-tokens: ingest billing from every AI provider plus Cursor, GitHub, Slack → per-IC dashboard → budget alerts → an LLM-judge that scores generated tokens against shipping outcomes. Distinct from Project 5 (Pulse) in the existing dev guide, Pulse is *external* per-customer margin observability; TokenFinOps is *internal* per-employee productivity attribution. The judge, the LLM that rates the value of each generated token, is the differentiator Metronome itself does not ship.

# 21. BlueprintCraft — "Copy for LLM" generator for any docs site

**Builds on:** Stripe Blueprints + "Copy for LLM" button (🟢 GA); the `.md` URL pattern (🟢). **Buildability: 7/10.**

Stripe shipped a "Copy for LLM" button on its Blueprints, one-click structured-context export for agents. Every other docs site needs one. BlueprintCraft is a Mintlify / Docusaurus / GitBook plugin: parses your existing docs structure, finds task-shaped pages, auto-generates structured blueprints with required objects + state machine + recommended config, drops a "Copy for LLM" button. Adjacent to DocsToMD (#6) but task-blueprint-shaped versus doc-page-shaped. Six-to-twelve-month window before Mintlify ships native.

# 22. RFP-as-a-Service — agent-to-agent procurement marketplace

**Builds on:** MPP + UCP (🟢); SPTs (🟢); `link.com/skill.md` (🟢). **Buildability: 5/10.**

Procurement is a multi-day human flow. With UCP-discoverable supplier catalogs + MPP for paid-per-call vendor APIs + SPT-scoped budgets, an agent runs a real RFP: *"find five fits for X, request proposals, run cross-comparison, present top two to the human, on approval execute purchase via Link wallet."* Tempo demoed the same agent acting as both buyer and seller, the loop is now provable. Pick a vertical first, cyber audit RFPs, cloud-cost audits, content writing, then expand. Without supply-side density it does not work.

# 23. Anti-AgentBlock — supplier-side agent allowlist & negotiation layer

**Builds on:** ACS catalog upload (🟢); SPTs (🟢); Radar bot abuse signals (🟢). **Buildability: 6/10.**

The most underrated contrarian take in agent commerce:

> Stripe cannot be trusted on Coase. Their past notes, agent buying coffee, MPP for agent search, have remained toys. Scaled retailers have shut out third-party agents. Adverse selection.
>
> — [@hypersoren](https://x.com/hypersoren/status/2050014667330736564), May 1, 2026

He is right. D2C brands and DTC retailers fear agent-driven margin compression. Anti-AgentBlock is the *vendor-side* tool: define agent policies, gate with SPT + Radar bot signals, A/B test agent-only pricing, negotiate via UCP-extension semantics. Inverts the AgentReady.io thesis. Frame it as "agent governance," not "anti-agent", the language matters.

# 24. CoasePilot — firm-vs-market arbitrage analyzer for SMBs

**Builds on:** Stripe Sigma (🟢); Stripe Database (🔴); the Coasean thesis from "Indexing the Economy." **Buildability: 5/10.**

Sands' Coasean argument: AI lowers both within-firm and between-firm transaction costs, but the elasticity differs by function. CoasePilot ingests a Stripe customer's vendor + payroll + invoice flows → benchmarks against the Stripe customer base (anonymized) → recommends which functions to spin out (market-mediated) versus keep in-house (within-firm). Output: a quarterly "firm boundary report." High-concept but high-conviction, the framing is the entire wedge. Sigma-only v0.5 is shippable today; Database access opens the larger benchmark layer.

# 25. PolicyWallet — give your agent a "policy" not a "limit"

**Builds on:** Link agent wallet (🟢); SPTs (🟢); Issuing for agents (🟡); Ginger Baker's "payments will pivot from being a moment to being a policy" line (talk 01). **Buildability: 5/10.**

Today's Link CLI flow asks the user to approve each charge. Baker's framing is that the future is policy-based: *"buy gifts under $200 from these merchants, replenish my pantry weekly, never pay foreign-tx fees."* PolicyWallet is the consumer app that codifies these policies into SPT scopes + Issuing-for-agents card constraints + Approval Rules, visual policy editor, not a shell prompt. Sell as 1Password-for-agents. Apple Wallet and Google Wallet will eat this within 24 months, the bet is accreting brand trust before they do. [@ParthSAhir captured the moment](https://x.com/ParthSAhir/status/2050288867866271912): *"Stripe Sessions 2026 in one line: agents are getting wallets. 288 launches but the one that broke my brain → Link now lets your AI agent pay on your behalf. One-time-use card per task. You approve. The agent never sees the card."* That is the substrate. PolicyWallet is the consumer surface on top of it.

![Seven anti-patterns to avoid: Stripe MCP wrappers, fifth agent-payment protocols, stablecoin Brex clones, and more.](/post-images/2026-05-02-stripe-sessions-2026-25-things-to-build/anti-patterns-x.jpg)

# 7 anti-patterns — what NOT to build

🔴 **Don't build a Stripe MCP wrapper.** Stripe owns `mcp.stripe.com` and ships new tools every quarter. Wrapping it makes you a thin veneer over the canonical surface. The temptation is huge; the moat is zero.

🔴 **Don't build yet another agent-payment protocol.** UCP + ACP + MPP + x402 cover the design space and Stripe accepts all four. A 5th protocol has zero adoption surface. Build *across* protocols (idea #6, AgentRouter) instead of inside them.

🔴 **Don't build the Brex / Mercury / Ramp clone with stablecoins.** Stripe Treasury is the answer; you will be subsumed within 12 months. The wedge is *vertical* (banking for fitness studios, banking for legal practices), the horizontal play is dead.

🔴 **Don't build a Tempo block explorer.** The vanilla version is undifferentiated. The agent-activity-only filter would have a wedge; the generic explorer has none.

🔴 **Don't build a Treasury aggregator.** You are re-skinning Stripe Treasury. No moat. Build *into* Treasury (idea #18, AgentReady-for-Banking) instead of around it.

🔴 **Don't build an LLM-fronted Stripe Dashboard ("chat with your Stripe data").** Stripe Console is exactly this and it ships in a few quarters with native primitive integration you cannot match. If you must, do it for *non-Stripe* finance data, fold in QuickBooks, Xero, Mercury, and price as a multi-source layer.

🔴 **Don't build a consumer agentic-shopping app for general retail.** [@hypersoren is right](https://x.com/hypersoren/status/2050014667330736564) that the big retailers are actively blocking agents. The vertical wedges (weddings, B2B procurement, hardware reorders, RFPs) work. The horizontal "Amazon-but-agent-driven" does not, because the supply side will not cooperate.

![The vertical-vs-horizontal split — narrow-vertical wedges (weddings, B2B procurement, hardware reorders, RFPs) work because supply is willing to cooperate; the horizontal Amazon-but-agent-driven play is crossed out because retailers are actively blocking agents.](/post-images/2026-05-02-stripe-sessions-2026-25-things-to-build/vertical-vs-horizontal.jpg)

![Pick one and ship it before next Sessions: the layer Stripe doesn't want to own is on the right side of the line.](/post-images/2026-05-02-stripe-sessions-2026-25-things-to-build/build-vs-wait.jpg)

# Closer: build the layer Stripe will not own

There is a counter-take worth taking seriously. [@nishancodes](https://x.com/nishancodes/status/2049865893480677573) posted the night of the keynote: *"Why buy something for Agents, when AI can build the same thing as a weekend project? Building SaaS for humans makes sense. But why, for Agents?"* It is a real question. If every agent can synthesize the API call from a `.md` URL and a `SKILL.md`, the "ship a product *for* agents" thesis weakens.

The answer is that the products that survive are not products that agents *consume*, they are products that humans use to *govern, observe, and bound* what agents do. ApprovalKit governs. AgentKey Vault observes. PolicyWallet bounds. SkillForge gives the human operator a Stripe-native admin surface for an agent-driven business. Minion-in-a-Box gives an engineering manager a dashboard over a fleet of agents. None of these are products an agent buys. All of them are products a human buys *because* there are agents.

The other reason this list is timely is that the window is shorter than it looks. [@dani_avila7](https://x.com/dani_avila7/status/2049665684146151683) lost his weekend to the Cloudflare-plus-Projects flow; [@FounderWilfred](https://x.com/FounderWilfred/status/2049601371041890490) shipped MCP-paid weather data in twelve hours; [@_MaxBlade](https://x.com/_MaxBlade/status/2049818764007370803) live-streamed himself vibe-coding into the new marketplace and got 167 likes for the announcement alone. Builders have already started. The asymmetric-information arbitrage on the dev keynote, Minions, the structured-error contract, agent-tagged keys, Custom Objects, the Integration Benchmark, Checkout Studio's PR flow, closes the moment a second wave of writeups lands. That is somewhere between three weeks and three months from now.

The position to take is the one Stripe itself takes: build for the layer that Stripe does *not* want to own. Stripe wants to own settlement, agent identity, agent-readable docs surface, and the Console as the agent-operable dashboard. Stripe does *not* want to own cross-API approvals, cross-API agent-key governance, cross-protocol payment routing, cross-LLM eval harnesses, vertical SaaS schemas, or the security perimeter around third-party MCP servers. Every idea on this list lives in that gap. Pick one and ship it before next Sessions.

## Sources

- [Stripe — Everything we announced at Sessions 2026](https://stripe.com/blog/everything-we-announced-at-sessions-2026)
- [Stripe Minions blog post](https://stripe.dev/blog/minions-stripes-one-shot-end-to-end-coding-agents)
- [Stripe roadmap](https://stripe.com/roadmap)
- [Stripe Custom Objects docs](https://docs.stripe.com/custom-objects)
- [Stripe Workflows docs](https://docs.stripe.com/workflows)
- [Stripe Agent Skills (github.com/stripe/ai)](https://github.com/stripe/ai)
- [Stripe MCP server](https://docs.stripe.com/mcp)
- [Universal Commerce Protocol (UCP)](https://ucp.dev)
- [Machine Payments Protocol (MPP)](https://mpp.dev)
- [x402 spec](https://www.x402.org)
- [link.com/agents](https://link.com/agents)
- [Stripe Projects provider catalog](https://projects.dev/providers)
- [Tempo docs](https://docs.tempo.xyz)
- [TDF — Stripe Sessions 2026 developer guide (Part 1)](https://thedeepfeed.com/posts/2026-04-30-stripe-sessions-2026-developer-guide/)
- [John Collison on X — Claude Code + MPP + Tempo demo](https://x.com/collision/status/2050232889766552027)
- [Daniel Avila on X — "Cloudflare just took my weekend"](https://x.com/dani_avila7/status/2049665684146151683)
- [Pejman John on X — Link CLI buys coffee beans](https://x.com/pejmanjohn/status/2049580208966304192)
- [Wilfred Lee on X — 12 hours to ship MCP agentic purchases](https://x.com/FounderWilfred/status/2049601371041890490)
- [Jon C. Phillips on X — "every product needs an MCP server"](https://x.com/joncphillips/status/2050243989865894087)
- [Aryan on X — "vibe coding tax"](https://x.com/aryanlabde/status/2049204286941483191)
- [Max Blade on X — Stripe created an entirely new marketplace](https://x.com/_MaxBlade/status/2049818764007370803)
- [Soren Larson on X — agent commerce skeptic](https://x.com/hypersoren/status/2050014667330736564)
- [Nishan on X — "why buy something for agents"](https://x.com/nishancodes/status/2049865893480677573)
- [Katie Haun on X — streaming payments](https://x.com/katiewav/status/2049538960540443043)
- [Ona on X — Alistair Gray on Minions](https://x.com/ona_hq/status/2050286794789339165)
- [Joshuwa Roomsburg on X — Tempo agent commerce loop](https://x.com/Joshuwa/status/2050029045782544508)
- [Paul Millerd on X — agentic purchasing of books](https://x.com/p_millerd/status/2050196719045165094)

---

Canonical: https://www.thedeepfeed.ai/posts/2026-05-02-stripe-sessions-2026-25-things-to-build/
Site: https://www.thedeepfeed.ai
Full corpus: https://www.thedeepfeed.ai/llms-full.txt