Over the past few months I have been watching how people interact with the newest AI tools, and it’s almost always the same reaction. Someone opens Claude’s Cowork, or Perplexity’s Computer, or Microsoft 365 Copilot, points it at a folder or an inbox, and watches it do the work. People are amazed. They should be. These things are genuinely impressive.
But look at what’s actually in front of you. None of them is a single exchange with a language model. Perplexity Computer takes one request and routes it across roughly twenty different models, spinning up sub-agents to handle the pieces. Cowork reaches into your files and keeps working in the background after you’ve closed your laptop. There’s a model somewhere inside each of them, wrapped in retrieval, tools, and orchestration. Calling one of these “an LLM” is like calling a car “an engine.”
Yet, however intricate the system gets, what comes back to you is still one smooth response. All that machinery collapses into prose that reads like one narrator who knows things.
So, before we get into how these systems work, and we will over the coming weeks, we have to cover something more fundamental. Knowledge itself. Specifically, the two kinds an LLM runs on, parametric and corpus.
Parametric knowledge, or what the model knows by heart. When a model is trained, it reads a staggering amount of text with a single job, predicting the next token. Tokens are chunks of text a few characters long, often a piece of a word rather than the whole word. Every time the model guesses, it nudges billions of internal dials, called parameters or weights, and over enough guesses the patterns in all that text get baked into those dials. There’s no library inside the model, no filing cabinet it flips through. The knowledge is smeared across the numbers, the way your ability to ride a bike is smeared across your muscles and nerves rather than written on an index card in your head. So when the model tells you water boils at 100°C, it isn’t looking that up. It’s remembering, the way you remember something you’ve read a thousand times.
Corpus knowledge, or what the model looks up. Sometimes called non-parametric knowledge, this one sits outside the model rather than inside it. Corpus is just a fancy word for a big pile of documents. Think Wikipedia, your company’s documentation and manuals, or the databases the government puts on the web. These are the sources we tend to treat as ground truth, because a human curated them rather than an LLM.
In RAG (retrieval-augmented generation) systems, we hand the model those documents along with the question. The prompt stops looking like this
“Water boils at what temperature?”
and starts looking like this
“Here is a question the user asked. ‘Water boils at what temperature?’ Here are the resources you should use to answer it.
[document 1]
[document 2]
[document 3]”
At the moment you ask, the system reaches into that external pile, pulls back the passages that look relevant, and hands them to the model to read on the spot. Retrieve, then generate. That’s the whole name. The model answers from what’s in front of it, not from what’s in its memory (it’s not as simple as this and CS geeks would kill me but for our purposes this does the job).
Two kinds of knowing. What’s memorized, and what’s looked up. Keep them separate in your head and a lot of confusing AI behavior suddenly makes sense.
What each one is good at, and where each one goes blind.
Parametric knowledge is fast, fluent, and always available. It’s why a model can write you a solid paragraph on photosynthesis without consulting anything. But it has three nasty blind spots. It’s frozen at training time, so it doesn’t know what happened after its cutoff. It’s blurry, so it can misremember in the same way you swear a movie quote goes a certain way when it doesn’t. Lastly, it’s silent about its own edges. The model has no built-in sense of where its memory stops, so when you wander past what it actually knows, it doesn’t hit a wall. It just keeps generating fluent words, and those fluent words are what we call a hallucination.
Corpus knowledge patches some of that. Point a model at a fresh, trustworthy pile of documents and it can answer about last week, or about your company’s internal policies, or about a niche it never memorized, and it can show you the source. But it inherits a different set of blind spots, and those are the ones we’re really here for. A lookup is only as complete as the pile it draws from. If the documents don’t cover an angle, the answer won’t either, and the model won’t feel the gap, because it can only work with what got pulled back. Worse, search is built to fetch what’s relevant, which usually means more of the same. Ten passages that all make the popular point, and none that cover the missing one.
Here’s the part that matters most. The two kinds of knowing can disagree.
The document you retrieved might say one thing and the model’s memory might say another. So which one wins? Blindly trust the documents and a single bad source can drag a right answer wrong. Blindly trust the memory and you’ve thrown away the whole point of looking things up. Most systems today just cross their fingers. This seam, where memorized knowledge and looked-up knowledge meet and sometimes clash, is one of the liveliest problems in AI right now, and it’s where completeness quietly lives or dies.
That’s what brings us to the question this whole series has been building toward. It started at “is this relevant?” Then came the accuracy question, “is this true?”, the one that FActScore and the Verifying AI series drilled into. Don’t trust the polish, check the pieces. The next one is harder. Is this everything?
Let’s push that question to its root. Before you can ask whether an answer covered everything, you have to ask something more fundamental. Does the system even know enough to cover everything, and does it know where its own knowledge runs out? A model can be completely right and still be answering about the wrong-sized slice of the world. Right about the three points it happened to hold, blind to the fourth it never had. Correct and incomplete at the same time. No model is exempt from this. It’s just the shape of how these things know things.
So the mental model to take away is simple. An AI answer is always drawing on two accounts, memory and lookup, and completeness is a question about both. When an answer matters, don’t just ask “is this true?” Ask which account it’s coming from. Memory is fast, fluent, frozen, and blind to its own edges. Lookup is fresh and sourced, but only as complete as the pile behind it. Then ask what the answer would look like if the other account disagreed, and what angle neither one thought to include.
If you want to get a level deeper into the specifics, there are three Toottee Papers, each taking one edge of that seam. R-Tuning works on the memory side, training a model to say "I don't know" instead of bluffing past the edge. Astute RAG works on the conflict, deciding which side to trust when memory and documents disagree. SAFE works on the finished answer, scoring it for completeness and not just correctness.