Retail - agent-ready commerce (RMS)

Agent-ready retail commerce,
catalog to fulfillment.

Retail is one audited commerce record for merchants, orders, payments and fulfillment. People work it through a console; agents work it through MCP - the same record, the same rules, either way in.

Merchant consoleorder OB-5573
Buyer
Office fit-out, 40 seats
Merchant
Northline Interiors
Total
$51,900
Payment
rms-simulated (hold)
  • 40Sit-stand desk, walnut$28,000
  • 40Ergonomic task chair$18,400
  • 1Acoustic panels + install$5,500
A stocked retail store aisle
A retail store aisle. Photo is illustrative.

The whole store

One platform, storefront to back office.

Selling, running the store and serving buyers - each is a real, built surface on the same record. One short line each, no jargon.

Sell

Marketplace storefront

A buyer home, product detail and per-merchant microsites, with cart and checkout.

Run

Merchant console

One dashboard for catalog, the quote inbox, the fulfillment queue and daily operations.

B2B

Buyer portal + price lists

Business accounts shop a catalog repriced for them, with negotiated account price lists.

Sell

Promotions & coupons

A discount and coupon engine that evaluates and expires codes consistently at checkout.

Run

Shipping & tax

Rate-shop across land, sea and air bands, and resolve tax by class and jurisdiction.

Run

Returns & RMA

Inspection, restock and refunds against a per-merchant return policy, all recorded.

Care

Help & support

Support cases with a full lifecycle, help articles and dispute escalation on one record.

Stock

Replenishment

Min, max, reorder point and safety stock, owned here as the system of record.

The commerce loop

Intent to fulfillment, one audited record.

Every step writes to the same audited commerce record, so each role picks up where the last left off. The quote-to-offer path is single-shot - SUBMITTED then ACCEPTED, not a live bargaining loop - and payments are simulated today.

01

Intent

Buyer requests a quote

02

Quote

QuoteRequest SUBMITTED

03

Offer accepted

Offer SUBMITTED -> ACCEPTED, single-shot

04

Order

OrderBooking CREATED -> CONFIRMED

05

Payment

Authorization held, simulated

06

Fulfillment

Picked, packed, shipped

07

Returns

RMA inspected, restocked, refunded

One record, two front doors

One commerce record, two front doors.

Merchants, catalogs, orders, payments and fulfillment all live in a single audited record. People reach it through a console; agents reach it through MCP. There is no second store bolted on for the bots - the same record answers both, so nothing drifts out of sync.
  • People work orders, catalog and fulfillment in a console
  • Agents call the same operations as typed MCP tools
  • Every write is scoped, idempotent and recorded, either way
A laptop showing a web applicationConsole
A laptop running a web app. Illustrative photo.

B2B pricing done right

B2B pricing that lives in the record, not a chat.

For business buyers, a negotiated deal is a durable account price list, not a live haggle. An AccountPriceList reprices the catalog for one company every time its members shop the portal, and purchases above a member's authority route through a recorded approval - so the deal is on the record, not in someone's inbox.
  • Account price lists reprice the catalog per company
  • Members and roles decide who browses, requests and approves
  • Approvals are recorded, not verbal
A boutique retail store interiorB2B
A boutique retail interior. Illustrative photo.

Where it fits

Where Retail fits.

Retail is the retail system of record - marketplace and B2B on one audited core. The neighbours keep their real strengths: it does not out-configure a mature CPQ suite or out-scale a production marketplace. Its one claimed edge is the native, scoped, audited MCP surface for agents.

RetailCPQ / quote-to-cashMarketplace / storefront
What it isRetail commerce system of record - marketplace and B2BConfigure-price-quote for complex B2B salesStorefront and marketplace platform
Agent / MCP surfaceNative MCP tools - one scope, an idempotency key and an audit record per writeAPIs; agent access is earlyAPIs; agent access is early
Negotiated pricingDurable account price lists - not live bargainingDeep, mature deal config and quote-to-cashCatalog pricing, promotions, B2B add-ons
System of recordYes - owns the commerce record for people and agentsOwns the quote and deal recordOwns the store and order record
Maturity & scalePre-revenue, v0.0.1, one demo seedEnterprise install base, provenProduction-proven at scale

Honest peers, real strengths: Salesforce Revenue Cloud, SAP CPQ, Oracle CPQ and DealHub for negotiated quote-to-cash; Shopify, commercetools and Mirakl for marketplace and storefront scale. Retail trails on maturity and scale, which we say plainly - its bet is the agent-native record that incumbents are only beginning to add.

Under the hood

Two front doors, one audited core.

The story above is the plain version. For evaluators, here is how it actually holds together - a React frontend and a Spring Boot backend on Java 17 and PostgreSQL, where the MCP tool catalog is a facade over the exact commerce service the console calls.

The same operation, either door

A person marks an order in the console over REST; an agent calls the matching MCP tool. Both hit one service method, one status guard and one audit record. Every write carries a single rms:* scope and an idempotency key, so a retry is a no-op, not a double order.

Human console - REST/merchant/orders

An operator opens the offer and accepts it. The console issues an authenticated REST call to the same commerce service the agent tool wraps.

POST /api/merchant/offers/OFR-2048/accept
{ idempotencyKey: "a1f9-...-7c" }
Authorization: Bearer <ICE merchant token>

scope rms:order:write . idempotent . audited

agent -> rms :: mcp tool callStreamable HTTP /mcp
{
"method": "tools/call",
"name": "offer.accept",
"arguments": {
"offerId": "OFR-2048",
"idempotencyKey": "a1f9-...-7c"
}
}
// rms-api checks scope rms:order:write, then:
OFR-2048 SUBMITTED ACCEPTED
OrderBooking OB-5573 CREATED
AuditRecord: rms://audit/offer/OFR-2048

About 55 tools, one scope each

The tool catalog is served over the official Java MCP SDK on Streamable HTTP at /mcp. A ScopeGatedToolHandler binds each tool to exactly one rms:* scope, so an agent can only reach what its ICE-issued token grants. A representative slice:

MCP toolscope
  • merchant.createrms:merchant:write
  • catalog_import.ingestrms:catalog-item:write
  • quote_request.createrms:quote-request:write
  • offer.acceptrms:order:write
  • payment_authorization.recordrms:payment-authorization:write
  • fulfillment.updaterms:fulfillment:write
  • return.approverms:returns:write
  • account_price_list.createrms:account-pricing:write
  • replenishment.order.createrms:replenishment:write

+ returns, support, tax, promotions and more - rms://orders/{id} resources readable too

The Arin replenishment loop

RMS owns replenishment as the system of record - min, max, reorder point, safety stock. Arin is a pure MCP client with no database access to RMS: it reads the record, and writes an approved reorder back over the tool catalog, mirroring the Arin and SCM po.approve pattern.

arin -> rms :: replenishment loopclient: arin-rms-client
// Arin's loop reads the SoR
replenishment.stock.list
replenishment.demand.list
replenishment.parameters.get
// an approved tier-1 reorder is written back
replenishment.order.create → ReplenishmentOrder
// proven end to end by an external MCP client smoke test:
initialize → tools/list → scoped call → scope-denied → resources/read

Private - early access

One record for your store, ready for people and agents.

Retail is pre-revenue and private - no public sign-up. We are talking to a small number of merchants and teams who want an agent-ready commerce record with negotiated B2B pricing and full quote-to-fulfillment audit. Tell us about your commerce and we will walk you through both front doors.