Agentic Commerce

When an agent buys,
the sale stays yours

We prepare your product data and checkout for AI assistants that shop for people, through the open protocols they use, so an agent can buy from you, and the order, the customer and the payment stay yours.

Thanks, we’ll be in touch soon.

{{ heroStatus }}

The drawing: a store of our own, with a product card at the left and the store’s own order list, “Your orders”, at the right. A person on the site taps “Place order”, and a row joins the list: “Placed on your site”, with a tick. Then a card, “An assistant, for a buyer”, comes to the same product, the button reads “Approved by the buyer”, and a second row joins the same list, in the same form: “Placed through an assistant”, with a tick. The list’s heading, “Your orders”, is marked: both are yours.

You’re in good company

A few of the companies we’ve worked with.

{{ wallSay }}

Built for people who browse

Your store was built for people. They look at the pictures, read the size guide, find the returns page and click through the checkout. An agent does none of that: it’s an AI assistant that acts for someone, here by shopping for them. It reads your product data and asks your store for an exact answer: the price with delivery, the size in stock, what happens if it doesn’t fit. Where the data is missing, it can’t answer, or it answers from somewhere else. Then it has to buy, through a way in built for agents, set out in a protocol: a published set of rules two systems follow to work together. Where there isn’t one, or your store turns away anything that isn’t a person, the buyer starts again somewhere else.

An example: what an agent asks for, and what a store’s product data can answer.

An assistant, for a buyer

“A waterproof jacket in medium, delivered to a home address, with free returns”

An exampleWhat your product data answers

  • Waterproof: yes
  • Medium in stock: yes
  • Delivery to this address: not in the dataCan’t be answered
  • Returns: on a page, not in the data

What we build

What an agent needs to buy from you, built into the systems you already run.

  • Product data agents can rely on

    Each product’s price with delivery, its variants, stock and returns, from your own systems, in the form each protocol asks for.

  • One source for every channel

    The same product data for your storefront and for every agent, so an answer never differs from the page, and a change reaches both.

  • A checkout agents can complete

    Your checkout offered through the protocols agents use, with your own rules for stock, tax, delivery and discounts on every step.

  • Approved by the buyer

    The exact items, delivery and total set out for the buyer’s approval before anything is charged, and a change after that sent back to them to approve.

  • Payment without the card

    Card details stay with your payment provider. Your store receives a token in their place, one it can charge only within its limits.

  • Agents that say who they are

    Signed requests checked against the keys each agent’s operator publishes, and your bot rules set so the agents you choose can buy.

  • Orders where they belong

    Each order in your own order system, as yours, with its updates sent back to the agent and the buyer.

  • Returns and help, the same as any order

    Refunds, exchanges and support for an order an agent placed, under the same policy as every other.

  • Tested before agents arrive

    Each protocol’s checkout tried in its test environment, with orders that go wrong on purpose: sold out, declined, a price that changed.

The storefront and the checkout people use? E-commerce →

Being found and recommended in AI answers? SEO & AI Search →

Assistants that use your product, beyond buying? MCP & Agent Integration →

Open ways to buy, not one per assistant

A few protocols now set out how an agent finds what a store sells, builds a cart, checks out and follows the order afterward: the Agentic Commerce Protocol (ACP) and the Universal Commerce Protocol (UCP) cover the purchase, and the Agent Payments Protocol covers how a buyer’s approval travels with the payment. Each is published openly and maintained by a group of companies, and each is still changing. They overlap, and an agent that supports one may not support another. So we build your product data, your checkout rules and your order flow once, in your own systems, and offer them through each protocol the agents your customers use support.

An example: a notice a store publishes for agents, at a known address on its own site.

An example

Published by your store, for agents

  • What agents can do here: browse, check out, follow an order
  • How to pay: through our payment provider
  • How to check it’s us: the keys we publish

Kept at a known address on your site

Paid for this order, and nothing else

