Agent Readiness Strategy

Arlem’s plan for AI agent discoverability, agentic commerce, and generative engine optimisation.

Last updated: February 2026

1. Current State Assessment

What’s in Place After Phase 1

This gives Arlem a solid foundation. AI agents crawling the site can find structured product data via llms.txt, understand products through JSON-LD, and access all public pages via sitemap.

Gap Analysis

2. WebMCP Evaluation

What WebMCP Is

WebMCP is a W3C proposed standard that shipped in Chrome 146 (February 2026) as an early preview behind the chrome://flags “WebMCP for testing” flag. Co-developed by Google and Microsoft engineers through the W3C Web Machine Learning community group, it adds a navigator.modelContext API to browsers. This lets websites register structured tools that AI agents can discover and call directly, rather than scraping the DOM or simulating clicks.

It claims 89% token efficiency improvement over screenshot-based agent methods.

Two APIs

Which Fits Arlem

Declarative first. Arlem’s site has well-structured forms (email capture, product variant selection) and product metadata that maps cleanly to declarative attributes. The imperative API is overkill for the current product range.

Concrete Implementation Plan (When Ready)

Declarative tools to expose:

<!-- Product metadata declaration -->
<meta name="model-context" content="site-info"
  data-tool-name="get_product_info"
  data-tool-description="Get Arlem bedhead cushion product details including pricing, materials, sizes, and availability">

<!-- Email capture form -->
<form data-tool-name="subscribe_email"
      data-tool-description="Subscribe to Arlem newsletter for bedroom styling tips and new product launches">
  <input name="email" type="email" data-tool-param-description="Customer email address" required>
  <button type="submit">Subscribe</button>
</form>

<!-- Product variant selection -->
<form data-tool-name="select_product_variant"
      data-tool-description="Select a bedhead cushion by size and cover material">
  <select name="size" data-tool-param-description="Bed size: King, Queen, or Double">
    <option value="king">King</option>
    <option value="queen">Queen</option>
    <option value="double">Double</option>
  </select>
  <select name="material" data-tool-param-description="Cover material: Linen or Boucle">
    <option value="linen">Linen</option>
    <option value="boucle">Boucle</option>
  </select>
</form>

Imperative tools (later, if needed):

// Only if declarative proves insufficient
navigator.modelContext.addTool({
  name: 'search_products',
  description: 'Search Arlem bedhead cushions by size, material, colour, and price range',
  parameters: {
    type: 'object',
    properties: {
      size: { type: 'string', enum: ['king', 'queen', 'double'] },
      material: { type: 'string', enum: ['linen', 'boucle'] },
      colour: { type: 'string' },
      maxPrice: { type: 'number' }
    }
  },
  handler: async (params) => {
    const results = await fetch(`/api/products?${new URLSearchParams(params)}`);
    return results.json();
  }
});

Recommendation

Monitor, don’t implement. WebMCP is behind a Chrome flag in Canary. No Safari or Firefox support. No stable release date announced. When Chrome ships it to stable and at least one major retailer adopts it, Arlem should implement the declarative API. That’s a one-day job given the simple product catalogue.

3. Agentic Commerce Protocols

Two competing protocols are shaping how AI agents complete purchases.

Stripe ACP (Agentic Commerce Protocol)

Google UCP (Universal Commerce Protocol)

Key Difference

ACP focuses on standardising checkout and payment flows. UCP is broader, covering the full commerce journey from discovery through to order management. ACP powers OpenAI’s ecosystem. UCP powers Google’s ecosystem. Both are open standards, and merchants may end up supporting both.

Shopify’s Path (and What It Means for Arlem)

Shopify has already acted. As of the Winter '26 Edition:

• Agentic Storefronts are live in Shopify Admin under Settings > Sales channels
• Merchants can toggle individual AI platforms on/off (ChatGPT, Google AI Mode/Gemini, Microsoft Copilot)
• Active by default for all Shopify merchants
• UCP is the underlying protocol for Google surfaces
• ACP powers the ChatGPT integration

