AI Doesn't Read. It Cross-References Fragments at Once
A Stanford study found models reliably lose facts buried in the middle of long documents — no matter how big the context window gets
The Word That Broke the Machine
In the summer of 2024, thousands of people typed some version of the same sentence into a chatbot: "How many r's are in strawberry?" A model built on hundreds of billions of parameters, capable of drafting sonnets and debugging code, answered "two." It was wrong. The internet treated this as a joke about AI stupidity, but it's a far more interesting failure than that. The model wasn't bad at counting. It was never looking at letters in the first place. It had already converted "strawberry" into a small number of statistical chunks — something closer to "straw" and "berry" fused together — and it was reasoning over those chunks, not over the twenty-six letters a human eye would scan. The model didn't misread the word. It never read the word at all, not in any sense a human would recognize.
That gap is the real story behind every headline about AI "reading" a contract, a research paper, or a 400-page filing in seconds. The comforting version of this story says AI just reads faster than we do — a tireless intern skimming at superhuman speed. The truth is stranger and more consequential: a large language model doesn't skim, scan, or comprehend in any operation resembling human reading. It performs a mathematical transformation on fragments of text, all at once, with no eyes, no attention span in the human sense, and — this is the counterintuitive part — no guarantee that giving it more of a document to "read" makes it understand that document better. In some well-documented cases, the opposite happens.
The Alphabet Machines Don't Use
Human reading starts with letters, which combine into morphemes and words we recognize instantly because we've seen them thousands of times. Language models start somewhere stranger: a fixed vocabulary of tens of thousands of subword fragments, assembled through an algorithm called byte-pair encoding (BPE), introduced for machine translation by Rico Sennrich and colleagues in 2015 and later adopted as the standard tokenization method for GPT-style models. BPE builds its vocabulary by repeatedly merging the most frequent adjacent character pairs in a training corpus, which means the chunks a model actually manipulates are frequency artifacts, not linguistic units. Common words become a single token; rarer words get sliced into two, three, or more pieces that don't line up with syllables or morphemes at all.
This is why letter-counting, rhyme detection, and reversing a word are disproportionately hard for models that otherwise ace the bar exam. The model isn't manipulating "s-t-r-a-w-b-e-r-r-y." It's manipulating token IDs — arbitrary integers standing in for chunks — and has to infer letter-level facts indirectly, the way a person might guess the spelling of a word they've only ever heard spoken aloud. OpenAI's own public tokenizer tool lets anyone paste in text and watch it fracture into these colored chunks in real time, and the exercise is quietly humbling: whole sentences you'd read as fluid meaning get carved into pieces that follow the statistics of the training data, not the logic of English.
No Eyes, No Skipping, No Doubt
Human reading is not actually a smooth left-to-right scan. Decades of eye-tracking research, going back to foundational work by psychologist Keith Rayner, established that our eyes move in quick jumps called saccades, landing on a word for roughly a quarter of a second, sometimes skipping short or predictable words entirely, and — crucially — jumping backward to re-read something we didn't quite trust. Regression, in reading research, isn't a flaw. It's the mechanism by which humans catch ambiguity, resolve a pronoun, or double back on a plot twist. Reading is an argument we have with the page, conducted in real time, guided by what we already believe the sentence is about to say.
A transformer model has none of this. The self-attention mechanism described in the 2017 paper "Attention Is All You Need" processes every token in the input simultaneously, computing a weighted relationship between each token and every other token in a single parallel pass. There's no scanning, no skipping based on interest, no moment of doubt that sends the model back to check a fact three paragraphs earlier — because there's no earlier or later in the way a human experiences it. Position is just a number added to each token's representation so the model can tell "the dog bit the man" from "the man bit the dog." It's bookkeeping, not eyesight. The model doesn't decide a passage is important and linger on it; it computes attention weights for all passages at once and averages accordingly. What looks like comprehension is closer to simultaneous cross-referencing than reading.
The Middle of the Book Goes Missing
Here is the finding that should unsettle anyone treating "context window size" as a proxy for how well an AI reads. In 2023, Stanford researcher Nelson Liu and colleagues published "Lost in the Middle: How Language Models Use Long Contexts," testing what happens when models are asked to find a specific fact buried at different positions within a long passage. If a model genuinely processed all tokens in parallel with equal fidelity, position shouldn't matter much. Instead, the researchers found a consistent U-shaped performance curve: models were reliably better at using information placed at the very beginning or the very end of a long context, and measurably worse at retrieving facts buried in the middle — even though every one of those tokens passed through the exact same attention computation.
This is the opposite of what "reading more carefully" would predict. A human given more pages to search doesn't necessarily forget the middle chapters; a careful reader can flip back to page 140 as easily as page 2. But a model's relative blindness to the middle of its own context is a structural side effect of how attention weights get distributed and how positional encodings behave at scale, not a matter of effort or attention in the colloquial sense. It means the marketing figure everyone quotes — a "1-million-token context window" — describes capacity, not comprehension. A bigger window lets you pour in more of a document. It does not promise the model will use the middle of it evenly.
Flattening the Page
There's a second, less-discussed casualty in how AI reads: the physical shape of a document. A printed page carries meaning in two dimensions — a header in a larger font, a footnote in smaller type, a table where meaning depends on which column a number sits in, a sidebar that isn't part of the main argument at all. Human readers reconstruct this instantly using visual layout cues before they've consciously parsed a single sentence. Standard text extraction throws all of that away, flattening a two-dimensional page into a single one-dimensional stream of tokens, sometimes stitching a footnote into the middle of a paragraph it has nothing to do with.
Researchers noticed this problem early enough that Microsoft's LayoutLM, introduced in 2019, was built specifically to bolt spatial coordinates back onto the text tokens a model sees, teaching the system that a word's position on the page carries its own signal. Newer document-AI systems go further, feeding models an image of the page alongside — or instead of — the extracted text, essentially admitting that stripping layout from language loses something reading depends on. That such a workaround was necessary tells you the default pipeline was never "reading" a document the way a person opens a PDF; it was harvesting a bag of tokens from it.
None of this means these systems are unimpressive — they're not. But the industry's preferred metaphor, that AI "reads" a contract or a court filing, quietly imports a claim about comprehension that the mechanics don't support. What's actually happening is closer to a very fast, very literal statistical cross-reference of fragments, indifferent to position in ways that occasionally cost it the middle of the very document it was asked to summarize. The next time a vendor advertises a bigger context window as proof their AI reads more thoroughly, the right question isn't how much it can hold. It's where, inside all that text, the machine quietly stopped looking.