How Models Store Knowledge

How Models Store Knowledge

When a language model answers a question, it's not looking anything up. There's no database being queried, no index being searched. The "knowledge" is baked into the weights of the neural network during training.

This is both remarkable and limiting. Understanding how it works explains why models know what they know — and why they sometimes don't.

Parametric Knowledge

The knowledge encoded in a model's weights is called parametric knowledge — it's stored in the parameters (weights) of the neural network.

During training, the model processes vast amounts of text. Patterns, facts, relationships, and concepts become embedded in the weight values. When you ask the model something, it's essentially reconstructing an answer from those encoded patterns.

This means:

• The model knows what was in its training data
• Knowledge has a cutoff date — training stopped at some point
• The model can't learn new facts after training (without fine-tuning or retraining)
• The model can't tell you what it doesn't know — it just generates the most plausible response

The Knowledge Cutoff Problem

Every model has a training cutoff date — the point at which its training data ends. Ask a model about an event that happened after its cutoff and it either won't know, will make something up, or (if it's been instructed to) will tell you it doesn't have that information.

This is why:

• Models confidently state outdated facts
• Models don't know about recent events unless told
• "What happened last week?" is a question no base LLM can answer reliably

The solution isn't to retrain the model constantly (that's extremely expensive). Instead, the common patterns are:

• RAG (retrieval-augmented generation): fetch current information and inject it into the context
• Tool use: let the model search the web or query a database
• Fine-tuning: update the model's weights on new data (less common for live information)

Emergent Knowledge

One surprising property of large language models is that they appear to store more than explicit facts. Large models seem to develop:

• Relational understanding: knowing that London is the capital of England, and that capitals are usually the largest or most politically important cities, without being explicitly taught every capital
• Reasoning patterns: the ability to apply logical steps to novel problems
• World models: rough simulations of how things work — physics, social dynamics, cause and effect

This "emergent" capability isn't fully understood. It seems to arise from scale — smaller models show it much less. It's one reason why large foundation models are so general-purpose, and why scaling model size has continued to produce surprising improvements.