A large language model (LLM) is an AI system trained on vast amounts of text to predict what words come next. From that single skill - guessing the most likely continuation - comes its apparent ability to answer questions, summarize documents, translate, and write.
How it works
An LLM learns statistical patterns across billions of sentences. When you give it a prompt, it doesn't look anything up; it generates a response token by token, each choice shaped by the patterns it absorbed during training. There is no database of facts inside it - only a compressed sense of how language tends to flow.
This is why an LLM can be so useful and so unreliable at once. Predicting fluent text is not the same as stating true text. A model will produce a confident, well-formed sentence whether or not the underlying claim is correct, because correctness was never what it optimized for. When that gap shows - a plausible answer with no basis in reality - it's called an AI hallucination.
Why grounding matters
On its own, an LLM answers from memory: a blur of everything it once read, with no way to point at a source. You can't check its work, because there's nothing to check it against.
Grounding closes that gap. Instead of asking the model to recall, you retrieve the relevant passages from a real document and place them in front of it - the approach known as retrieval-augmented generation. The model then writes from text you can see, and source-grounding keeps each statement tied to the passage it came from. The output stops being a guess and becomes something verifiable.
How an LLM "knows" things, versus traditional software
The comparison that makes an LLM click for most people is against the software they already understand - a spreadsheet formula, a search index, a rules engine. Traditional software is deterministic: a developer writes explicit logic, and the same input always produces the same output because a human specified exactly what should happen in every case. An LLM has no such rules written anywhere. What it "knows" is a statistical pattern absorbed from training text, which is why it can handle a question no one explicitly programmed for - and also why it can state something false with the same fluent confidence as something true.
| Large language model | Traditional rule-based software | |
|---|---|---|
| How it "knows" things | Statistical patterns learned from training text | Explicit rules and logic written by a developer |
| Handles novel/unseen input | Yes - generalizes from patterns, often gracefully | No - only handles cases the rules anticipate |
| Same input, same output | Not guaranteed (can vary run to run) | Always, unless the code or data changes |
| Can explain why it produced an answer | Not directly - no built-in citation to a rule | Yes - traceable to the exact rule or line of code |
| Can be confidently wrong | Yes - fluency and accuracy are independent | No - wrong output means a bug, not a "guess" |
| Improves by | Training on more/better data | A developer changing the code |
Neither model is strictly better - they're suited to different problems. A tax calculator should be deterministic rule-based software, because "confidently wrong" is unacceptable there. A tool that has to make sense of open-ended human language - a question, a document, a request phrased ten different ways - is exactly the kind of problem an LLM is built for, because no developer could pre-write rules for every possible phrasing.
This is the whole shape of how Sidenote works: it reads your document, retrieves the passages that matter, and grounds every answer in them - so each claim carries a citation you can click straight back to the source. See it in action on the Citations feature page.