Magento and Adobe Commerce Have the Most AI Agent Potential. Here Is Why Almost Nobody Uses It.

Magento and Adobe Commerce give you full control over every HTML tag, every HTTP header, and every API endpoint your store serves. That control is the single most important advantage for AI agent discoverability in 2026. Shopify stores fight their platform’s limitations at every turn. WooCommerce stores wrestle with plugin conflicts. Magento stores just need to configure what they already have.

The problem: almost nobody does.

According to Adobe’s own 2025 Commerce benchmark report, only 12% of Magento merchants have implemented comprehensive Product structured data beyond the default breadcrumb markup. Fewer than 3% serve an llms.txt file. Almost none expose product data through an MCP-compatible endpoint.

This guide covers the exact architecture changes, module configurations, and content strategies that make Magento and Adobe Commerce the best-positioned platforms for AI shopping agent discoverability.

Why Magento Has the AI Discoverability Advantage

Full Control Over HTML Output

Unlike Shopify, where you fight Liquid template constraints and app injection conflicts, Magento lets you modify every aspect of your storefront HTML. This matters because AI agents parse structured data differently than search engines.

ChatGPT, Perplexity, and Gemini look for:

• Clean JSON-LD without duplicate @type declarations
• Consistent sku, gtin, and brand fields across all product pages
• Accurate offers.availability that matches real stock levels
• aggregateRating tied to actual review data, not static numbers

On Magento, you control all of this through layout XML, block classes, and template overrides. No workaround needed.

API-First Architecture

Adobe Commerce’s GraphQL API and Magento 2’s REST API expose every product attribute, category relationship, and inventory status as structured data. AI agents that crawl APIs directly (Perplexity’s commerce features, Google’s Shopping Graph) can ingest your catalog without parsing HTML at all.

The default GraphQL endpoint at /graphql already returns:

This is machine-readable product data served on a silver platter. Most stores do not even verify their GraphQL schema is publicly accessible.

Headless Mode as AI Agent Superpower

Magento’s headless commerce capabilities (via PWA Studio, Hyvä, or custom frontends) mean you can serve AI-optimized content without compromising the human shopping experience. You can:

• Serve answer-first content blocks to AI crawlers via user-agent detection
• Deliver full product specifications in JSON-LD to bots while keeping clean UI for humans
• Expose a dedicated /ai route with structured product feeds
• Run separate caching rules for agent traffic vs. human traffic

Shopify stores need third-party apps for most of this. Magento builds it into the architecture.

The AI Discoverability Audit for Magento Stores

Before making changes, run this audit to understand where your store stands.

Step 1: Verify GraphQL Endpoint Accessibility

curl -s 'https://yourstore.com/graphql' \
  -H 'Content-Type: application/json' \
  -d '{"query":"{ products(search: \"test\", pageSize: 1) { items { name sku price_range { minimum_price { final_price { value } } } } } }"}' \
  | python3 -m json.tool

If this returns product data, your catalog is already partially exposed to AI agents. If it returns a 403 or authentication error, your GraphQL endpoint is blocked and needs to be opened for public read access.

Step 2: Check Structured Data Coverage

Open any product page and run it through Google’s Rich Results Test. Magento’s default Luma theme includes basic Product schema, but most stores have gaps:

Common missing fields:

• gtin13 or gtin14 (barcode identifiers)
• brand (manufacturer name as a linked entity)
• material and color (physical product attributes)
• shippingDetails (delivery options and regions)
• returnPolicy (return window and conditions)

AI agents use these fields to filter and compare products. A query like “show me red cotton dresses under $80 with free shipping” requires all four attributes to be present in your structured data.

Step 3: Test AI Crawler Access

Check your robots.txt for blocks against AI crawlers:

curl -s https://yourstore.com/robots.txt

Look for these user-agents and make sure they are NOT disallowed:

• ChatGPT-User (OpenAI)
• Googlebot (Google AI Overviews)
• PerplexityBot
• ClaudeBot (Anthropic)
• Bytespider (TikTok/Douyin AI)
• Amazonbot (Alexa/shopping AI)

