Phase 4 · Agentic & Advanced · L3 → L4

Make your site transactable
by autonomous agents.

The next wave of AI commerce is agent-initiated. WebMCP annotations, tool manifests, and machine-payment signaling make your catalogue discoverable and actionable before your competitors are aware these standards exist.

L3 → L4AdvancedEarly-moverDeveloper required

·

Why this matters

TL;DR

Agentic commerce lets AI buy on behalf of users. WebMCP annotations and tool manifests make your forms agent-invocable; x402 and BuyAction schema are the emerging payment rails. Adoption is low now — early movers gain catalogue positioning before these standards reach mainstream tooling.

The next wave of AI commerce is agent-initiated: AI systems browse, compare, and buy on behalf of users. Phase 4 makes your catalogue discoverable and actionable by these agents before your competitors are even aware of the standards.

0 of 118

domains audited by Hidden Layer have deployed any agent-specific endpoint. The gap is real — and open.

Phase 4 steps

These are early-adopter moves. All items are P2 — the standard is emerging, not required. Implement in order: forms → manifest → schema → monitoring.

P2

Annotate HTML forms with WebMCP toolname + tooldescription

Make your existing forms agent-discoverable without JavaScript. Each annotated form is a tool an agent can invoke on your behalf — search, add-to-cart, contact. Hidden Layer audits of 118 domains found 0 sites with any WebMCP annotations. First-mover advantage is real and measurable.

Impact
High
Effort
Low
Time
2–4 hours
Owner
Developer
What the data says
How to
  1. Identify your 2–3 highest-value forms: product search, add-to-cart, contact/lead form. These are the forms agents would most want to invoke.
  2. Add data-toolname and data-tooldescription attributes to each form. Write the description as if briefing an assistant — what the form does, what inputs it accepts, what it returns.
    HTML
    <!-- Product search form — agent-annotated -->
<form
  action="/search"
  method="GET"
  data-toolname="product-search"
  data-tooldescription="Search the YourBrand product catalog by name, category, or keyword. Returns a list of matching products with prices and availability."
>
  <label for="q">Search products</label>
  <input id="q" name="q" type="search" placeholder="e.g. running shoes size 42" />
  <button type="submit">Search</button>
</form>

<!-- Add to cart form — agent-annotated -->
<form
  action="/cart/add"
  method="POST"
  data-toolname="add-to-cart"
  data-tooldescription="Add a specific product SKU to the shopping cart. Requires sku parameter. Returns cart summary with total items and price."
>
  <input type="hidden" name="sku" value="RX1-BLK-42" />
  <button type="submit">Add to cart</button>
</form>
  3. Write tooldescription values as if briefing a new assistant: what does the form do, what inputs does it accept, what does it return? Agent models parse these descriptions to decide which tool to invoke.
  4. No backend changes required — these are HTML attributes. The annotation is purely declarative. Start with your highest-value form and expand from there.
Agent integration frontier →
P2Quick win

Publish /.well-known/webmcp tool manifest

The WebMCP discovery endpoint. Browser agents check this path to discover your available tools before probing the DOM. Publishing it makes your site machine-readable at the protocol level — agents know what you offer without crawling every page.

Impact
High
Effort
Low
Time
1–2 hours
Owner
Developer
How to
  1. Create a JSON file served at /.well-known/webmcp. It must be accessible without authentication and return Content-Type: application/json.
  2. Populate the manifest with your tool definitions. Mirror the forms you annotated in the previous step.
    JSON
    {
  "version": "1.0",
  "name": "YourBrand",
  "description": "YourBrand product catalog and commerce tools.",
  "tools": [
    {
      "name": "product-search",
      "description": "Search the YourBrand product catalog by name, category, or keyword.",
      "form": "/search",
      "method": "GET",
      "parameters": [
        {
          "name": "q",
          "type": "string",
          "description": "Search query — product name, category, or keyword",
          "required": true
        }
      ]
    },
    {
      "name": "add-to-cart",
      "description": "Add a product to the shopping cart by SKU.",
      "form": "/cart/add",
      "method": "POST",
      "parameters": [
        {
          "name": "sku",
          "type": "string",
          "description": "Product SKU identifier",
          "required": true
        }
      ]
    }
  ]
}
  3. Add a Link header on your homepage: <link rel="manifest" type="application/webmcp+json" href="/.well-known/webmcp" /> — some agent implementations look for this before checking the well-known path.
  4. Validate: curl -I https://yourdomain.com/.well-known/webmcp — should return 200 with Content-Type: application/json.
