Why a small model forgets facts but never forgets how to write

We've made the practical version of this argument before — what on-device AI can actually do is a capability map of where a phone-sized model matches the cloud. This is the mechanism underneath it. Once you see why the gap falls where it does, you stop being surprised by it, and you get much better at deciding which tool to open.

Weights are compression

Training a language model isn't storing text. It's fitting a very large set of numbers so that they predict text well. Those numbers — the parameters — end up holding a compressed representation of the regularities in the training data.

Compression is the key word, and it's lossy. A frontier model with hundreds of billions of parameters has room to keep a great deal of specific detail. A model with a few billion, small enough to run inside your phone's memory budget, has drastically less. Something has to be dropped.

What gets dropped isn't random. Training pressure keeps whatever reduces prediction error the most, and that produces a very predictable ranking.

Facts are expensive. Language is cheap.

Think about what it costs to store each kind of thing.

A fact — the year a specific building was finished, the third argument of an obscure function, a mid-sized city's population — appears in the training data a handful of times and has no structure that lets it be derived from anything else. There is no rule that generates it. It has to be memorized on its own, and there are hundreds of millions of such facts. That's a huge, flat, expensive tail.

Now think about English grammar. Subject-verb agreement appears in every sentence of every document. The shape of a polite email, the rhythm of a bulleted list, how a summary compresses a paragraph, what a formal register sounds like versus a casual one — each of these is reinforced billions of times. They're a small number of very high-frequency patterns.

So when capacity gets tight, the model keeps the patterns that pay off constantly and loses the specifics that pay off once. A small model writes a clean, fluent, correctly structured sentence about a fact it has half-forgotten. Which is exactly the behavior everyone finds so maddening — and it's not a defect, it's the shape of the compression.

The escape hatch: put the facts in the prompt

Here's the part that makes on-device useful rather than just interesting.

A model has two sources of information: what's in its weights, and what's in the text you gave it. The second source isn't compressed at all. When you paste in an email, a paragraph of notes, or a chunk of a document, those facts are sitting right there in front of the model at full fidelity.

Which means you can convert a knowledge task into a transformation task just by supplying the material. "What are the payment terms in this contract?" is a recall question if the model has to remember your contract, and a reading-comprehension question if you paste the contract in. Small models are bad at the first and genuinely good at the second — because reading comprehension is a language skill, and language skills are the ones that survived compression.

That single move is why an offline summarizer, email writer, or flashcard maker works on a phone, while "what happened in the news today" never will.

What the theory predicts, concretely

If the compression story is right, you should be able to predict what works without testing it. You can:

• Works well: rewriting, shortening, changing tone, fixing grammar, summarizing text you supply, extracting names and dates and action items out of a block of text, turning your own notes into questions, drafting from an outline you provide, generating variations on a phrase, formatting and restructuring.
• Works badly: trivia and dates, specific API or library syntax recalled from memory, anything about current events, niche technical detail, precise quotations, long multi-step arithmetic or logic, and very long documents that exceed what the model can hold at once.

Notice the pattern. Everything in the first list operates on text you brought. Everything in the second asks the weights to cough up a specific it probably compressed away.

Why it sounds so confident when it's wrong

Worth understanding, because it changes how you use the thing. A model doesn't have a separate "do I know this?" signal it consults before answering. It produces the most plausible continuation. When the specific has been compressed away, the most plausible continuation is a fluent, correctly-formatted, confidently-worded answer that happens to be fabricated — a plausible-looking author, a plausible-looking year, a plausible-looking function name.

Confidence is not evidence of recall. It's evidence of fluency, and fluency is the thing that survived. The practical rule that falls out: if the answer wasn't in what you supplied, verify it. If it was, you're on solid ground.

Where the cloud is genuinely better

Being straight about this, as always. A frontier model has enormously more room for the long tail, plus live retrieval, plus more capacity for multi-step reasoning. For research questions, current information, hard debugging, and anything that needs breadth of world knowledge, it wins and it isn't close.

The argument isn't that small beats large. It's that the everyday half of what people use AI for — rewrite this, summarize that, pull the tasks out of these notes, make this email less annoyed — is entirely the transformation half. That half doesn't need the long tail, doesn't need a server, and doesn't need a monthly bill. It also doesn't need to send your text anywhere.

The rule worth remembering

Bring the facts, ask for the work.

If you supply the material, a phone-sized model is a capable, private, instant collaborator that works on a plane. If you ask it to be an encyclopedia, it will politely make one up. Both of those follow from the same sentence: the weights are compression, and specifics compress worst.