Agentic commerce · Live on every storefront

AI agents can check price and stock. Now they can answer “will it fit?”

Every store running Rendered Fits automatically publishes structured fit data, a size recommender and its own MCP server — on the store's own domain. The fit-confidence layer for the shoppers of tomorrow, human or agent.

Read the agent docs Book a walkthrough

Live production endpoints
No merchant configuration
OpenAPI 3.1 contract

mcp session · recommend_sizelive

$ agent → POST https://api.renderedfits.com/api/v1/mcp

{ "method": "tools/call",

"params": { "name": "recommend_size",

"arguments": { "productId": "8619145036",

"heightCm": 173, "weightKg": 62, "fit": "regular" } } }

← 200 OK · 74 ms

{ "recommendedSize": "M",

"confidence": 0.92,

"fitNote": "True to size — tailored through the shoulder",

"predictionId": "pred_7f3a19c4",

"attribution": { "lineItemProperty": "_rf_pred" } }

# agent echoes _rf_pred at checkout — the sale is attributed,

# and kept/returned outcomes label the prediction.

Illustrative session — the live contract is served at /api/v1/openapi.json

The fit layer

Legible. Callable. Learning.

Three layers turn a try-on widget into infrastructure: fit data agents can read, tools they can call, and a feedback loop that makes both sharper.

LAYER 01

Legible

Every product carries an AI-generated fit profile — fit type, silhouette, size advice, confidence — published where agents and answer engines already look.

Public fit-profile metafield, readable via Shopify’s Storefront API
Schema.org JSON-LD per product, built for PDP embedding and answer engines
Catalogue-level fit feed for discovery, in JSON or CSV

renderedfits.fit_profilefit-jsonldfit feed

LAYER 02

Callable

Agents don’t read pages, they call tools. Every storefront is its own MCP server, backed by the same recommender the widget uses — plus a hosted REST API for partners.

MCP server on each merchant’s own domain — no central registry to depend on
Hosted MCP + REST at api.renderedfits.com, per-shop API keys
Public OpenAPI 3.1 contract for everything

tools/callrecommend_sizeget_fit_profile

LAYER 03

Learning

Every consultation banks a prediction; every kept-or-returned item labels it. The dataset of body, garment and outcome compounds with every order — agent-driven or human.

Deterministic outcome link — predictions echoed onto the cart line
Outcome ingestion for headless and off-Shopify platforms
Fit answers grounded in what shoppers actually kept

predictionId_rf_predkept / returned

Shipped, not roadmap

What’s live today

Production endpoints, running now. Hosted at api.renderedfits.com with per-shop API keys — and mirrored on every merchant's own domain with zero extra configuration.

api.renderedfits.com

POST/api/v1/mcp

Hosted MCP server — fit-profile, size-recommendation and fit-summary tools for any MCP-capable agent.

GET/api/v1/fit/{productId}

Per-product fit profile: fit type, size guidance and confidence per variant.

POST/api/v1/size-recommendation

Size recommendation for a shopper’s measurements against a specific product.

GET/api/v1/feed

Catalogue-level fit-data feed for a store — discovery, where fit endpoints are interrogation.

POST/api/v1/outcomes

Outcome ingestion — platforms report kept/returned results so the dataset learns from reality. Idempotent.

GET/api/v1/openapi.json

Public OpenAPI 3.1 specification for everything above.

On every merchant’s own domain

GET/apps/rendered-fits/fit/{productId}

Structured fit data with the attribution contract.

GET/apps/rendered-fits/fit-jsonld/{productId}

Schema.org JSON-LD, incl. SizeSpecification.

GET/apps/rendered-fits/agent-manifest

Capability discovery — fit.query, fit.sizing, fit.visual.tryon.

POST/apps/rendered-fits/mcp

The store’s own MCP server, on its own hostname.

Connect over MCP

One config block away.

Keys are issued per shop through the Rendered Fits app. Agent platforms and integration partners can request access by email — the same tools are also served on each merchant’s own domain, no key required for public fit data.

Request an API key

{
  "mcpServers": {
    "renderedfits": {
      "url": "https://api.renderedfits.com/api/v1/mcp",
      "headers": {
        "Authorization": "Bearer rfk_..."
      }
    }
  }
}

From question to kept order

The journey of one fit answer

What actually happens when an AI shopping agent asks whether a garment fits — and how that single question keeps paying the merchant back.

Discover

The agent finds the store’s capability manifest and catalogue fit feed on the store’s own domain.

GET /apps/rendered-fits/agent-manifest

Ask

It calls the size recommender over MCP with the shopper’s measurements and fit preference.

tools/call · recommend_size

Answer

Structured size, confidence and fit notes come back — with a predictionId attached.

"recommendedSize": "M" · 0.92

Attribute

The agent echoes the prediction onto the cart line at checkout, so the consultation is linked to the sale.

line item · _rf_pred

Learn

The item is kept or returned — and that outcome labels the prediction. Every order sharpens the next answer.

kept ✓ → dataset

Why this data is different

Grounded in what shoppers actually did

Most fit tools are statistical size-chart engines. The Rendered Fits signal is built from behaviour — and it's the only layer that can also show the human a photorealistic render for the final call.

Try-on sessions

Photorealistic renders of real shoppers in real garments — the visual half no size-chart engine has.

Purchase-moment recommendations

The size shown at the exact moment of decision, banked as a prediction — not a survey answer after the fact.

Kept-or-returned outcomes

Sales and refunds close the loop, turning each prediction into a labelled example of what actually fitted.

Questions agents ask

Frequently asked

Does Rendered Fits have an MCP server?

Yes. A hosted MCP server runs at api.renderedfits.com/api/v1/mcp, authenticated with a per-shop API key, exposing fit-profile, size-recommendation and fit-summary tools. The same tools are served on each merchant’s own domain via the Shopify app proxy.

Can AI shopping agents query fit data for a specific product?

Yes. Every store running Rendered Fits exposes agent-callable endpoints on its own domain: /apps/rendered-fits/fit/{productId} for structured fit data, /fit-jsonld/{productId} for Schema.org JSON-LD, and /agent-manifest for capability discovery.

What does a merchant have to configure?

Nothing. The agent surface ships with the Shopify app — fit profiles, the manifest, the JSON-LD endpoint and the storefront MCP server are live on the store’s domain the moment the app is installed.

How are agent-driven sales attributed?

Fit and size-recommendation responses return a predictionId and an attribution contract. The agent echoes the marker onto the cart line at checkout, which links the consultation to the order — and the eventual kept-or-returned outcome — in the merchant’s analytics.

Agent platforms & partners: [email protected]

Schedule a Meeting

Home Agent docs Legal Contact Us

© 2026 Rendered Fits Ltd · Company No. 16922551 · VAT No. 510026164
Registered office: 50-54 Oswald Road, Scunthorpe, North Lincolnshire, DN15 7PQ, United Kingdom · [email protected]