Step 4: Verify llms.txt Presence

curl -s https://yourstore.com/llms.txt

If this returns 404, you are missing the single most important file for AI agent discoverability. More on setting this up below.

Implementation Guide: Structured Data for AI Agents

Module 1: Fix Product Schema

Create a custom module to override Magento’s default Product structured data. The default schema misses critical fields for AI agents.

File: app/code/YourVendor/AiDiscoverability/Model/StructuredData/Product.php

The key additions AI agents need that Magento omits by default:

1. Brand as a linked entity instead of a plain string
2. GTIN/barcode from product attributes
3. Material and weight as explicit properties
4. Shipping details linked to your shipping tables
5. Review aggregation from your actual review module (not hardcoded)

A properly configured Product schema should look like this:

{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Classic Cotton Oxford Shirt",
  "sku": "OXF-001-BLU-M",
  "gtin13": "0123456789012",
  "brand": {
    "@type": "Brand",
    "name": "Your Brand"
  },
  "description": "Classic fit cotton oxford shirt in navy blue...",
  "material": "100% Cotton",
  "color": "Navy Blue",
  "weight": {
    "@type": "QuantitativeValue",
    "value": "0.25",
    "unitCode": "KGM"
  },
  "image": ["https://yourstore.com/media/catalog/product/oxf-001.jpg"],
  "offers": {
    "@type": "Offer",
    "url": "https://yourstore.com/classic-oxford-shirt.html",
    "priceCurrency": "USD",
    "price": "79.00",
    "priceValidUntil": "2026-12-31",
    "availability": "https://schema.org/InStock",
    "shippingDetails": {
      "@type": "OfferShippingDetails",
      "shippingDestination": {
        "@type": "DefinedRegion",
        "addressCountry": "US"
      },
      "deliveryTime": {
        "@type": "ShippingDeliveryTime",
        "handlingTime": {"@type": "QuantitativeValue", "value": "1", "unitCode": "DAY"},
        "transitTime": {"@type": "QuantitativeValue", "value": "3", "unitCode": "DAY"}
      }
    }
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.7",
    "reviewCount": "342"
  }
}

Module 2: Category and Organization Schema

AI agents navigate product taxonomies to understand what you sell. Add ItemList and CollectionPage schema to category pages:

• Every category page should have an ItemList with all visible products
• Include numberOfItems matching the actual product count
• Add breadcrumb schema mapping your full category hierarchy
• Link categories with @id references so agents can trace parent-child relationships

Module 3: Store and Organization Schema

Your homepage needs comprehensive Organization and WebSite schema:

{
  "@type": "Organization",
  "name": "Your Store Name",
  "url": "https://yourstore.com",
  "logo": "https://yourstore.com/logo.png",
  "sameAs": [
    "https://twitter.com/yourstore",
    "https://instagram.com/yourstore"
  ],
  "contactPoint": {
    "@type": "ContactPoint",
    "contactType": "customer service",
    "email": "[email protected]"
  }
}

This establishes your store as an entity that AI agents can cite by name. Without it, you are just a URL.

Setting Up llms.txt on Magento

The llms.txt file tells AI agents exactly what your store contains, how it is organized, and how to access product data. It is the most impactful single file you can add for AI discoverability.

What to Include

Your llms.txt should cover:

1. Store identity: name, URL, what you sell, your value proposition
2. Product catalog summary: number of products, main categories, price range
3. Content inventory: blog posts, buying guides, size guides, FAQ pages
4. Structured data locations: where to find JSON-LD, sitemaps, product feeds
5. API endpoints: GraphQL endpoint, REST API paths, any public feeds
6. Crawl guidance: preferred crawl times, rate limits, restricted areas

Magento-Specific Implementation

Create the file at pub/llms.txt so it is served from your store root:

# Your Store Name

> Premium [your category] since [year]. [One sentence value proposition].
> [Another sentence about what makes you different].

## Product Catalog

