Passage Extraction: How LLMs Pull and Quote the Exact Sentences They Cite

You wrote a good page. It ranks. And still, when someone asks ChatGPT or Perplexity the exact question your page answers, the engine quotes a competitor's sentence instead of yours.

If that stings a little, take a breath. It is not a flaw in your writing. It is a step most people have never seen: the moment an answer engine reaches inside a page it has already pulled and picks one specific sentence to lift into its answer.

That step is passage extraction. Understanding how AI extracts passages is the difference between guessing why you got skipped and knowing exactly where the decision happened.

Here is what you will walk away with: a clear picture of how an engine chooses the single sentence or short span it quotes, why that choice is separate from ranking, and what makes one of your sentences get pulled while the one right next to it gets ignored.

Let's take it one step at a time.

Passage extraction, in one sentence

Passage extraction is the step where an answer engine reaches into a page it has already retrieved, selects one specific sentence or short span, and lifts it (or a close paraphrase) into its answer beside a citation.

That is the whole idea. The unit it pulls is a sentence, not your page and not a big block of it.

It helps to see the three jobs that keep getting confused with each other:

• Chunking splits your page into pieces at index time. A storage decision.
• Retrieval decides which of those pieces surface for a question. A recall decision.
• Passage extraction decides which sentence inside the surfaced piece gets quoted. A selection decision.

Chunking and retrieval get your page into the room. Passage extraction decides which of your sentences gets to speak. When you ask which sentence AI cites, you are really asking about this last step, and it is the one most content advice skips right over.

The passage extraction LLM engines perform is not a separate screen you can watch. It is folded into how the model reads and writes, so it stays invisible unless you know to look for it. That is exactly why it feels like a mystery, and why it stops feeling like one the moment you can name it.

Chunking finds the page. Extraction picks the sentence.

Here is the trap. Teams pour effort into ranking, get the page retrieved, and assume the citation just follows. It does not.

A page can win retrieval and still lose extraction. The engine pulled your page into its shortlist, read it, and decided that no single sentence in it was clean enough to quote. So it quoted someone else.

Why does that happen? Because ranking rewards a whole page that is broadly relevant, while extraction rewards one sentence that stands on its own. Those are two different bars.

Picture a page ranked fifteenth whose definition sentence is crisp and complete. It can beat the top-ranked page whose answer is buried inside a rambling paragraph. At the passage level, position on the results page stops mattering as much as the shape of the sentence itself.

This is also why chunking and extraction are siblings, not the same job. Chunking is about how your page is cut for storage and retrieval. Extraction is about which sentence survives once a chunk is already in hand. You can get one right and still trip on the other, which is worth knowing before you rewrite anything.

Where passage extraction sits in the pipeline

Let's zoom out and put extraction on the map. Most answer engines move through four stages:

1. Indexing and chunking. Your page is split into retrieval units when it is crawled.
2. Retrieval and ranking. A short list of chunks surfaces for the question.
3. Passage extraction. Inside those chunks, specific spans are marked as evidence for the small claims the answer is about to make.
4. Grounded generation. The model writes the answer one sentence at a time, tying each sentence to a chosen span and a source URL.

Extraction sits in the middle, between finding your page and writing the answer. That middle step is the part that decides how AI quotes a source: it picks the span, then generation binds that span to the sentence you read and the little citation marker next to it.

This whole loop is retrieval-augmented generation, usually shortened to RAG. The act of tying a written sentence back to a source span is called grounding. When grounding works, the sentence in the answer points at a real span on a real page. When it drifts, you get a citation that does not hold up, and we will come back to that.

There is a reason engines bother with sentence-level binding at all. Tying each claim to a specific span, rather than to a whole document, is what keeps the answer honest. Research on retrieval-augmented systems consistently finds that span-level grounding cuts down on made-up facts and improves how well a citation matches the claim it supports. The engine is not being fussy for the fun of it. Narrow grounding is how it tries to earn your trust, and it is why your sentences, not your pages, are the thing being judged.

