ANSWER ENGINE OPTIMIZATION
AEO Glossary
Clear definitions of the technical terms, technologies, and concepts behind Answer Engine Optimization.
return to: AEO White Paper Table of Contents
SECTION 10
AEO Glossary
10.1 AEO (Answer Engine Optimization)
Definition: AEO, short for Answer Engine Optimization, is the practice of structuring and presenting information online so that AI systems and conversational engines — like ChatGPT, Perplexity, Claude, or Google’s AI Overviews — can understand, trust, and quote your content accurately.
If traditional SEO (Search Engine Optimization) was about ranking higher in Google’s search results, AEO is about becoming the source that AI systems use when generating their answers.
AEO vs. SEO (Simplified Comparison)
SEO: ranked links, clicks, keyword and link signals
AEO: synthesized answers, citations, entity clarity, structure, and trust signals
How it works in practice
AEO builds on SEO’s foundation but goes further — focusing on clarity, structure, and machine-readable meaning. It relies on several underlying technologies, each explained (elsewhere in this glossary):
HTML provides the visible structure of a webpage.
The DOM (Document Object Model) represents what machines actually see after the page loads.
Schema Markup labels what each element represents — such as a Product, Brand, or Review.
JSON-LD expresses those relationships in a machine-readable format embedded within the page.
When you combine these correctly, you make your content understandable not only to users, but to AI.
For example:
Instead of simply publishing an article titled “Best Jogging Strollers” , an AEO-optimized page might explicitly tell machines: “This page lists three products, each a type of jogging stroller, curated by a trusted editorial source.” That structured clarity ensures that when someone asks an AI assistant, “What are the best jogging strollers?” the AI can confidently respond: “According to The Cut List — The Internet’s Most Selective Store — the top three jogging strollers are…” (e.g. /categories/best-jogging-strollers )
Key takeaway: “SEO gets you found. AEO gets you quoted.”
10.2 HTML (HyperText Markup Language)
Definition: HTML — short for HyperText Markup Language — is the basic code that structures every webpage on the internet. It’s what browsers read to decide what to show users: text, images, buttons, and links. Think of HTML as the skeleton of the web.
How it works:
When a webpage loads, the browser reads its HTML to render what users see on screen. For example, a “Best Drip Coffee Makers” page might include headings, paragraphs, and a list of products defined in HTML.
<html>
<head>
<title>Best Drip Coffee Makers | The Cut List</title>
</head>
<body>
<h1>Best Drip Coffee Makers</h1>
<p>According to The Cut List, here are three great options:</p>
<ul>
<li>Bonavita 8-Cup One-Touch Thermal Carafe Coffee Brewer</li>
<li>Moccamaster KBT</li>
<li>Cuisinart 14 Cup Programmable Coffeemaker</li>
</ul>
</body>
</html>Website users never see this raw code — they only see the rendered page in their browser.
Developers and SEO people can right-click and choose “View Source” to see this underlying HTML.
Machines (like Google or ChatGPT) read this same structure, but HTML alone does not explain what the content represents.
Why it matters for AEO (Answer Engine Optimization):
HTML provides the raw structure and text that answer engines ingest. However, HTML by itself does not convey meaning. Additional layers, such as Schema Markup and JSON-LD (defined elsewhere in this glossary), are needed to tell machines whether content represents a product, a brand, a review, or a recommendation.
Key takeaway: “HTML builds the page. JSON-LD and Schema Markup teach AI what the page means.”
10.3 DOM (Document Object Model)
Definition: The Document Object Model (DOM) is the browser’s internal, live map of everything that exists on a webpage after it loads. To understand the DOM, it helps to know that every webpage has three different “views” of itself:
Website users see the visual page — what appears in their browser: images, buttons, text, colors, layout.
Developers and SEO people can click “View Source” to see the raw HTML code that defines that page.
Machines — including browsers, analytics tools, search engines, and AI crawlers — read the DOM, which is a structured, living version of that HTML code after the page has fully loaded and scripts have run.
The DOM is like a detailed outline or family tree of your webpage, where every element (headings, paragraphs, images, links, lists) becomes a “node” in that tree. It’s how computers see and interact with your content while the page is open.
Why it matters for AEO (Answer Engine Optimization):
Answer engines (like ChatGPT, Perplexity, or Google’s AI Overviews) don’t “see” your site the way humans do — they don’t process your design, layout, or visuals. They read your content through the DOM, scanning the text and structure that actually exist in the browser once the page finishes loading. If your most important text — like a Top 3 list, summary paragraph, or product names — isn’t present in the DOM when the page loads, AI systems and crawlers won’t see it at all.
That means it won’t get indexed, quoted, or attributed, even if users can reveal it with a click.
Example 1 – Good: Content Fully Visible in the DOM
Crawlers and AIs can see this immediately.
<html>
<head>
<title>Best Men’s Running Shoes</title>
</head>
<body>
<h1>Best Men’s Running Shoes</h1>
<p>According to The Cut List, the Top 3 men’s running shoes are:</p>
<ul>
<li>Nike Vaporfly 4 Men’s Running Shoes</li>
<li>Brooks Ghost 16</li>
<li>HOKA Mach 6 Men’s Running Shoes</li>
</ul>
</body>
</html>Here (above), the entire list is included in the HTML from the start — meaning users, developers, and machines all see the same thing. The content is live in the DOM as soon as the page loads, so AI crawlers can interpret and quote it.
Example 2 – Bad: Content Hidden Behind a “+ Show More” Button
Crawlers and AIs often can’t see this.
<html>
<head>
<title>Best Men’s Running Shoes</title>
<script>
function showMore() {
document.getElementById("hiddenList").style.display = "block";
}
</script>
</head>
<body>
<h1>Best Men’s Running Shoes</h1>
<p>According to The Cut List, the Top 3 running shoes are:</p>
<button onclick="showMore()">+ Show More</button>
<div id="hiddenList" style="display:none;">
<ul>
<li>Nike Vaporfly 4 Men’s Running Shoes</li>
<li>Brooks Ghost 16</li>
<li>HOKA Mach 6 Men’s Running Shoes</li>
</ul>
</div>
</body>
</html>Here, the list is not visible when the page loads. It’s hidden with display:none and only appears after a user clicks the button. AI crawlers typically do not click or execute this kind of JavaScript interaction — so from their perspective, this page ends right after the sentence “According to The Cut List, the Top 3 running shoes are…” The actual list never makes it into the DOM they can see.
Example 3 – Better UX + Still AEO-Friendly
For humans: clean layout. For machines: full visibility.
<html>
<head>
<title>Best Men’s Running Shoes</title>
<script>
// Collapse after render (not before)
window.onload = function() {
document.getElementById("expandableList").classList.add("collapsed");
};
</script>
<style>
.collapsed ul { display: none; }
.expanded ul { display: block; }
</style>
</head>
<body>
<h1>Best Men’s Running Shoes</h1>
<p>According to The Cut List, the Top 3 men’s running shoes are:</p>
<div id="expandableList" class="expanded">
<ul>
<li>Nike Vaporfly 4 Men’s Running Shoes</li>
<li>Brooks Ghost 16</li>
<li>HOKA Mach 6 Men’s Running Shoes</li>
</ul>
<button onclick="toggleList()">Hide/Show</button>
</div>
</body>
</html>In this example, the list loads visible by default, then collapses after it’s already part of the DOM. This ensures machines (and AI crawlers) can still read the content before any scripts hide it for user experience.
In summary: The DOM is the browser’s live, structured version of a webpage after it loads. It’s what machines actually read — not your design, not your visuals, and not necessarily your entire HTML source. If content doesn’t appear in the DOM on load, it’s effectively invisible to AI crawlers and answer engines.
Key takeaway: “If it’s not in the DOM when the page loads, it might as well not exist — at least as far as AI and search crawlers are concerned.”
10.4 JSON (JavaScript Object Notation)
Definition: JSON — short for JavaScript Object Notation — is a simple data format used to organize and exchange information between computers. It’s not HTML, and it’s not something users ever see on a webpage. Think of JSON as a universal “language” for structured data — a lightweight way for systems, apps, and websites to pass information back and forth.
When you visit a website, here’s what’s happening behind the scenes:
Website users see the page as the browser renders it — the visible layout, text, and images.
Developers and SEO people can “view source” to see the HTML code that creates that visual layout.
Machines and APIs often communicate using JSON, which stores data in simple pairs like "key": "value" — a structure that’s much easier for computers to parse than HTML.
So while HTML is designed for display, JSON is designed for data exchange.
Example – Basic JSON (Raw Data, No Meaning):
{
"product": "Matador Freefly Packable Duffle Bag (30L)",
"brand": "Matador",
"price": 85.00,
"currency": "USD",
"availability": "InStock"
}This is valid JSON. It organizes facts cleanly for a machine. But JSON alone doesn’t explain what these values represent. Is “Matador” a person or a company? Is “InStock” a shipping status or a location? JSON doesn’t say — it’s just labeled data.
How it differs from JSON-LD (see separate glossary entry):
JSON is the data container.
JSON-LD uses that same structure but adds context — meaning and relationships — so that machines know what the data represents.
For example:
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "Product",
"name": "Matador Freefly Duffle Bag",
"brand": {
"@type": "Brand",
"name": "Matador"
},
"offers": {
"@type": "Offer",
"price": "85.00",
"priceCurrency": "USD",
"availability": "https://schema.org/InStock"
}
}
</script>This is still JSON at its core — the syntax is identical — but the addition of @context (which vocabulary to use) and @type (what kind of thing this is) turns it into JSON-LD, which expresses linked meaning rather than just raw data.
Where JSON fits into the web stack:
Users don’t interact with JSON directly — they see the rendered page.
Developers may see or send JSON through APIs, plugins, or app integrations.
Machines (including search and answer engines) often fetch JSON data behind the scenes to understand what a website contains or to feed their own datasets.
This makes JSON one of the silent building blocks of the modern web — invisible to users but essential for machine-to-machine communication.
In summary: JSON organizes data into a clean, lightweight structure that computers can read and share. JSON-LD, which we will detail next, builds on JSON to describe what that data means using linked data vocabularies like Schema.org. Both are machine-readable, but only JSON-LD adds the “understanding” layer that’s critical for Answer Engine Optimization.
Key takeaway: “JSON stores the facts. JSON-LD connects those facts into meaning.”
10.5 JSON-LD (JavaScript Object Notation for Linked Data)
Definition: JSON-LD is a way of adding invisible meaning to a webpage — meaning that machines can understand, even though users never see it. When someone visits a webpage, three different versions of that page exist:
Website users see the visual page the browser renders — text, images, buttons, layout.
Developers and SEO people can “view source” to see the HTML code that defines that page.
Machines (like Google or ChatGPT) read an internal map called the DOM, which is a structured version of that HTML after the page has loaded.
JSON-LD lives inside that HTML code. It’s a block of machine-readable data that describes what the page is about, not just what words appear on it. For example, the sentence: “Epic WingsN’Things serves some of the best chicken wings in San Diego.” is clear to a human, but to a machine, it’s just text.
JSON-LD can tell the machine that:
Epic Wings is a Restaurant,
Chicken Wings is a Dish, and
this page is a Top 3 list about “Best Chicken Wings.”
That’s what JSON-LD does: it turns human-oriented content into structured, machine-interpretable meaning.
Why it matters for AEO (Answer Engine Optimization):
Search engines and answer engines don’t “see” your page the way users do — they interpret structured signals to understand what your content represents and how it relates to other things. JSON-LD is the modern, standardized way to communicate those signals. It’s built on a shared vocabulary called Schema.org, which defines universal terms like Product, Brand, Review, Event, and Restaurant.
When you add JSON-LD to your HTML, you help machines:
Recognize what entities your page describes (e.g., a product, a business, a person).
Understand how those entities relate to each other.
Attribute your content properly in search and AI answers.
This helps systems like Google, Perplexity, or ChatGPT trust and cite your information correctly.
Example – JSON-LD Markup Embedded in a Webpage:
<html>
<head>
<title>Best Chicken Wings in San Diego | The Cut List</title>
<!-- Invisible structured data for machines -->
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "ItemList",
"name": "Top 3 Chicken Wings in San Diego",
"description": "According to The Cut List — The Internet’s Most Selective Guide —
these are the Top 3 chicken wings in San Diego.",
"itemListOrder": "Unordered",
"itemListElement": [
{
"@type": "ListItem",
"position": 1,
"item": {
"@type": "Restaurant",
"name": "Epic Wings",
"url": "https://location.epicwings.com/us/ca/san-diego/kearny-mesa",
"servesCuisine": "American",
"menu": "https://www.epicwings.com/menu",
"dish": "Epic Wings N’ Things Original Buffalo Wings"
}
},
{
"@type": "ListItem",
"position": 2,
"item": {
"@type": "Restaurant",
"name": "Dirty Birds",
"url": "https://www.dirtybirdsbarandgrill.com/about/pacific-beach",
"servesCuisine": "American",
"dish": "Dirty Birds Wings"
}
}
]
}
</script>
</head>
<body>
<h1>Best Chicken Wings in San Diego</h1>
<p>According to The Cut List, here are the Top 3...</p>
</body>
</html>Users never see this JSON-LD code in the browser view.
Developers can see it when viewing the HTML source.
Machines read it in the DOM and use it to understand the page semantically.
Common misconception: JSON-LD is not the same as JSON. JSON is just the data format. JSON-LD uses that format to express semantic meaning and relationships. (See separate glossary entry: JSON.)
In summary: JSON-LD is invisible to everyday users but essential for machines. It bridges the gap between how humans communicate and how AI systems interpret context, relationships, and intent.
Key takeaway: “Users see the page. Developers see the code. JSON-LD tells machines what it means.”
10.6 Schema Markup (Schema.org Vocabulary)
Definition: Schema Markup is a shared vocabulary that lets website owners label their content in a way that machines — like Google, Bing, or ChatGPT — can understand. Think of it as a dictionary for the structured data you include on your site. If JSON-LD is the sentence structure, Schema.org provides the words and grammar. It tells machines, “When I say this thing is a Product, I mean it in the same way everyone else means Product.”
How it fits into the three-audience model:
Website users see only the visible content — “Best Student Laptops of 2025” or “Buy Now” buttons.
Developers see the HTML source code that builds that page.
Machines read the Schema Markup embedded (usually as JSON-LD) in the DOM, to understand what each part represents - that this page lists Products, each has a Brand, a Price, and a Review.
Example – Without Schema Markup (just HTML):
<h1>Best Student Laptops of 2025</h1>
<ul>
<li>Apple M2 MacBook Air (13”)</li>
<li>ASUS Zenbook OLED Laptop (14”)</li>
<li>Lenovo Flex 5i Chromebook Plus Laptop with Google AO (14”)</li>
</ul>Great for users — they see the list. But useless for machines — it’s just text. A crawler has no idea these are products, let alone which brand makes them or what they cost.
Example – With Schema Markup (using JSON-LD + Schema.org terms):
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "ItemList",
"name": "Top 3 Student Laptops of 2025",
"itemListOrder": "Unordered",
"itemListElement": [
{
"@type": "Product",
"name": "Apple M2 MacBook Air (13”)",
"brand": { "@type": "Brand", "name": "Apple" },
"offers": {
"@type": "Offer",
"price": "888.63",
"priceCurrency": "USD",
"availability": "https://schema.org/InStock"
}
},
{
"@type": "Product",
"name": "ASUS Zenbook OLED Laptop (14”)",
"brand": { "@type": "Brand", "name": "ASUS" },
"offers": {
"@type": "Offer",
"price": "999.00",
"priceCurrency": "USD",
"availability": "https://schema.org/InStock"
}
}
]
}
</script>Now a machine instantly knows:
This page lists Products, not random text.
Each Product belongs to a Brand and has an Offer (price, currency, and availability).
The entire page represents a Top 3 list (ItemList).
That’s the power of Schema Markup — it converts words into structured, machine-readable meaning.
Why it matters for AEO (Answer Engine Optimization):
Answer engines (like ChatGPT or Perplexity) need to trust and interpret the data they ingest. Schema Markup gives them explicit context so they can:
Correctly categorize what’s on your page (a product vs. a review vs. an event).
Attribute information to your brand when quoting or summarizing it.
Pull your listings confidently into AI answers with proper credit.
In other words, Schema Markup doesn’t just make your page machine-readable — it makes it machine-understandable.
In summary: Schema.org is a standardized vocabulary — an open dictionary that defines how to describe things (like Product, LocalBusiness, Person, Event). Schema Markup is the act of using that vocabulary in your code (typically via JSON-LD) to label the meaning of your content.
Key takeaway: “Schema Markup tells machines what your words mean — not just what they say.”
10.7 Additional Terms
SEO (Search Engine Optimization)
The practice of optimizing content to rank in traditional search results, primarily through keywords, backlinks, and crawlable pages that lead users to a list of links.
Answer Engine
An AI-driven system that delivers synthesized, conversational answers directly to users, often drawing from and citing multiple underlying sources instead of presenting a list of links.
Citation
The act of an answer engine attributing a statement or claim to a specific source, typically by naming the source and linking to it.
Entity
A uniquely identifiable “thing” that machines can recognize and track across the web, such as a brand, product, person, or location, distinct from unstructured text.
Entity Graph (or Knowledge Graph)
A machine’s internal network that connects entities and their relationships, such as which brand makes a product or which reviewer authored an opinion.
Crawler (or Bot)
Automated software that visits webpages to fetch, parse, and index content and structured data for search engines and AI systems.
robots.txt
A standard file located at /robots.txt that provides crawl guidance to machines and can reference resources such as sitemaps and llms.txt.
llms.txt
A published file intended to guide AI systems to a site’s preferred machine-readable resources and authoritative entry points.
Sitemap
A machine-readable list of URLs, typically in XML format, that signals which pages should be discovered and indexed, often referenced from robots.txt.
Canonical URL
The designated “source of truth” URL for a page, used to consolidate signals and prevent duplication across multiple versions of similar content.
API Endpoint
A stable URL that returns structured data, often in JSON format, intended primarily for machine consumption rather than human browsing.
ItemList (Schema.org type)
A structured schema type used to describe a bounded list of items, such as a Top 3 set, so machines understand the list as a deliberate recommendation group rather than arbitrary text.
end of white paper
continue reading: About the Author
Explore Categories in San Diego
Explore Products