- 2,400+ products across 45 categories
- Categories: [list top-level categories with links]
- Price range: $12 - $450
- Key brands: [list brands if multi-brand store]

## Product Data Access

- JSON-LD structured data on every product page
- GraphQL API: https://yourstore.com/graphql
- Product sitemap: https://yourstore.com/sitemap.xml
- Product feed: https://yourstore.com/feed/products.json

## Content

- Blog: https://yourstore.com/blog/ (120+ buying guides and product comparisons)
- Size guide: https://yourstore.com/size-guide
- Shipping info: https://yourstore.com/shipping
- Returns: https://yourstore.com/returns

## Technical

- Platform: Magento 2 / Adobe Commerce
- Structured data: JSON-LD (Product, Organization, BreadcrumbList)
- Currency: USD
- Ships to: US, Canada, EU, UK

Product Feed for AI Agents

Beyond structured data on individual pages, AI agents benefit from a comprehensive product feed they can ingest in bulk.

Building a Magento Product Feed

Create a custom controller that generates a JSON product feed:

Feed endpoint: https://yourstore.com/feed/ai-products.json

Include per product:

• id, sku, name, description
• price, sale_price, currency
• url, image_url
• category_path (e.g., “Men > Shirts > Oxford”)
• brand, material, color, size_options
• stock_status, shipping_estimate
• rating, review_count
• last_updated timestamp

Optimization tips:

• Cache the feed for 6-12 hours (product data does not change minute to minute)
• Limit to 5,000-10,000 products per feed file; paginate with ?page=2
• Include HTTP headers: Content-Type: application/json, X-Total-Products: 2400
• Add a last_modified field so agents can do incremental updates
• Compress with gzip for agents that accept Accept-Encoding: gzip

MCP Server Integration for Magento

Model Context Protocol (MCP) servers let AI agents interact with your store directly: search products, check inventory, and even initiate checkout. Magento’s API-first architecture makes this straightforward.

What an MCP Server Exposes for Magento

Security Considerations

• Rate-limit MCP endpoints to 100 requests per minute per agent
• Use read-only credentials for product search and inventory
• Require separate authentication for cart and order operations
• Log all MCP requests for monitoring and debugging
• Never expose customer data through MCP endpoints

For a detailed walkthrough of MCP server setup, see our guide on what MCP servers are and why your ecommerce store needs one.

Adobe Commerce vs Magento Open Source: AI Discoverability Differences

Adobe Commerce (the paid enterprise version) includes several features that help with AI agent discoverability out of the box:

The key difference: Adobe Commerce’s native Live Search and Product Recommendations already use AI to understand your catalog. This means your product data is already structured in a way that external AI agents can consume. You just need to expose it.

Magento Open Source stores can achieve the same results with custom modules and third-party extensions. The effort is higher, but the control is identical.

Common Magento AI Discoverability Mistakes

Mistake 1: Relying on SEO Extensions for AI

SEO extensions like MagePlaza SEO or Mirasvit SEO are built for Google, not AI agents. They handle meta titles, canonical tags, and sitemaps. They do not add gtin, material, or shippingDetails to your Product schema. They do not generate llms.txt. They do not configure GraphQL access for crawlers.

You need AI-specific configuration on top of your SEO extension.

Mistake 2: Blocking GraphQL in Production

Many Magento stores restrict GraphQL access to authenticated requests, especially after security advisories. This blocks AI agents from querying your catalog programmatically.

Solution: allow unauthenticated read access to product, category, and CMS queries. Require authentication only for mutations (cart, checkout, customer data).

Mistake 3: Duplicate JSON-LD from Multiple Sources

Magento sites often accumulate multiple sources of structured data: theme defaults, SEO extensions, rich snippet modules, and Google Tag Manager. This creates duplicate or conflicting JSON-LD blocks that confuse AI agents.

Audit your product pages for multiple <script type="application/ld+json"> blocks. Consolidate into one authoritative source.

Mistake 4: Ignoring Category Schema

