What Is an MCP Checkout? The Agentic Commerce Stack, Explained

Sam Bakker · Founder, gocushy · July 16, 2026

Somewhere in the last two years the question changed from "can an AI write my sales page?" to "can an AI actually run the selling?" — create the product, attach the upsell, wire the follow-up, read the numbers, iterate. The answer is yes. The plumbing is a protocol called MCP, and this post explains how the stack fits together — and how to make it safe to let an agent operate the one part of your business that touches money.

MCP in sixty seconds

MCP — the Model Context Protocol — is an open protocol introduced by Anthropic in late 2024. It gives AI models a standard way to discover and call tools in outside software. A tool is a typed, documented action: create_offer, get_sales, refund_order. The model reads the tool list, decides what to call, sends structured arguments, and gets structured results back.

Because the protocol is open, it spread quickly. As of this writing, Claude, ChatGPT, Cursor, and most serious agent frameworks speak MCP, and there is an official MCP registry where servers are published and discovered — the closest thing agentic software has to an app store.

The practical consequence: any product that publishes an MCP server can be operated by any of those agents, in plain English, with no custom integration work.

So what is an MCP checkout?

An MCP checkout is checkout software exposed to agents as a set of MCP tools. Instead of a human clicking through a dashboard and copying webhook URLs between tabs, the agent does the work. You say:

"Set up a checkout for my $49 course. Add the $17 workbook as an order bump, and put buyers on my course-buyers list."

…and the agent turns that sentence into tool calls: create_offer, set_followup, get_checkout_link. Moments later there's a live, mobile-first checkout page it can hand back to you as a link.

gocushy exposes 22 tools covering products, offers, checkout copy, email connections, webhooks, affiliates, refunds, subscription cancellations, and sales stats. The breadth matters: an agent that can only create things is a form-filler; one that can also read results and adjust is a colleague. For what that looks like day to day, see how to sell digital products with ChatGPT.

The agentic commerce stack

Agentic selling isn't one product. It's three layers, and confusion between them is where most of the bad takes come from.

Layer 1: The payments rail — Stripe

Stripe moves the money: cards, wallets, Link, buy-now-pay-later, disputes, payouts, and the legally required identity checks (KYC). Stripe also ships its own agent tooling — as of this writing, its MCP server can do things like create payment links and manage Stripe resources. That's real and genuinely useful. But a payment link is a cash register, not a store — it's built to collect a payment, not to run an offer stack, tag buyers into email sequences, or track affiliates.

Layer 2: The selling machinery — gocushy

This is the layer that turns a payment into a sales process: order bumps (+20–40% average order value), one-click post-purchase upsells on the saved card, buyers tagged and sequenced in Kit, Mailchimp, or ActiveCampaign, affiliate links with server-side attribution, sequential tax invoices, dunning for failed payments, and stats the agent can read back. It also handles real tax — Stripe Tax on your registrations, with EU B2B reverse charge and NZ/AU GST support. (A description of features, not tax or legal advice — where you must register is a question for your accountant.)

The one-liner we use internally: Stripe's MCP gives your agent a payment link. gocushy gives it a funnel.

Layer 3: The agent

Claude, ChatGPT, Cursor, or your own code. The agent is the operator — it decides what to build and when to iterate. The stack below it decides what's possible and what's safe.

Here's how the two approaches differ from the buyer's side:

For a deeper side-by-side of the first two layers, see Stripe payment links vs. a real funnel.

The safety model: letting an agent near money

The obvious objection: "you want a language model operating my checkout?" The answer isn't "trust the model." It's building the platform so the agent cannot do the damaging thing, no matter what it's told. Five mechanisms do the work on gocushy:

1. Server-side pricing

Prices are set once, on the server, when a product is created, and every checkout reads that record at payment time — nothing in a URL, page markup, or checkout-time tool call can alter what a buyer is charged. An agent can create an offer; it cannot ship a mispriced checkout.

2. Whitelisted checkout blocks

Checkout pages are described, not designed. The agent sets content into fixed slots — headline, subheadline, up to six benefit bullets, up to three testimonials, a guarantee badge, hero image, button text, and a brand accent color. It can't inject scripts, rearrange the layout, or ship the uncanny half-broken pages free-form generation produces — the layout is structurally unbreakable.

3. Honest countdowns

Scarcity is the most abused mechanic in direct response. On gocushy, a countdown hides itself at zero and can never fake-reset — the system simply has no way to express a dishonest timer. An agent told to "make the countdown restart for every visitor" will fail, correctly.

4. Signed URLs everywhere it matters

One-click upsells charge a saved card, delivery pages unlock paid content, and invoices carry tax details — so all of those live behind signed URLs. They can't be guessed or forged — by an agent or anyone else.

5. One human step, by law

The single thing your agent can't do is pass Stripe's KYC — identity verification is a legal requirement and a human one. You connect your own Stripe account once, and money lands there directly on every sale — gocushy never holds your funds. Everything after that handshake, the agent can run.

Beneath the principles sits ordinary engineering discipline: 67 automated tests and 40+ adversarial review findings fixed before launch. To watch the whole loop run — agent builds, sells, reads results, iterates — see what happens when a Claude agent runs your sales.

MCP-native from day one

We built gocushy MCP-native from day one, and it shows in where you'll find it: com.gocushy/mcp is published in the official MCP registry — to our knowledge the first checkout platform listed there. Claude Desktop, Claude Code, and Cursor connect with one line (npx -y @gocushy/mcp); ChatGPT and other hosted agents use the remote MCP endpoint; and everything the 22 tools do is also available over a plain REST API. Setup details are in the docs, and you can create an account to get started.

When a bare payment link is the better choice

Honesty cuts both ways. If you sell one thing occasionally — a single consulting invoice, a one-off deposit — with no upsell path, no email list, and no affiliates, Stripe's own tooling is simpler and involves one less layer, and we'd recommend it without hesitation. The checkout layer earns its keep the moment selling becomes a process: multiple offers, order value optimization, list building, recurring revenue, partners promoting you. That's the machinery gocushy hands to your agent.

Frequently asked questions

Sam Bakker is the founder of gocushy. He has a long track record building launch and funnel software for creators, and builds from New Zealand.