# MCP, agent tool calls and product feeds: the merchant’s guide to what to implement first

Shopify made catalogue, cart and checkout tool-calling free and automatic in August 2026. Here is what that changes about MCP, OpenAI tools and Google’s agent feed, what it deliberately does not give an agent, and a vendor-ready RFP template.

By Rohin Aggarwal · 2025-12-17 · (updated 2026-09-14)

The CTO had three vendor pitches open on his screen. Each used the term MCP a different way, each described agent tool calls a different way, and each priced the work very differently. The merchant question underneath all three pitches is the same: what should we actually implement first, and what can wait? This is the answer.

**TL;DR**

- **Updated September 2026.** If you are on Shopify Liquid, the cheapest surface is already done. Shopify switched **WebMCP** on across every Liquid storefront on 21 August 2026 (announced 5 August) with no app install and no configuration, exposing catalogue search, cart, checkout and policy lookup to an agent running in the shopper’s Chromium browser.
- What WebMCP hands an agent is a set of verbs. It does not hand it rights-cleared UGC, product-tagged reviews, or any signal for deciding a product is _trustworthy_ rather than merely _purchasable_. That gap is the work that is left.
- Three agent surfaces still matter in 2026: **Anthropic MCP** (Claude + downstream apps), **OpenAI tools** (ChatGPT Plus + the API), and **Google’s product agent feed** (Gemini + Shopping Graph).
- MCP gives you the deepest control, you publish a server, agents call your tools directly. It also takes the most engineering. Implement second.
- OpenAI tools (function-calling against your API) are the cheapest to land, wrap your existing feed endpoints with a public JSON schema and an OAuth flow. Implement first, unless Shopify Liquid already covers your read paths, in which case skip ahead to the evidence layer.
- Google’s agent feed is just an enriched product feed with schema.org annotations + price/inventory freshness SLA. If you already have a Merchant Center feed, you are 70% of the way there. Implement third.
- A vendor-ready RFP template at the bottom, copy-paste into your procurement system and tell whichever martech vendor you are evaluating to fill it in.
- **Updated again, mid-September 2026.** Anthropic open-sourced [Claude Commerce Agents](https://github.com/anthropics/commerce-agents) on 2 September, a free reference blueprint that shortens the MCP server build considerably. It does not close the evidence gap either; see the callout in the MCP section below.

- **< 200 ms** — Tool-call latency (Median budget agents will tolerate before they fall back to a competitor)
- **99.9%** — Feed availability SLA (What Google + Shopping Graph require from a publishing source)
- **15 min** — Inventory freshness (Max staleness before an agent loses confidence in your "in stock" claim)
- **6** — Required JSON-LD fields (sku, price, priceCurrency, availability, gtin, image, bare minimum)

_What your catalogue has to do to be agent-discoverable, three surfaces, three different bars._

## What changed in August 2026: Shopify shipped the first surface for you

This guide originally opened by telling you to wrap your read endpoints in an OpenAPI schema, because that was the cheapest way to let an agent search your catalogue. On Shopify Liquid, that advice is now partly obsolete, and it is worth being direct about which part.

Shopify announced WebMCP support for Liquid and Hydrogen storefronts on 5 August 2026, effective 21 August. It is live on every Liquid storefront with no app to install and no admin configuration, which means most Shopify merchants shipped an agent API without doing anything and without being told. An AI agent running inside the shopper’s Chromium browser can call the tools the page declares: catalogue search and browsing (search_catalog, browse_store, get_product, show_variant), cart work (get_cart, update_cart, cancel_cart), checkout and order handling (proceed_to_checkout, manage_orders), and policy lookup (search_shop_policies_and_faqs). Hydrogen support arrived as a developer preview rather than a default.

The mechanism is worth understanding because it shapes what you can and cannot verify. WebMCP tools are registered at runtime through a browser JavaScript API (navigator.modelContext under the Chrome 149 origin trial, document.modelContext from Chrome 150). There is no well-known URL and no global registry, so an agent has to be on the page to see the tools, and you cannot check a competitor’s implementation with a curl. Consumption is currently limited to Chromium under an origin trial, with Gemini in Chrome the main consumer today.

> **What this deletes from your backlog, and what it does not:** Deleted, if you are on Shopify Liquid: building and hosting your own read-path tool server so an agent can search the catalogue, look at a variant, or move something into a cart. That is now table stakes your platform pays for. Not deleted: everything an agent uses to decide _which_ product to put in that cart. WebMCP will happily tell an agent you sell four waterproof jackets. It has nothing to say about which one held up in the rain.

The competitive consequence follows immediately. When every Shopify store gets identical verbs on the same day, the verbs stop being a differentiator, in the same way that having a checkout stopped being one. What separates two catalogues in front of the same agent is the evidence attached to the products: complete structured data, attributable reviews with real ratings and dates, and rights-cleared, product-tagged customer photos and video the engine can quote. Idukki’s llms.txt and MCP output exist to supply exactly that layer, on top of whatever agent-callable commerce layer your platform hands you. The two are complements, not alternatives.

If you want to know whether a given storefront is exposing agent tooling today, our free [AI Visibility Check](/tools/ai-visibility-check) now grades that alongside schema, crawl access and llms.txt, with an explicit caveat about what a server-side fetch can and cannot confirm.

## The three surfaces that matter in 2026

You will hear "[the AI agents are coming for your storefront](/blog/what-is-agentic-commerce-for-merchants)" a lot this year. Strip the noise out and there are three concrete things you can implement, with three different cost/value profiles. Pick the order based on your engineering bandwidth, not on which one trended last week.

### Three agent surfaces side-by-side
_What each surface needs from your catalogue, what it gives you back, and where it tends to break._

**01 · Surface: OpenAI tools (function-calling)**
Your existing product API, wrapped with an OpenAPI schema. ChatGPT (and the API) calls it when a shopper asks.
~1 sprint — to wire up
- ✓ Lowest engineering cost to ship
- ✓ Reuses your existing public API
- ✓ Tool catalogue editable per assistant
- ✓ OAuth flow keeps you in control of auth
- ✗ Tool-call latency is unforgiving (≤ 200 ms median)
- ✗ Schema versioning, break it and the agent silently degrades
- ✗ OpenAI rate-limits, not yours, govern peak

**02 · Surface: Anthropic MCP server**
You publish an MCP server; Claude and any MCP-compatible client (Claude Code, Claude.ai, downstream apps) discover + call your tools.
4–6 weeks — to ship
- ✓ Deeper integration: tool list + prompts + resources
- ✓ Works across many client surfaces, not just one
- ✓ Stateful, you can expose a search session
- ✓ Self-documenting via the MCP manifest
- ✗ Newer protocol, fewer reference implementations
- ✗ Auth story is still maturing (OAuth, API keys, both)
- ✗ Engineering cost is real, usually 4–6 weeks first time

**03 · Surface: Google product agent feed**
An enriched Merchant Center feed + schema.org markup that Gemini and Shopping Graph use to recommend your products.
1–2 weeks — if Merchant Center is set up
- ✓ Reuses your Merchant Center setup
- ✓ No new endpoint to maintain
- ✓ Picked up by Gemini + Search Shopping cards
- ✓ Validation tooling already exists (Rich Results Test)
- ✗ 99.9% feed uptime SLA, your CDN had better be solid
- ✗ Inventory freshness ≤ 15 min or you get suppressed
- ✗ Less control over which products get surfaced

**Takeaway:** A merchant with 6 engineers and 12 months of agent budget should ship in the order: **OpenAI tools → MCP server → Google agent feed**. Cheap wins first, deep integration second, distribution layer third. Doing it the other way around (MCP first) is the most common mistake, you spend a quarter building a deep integration that nobody uses yet, then run out of budget for the easy wins.

**The September 2026 amendment to that order:** On Shopify Liquid, the in-browser read paths are already covered by WebMCP, so the first slot in that sequence is smaller than it was. Spend the reclaimed sprint on the evidence layer instead: complete Product and AggregateRating schema, attributable reviews, product-tagged UGC with consent records, and an llms.txt index an engine can read outside the browser session. WebMCP only fires when an agent is on your page in a Chromium tab. The engines answering a shopper who never visits your site are reading something else entirely, and that something else is still yours to publish.

## What each surface actually requires from your catalogue

### OpenAI tools, the function-calling shape

OpenAI tools are JSON-schema function definitions. You write the schema; OpenAI calls your function when the model needs it. The functions you typically expose for commerce: search_products, get_product_details, check_inventory, get_pricing, optionally add_to_cart if you trust the agent to write. Authentication is OAuth 2.0 with PKCE; the user authorises the assistant once and your token lasts the session.

Latency is the killer. The OpenAI orchestrator times out at the platform level; your tool call has to round-trip in under 200 ms median for the assistant to stay coherent. Cache the read paths aggressively (your existing CDN is fine). For write paths (cart, checkout), be conservative, return the optimistic state quickly and let your backend resolve async.

### Anthropic MCP, the server you publish

MCP is a protocol, not a single product. You implement a server that exposes three things: **tools** (callable functions, similar to OpenAI tools but with richer metadata), **resources** (read-only references the model can fetch, e.g., a product catalogue index), and **prompts** (parametrised prompt templates the host app can compose into the user prompt). Claude and any MCP-compatible client discover your server, list its tools, and call them.

The win MCP gives you over OpenAI tools: state. You can expose a search session where the agent narrows down via successive calls; the server holds the search state. That lets Claude do things like "show me what you have in sage linen, size M, under £100, sorted by reviews" without re-listing the full catalogue on every call. It is much closer to how a human shops.

> **Update, September 2026: Anthropic open-sourced a reference build:** On 2 September 2026 Anthropic released [Claude Commerce Agents](https://github.com/anthropics/commerce-agents), a free, Apache-2.0 blueprint with working shopping-agent and merchant-agent examples across retail, travel, telecom and entertainment, plus a Claude Code plugin to scaffold from it. It shortens the "4–6 weeks to ship" estimate above considerably for a team willing to build on someone else's reference rather than the bare spec. It still does not solve the evidence gap: the blueprint's shopping agent can search, compare and cart, and has nothing to say about which product deserves the sale. Full writeup: [Anthropic just open-sourced shopping and merchant agents](/blog/anthropic-claude-commerce-agents-open-source-blueprint).

### Google agent feed, the enriched product feed

This one is structurally simple but operationally demanding. Take your Merchant Center feed and enrich every product with the [schema.org Product markup](/blog/schema-org-ecommerce-agentic-era-14-schemas-ranked) that Google requires for the Shopping Graph: sku, gtin, price, priceCurrency, availability, image, aggregateRating, review (if you have them), shippingDetails, hasMerchantReturnPolicy. Validate with the Rich Results Test on three representative SKUs.

Where it breaks: inventory freshness. Google suppresses products whose availability field is stale (≥ 15 minutes behind your actual stock). If your inventory pipeline runs nightly, you have to fix that before you turn the agent feed on, or every "buy" intent will be suppressed by Gemini and pushed to a competitor whose feed is fresh.

> The MCP server is the deepest integration, but the feed is the one that earns distribution. Build both. Sequence them by how much engineering bandwidth you actually have, not by which one trended last week.
> — Rohin Aggarwal · Idukki

**Anatomy of a single MCP tool call from agent to checkout**
1. **1. Agent intent** — Shopper prompt triggers the agent to invoke search_products or get_product. The tool descriptor must match the prompt language exactly. (p50 ~80ms)
2. **2. Auth + retrieve** — MCP server validates the API key or OAuth token, runs the catalogue query, hydrates pricing and inventory. (p50 ~300ms)
3. **3. Shape response** — Return JSON shaped as product + offer + rating. Field order matters: agents truncate after ~3KB on large catalogues. (p50 ~120ms)
4. **4. Cite + convert** — Agent renders the shortlist with your URL, hands off to deep-link checkout. Conversion attribution flows back via referrer + UTM. (session id token)
_Each stage logs its own latency budget. Brands that exceed ~1.2s end-to-end drop out of the agent's shortlist in roughly 1 in 4 sessions._

## A 90-day implementation sequence

1. **Week 1–2 · OpenAI tools, or the evidence layer if you are on Shopify Liquid.** On a non-Shopify stack: wrap your existing search, get_product, get_inventory endpoints in OpenAPI schemas, add OAuth, ship to a private test plugin, and test with five real shopper prompts before exposing to anyone. On Shopify Liquid, WebMCP already covers those read paths in-browser, so spend the fortnight on schema completeness and llms.txt instead and pick the OpenAI work back up when you need the out-of-browser surface.
2. **Week 3–4 · Google agent feed.** Audit your Merchant Center feed against schema.org Product spec. Fix the missing fields. Get inventory freshness under 15 min. Run the Rich Results Test on 20 SKUs.
3. **Week 5–8 · MCP server prototype.** Stand up the minimal MCP server: list_products, get_product, search_products tools. No write paths. No state yet. Test locally with Claude Code; iterate on the JSON-LD shape.
4. **Week 9–10 · MCP server, productionised.** Add auth (API key first, OAuth later). Add stateful search (session id token in tool args). Add observability, every tool call should land in your existing API logs alongside human API calls.
5. **Week 11–12 · Cross-surface observability + the RFP.** One dashboard that shows tool-call volume by surface (OpenAI / MCP / Google), conversion attributable to each, and the top failing prompts. Bring the RFP template (below) to your next martech vendor review.

## The "MCP-ready vendor" RFP template

Copy this verbatim into your procurement system. Make every shortlisted vendor fill it in before they get to a demo. You will eliminate half the field in the first round.

```markdown
# MCP / Agent Surface. Vendor RFP

## 1. Agent surface support
- [ ] Do you publish an MCP server today? (Y/N + URL of public manifest)
- [ ] Do you support OpenAI function-calling against your API? (Y/N + link to OpenAPI schema)
- [ ] Do you expose a Google-compatible Product agent feed? (Y/N + sample URL)

## 2. Latency + freshness
- [ ] What is your median tool-call latency, measured from edge?
- [ ] What is your p95 tool-call latency?
- [ ] What is the staleness budget on your "availability" + "price" fields?

## 3. Auth + tenancy
- [ ] How does the agent authenticate against your tools? (OAuth 2.0 / API key / both)
- [ ] How do you handle per-shopper auth scope?
- [ ] Can a single agent access multiple of our stores in one session?

## 4. Observability
- [ ] Do you provide a tool-call audit log per merchant? (Y/N + access mechanism)
- [ ] Do you surface "model called X tool, got Y answer, shopper converted Z"?
- [ ] Can we route tool-call logs to our SIEM in real time?

## 5. Trust + safety
- [ ] How do you prevent prompt-injection through <a href="/glossary/ugc">user-generated content</a>?
- [ ] How do you handle rights-cleared review media exposed to agents?
- [ ] Do you have a redaction pathway for content the brand later un-cleared?

## 6. Pricing model
- [ ] Is pricing per tool-call, per impression, per merchant, or flat?
- [ ] What is the cost cliff at 10x our current traffic?
- [ ] Is the agent-surface line item separable from the rest of the contract?
```

## What we got wrong in our first MCP build

- **We shipped tools before resources.** Tools are obvious; resources are less so. A static catalogue resource the agent can read on session start gave us a 40% drop in pointless list_products calls. Ship resources second-to-first.
- **We made the search tool too clever.** The first version had 14 optional parameters. The agent used three. Trim ruthlessly, every parameter is one more thing for the model to get wrong.
- **We forgot prompts.** MCP prompt templates parametrised by industry / persona / season pre-empt 60% of the disambiguation rounds an agent does on its own. Cheap, under-used.
- **We treated the tool calls as one-shot.** A real shopper agent calls four to six tools before it decides anything. Hold a session id; charge once.

## Your action list, this week

1. Audit your existing public API for OpenAI tool-call readiness. Anything that takes > 200 ms median is on the critical path.
2. Pull your Merchant Center feed. Run three SKUs through the Rich Results Test. Note every red flag.
3. Read Anthropic’s MCP spec end-to-end (yes, the whole thing). 90 minutes; saves you a quarter of guessing.
4. Pick the order that matches your bandwidth: 6+ engineers → all three in 90 days; 2–3 engineers → OpenAI tools + Google feed this quarter, MCP next quarter.
5. Send the RFP template above to every martech vendor in your funnel. Watch the field thin out.

### References + reading
- [Shopify, WebMCP support for Liquid and Hydrogen storefronts](https://shopify.dev/changelog/webmcp-liquid-hydrogen) — Primary source. Announced 5 Aug 2026, effective 21 Aug 2026, no merchant setup required.
- [Shopify, WebMCP tools reference](https://shopify.dev/docs/api/web-mcp) — The tool list: catalogue, cart, checkout, orders and policy search.
- [Chrome, WebMCP tool security](https://developer.chrome.com/docs/ai/webmcp/secure-tools) — Browser-side model: runtime registration, origin trial, no global tool registry.
- [Anthropic, Model Context Protocol spec](https://modelcontextprotocol.io/) — Canonical spec for tools, resources, prompts, transports.
- [Anthropic, MCP server quickstart](https://modelcontextprotocol.io/quickstart) — Reference TypeScript + Python servers.
- [OpenAI, Function calling guide](https://platform.openai.com/docs/guides/function-calling) — JSON schema definitions + worked examples.
- [OpenAI, Custom GPT tools + actions](https://platform.openai.com/docs/actions) — OAuth + OpenAPI patterns for ChatGPT plugins / actions.
- [Google, Shopping Graph + product structured data](https://developers.google.com/search/docs/appearance/structured-data/product) — Required + recommended schema.org Product fields.
- [Google, Merchant Center feed specifications](https://support.google.com/merchants/answer/7052112) — Field list, refresh cadence, validation tooling.
- [Schema.org Product type](https://schema.org/Product) — Source of truth for the JSON-LD shape every surface reads.
- [Idukki Agentic Commerce Stack: reference architecture](/blog/the-agentic-commerce-stack-reference-architecture) — How these three surfaces fit into the broader agent stack.
- [Idukki: review and UGC apps with MCP servers](/blog/review-and-ugc-apps-with-mcp-servers) — Idukki, Okendo, Tolstoy and EmbedSocial MCP servers compared.
- [Anthropic, commerce-agents (GitHub repository)](https://github.com/anthropics/commerce-agents) — Open-source shopping + merchant agent blueprint, released 2 Sep 2026.
- [Idukki, Anthropic just open-sourced shopping and merchant agents](/blog/anthropic-claude-commerce-agents-open-source-blueprint) — Full writeup: what the blueprint gives you and what it still does not.

---
Canonical: https://idukki.io/blog/mcp-tool-calls-product-feeds-the-merchants-guide
Tags: mcp, agentic-commerce, engineering, rfp, product-feed