owlchart.com

Your robots.txt currently disallows GPTBot, ClaudeBot, Meta-ExternalAgent, Google-Extended, and Bytespider for https://owlchart.com/.

GPTBot, ClaudeBot, Meta-ExternalAgent, Google-Extended, and Bytespider are training or indexing crawlers. You can keep them out if you prefer, but note the score counts every named agent, and the indexes these crawlers build are what shopping agents search first.

Add an allow group for the agents you want in (an explicit Allow: / wins over a broader Disallow):

User-agent: GPTBot
User-agent: ClaudeBot
User-agent: Meta-ExternalAgent
User-agent: Google-Extended
User-agent: Bytespider
Allow: /

Make sure no path rule such as Disallow: /products/ or Disallow: /*? applies to product URLs for these agents, and keep the Sitemap: line.

Edit the robots.txt served from your web root (or the CDN/edge rule that generates it) and redeploy. Crawlers cache robots.txt for up to 24 hours, so re-scan after a day.

Nothing usable was found at /.well-known/http-message-signatures-directory (HTTP 404). Web Bot Auth is the IETF draft that lets agents sign requests with HTTP Message Signatures; parties that sign publish their Ed25519 public keys in this directory, and verifiers fetch it to check the Signature and Signature-Input headers. Visa's Trusted Agent Protocol, Mastercard's Agent Pay, and Cloudflare's signed-agent verification are all built on it.

Two steps matter for a storefront:

• Verify signatures at your edge so signed agents are let through bot management instead of challenged. On Cloudflare this is the Verified Bots / signed agents setting; other WAFs are adding the same.
• Publish your own directory for any requests you sign (your own agent, service-to-service calls, or a verifier that expects one to exist). Serve it with Content-Type: application/http-message-signatures-directory+json:

{
  "keys": [
    {
      "kty": "OKP",
      "crv": "Ed25519",
      "kid": "2026-01",
      "x": "<base64url-encoded public key>",
      "nbf": 1767225600,
      "exp": 1798761600
    }
  ]
}

Serve the file from the same origin as the storefront, with a long cache lifetime, and rotate keys by adding the new one before removing the old.

Your sitemap (https://owlchart.com/sitemap.xml) is reachable and we sampled 187 URLs, but none looked like a product URL and no child sitemap was named after products. Agents use the sitemap to enumerate the catalog without crawling.

Make product entries recognisable: either keep product URLs on a conventional path (/products/…, /product/…, /p/…, /item/…) or split products into a child sitemap whose filename contains "product" (for example sitemap-products-1.xml). Compressed (.xml.gz) sitemaps are skipped; serve plain XML.

No profile was found at /.well-known/ucp. The Universal Commerce Protocol (ucp.dev) is how an agent discovers, in one request, that your store can be shopped programmatically: which services you expose, over which transports (REST and MCP), and whether checkout is supported. It is the largest single item in the transactability pillar, and without it (or an attested ACP integration) your AUR is capped at 79.

A complete profile declares a shopping service with an endpoint and a checkout capability:

{
  "ucp": {
    "version": "2026-01-11",
    "services": {
      "dev.ucp.shopping": {
        "version": "2026-01-11",
        "spec": "https://ucp.dev/specification/overview",
        "rest": {
          "schema": "https://ucp.dev/services/shopping/openapi.json",
          "endpoint": "https://www.example.com/api/ucp"
        },
        "mcp": {
          "schema": "https://ucp.dev/services/shopping/mcp.json",
          "endpoint": "https://www.example.com/api/ucp/mcp"
        }
      }
    },
    "capabilities": [
      {
        "name": "dev.ucp.shopping.checkout",
        "version": "2026-01-11",
        "spec": "https://ucp.dev/specification/checkout",
        "schema": "https://ucp.dev/schemas/shopping/checkout.json"
      },
      {
        "name": "dev.ucp.shopping.order",
        "version": "2026-01-11",
        "spec": "https://ucp.dev/specification/order",
        "schema": "https://ucp.dev/schemas/shopping/order.json"
      }
    ],
    "payment_handlers": []
  }
}

Serve it as application/json from the storefront origin. The endpoints must exist and speak the protocol; the MCP one is tested by the next check. Check ucp.dev for the current version string and schema URLs.

Serve the profile from the storefront origin and implement the shopping service behind it; most of the work is the checkout capability, which maps onto your existing cart and checkout APIs.

https://owlchart.com/api/ucp/mcp did not return a tool list (HTTP 404). The endpoint must speak MCP over Streamable HTTP: accept a JSON-RPC POST and answer with JSON or an SSE stream.

Test it the way we do:

curl -sS -X POST https://owlchart.com/api/ucp/mcp \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json, text/event-stream' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}'

• tools/list must work without authentication; require auth on the tool calls that need it, and advertise it through OAuth discovery (see that fix).
• Return 200 with Content-Type: application/json (or text/event-stream), never a 405 for POST or an HTML page.
• Make sure the URL in the UCP profile (services → dev.ucp.shopping → mcp.endpoint) points at this endpoint exactly.

Any MCP server SDK (TypeScript, Python, Go) with the Streamable HTTP transport will do; mount it on the storefront origin so the profile, the endpoint, and the cookies share a domain.

No MCP server answered tools/list at /api/mcp (HTTP 404). This is the conventional storefront endpoint (Shopify's Storefront MCP lives here) where an agent can search the catalog, read policies, and manage a cart without scraping.

Expose an MCP server over Streamable HTTP at that path with tools such as search_shop_catalog, get_product_details, search_shop_policies_and_faqs, get_cart, and update_cart. tools/list must be callable without authentication.

If you already run the UCP MCP endpoint, mounting the same server at /api/mcp is enough.

We could not find a return/refund and shipping policy page. We look for links on the homepage whose text or path mentions returns/refunds and shipping/delivery, plus your platform's standard paths, and require the page to load (200, HTML). Agents read these to answer "can I send it back" and "when will it arrive" before they recommend a purchase.

• Give each policy its own URL (not a tab inside an FAQ accordion, not a PDF).
• Link both from the homepage footer with plain anchor text: "Returns" / "Refund policy" and "Shipping".
• Keep the pages public and server-rendered; a 200 with an empty JavaScript shell does not count.

Conventional paths such as /returns, /return-policy, /shipping, and /shipping-policy are also probed directly.

No MerchantReturnPolicy structured data was found on the product offer, the homepage, or the organization. A written policy page is good; machine-readable terms let agents compare return windows and fees across stores without reading prose.

Attach it to the product Offer (preferred, since that is where agents are when deciding) or to the Organization/OnlineStore on the homepage:

"hasMerchantReturnPolicy": {
  "@type": "MerchantReturnPolicy",
  "applicableCountry": "US",
  "returnPolicyCategory": "https://schema.org/MerchantReturnFiniteReturnWindow",
  "merchantReturnDays": 30,
  "returnMethod": "https://schema.org/ReturnByMail",
  "returnFees": "https://schema.org/FreeReturn",
  "refundType": "https://schema.org/FullRefund",
  "merchantReturnLink": "https://www.example.com/policies/refund-policy"
}

Use MerchantReturnNotPermitted for final-sale items and MerchantReturnUnlimitedWindow if you accept returns indefinitely. Keep it consistent with the written policy page.