This is the critical insight: Arlem does not need to build custom ACP or UCP integrations. Shopify handles the protocol layer. Arlem’s job is to ensure product data is clean, complete, and well-structured in Shopify Admin so it translates correctly through these protocols.

What Arlem Should Do Now

1. Check Agentic Storefronts settings in Shopify Admin. Verify all desired AI platforms are toggled on.
2. Audit product data in Shopify: titles, descriptions, variant names, images, metafields. This is what agents will surface to customers.
3. Do not build custom protocol integrations. Shopify is the abstraction layer.
4. Monitor Shopify changelog for new AI platform integrations as they roll out.

4. Public Product API (Phase 2 Spec)

A lightweight, public JSON endpoint that agent frameworks and third-party tools can query directly.

Endpoint

GET /api/products

No authentication required. Intended for AI agent consumption alongside llms.txt.

Response Format

{
  "brand": "Arlem",
  "currency": "AUD",
  "updated_at": "2026-02-16T10:00:00Z",
  "products": [
    {
      "name": "Linen Bedhead Cushion - Natural",
      "handle": "linen-bedhead-cushion-natural",
      "url": "https://arlem.com.au/products/linen-bedhead-cushion-natural",
      "description": "Premium European linen bedhead cushion. Replaces a traditional headboard with a single cushion that leans against the wall.",
      "category": "Bedhead Cushion",
      "material": "100% Oeko-Tex Certified European Linen",
      "country_of_origin": "AU",
      "style_options": ["French Seam", "Relaxed Fit"],
      "variants": [
        {
          "size": "King",
          "fits_bed": "183 x 203cm",
          "dimensions": "183cm x 65cm",
          "price": 399.00,
          "available": true
        },
        {
          "size": "Queen",
          "fits_bed": "153 x 203cm",
          "dimensions": "153cm x 65cm",
          "price": 389.00,
          "available": true
        },
        {
          "size": "Double",
          "fits_bed": "138 x 188cm",
          "dimensions": "138cm x 65cm",
          "price": 379.00,
          "available": true
        }
      ],
      "images": [
        {
          "url": "https://cdn.shopify.com/...",
          "alt": "Linen bedhead cushion in Natural on a queen bed"
        }
      ]
    }
  ]
}

OpenAPI 3.1 Spec Outline

openapi: 3.1.0
info:
  title: Arlem Product API
  version: 1.0.0
  description: Public product data for Arlem bedhead cushions. No authentication required.
paths:
  /api/products:
    get:
      summary: List all products
      description: Returns all Arlem products with variants, pricing, availability, and material details.
      responses:
        '200':
          description: Product catalogue
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ProductCatalogue'
      parameters:
        - name: material
          in: query
          schema:
            type: string
            enum: [linen, boucle]
          description: Filter by cover material
        - name: size
          in: query
          schema:
            type: string
            enum: [king, queen, double]
          description: Filter by bed size
components:
  schemas:
    ProductCatalogue:
      type: object
      properties:
        brand:
          type: string
        currency:
          type: string
        updated_at:
          type: string
          format: date-time
        products:
          type: array
          items:
            $ref: '#/components/schemas/Product'
    Product:
      type: object
      properties:
        name:
          type: string
        handle:
          type: string
        url:
          type: string
          format: uri
        description:
          type: string
        category:
          type: string
        material:
          type: string
        country_of_origin:
          type: string
        variants:
          type: array
          items:
            $ref: '#/components/schemas/Variant'
    Variant:
      type: object
      properties:
        size:
          type: string
        fits_bed:
          type: string
        dimensions:
          type: string
        price:
          type: number
        available:
          type: boolean

Implementation

• Next.js route handler at web/src/app/api/products/route.ts
• Pulls from Shopify Storefront API (same pattern as llms.txt)
• Cache: revalidate = 3600 (1 hour) with on-demand revalidation via Shopify product webhook
• Response headers: Cache-Control: public, s-maxage=3600, stale-while-revalidate=86400

robots.txt Update

Add to the existing robots.txt to explicitly allow AI bot access to the API:

# AI agent product API
Allow: /api/products

