Ask an AI a factual question and it will answer — that's the problem. It answers the same way whether it actually knows or is filling a gap with something plausible, and there's usually nothing in the tone or confidence of the response to tell you which one just happened. "AI that doesn't hallucinate" is the search every one of us eventually runs after being burned by a confident, wrong answer. The honest version of that search doesn't end at a tool that never makes mistakes — it ends at a mechanism that makes mistakes visible before they reach you.
That mechanism is called source-grounding, and it's worth understanding properly, because it's the difference between a tool that merely claims to be accurate and one that's built so you can check.
Why LLMs hallucinate in the first place
A large language model doesn't look things up and report what it finds. It predicts the next most likely token, over and over, based on statistical patterns learned from training data. Ask it a question and it produces the text that looks like a good answer to a question like yours — not a verified fact retrieved from a specific source.
Most of the time that prediction is close enough to correct that nobody notices. Language models have seen enormous amounts of text, so "plausible" and "true" overlap a lot. But they are not the same target, and the gap between them is where AI hallucination lives: fluent, confident, well-formatted output that simply isn't anchored to anything real.
A few structural reasons this keeps happening:
- The model answers from memory, not from your document. Unless something explicitly feeds it the actual text you're asking about, it's reconstructing an answer from the general shape of similar documents it's seen before — which can be true in general and wrong for your specific case.
- Fluency and correctness are trained separately, if at all. A model is optimized to produce text that reads well and satisfies the prompt. Nothing in that objective directly rewards "and this is checkable against a real source."
- Confidence doesn't correlate with accuracy. A hallucinated sentence and a well-supported one can come out in identical tone. There's no built-in signal — no hesitation, no hedge — that flags the invented one.
This is also why "AI that doesn't hallucinate" is a slightly misleading way to phrase the goal. No system can promise zero hallucination any more than a spell-checker can promise zero typos — what you actually want is a system where hallucination gets caught rather than delivered. That's what grounding is for.
How source-grounding actually works
Source-grounding is not a setting you turn on inside a chatbot. It's a design choice that runs through the whole answer pipeline, from retrieval to the moment text renders on your screen. There are three parts, and skipping any one of them leaves a gap.
1. Retrieve the actual passages before answering
The first step is retrieval-augmented generation: before the model writes anything, the system searches the document or page you're asking about and pulls out the specific passages relevant to your question. The model is then asked to answer from those passages, not from its general training.
This matters because it changes what the model is doing. Instead of "write something that sounds like a good answer to this kind of question," the task becomes "answer using only the text in front of you." That's a much narrower, much more checkable task — and it's the step that's missing entirely in a plain chatbot answering from memory.
2. Cite the exact passage, not just the document
Retrieval alone isn't enough if you can't verify it happened. The second half of grounding is attaching a citation to each claim that points at the specific sentence it came from — not a page number, not a link to "the document," but the exact passage, ideally one you can jump straight to.
This is the part most products get partway right. A citation that names a source but doesn't take you to the passage still leaves you hunting through a 40-page PDF to check one sentence. A citation that scrolls the live page to and highlights the exact passage — what's sometimes called scroll-to-source citation — turns verification into a one-click check instead of a search.
3. Drop the claim if it isn't supported
This is the step that makes grounding a mechanism rather than a marketing claim: after the model produces an answer, something has to check whether each claim actually matches a retrieved passage — and remove the ones that don't.
Without this step, grounding is only a bias, not a guarantee. A model can still be asked to "answer from these passages" and quietly generalize past what they say, especially on an ambiguous question. The verification pass is what catches that: if a sentence in the answer can't be traced back to text that was actually retrieved, it gets cut before you ever see it, rather than shipped with a citation bolted on after the fact.
This three-step chain — retrieve, cite the exact passage, verify and drop what fails — is the mechanism Sidenote runs on every answer. It reads the document, PDF, or page you already have open in your browser, retrieves the passages relevant to your question, and cites each claim with a link that scrolls to and highlights the source sentence. A server-side check runs before the answer reaches you: if a claim can't be matched back to a retrieved passage, its citation is dropped and the claim is removed rather than shown unverified. The result isn't a promise that every answer is perfect — it's a design where an unsupported claim gets caught instead of delivered with a straight face.
For a closer look at how this plays out specifically in summaries — where compression gives a model the most room to invent — see Do AI Summaries Hallucinate? How to Stop It, which walks through the same grounding mechanism from the summarization angle. The two posts are a pair: this one covers grounding as a general mechanism, that one covers the specific failure mode it fixes in summaries.
AI tools by grounding approach, compared
"Grounded" and "cites sources" get used loosely across the industry, so it's worth comparing what different tools actually do, not just what they claim. The table below is a roll-up of claims already published on Sidenote's head-to-head comparison pages — see those pages for the full detail on pricing, sources, and use case fit.
| Tool | Grounding approach | Verifiable to the passage? | Best for |
|---|---|---|---|
| Sidenote | Retrieves passages from the live page, cites each claim, drops unsupported ones server-side | Yes — scrolls & highlights the exact sentence | Everyday work docs, PDFs & web pages read in your browser |
| NotebookLM | Retrieves from uploaded sources, adds inline citation chips | No — cites the source, no jump to the passage in a live tab | Assembling a workspace of uploaded sources |
| Perplexity | Retrieves from public web search results, links each source | No — links the page, no passage highlight | Open web research questions |
| ChatGPT | Grounds only when it browses or you attach a file; otherwise answers from training | No — cites a link or file mention, no passage jump | General-purpose chat, with retrieval as an occasional add-on |
| Elicit | Retrieves from its academic paper database, cites at sentence level | Partial — points at a paper, not the live document you're reading | Literature review across published research |
| Consensus | Retrieves from a 200M+ peer-reviewed paper index, links to each cited paper | Partial — links the paper, not a highlighted passage | Evidence search against published studies |
| SciSpace | Retrieves from its paper database and uploaded PDFs, cites sources | Partial — passage jump works some of the time | Academic workflows: papers, methodology, lit review |
| Glean | Retrieves across a company's connected apps, cites the source document | No — cited answer, no passage-level highlight | Enterprise search across many internal tools |
The pattern across this table is consistent: retrieval is common, citation is common, but verifiable-to-the-exact-passage is rare. Most tools stop at "here's the document this came from" and leave the actual checking to you. Pricing and feature details change often — treat this as directional and check each tool's own page, linked above, before deciding.
How to test whether an AI tool actually hallucinates
Marketing copy is not evidence. Before you trust a tool with anything that matters, run it through a short test using a document you already know well — a report, a contract, a paper you've read closely.
- Ask a question with a definite, checkable answer. Pick something you know the document states clearly, so you can tell immediately whether the AI got it right.
- Click the citation, if there is one. Does it take you to the specific sentence, or just to the top of the document? Landing on page one of a forty-page file isn't meaningfully different from no citation.
- Read the passage and confirm it actually says the claim. This is the step people skip. A citation that points near the topic isn't the same as one that supports the specific sentence — read it and check.
- Ask something the document doesn't cover. A genuinely grounded tool will tell you it doesn't know or can't find support. A tool that always produces a confident, cited-looking answer — even to questions the source never addresses — is generating rather than retrieving.
- Repeat the same question and compare. If the citation points somewhere different each time, or the claim shifts slightly, the answer likely isn't as grounded as it first appeared.
- Try a document with a known gap or contradiction. If you have a source where two sections disagree, or one plainly doesn't cover a topic, a well-grounded tool should surface that tension or admit the limit rather than smoothing over it with a confident guess.
Where this leaves you
"AI that doesn't hallucinate" isn't a product category — it's a design property, and the tools above sit at very different points on it. If your reading is mostly published academic papers, Elicit, Consensus, and SciSpace all do a reasonable job of citing the literature. If you're inside one company's app ecosystem, Glean's enterprise-wide retrieval is a genuine strength even without passage-level highlighting.
But for the case most people actually have day to day — a mix of PDFs, web pages, Confluence runbooks, and shared docs, where you need to trust an answer without re-reading the whole source yourself — the property that matters most is whether a claim is verifiable down to the exact passage, and whether unsupported claims get dropped rather than shown. See exactly how that mechanism works, including the server-side check that removes any citation it can't verify, on the citations feature page.