Agent integration frontier →
P2

Evaluate x402 / BuyAction schema for transactable products

x402 and BuyAction schema are the emerging rails for agent-initiated purchases. Low adoption now — early movers gain catalogue positioning before mainstream tooling arrives. Even partial adoption (BuyAction schema on product pages) signals agent-readiness to AI systems evaluating your catalogue.

Impact
High
Effort
High
Time
1–4 weeks
Owner
Developer / Product
What the data says
How to
  1. Step 1 — BuyAction schema (lower effort, do first): Add BuyAction JSON-LD to product pages to signal that the product is purchasable.
    JSON
    {
  "@context": "https://schema.org",
  "@type": "BuyAction",
  "object": {
    "@type": "Product",
    "name": "Runner X1 Sneaker",
    "sku": "RX1-BLK-42"
  },
  "target": {
    "@type": "EntryPoint",
    "urlTemplate": "https://yourdomain.com/cart/add?sku=RX1-BLK-42",
    "actionAccessibilityRequirement": {
      "@type": "ActionAccessSpecification",
      "requiresSubscription": false
    }
  },
  "price": "129.00",
  "priceCurrency": "USD"
}
  2. Step 2 — x402 (higher effort, evaluate readiness): x402 is an HTTP payment protocol (402 Payment Required + machine-readable payment headers) that enables agent-to-merchant micropayments without human checkout. Evaluate if your product catalog fits this model — it is most applicable to digital goods and API-priced services.
  3. Step 3 — Assessment: If you sell physical goods, start with BuyAction schema. If you sell digital goods or APIs, prototype an x402 endpoint on one product and measure agent interaction rate.
Agent integration frontier →
P2

Monitor agent tool completion rate and description clarity quarterly

Agent models improve over time. A tool description or form annotation that worked 6 months ago may now be ambiguous — newer models parse descriptions differently and have higher expectations for specificity. Quarterly review keeps your tool surface current.

Impact
Medium
Effort
Low
Time
1 hour per quarter
Owner
Dev / Analytics
How to
  1. Test your annotated forms quarterly by simulating agent behavior: describe the task to GPT-4 or Claude ("I want to search YourBrand for running shoes size 42") and observe whether it correctly identifies and invokes your search form.
  2. Check server logs for agent user-agents (common patterns: "GPT", "Claude", "Perplexity", "agent", "bot") attempting to use your forms. Unexpected 400/422 errors indicate parameter schema mismatches.
  3. Review tooldescription clarity: are the parameter names self-explanatory? Does the description explain what is returned? Add examples if descriptions are ambiguous.
  4. Track in your quarterly GEO review alongside cold recall and AI referral traffic (Phase 3). Phase 4 metrics are early-stage — even 1–2 agent interactions per week is a signal worth tracking.

What AI actually sees

This is what an agent browsing on behalf of a buyer encounters when it checks for machine-readable tool endpoints. An agent-ready competitor is invocable immediately; a site with no manifest requires brittle DOM scraping or is skipped entirely.

AI-generated answersimulated

When searching for enterprise software with API access, AI agents can directly query vendors with /.well-known/webmcp manifests — their available tools are machine-readable at the protocol level. Acme Corp's catalog is discoverable and invocable without human intervention.

YourBrand has no agent-readable endpoints. [/.well-known/webmcp returns 404 — no tools discoverable] An agent browsing on behalf of a buyer cannot programmatically search or interact with your catalog without manually parsing your DOM.

Signal analysis
  1. PASS
    Agent-readyCompetitor has webmcp manifest and annotated forms — browser agents can discover and invoke tools without scraping.
  2. THIN
    No discoveryYour site has no agent-readable endpoints. Agents fall back to DOM scraping — unreliable and fragile.
  3. BLOCKED
    404 manifestThe /.well-known/webmcp endpoint returns 404. Agent auto-discovery fails at the first check.
Simulated agent discovery — illustrates the gap between a site with a WebMCP manifest and one returning 404

Key takeaways

After completing Phase 4, you should have:
  • At least one key form (search, add-to-cart, contact) is annotated with WebMCP toolname and tooldescription.
  • /.well-known/webmcp tool manifest is published and lists your available agent tools.
  • x402 and BuyAction schema have been evaluated for transactable product pages.
  • Agent tool completion rate is scheduled for quarterly review.
← Phase 3 — Content & CitationGlossary →