Discoverability

Reference the API from llms.txt:

## Product API
GET https://arlem.com.au/api/products - JSON product catalogue with pricing, variants, and availability
OpenAPI spec: https://arlem.com.au/api/products/openapi.json

5. Generative Engine Optimisation (GEO)

How AI Agents Discover and Recommend Products

AI agents surface products through three mechanisms:

1. Indexed content citation. The agent’s training data or retrieval system includes crawled web pages. Well-structured product pages with clear descriptions get cited in responses.
2. Structured data matching. JSON-LD, llms.txt, and API responses give agents machine-readable product attributes to match against user queries.
3. Agentic commerce protocols. UCP/ACP let agents query live catalogues during conversation (Shopify handles this for Arlem).

What Attributes Matter for Matching

When a user asks an AI agent “what’s a good alternative to a headboard in Australia?”, the agent needs to match on:

The Category Creation Challenge

“Bedhead cushion” is not an established product category. Traditional headboards, bed frames with built-in headboards, and decorative pillows are what agents know about. If someone asks “what should I put behind my bed?”, an agent might not know bedhead cushions exist.

How llms.txt solves this: The file explicitly describes the product category and its relationship to traditional alternatives:

Arlem bedhead cushions are a modern alternative to traditional headboards. A single cushion leans against the wall behind your bed, replacing the need for a mounted headboard or bed frame with built-in headboard.

This context gets ingested by crawling agents and becomes part of how they understand the category.

Content Strategy for GEO

Current content gaps and what to create:

Each piece of content should include:

• Clear, factual statements that agents can cite directly (not marketing fluff)
• Explicit mention of “bedhead cushion” alongside “headboard alternative” for category association
• Specific numbers: dimensions, prices, materials
• Structured data (FAQ schema, HowTo schema where appropriate)

Measuring GEO Performance

6. Monitoring and Triggers

WebMCP Implementation Triggers

Current status: Chrome 146 Canary behind flag. Not in stable. No cross-browser support. Do not implement yet.

Agentic Commerce Triggers

Current status: Shopify Agentic Storefronts are live. Arlem should verify settings are enabled and product data is clean. No custom protocol work needed.

What to Watch

Review Cadence

Quarterly review of this strategy document. Each review should cover:

1. Has WebMCP moved to Chrome stable?
2. Has Shopify added new agentic platform integrations?
3. What AI bot traffic are we seeing in server logs?
4. Are we being cited correctly in AI agent responses for target queries?
5. Are there new protocols or standards we should track?

7. Roadmap

Now: Phase 1 (February 2026) – Complete

• Dynamic /llms.txt route with product data from Shopify
• /.well-known/llms.txt redirect
• Enhanced JSON-LD with material, countryOfOrigin, additionalProperty
• Deleted obsolete ai-info.json
• AI bot access rules in robots.txt
• Sitemap coverage

Q2 2026: Phase 2

• Build GET /api/products public endpoint
• Publish OpenAPI 3.1 spec at /api/products/openapi.json
• Reference API in llms.txt
• Update robots.txt to allow /api/products
• Verify Shopify Agentic Storefronts settings are enabled
• Audit Shopify product data quality (titles, descriptions, images, metafields)
• Set up AI bot traffic monitoring in analytics
• Publish “Bedhead cushion vs headboard” guide (GEO content)
• Publish material explainer page (linen vs boucle)

H2 2026: Phase 3

• WebMCP declarative implementation (if Chrome ships to stable)
• Expand GEO content (styling guides, FAQ pages with structured data)
• Baseline AI brand mention tracking across ChatGPT, Perplexity, Gemini
• Review Shopify Agentic Storefronts performance data (if Shopify provides merchant analytics)
• First quarterly strategy review

2027 and Beyond

• WebMCP imperative API (if product range expands and warrants it)
• Respond to new agentic commerce protocols as Shopify adopts them
• Evaluate whether a custom product recommendation agent adds value (e.g. “which size and material for my bed?”)
• Review whether a standalone MCP server for Arlem product data serves any agent ecosystem need

Summary of Decisions