Paying through an agent sounds like handing it your card. It isn’t. The buyer approves the cart, and the agent passes on a token: it stands in for the card, and can pay for that cart and nothing else. We build your checkout to accept those tokens through your own payment provider, to charge no more than was approved, and to send any change back to the buyer.

An example

The cart, as approved

Items
(the items)
Delivery
(the delivery)
Total
(the total)

Approved by the buyer

The token the agent passes on

  • This store only
  • This checkout only
  • Up to a set amount
  • Until it expires, and once

Delivery changed after approval

No longer the total the buyer approved. Back to the buyer to approve.

The card number stays with your payment provider. What reaches your store is a token it can charge only within its limits.

Each protocol sets the limits its own way. The idea is the same: the payment fits one store, one order and a limited amount.

Your store still checks every price, discount and total itself, against what the buyer approved. Nothing an agent says changes them.

Agents read text they didn’t write. AI Security & Governance →

Agents that say who they are

Your store’s bot rules may turn away automated visitors, and an agent can look like one. One of the protocols lets an agent sign each request with a key its operator publishes, and a standard in draft does the same for agents across the web. So your store can check which agent is asking before deciding what it may do. We set your rules so the agents you choose can browse and buy, within the limits you set, while every other automated visitor meets the rules you have today.

Which agents may buy, and within what limits, is yours to decide.

An example: one request to buy, as your store checks it.

An example

A request to buy

  • Signed by: an agent’s operator
  • Key: matches the one it publishes
  • Then: your rules for the agents you’ve chosen

Not signed: your rules for other automated visitors

Start with one range of products

We begin by reading your product data the way an agent does, for one range of products, and listing every question it couldn’t answer. Then we connect that range to one protocol’s checkout, in its test environment, and place orders that go right and orders that go wrong: sold out, declined, a price that changed. You get a written list of what your data and checkout need, that one range buying correctly in the test environment, and a plan for the rest, in the order we’d do it.

Work with us as a dedicated team, on a fixed price project or a mix of both. Compare engagement models →

How each is paid for: Pricing →

An example: the slip from one test order, with its items, “Paid with a test token” and “In your order list”.

Questions worth asking

Which protocol should we support?

The one the agents your customers use support, first. The protocols overlap, and they’re still changing, so we build your product data, checkout rules and order flow once, in your own systems. Adding a second protocol then means a new connection, not a new store.

Do we lose the customer to the assistant?

No. You stay the seller. The order is placed in your own system and paid through your own payment provider, under your own terms and returns, and the buyer’s details the protocol passes come to you.

Our platform says it already works with agents. Do we need this?

Maybe not all of it. Some commerce platforms now offer their own connection for agents. We start with what yours offers, and build what it doesn’t: the product data it needs, your own checkout rules, and the orders and returns behind them.

Do we need MCP as well?

Not for this. Some of the protocols can also run through MCP, so a store that already has an MCP server can offer them through it. MCP & Agent Integration →

What if the buyer didn’t mean to buy it?

The same returns and refunds as any order. And the order keeps what the buyer approved, as the protocol passed it, so your team can see it in one look.

Can we choose which agents buy from us?

Yes. Agents that sign their requests can be recognized, and which of them may buy, and within what limits, is your decision. Every other automated visitor meets the rules you have today.

Will it help us appear in AI answers?

Being found and recommended is a different job: SEO & AI Search → This work starts once an agent comes to buy.

Who looks after it as the protocols change?

We can. Each new version of a protocol is read and tried in its test environment before it reaches your store, and your support plan sets the first response time for each priority. Support & Maintenance →

What does it cost?

It depends on your platform, your product data and the protocols you start with. The first call is free. Your proposal sets out the scope, the price or rate, and how you pay, before any work starts. Pricing →

Let’s connect it better

Tell us how your store sells today. We’ll suggest where an agent should start.

Thanks, we’ll be in touch soon.

{{ ctaStatus }}