How modern search actually works: the five-stage retrieval funnel

Before an AI answer engine writes one word, it has already thrown away almost everything. If you do not know where in the pipeline your content is failing, you cannot fix it.

Most of the effort I see spent on AI search optimisation is spent in the wrong place. People polish the quality of a page, its tone, its authority, its citations, and then they wonder why ChatGPT or Perplexity never mentions them. The uncomfortable answer is usually that the system never read the page closely enough to judge any of that. It had already eliminated the content much earlier, at a stage where writing quality has almost no effect at all.

So before we talk about tactics, let’s notice a simpler fact. A modern answer engine does not read the web the way a human does. It runs your content through a narrowing funnel, and by the time it is choosing which claims to put into an answer, roughly ninety-nine percent of what it could have used is already gone. If you do not know where in that funnel your content is failing, you cannot fix it. You are, at best, guessing.

This piece is a mechanical explainer. No opinions, no predictions. Just the pipeline, stage by stage, so that you can diagnose which gate is closing on you instead of reaching for a generic tactic. It pairs with the deeper walk-through in the AI Search Optimisation & Agentic SEO course, and with the chunk, not the page, where we get concrete about the unit the machine actually reads.

The query is not the task, and the task is not the objective

Start before the funnel, with what the system thinks you are even asking. There are three layers here and they are easy to conflate. The query is the surface string a person types. The task is what the system infers as the actual work to be done. The objective is the underlying goal, which is often never stated at all.

Take “best CRM for a small business.” The query is those five words. The task the system infers is: find and evaluate CRM options suitable for a small-business context. The objective underneath it is something like reduce administrative overhead and make the sales process less painful. Your content is not matched against the string. It is matched against the inferred task. Which means a page stuffed with the exact phrase “best CRM for small business” can still miss, because it answers the words and not the work.

And here is the part that changes how you plan content. A single complex query does not stay whole. Before anything is retrieved, the system runs a short sequence: it classifies the intent, infers the task, then decomposes that task into sub-tasks that are each retrieved separately. That sequence is worth seeing laid out, because every later stage inherits its shape.

So the query string you are trying to “target” is only the first box in that chain. By the time the system is retrieving, it is no longer looking for your keywords. It is looking for the best source for one inferred sub-task at a time.

One query becomes many sub-retrievals

Ask “what marketing strategies work best for SaaS companies?” and the system does not run one big search. It breaks the question into distinct sub-tasks: define what characterises SaaS, identify the relevant B2B channels, retrieve performance data, evaluate the credibility and recency of that data, then synthesise the pattern. A single user query can generate five to ten internal searches of this kind.

The important consequence is that these sub-retrievals do not share a pool. Each one has its own embedding, its own set of candidates, its own winners, and the pools barely overlap. So a long, comprehensive guide that tries to answer the whole question can win one sub-task and quietly lose the other six to smaller pages whose headings mirror the sub-question exactly. As I put it in the course: complex queries are not answered by one page, they are assembled from winning chunks across multiple independent sub-retrievals.

So the useful question stops being “does my content cover this topic?” and becomes “which sub-task of this query can my content definitely be the best answer for?” That is a much sharper question, and it is answerable.

The five-stage funnel

Now the funnel itself. For each of those sub-retrievals, the system runs through five stages, and each one is an elimination. Let’s dive into them.

Stage one is candidate retrieval. Millions of possible chunks are narrowed to thousands using keyword and vector similarity, and simple index presence. If you are not crawled, not indexed, or semantically far from the query, you never enter. Stage two is initial filtering. Thousands become hundreds through entity matching, recency where it applies, and basic credibility. Stage three is re-ranking. Hundreds become tens, and this is where deeper relevance, claim-level authority, information density and cross-source consistency start to matter.

Stage four is where the unit changes. Up to here the system has been handling documents and passages. Now it switches to the claim. It extracts individual statements from the survivors and stops thinking about your page as a page at all. Stage five is synthesis selection, where agreement across sources becomes the dominant signal and the system decides which claims actually enter the answer, and whether it names you.

Do the arithmetic. If millions enter at stage one and roughly ten survive to stage four, then about ninety-nine point nine percent of content is eliminated before any individual claim is even assessed. That single number reorganises priorities. Optimising your claim-level phrasing at stage three or four is irrelevant if you are being cut at stage one or two. You are perfecting a sentence that the machine will never reach.

Two gates, two completely different machines

Here is the distinction that I find most people miss, and it is the one that makes diagnosis possible. The funnel is not one long test with a consistent standard. It is two different machines, and they judge on completely different criteria. These are not two versions of the same test.

The early gate, roughly stages one to three, is geometry. It compares the vector of your chunk to the vector of the query and keeps the ones that sit closest in an abstract mathematical space. That is cosine similarity, and it is not language understanding. It has a consequence that sounds wrong the first time you hear it: a factually incorrect chunk about the right topic will score higher than a factually correct chunk about the wrong topic. At this gate, your writing quality, your citations and your domain authority have almost no effect. The system is not testing quality. It is testing geometric proximity.

The late gate, stages four and five, is language. Now the surviving chunks are actually read as text by the generator, and evaluated on things like whether each one stands on its own, whether its claims can be attributed, whether it agrees with the other sources, and whether it adds anything the others do not. A chunk that is perfectly positioned in vector space can still be dropped here, silently, with no signal back to you that it happened.

So the two failure modes need opposite fixes. If you are being cut at the early gate, no amount of rewriting the prose will help, because the machine deciding your fate does not read prose. You have a geometry problem: your topic is diffuse, your entities are absent, your headings do not match the sub-query. If you are surviving retrieval but never getting cited, you have a language problem at the late gate. Fix the geometry before you evaluate the prose. And, plainly: you cannot fix quality problems that the system never gets to evaluate.

Retrieved and being cited are two different achievements.

Why the funnel is your diagnostic map

The reason the funnel matters is not that it is interesting architecture. It is that it turns a vague complaint, “the AI never mentions us,” into a locatable problem. Zero citations with heavy crawler activity in your logs is an early-gate symptom, a geometry problem to fix at the embedding level. Being retrieved but consistently absent from the final answer, or cited only in the wrong context, is a late-gate symptom, a language and structure problem.

Let’s put a few of the numbers in one place, because they set the priorities for everything else you might do.

After the early filter you are looking at a top pool of roughly twenty to fifty chunks. Re-ranking cuts that to three to eight. The generator reads those three to eight and typically cites one to four. Every stage is another chance to be eliminated, and the earliest stages eliminate the most. This is why I keep telling people to work in funnel order: survive stage one and two first, through crawlability, entity clarity and topical sharpness, and only then invest in the claim-level polish that the later stages reward.

None of this is a metaphor for how search feels. It is a functional description of what the system does to your content before it decides anything. Once you can see the funnel, most “AI SEO” advice sorts itself into two piles: the advice that addresses a stage you are actually failing, and the advice that polishes a stage you never reach.

Where this goes next

The single most useful move that follows from all of this is at the early gate, and it is about the unit the machine retrieves. Not your page. A roughly five-hundred-token chunk of it, judged in isolation, on geometry. If your content is not built so that those chunks survive on their own, the rest of the funnel is academic. That is the subject of the chunk, not the page.

In the course I take this apart with the discard map, the sub-query mapping exercise and the two self-run tests that tell you which gate is closing on a specific page, so that you stop optimising in the dark. The funnel is the diagnostic backbone for all of it.