Schema.org markup: the language AI agents actually understand

When an AI agent lands on your website, it does not read the page the way a human does. It looks for structure. Schema.org markup gives that structure a shared vocabulary, and getting it right is the difference between an agent that understands your content and one that guesses.

Why Schema.org matters for agents

Search engines have used structured data for years to generate rich snippets. AI agents take this further. They use Schema.org types and properties to build an internal model of what your page represents, what actions are available, and how different entities relate to each other.

Without markup, an agent has to infer meaning from raw HTML. A price might be a phone number. A product name might be a heading for a blog post. Schema.org removes that ambiguity.

JSON-LD is the format to use

There are three ways to add Schema.org data: Microdata, RDFa, and JSON-LD. For agent compatibility, JSON-LD wins. It lives in a single <script> block, separate from your HTML, so agents can extract it without parsing the DOM.

Here is a basic product example:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Wireless Keyboard",
  "description": "Compact wireless keyboard with UK layout",
  "brand": {
    "@type": "Brand",
    "name": "TypeWell"
  },
  "offers": {
    "@type": "Offer",
    "price": "49.99",
    "priceCurrency": "GBP",
    "availability": "https://schema.org/InStock",
    "url": "https://example.com/keyboards/wireless"
  }
}
</script>

Common types that agents look for

Not all Schema.org types carry equal weight for agents. These are the ones that matter most:

• Product and Offer: price, availability, variants. Agents performing comparison shopping depend on these.
• LocalBusiness: address, opening hours, contact details. Agents answering "find me a plumber near..." questions use this data. Industries like property listings rely heavily on structured data for the same reason.
• Article and BlogPosting: author, publish date, content body. Agents summarising content rely on these fields.
• FAQPage: question and answer pairs. Agents love this format because it maps directly to how users ask questions.
• BreadcrumbList: site hierarchy. Agents use this to understand where a page sits within your site.

Nesting types properly

Flat markup only tells part of the story. Nesting gives agents the relationships between entities. Compare these two approaches:

Bad (flat, disconnected):

{
  "@type": "Product",
  "name": "Running Shoes",
  "brand": "SpeedCo"
}

Better (nested, typed):

{
  "@type": "Product",
  "name": "Running Shoes",
  "brand": {
    "@type": "Brand",
    "name": "SpeedCo"
  },
  "review": {
    "@type": "Review",
    "reviewRating": {
      "@type": "Rating",
      "ratingValue": "4.5",
      "bestRating": "5"
    },
    "author": {
      "@type": "Person",
      "name": "Jane Smith"
    }
  }
}

The nested version tells the agent that "SpeedCo" is specifically a brand, that there is a review with a rating, and that the reviewer is a person. An agent can extract each of these entities independently.

Practical tips for implementation

Use specific types over generic ones. LocalBusiness is fine, but Restaurant or Dentist is better. The more specific the type, the more the agent knows without guessing.

Fill in optional properties. Schema.org has many optional fields. Agents that encounter a Product with sku, gtin13, colour, and material can do far more than one with just a name and price.

Keep your markup consistent with visible content. If your JSON-LD says a product costs 49.99 but the page shows 59.99, agents will flag the mismatch and may distrust the structured data entirely.

Add @id properties for cross-referencing. When you have multiple JSON-LD blocks on a page, use @id to link them:

{
  "@type": "Organization",
  "@id": "https://example.com/#org",
  "name": "Example Ltd"
}

Other blocks can then reference this with "publisher": {"@id": "https://example.com/#org"}.

Testing your markup

Google's Rich Results Test will validate syntax, but it only checks types Google cares about. For a deeper look at structured data testing tools, you also want to verify that your JSON-LD parses correctly as standalone data. Drop it into any JSON validator and confirm the structure makes sense without the surrounding page.

Schema.org is not glamorous work. But it is the single most effective thing you can do to help AI agents understand your site. Get the markup right, and agents will treat your pages as a reliable data source rather than something they have to guess about.