Most Magento SEO efforts focus on product pages and ignore category pages. AI agents use category pages to understand your store’s full product range. Without ItemList schema on categories, agents cannot navigate your taxonomy.

Mistake 5: Static Structured Data

Magento stores with large catalogs often cache product page HTML including the JSON-LD. If your structured data shows “InStock” for products that have been backordered for weeks, AI agents learn not to trust your data.

Connect your JSON-LD to real-time inventory through Magento’s inventory registry, or at minimum update cached structured data when stock status changes.

Measuring AI Discoverability on Magento

Track these metrics to measure your progress:

1. AI crawler visits: Monitor ChatGPT-User, PerplexityBot, ClaudeBot in your access logs
2. GraphQL query volume: Track unauthenticated GraphQL queries as a proxy for agent interest
3. AI citation frequency: Search ChatGPT, Perplexity, and Gemini for your products monthly
4. Rich result eligibility: Use Google’s Rich Results Test and Schema.org Validator
5. Feed download count: Monitor /feed/ai-products.json access in logs
6. llms.txt requests: Track how often AI agents fetch your llms.txt file

For more on tracking AI citations specifically, see our guide on how to track and optimize AI citations for ecommerce stores.

The Implementation Checklist

Here is your prioritized checklist for Magento AI agent discoverability:

• Verify GraphQL endpoint is publicly accessible for read queries
• Audit product JSON-LD for missing fields (gtin, brand, material, shippingDetails)
• Remove duplicate JSON-LD blocks from product pages
• Create and deploy llms.txt at store root
• Build JSON product feed at /feed/ai-products.json
• Add ItemList schema to all category pages
• Add Organization and WebSite schema to homepage
• Verify robots.txt allows all major AI crawlers
• Set up monitoring for AI crawler user-agents in access logs
• Connect structured data to real-time inventory (not static cache)
• Consider MCP server for agent-initiated product search and checkout

Conclusion

Magento and Adobe Commerce are technically the best-positioned ecommerce platforms for AI agent discoverability. Full HTML control, API-first architecture, and headless capabilities give you everything needed to make your products findable and purchasable by AI shopping agents.

The gap is not technical. It is execution. Most Magento stores have not configured the infrastructure they already own.

Start with the audit. Fix your structured data. Deploy llms.txt. Build the product feed. Then measure what changes when AI agents can actually read your catalog.

For a broader look at how different platforms compare on AI agent readiness, see our analysis of Shopify, WooCommerce, and BigCommerce AI discoverability.

Check your store agent discoverability score free at shopti.ai

FAQ

Does Magento support AI agent discoverability out of the box?

Magento includes basic Product schema in its default Luma theme and exposes a full GraphQL API. However, the default structured data is incomplete for AI agent needs. You must add fields like gtin, brand entity, material, shippingDetails, and aggregateRating. The GraphQL endpoint also needs to be verified as publicly accessible, as some hosting configurations block unauthenticated requests.

What is the single highest-impact change for Magento AI discoverability?

Adding an llms.txt file. It takes 30 minutes to write and deploy, requires no code changes, and immediately tells every major AI agent what your store contains and how to access product data. No other change gives you this much impact for this little effort.

Do I need to build an MCP server for my Magento store?

Not immediately. An MCP server enables AI agents to search your catalog and initiate checkout directly, which is the long-term vision for agentic commerce. Start with structured data, llms.txt, and a product feed. Add MCP when you want to enable direct agent-initiated purchases.

How is AI agent discoverability different from SEO on Magento?

SEO optimizes for Google’s ranking algorithm: backlinks, page speed, keyword targeting. AI agent discoverability optimizes for structured data completeness, machine-readable feeds, and content that answers direct product questions. They overlap on structured data and crawlability, but AI agents need richer product attributes (material, shipping, returns) that Google does not require for ranking.

Can I use Magento’s built-in search for AI agents?

Magento’s built-in search (whether MySQL-based or Elasticsearch/OpenSearch) is designed for human shoppers typing keywords. AI agents need structured product data, not search results. Use your GraphQL API and product feed for agent access, not the storefront search interface.