How the engines actually pick a sentence

The mechanics differ by engine, but they collapse into three patterns. You do not need the math. You need the shape.

Pattern one: a reader model scores spans. An older but still-used design encodes your question together with a candidate passage, scores where the best answer starts and ends, then returns the highest-scoring short span, usually a few dozen tokens long. This is the classic extractive answer AI approach, and pieces of it still live inside modern stacks.

Pattern two: the model writes, then binds each sentence to a span. This is what you see in ChatGPT. As it generates, it pairs each sentence with an offset range in the source, the exact start and end of the text that sentence leans on. The citation you click carries that matched text underneath it.

Pattern three: the model trims the context before it writes. This is Perplexity's approach. After retrieval, it runs a compression step that scores every sentence and keeps only the ones that earn their place, labeling the rest as off-topic, ads, navigation, or duplicate. That compression model was trained on hundreds of thousands of query-document pairs, with a separate judge marking each span as vital or noise, so it learned what a keepable sentence looks like. Sentences that get dropped here never reach the writer, so they cannot be quoted, even if a human would call one of them the most relevant line on the page.

That is how AI extracts passages in practice, three different machines reaching for the same kind of sentence. Across the named engines, the same logic shows up in different clothes:

• Perplexity typically pulls five to ten pages for a question and ends up citing three or four. The compression step is where most of the rest fall away.
• Google already indexes pages at the passage level, ranking passages on their own rather than only whole pages. Its AI answers hyperlink each sentence to the specific passage it came from.
• ChatGPT quotes or near-quotes the sentence whose span matches the claim it is making, and it leans toward declarative sentences with named entities.
• Gemini, when it is grounded in Search, links its citations to specific passages inside a page, not to the page as a whole.
• Claude tends to quote when the source is concise and accurate, and paraphrase when the source is hedged or wordy.

Different engines, one shared habit. Every passage extraction LLM stacks run still comes down to reaching for the cleanest, most self-contained sentence that answers the exact sub-question in front of it.

If you want the sequence in one glance, here is how a sentence gets chosen once your page is retrieved:

1. The engine breaks your question into the smaller claims the answer will need to make.
2. It maps each claim to candidate sentences from the pages it pulled.
3. It scores every sentence for how well it fits its claim.
4. It drops the ones that are hedged, vague, missing entities, or duplicates of a stronger line.
5. It binds the surviving sentence to a citation marker and writes the answer.

The sentence that gets quoted is almost always the one that scored highest at step three and survived step four. Nothing else about your page enters the room at this point.

What makes one sentence extractable over another

So what actually decides which sentence AI cites once your page is in the running? The engines are not identical, but their preferences rhyme. The sentences that get extracted tend to share these traits:

• Self-containment. The sentence makes sense lifted out of its paragraph. No "this," "that," or "as shown above" pointing at something the reader can no longer see.
• Declarative shape. Subject, verb, object. A plain statement of fact, not a question, a hedge, or a transition.
• Concrete detail. Names, numbers, dates, units. The stuff an answer-seeker actually came for.
• Answer-shaped phrasing. A sentence built like the expected answer beats a paragraph that merely mentions the topic.
• Top-of-section position. The first sentence after a heading, the first item in a list, the lead of a definition. Extractors hit these spots far more than the middle of a paragraph.
• A source named inline. "According to a 2025 Pew study, X" is easier to bind to a citation than the same fact stated bare.
• A fact worth adding. A sentence that contributes something the other retrieved pages do not gets picked over one that restates the obvious.
• Freshness on moving topics. An explicit date or an "updated" marker beats an undated sentence when the question is about something that changes.

Audits back the pattern up. Roughly nine in ten top Perplexity citations put the answer in the first sentence or two of a section, a bottom-line-up-front habit. Pages marked with FAQ or HowTo schema showed top-three citation rates near 47 percent in observed audits, against about 28 percent for comparable unmarked pages. Treat those as patterns seen in specific audits, not laws of physics, but the direction is clear enough to act on.

