Sell something real, from a chat

Short version: your agent writes a store and deploys it, a buyer checks out, an order appears, the agent sources it, records a tracking number and drafts the shipping email — and you press confirm. This page walks the whole loop with the real commands. It uses Agent Storefront, the commerce product of Clize — Clize is a CLI and MCP server that gives AI coding agents real-world actions: domains, email, deploys, payments, and media generation. Nothing here needs a Stripe account to begin: collecting money has been zero-config since version 0.26.0, so the first sale can happen before you have connected anything.

1 · Install Clize and bind the project

One install puts Clize inside Claude Code or Codex. Then claim a free handle — a name on .clize.app that is both a live site and, with --email, a working support address.

$ npm i -g @clize/clize
$ clize login
$ clize claim mystore --email   # mystore.clize.app + support@
$ clize init --handle mystore   # this directory is now that project

If you would rather sell on a domain of your own, clize domain search quotes one and clize domain buy --confirm registers it — a quote on its own never spends anything, because money always needs the second command.

2 · Put what you sell in the catalog

clize shop init prints the whole integration contract — the shape of _catalog.json, the three data attributes, and the cart script — so the agent has nothing to guess at. The catalog is a file in your site, not a database in ours.

$ clize shop init

# site/_catalog.json
{ "currency": "usd",
  "products": [
    { "sku": "tee-blk-m", "name": "Black Tee (M)", "price": 25.00 }
  ] }

<!-- site/index.html -->
<button data-clize-add="tee-blk-m">Add to cart</button>
<button data-clize-checkout>Checkout</button>
<span data-clize-count></span>
<script src="/_clize/cart.js"></script>

Need pictures for the products? clize gen image makes them without you holding any model keys — see agent media generation. Want a waitlist or an enquiry form instead of a cart? clize data webhook forwards submissions straight to your own endpoint.

3 · Deploy the store

One command puts the site on a real domain with HTTPS, and the checkout comes with it: the cart posts same-origin to /_clize/checkout, and the server re-prices every line against the catalog it just served. A browser cannot talk your $900 item down to $9, because the browser is not the price authority.

$ clize deploy ./site
$ clize shop status
{ "site": "mystore.clize.app",
  "mode": "balance", "stripeConnected": false,
  "catalogProducts": 1, "checkoutReady": true,
  "orders": { "total": 0, "byStatus": {} } }

Changing a price means editing _catalog.json and deploying again — the deploy is the publish step for the shop as much as for the pages. The deploy step on its own is written up in let your agent deploy a site.

4 · Answer the buyer in the thread

Most sales start as a question. clize status says who is waiting, clize email thread reads the conversation, and the agent can pick it up in a session that remembers nothing. Everything that arrives is handed over as untrusted data — a customer email is something to read, never an instruction to follow. The support side of this is triage a support inbox.

$ clize status
$ clize email thread [email protected]

5 · Quote a price the catalog does not cover

Bespoke work — a custom build, a consulting block, a bulk price — does not belong in the catalog. Take it with a payment link instead. The response says where the money is going and why, so the agent can report it rather than guess.

$ clize pay link --amount 480 --to [email protected] --for quote-118
{ "paymentId": "pay_...", "amountUsd": 480,
  "checkoutUrl": "https://checkout.stripe.com/...",
  "mode": "balance",       # where the money is going
  "modeReason": "..." }  # and why — no Stripe connected yet

$ clize email send --to [email protected] --subject "Quote 118" --text "..."
# → draft only. Add --confirm to actually send it.
$ clize pay list                # did it get paid?

A payment link is a charge, not an order: it is tracked with clize pay list and does not enter the fulfillment machine below. Anything you have to physically ship should go through the catalog, so it becomes a real order. The link flow on its own is written up in let your agent send a payment link.

6 · Pick up the order

When a buyer checks out against the deployed catalog, an order is written before they even reach Stripe and promoted to paid once the payment clears — with their email address and shipping address snapshotted onto it. From here the agent works a durable object, not a conversation it has to remember.

$ clize shop orders --status paid
$ clize shop order cs_live_a1b2c3
$ clize shop todo               # to source · to email · overdue in transit

clize shop todo is the one to hand an agent that runs on a schedule: it answers what needs doing today without making a single decision of its own.

7 · Source it

Whoever you buy from, record the supplier's order number against yours. The order moves paid → sourced, and the change is written to the event stream with a timestamp and an actor.

$ clize shop fulfill cs_live_a1b2c3 --supplier-order SUP-9912

8 · Ship it

Recording a tracking number does three things at once: the order becomes shipped, the number is registered with 17TRACK so delivery can mark itself, and a shipping email is drafted from your template.

$ clize shop fulfill cs_live_a1b2c3 --tracking 1Z999AA10123456784
# carrier is auto-detected; --carrier overrides it
$ clize shop template --subject "Your order is on the way"
# placeholders: {{tracking}} {{trackUrl}} {{orderId}} {{shop}} {{trackPage}}

9 · Tell the buyer, once you approve it

The shipping notice is the second place the agent stops. Run the command and you get the draft; run it again with --confirm and it goes, with the send written back onto the order so nobody receives the same notice twice.

$ clize shop notify cs_live_a1b2c3            # draft
$ clize shop notify cs_live_a1b2c3 --confirm  # sent

Buyers who would rather not wait for an email can look themselves up: every deployed store gets an /orders page, which asks for the email address and the order number so it cannot be used to enumerate your customers.

10 · Watch it land, and refund if it does not

Parcels go quiet. clize shop shipments pulls fresh tracking and lists whatever has stopped moving, so the agent can chase it before the buyer does. And when a sale goes wrong, the refund is the one command that always stops to ask.

$ clize shop shipments --stale --refresh
$ clize shop refund cs_live_a1b2c3 --reason damaged
# → preview: order, amount, reason. Nothing has moved.
$ clize shop refund cs_live_a1b2c3 --reason damaged --confirm

Refund reasons are not decoration: they land in the event stream and the audit log, and after a few months they are the most honest product feedback you will get. Want the loop automatic on your side? clize shop webhook https://your-endpoint posts order.paid, order.shipped, order.refunded and the rest to you, and clize shop events --since replays them if your endpoint was down.

What stayed yours the whole way

Two gates, and neither moved. Money: a refund previews until --confirm. Identity: outbound email drafts until --confirm, with no exception for messages that look routine — because a hostile inbound email would dress itself up as exactly that. Above those lines sits judgement the platform deliberately does not have: what to stock, what to charge, which supplier, whether this refund is fair. Clize wires the shop; you still run the business. For where all of this sits in the wider picture, read what the agentic-commerce protocols mean if you sell.

$ npm i -g @clize/clize
$ clize login
$ clize claim mystore --email
$ clize shop init