AI search runs on five core technologies working together: large language models that write the answer, retrieval systems that fetch live information, embeddings that match questions to content by meaning rather than by keyword, web indexes kept fresh by AI crawlers, and grounding layers that tie each claim to a citable source. No single component does the searching. The language model supplies the writing, and everything factual in a good AI answer comes from the layers wrapped around it.
Each component exists to fix a specific weakness in the one before it, which is why the stack looks the way it does. This post explains every layer in plain language: what it does, why it is there, and where you can watch it working in tools like ChatGPT, Perplexity, and Google's AI Mode. If you want the end-to-end journey from typed question to finished answer, that pipeline has its own walkthrough. And if you are new to the topic entirely, start with our guide to what AI search is.
The stack at a glance
| Layer | What it does | Where you see it |
|---|---|---|
| Large language model | Reads retrieved material and writes a fluent answer | The conversational reply in ChatGPT, Gemini, or Claude |
| Retrieval (RAG) | Fetches relevant, current documents before the model writes | The searching-the-web indicator before an answer appears |
| Embeddings | Turn text into numbers so meaning can be compared | Engines understanding a question however you phrase it |
| Live index and crawlers | Keep a fresh, searchable copy of the web | Answers that reference last week's news |
| Grounding and citations | Tie claims to sources and show them as links | Numbered footnotes in Perplexity, source chips in AI Overviews |
Every major engine assembles some version of this stack. The differences you notice between engines, such as Perplexity's heavy sourcing or the source chips Google folds into AI Overviews, mostly come down to which layers each company has invested in. Here is each one in turn.
Large language models: the writing layer
A large language model is a neural network trained on an enormous body of text until it becomes very good at predicting what comes next in a sentence. That one skill, scaled up, produces a system that can read a question, follow instructions, and write a coherent answer. GPT models power ChatGPT. Microsoft Copilot is grounded in Bing and built into Windows, Edge, and Microsoft 365. Gemini powers Google's AI surfaces. Claude, Grok, and others run their own assistants and a long tail of products built on top of them.
On its own, a language model is a poor search engine. Its knowledge is frozen at the point its training data was collected, so it knows nothing about last month's product launch or this morning's price change. It also writes with the same confidence whether it is recalling something accurate or filling a gap with plausible text. Engineers call those fabrications hallucinations, and they are the main reason no serious engine answers from model memory alone.
What the model genuinely contributes to the stack:
- Comprehension. It reads several retrieved pages at once and works out which parts are relevant to your specific question.
- Synthesis. It merges overlapping and sometimes contradictory sources into one coherent answer.
- Conversation. It holds context across follow-ups, so you can refine a question instead of starting over.
- Judgement under instruction. Told to compare, summarise, or recommend, it structures the answer accordingly.
A more capable model improves all four of those, but model quality alone does not make search quality. A brilliant writer working from stale or thin source material still produces a wrong answer. That is why the next four layers matter as much as the model itself.
Retrieval-augmented generation: why engines do not answer from memory
Retrieval-augmented generation, usually shortened to RAG, fixes the frozen-knowledge problem. Before the model writes anything, the system runs searches against a live index, fetches the most relevant pages, and places extracts from them directly into the model's working context. The model then answers from that supplied material rather than from memory. The closest everyday analogy is an open-book exam. The student still does the reading and the writing, but the facts come from the books on the desk.
You can watch RAG happen. Ask ChatGPT about something recent and a small searching-the-web indicator appears before the answer does. Ask Perplexity anything and the source panel fills before the first sentence renders. That pause is retrieval at work: queries being fired, pages being fetched, passages being selected and ranked.
For brands, retrieval is the most consequential layer in the stack. It decides which pages the model gets to read at all. If your page is never retrieved, nothing downstream matters. The model cannot cite, recommend, or even misquote content it has never seen.
Embeddings and semantic search: meaning over keywords
Embeddings are how machines compare meaning. An embedding model converts a piece of text into a long list of numbers, called a vector, positioned so that texts with similar meanings sit close together in mathematical space. A question like 'affordable CRM for a small plumbing firm' and a page titled 'low-cost customer software for trade contractors' share almost no words, yet their vectors land near each other because the intent is the same.
This is the sharpest practical break from traditional search. Keyword retrieval needed your query and the page to share terms, which is why a generation of SEO advice obsessed over exact-match phrases. Semantic retrieval matches intent to meaning. Vector databases hold embeddings at enormous scale and find the nearest neighbours to a question almost instantly, and the same technique helps an engine choose which specific passages from a long page are worth quoting.
The consequence for anyone who writes content: covering an intent clearly now beats repeating a phrase. A page that genuinely answers how long a basement conversion takes can be retrieved for dozens of differently worded questions it never literally contains. For what this changes at the results level, see AI search vs traditional search.
Live web indexes and AI crawlers
Retrieval needs something to retrieve from, and that something is an index: a continuously refreshed, searchable copy of the web. Very few companies own one. Google's AI Overviews and AI Mode draw on Google's index. Copilot is grounded in Bing. Brave is a rare exception that runs its own fully independent index. Most other players license, partner, or crawl for their specific needs.
Want to see this in action?
Check how AI models talk about your brand — free, instant, no signup required.
Keeping an index fresh is the job of crawlers, and AI companies now operate several each, with distinct purposes. Some gather training data for future models. Others fetch pages on demand at the moment a user asks a question. The distinction matters because robots.txt treats each user agent separately. Block the wrong one and you disappear from live answers while still feeding training sets, or the reverse. Our AI crawler user-agent reference lists who runs what and which ones to allow.
A newer convention sits alongside robots.txt: llms.txt, a plain-text file at the root of a site that gives AI systems a curated map of its most important pages and what they cover. No engine has committed to honouring it yet, but major technology sites already publish one and it costs little to add.
These indexes move quickly, and so do the answers built on them. Ahrefs found that Google's AI Overviews change every 2.15 days on average, with around 70% of the content drifting between versions. We unpack that finding and nine others in our breakdown of the Ahrefs research. The practical point: an AI answer is not a ranking you win once. It is a surface that rebuilds itself from whatever the index currently holds.
Citation and grounding layers
Grounding is the discipline of tying each claim in a generated answer back to a retrieved source. Citation is the visible half of it: the numbered footnotes in Perplexity, the source chips under an AI Overview, the link cards in ChatGPT search. Together they are the engine's defence against hallucination and the user's way of checking the work.
The crucial detail for anyone hoping to appear in AI answers is that retrieved does not mean cited. Engines fetch far more material than they credit. The same Ahrefs research found ChatGPT cites only around half of the URLs it actually retrieves. The grounding layer acts as a final filter, and it favours pages that make clear, specific, quotable claims over pages that circle a topic without committing to anything.
Engines weight this layer differently. Perplexity built its identity on citation-first answers and shows sources before almost anything else. Google attaches sources to AI Overviews but folds them into the page. Some chat products still produce uncited answers for casual questions. The variation is one reason the same brand can be prominent on one engine and invisible on another.
What the stack means for content owners
Each layer translates into something concrete you can act on:
- Be retrievable. Allow the answering crawlers in robots.txt and keep important content in plain HTML rather than behind scripts or logins.
- Write for intent, not exact phrases. Embeddings retrieve meaning, so cover the question fully instead of repeating a target keyword.
- Make claims extractable. Grounding layers cite sentences that stand on their own: a clean definition, a specific number, an answer-first opening paragraph.
- Be realistic about structured data. Ahrefs found broad schema markup produced no meaningful citation lift. Schema still helps machines parse your pages, but it is not a citation shortcut. Our schema markup reality check covers what it still does well.
Because every engine assembles these layers differently, the same question produces different answers, sources, and brand mentions on ChatGPT, Perplexity, Gemini, and Google's AI surfaces. That gap is what Honeyb measures. It runs your important prompts across the major engines on a schedule and records where your brand is mentioned, cited, and recommended, so you see how each stack actually treats you instead of guessing from one manual search.
If you want a first read on that today, run a free AI visibility check to see which engines mention your brand and which sources they lean on.
Frequently asked questions
Is an AI search engine just a chatbot with web access? No. A chatbot with web access answers mostly from model memory and looks things up occasionally. A purpose-built AI search engine inverts that: retrieval runs first, the answer is composed from the retrieved material, and a grounding layer ties claims to citations. The difference shows in how consistently each one can show you where a claim came from.
What is the difference between RAG and training the model? Training bakes knowledge into the model's weights, which is slow, expensive, and fixed until the next training run. RAG supplies knowledge at question time by fetching documents and putting them in front of the model. Training shapes how the model writes and reasons. RAG controls which current facts it has to work with. AI search needs both.
Which search index does each AI engine use? Google's AI Overviews and AI Mode use Google's index. Microsoft Copilot is grounded in Bing. Brave runs its own fully independent index, and Perplexity operates its own crawler. Most assistants without their own index license or partner for one. The index shapes what an engine can retrieve, which is one reason the same question surfaces different sources on different engines.
What is llms.txt and should I publish one? llms.txt is a plain-text file at the root of a website that lists its most important pages with short descriptions, written for AI systems rather than browsers. No major engine has committed to using it yet, so treat it as a low-cost hedge rather than a lever. It takes minutes to create, does no harm, and if engines adopt it your site is already on the list.