Freshness shows up in the audits too. Around seven in ten cited pages had been updated within the prior twelve to eighteen months at the time they were checked. On questions where the answer moves, a dated sentence quietly wins the spot.

Length matters too. Sentences under about thirty words dominate citations. Sentences over fifty words are almost never quoted word for word, because they blow past the span budget the model and the display are working with.

Now the other side. The sentences that rarely get pulled, even when the page ranks: hedged ones ("might," "could," "it seems"), context-dependent ones (a pronoun with no antecedent inside the lifted span), long winding paragraphs, and lines that just repeat what every other page already said. The extractive answer AI builds has no reason to quote the twentieth version of a sentence it has already seen.

One boundary worth naming out loud. This piece is about why the extractor prefers one sentence over another, the mechanism. Turning that into a repeatable way to write passages that get pulled is its own how-to, and it deserves its own walkthrough on self-contained passages. Here we are staying on the why.

What this looks like for four common questions

Abstract criteria get real fast when you tie them to the question being asked. Here is how extraction tends to land across four everyday query types.

A comparison question ("X vs Y") pulls the row or the single sentence that names the specific difference. A long paragraph weighing the same two things loses to a table row that states the contrast outright.

A how-to question pulls the numbered step that performs the action. Ordered lists with clear step-level structure win. The same instructions written as flowing prose get passed over.

A definition question pulls the first sentence after the heading, or the contents of a definition block. Pages that lead each section with a one-sentence definition get lifted. Pages that warm up for three sentences before defining the term do not.

A statistic question pulls the sentence that carries the number, the date, and the source in one span. "Recent studies show growth" loses to "In 2025, X grew 12 percent, according to Pew." The engine wants the whole fact in a single liftable line.

See the pattern? Every one of these rewards the same thing: one sentence that answers the exact question and needs nothing around it to make sense.

One more thing that trips people up. The engine can reword the surface of your sentence while still pulling the same underlying span. If you see a paraphrase in the answer instead of your exact words, the selection did not change. The model simply smoothed the wording on its way out the door. The span it chose is stable even when the phrasing shifts, which is why chasing the perfect quote matters less than owning the sentence that gets picked.

When extraction picks the sentence but botches the quote

There is a failure mode worth knowing, because it saves you from chasing a ghost.

Selecting the right sentence and quoting it faithfully are two separate steps, and they can come apart. An engine can pick a genuinely relevant span, then present a quote whose words do not actually appear at the linked page. In ChatGPT Search, public analyses have surfaced exactly this: quoted text attributed to a URL that never contained it. The name for it is unfaithful citation.

It is a known glitch, not a sign the system is doing its job well. Selection can be right while reproduction drifts. So if you audit your citations and find a quote that misquotes you, that is not proof your page is fine, and not proof it is broken. It is proof that how AI quotes a source and how AI reproduces that source are two different things, each able to fail on its own.

This is also why "cited" and "quoted" are not the same word. A page can be cited without being quoted, and quoted without being cleanly attributed. The strongest spot to be in is both at once: the sentence pulled and the link pointing home.

Bringing it home

Let's land this. Ranking gets your page into the room. Chunking and retrieval get a piece of it onto the table. Passage extraction is the quiet step that decides which of your sentences the engine actually says out loud.

You do not need to master the scoring math to use any of this. You need to see that the step exists, and to start reading your own pages the way an extractor does: sentence by sentence, asking whether any one line could stand alone as the answer.

Start with one page and one question you want to win. Read the section that should answer it. Is the answer in the first sentence, stated plainly, with the concrete detail intact? If not, you just found why you are getting skipped.

If you would rather see this at the page level across your whole site, a platform like DeepSmith tracks which of your pages AI actually cites and for which prompts, so you can spot the gap before you rewrite a single word. That turns "why did they quote someone else" into a short list you can work through.

You are closer than this felt at the start. One page, one sentence, one step.