The Strawberry Problem

Language models fail spelling tests not because they cannot think, but because they have never once seen a letter.

The Mirror Test, Part I: Reading

---

In the summer of 2024, a fruit humiliated the most expensive machines ever built.

Ask GPT-4 how many times the letter r appears in the word strawberry, and it would often answer two. Not sometimes. Often. Users posted screenshots by the thousands. The model that could pass the bar exam, write working code, and explain quantum field theory could not count to three inside a ten-letter word. OpenAI leaned into the joke and codenamed its next reasoning model Strawberry. The meme became a shorthand for a whole genre of skepticism: if it can’t even spell, how can it think?

It is a fair question. It also has a precise, mechanical, and illuminating answer. The answer is not that the model is stupid. The answer is that the model has never seen the word strawberry. Not once. Not in training, not at inference, not ever. What it has seen is something else entirely, and once you understand what that something is, an entire family of famous AI failures snaps into focus at once: the spelling errors, the arithmetic slips, the reason a Burmese sentence still costs nearly triple its English translation, and a haunted token called SolidGoldMagikarp that once made GPT-3 lose its mind.

Strawberry is a story about perception. And like every story about perception, it is really a story about what a mind can and cannot know.

The text that isn’t there

One fact underlies everything else: a large language model does not read text. It reads tokens.

Before your words ever reach the neural network, they pass through a preprocessing step called tokenization. A tokenizer is a fixed lookup procedure, built once and frozen before training begins, that chops the stream of characters into chunks and replaces each chunk with an integer ID. The model then operates purely on those integers. The characters are gone. From the network’s point of view, they never existed.

The chunks are not letters, and they are usually not whole words either. They are statistical fragments, learned by an algorithm called byte pair encoding, or BPE. The idea is older than modern AI. Philip Gage published it in 1994 as a data compression trick: scan a corpus, find the pair of symbols that occurs together most often, merge that pair into a new single symbol, and repeat. Do this fifty thousand or two hundred thousand times and you get a vocabulary of chunks that is beautifully tuned to the statistics of the training data. Common words become single tokens. Rare words shatter into pieces. In 2016, machine translation researchers realized this compression trick solved a deep problem in neural text processing, and by the time GPT-2 arrived it had become the default way every major language model ingests the world.

The efficiency gains are enormous. A token vocabulary compresses typical English by roughly a factor of four compared to raw characters, which means four times more text fits in the same context window, and attention, whose cost grows with the square of sequence length, runs an order of magnitude cheaper. Tokenization is not a hack. It is load-bearing infrastructure. Every dollar of compute in the modern AI economy flows through it.

But compression has a price, and the price is exactly what the strawberry meme discovered.

Running the experiment

Claims about tokenizers are cheap, so let us measure. OpenAI publishes its tokenizers in an open-source library called tiktoken, which means anyone can check precisely what GPT sees. I ran the word strawberry through the two vocabularies that powered the models at the center of the meme: cl100k_base, used by GPT-3.5 and GPT-4, and o200k_base, used by GPT-4o.

Here is what cl100k_base does to the word when it appears at the start of a sentence or standing alone:

And here is the same word with a leading space, which is how it appears in the middle of any normal sentence:

The second table is the stranger one. In the sentence “I love strawberry ice cream,” the word strawberry is one indivisible unit, token ID 73700, a single opaque integer with no internal structure whatsoever. The model receives 73700 the way you receive the color red: whole, immediate, unanalyzable. There is no r inside token 73700. There are no letters inside it at all. Asking the model to count the r’s in that token is like asking you to count the photons in a sunset. The information existed upstream of your perception, but your perception did not preserve it.

The newer o200k_base vocabulary tells the same story with one twist. The standalone lowercase word now splits differently, into st, raw, and berry. Same word, same meaning, different model generation, entirely different perceptual chunks. And notice what the split does to our counting problem: the letter r now hides in two separate fragments, one r inside raw and two inside berry, and no fragment’s ID advertises how many r’s it contains. To count correctly, the model would need to have memorized the exact spelling of every fragment in its vocabulary and then perform addition across them, blind, in a single forward pass.

Which brings us to the strangest fact in the tables. The same word tokenizes differently depending on where it sits in a sentence. Strawberry after a space is one token. Strawberry after a quotation mark is three. Strawberry at the start of a line is three different tokens than strawberry in lowercase. A human reader would say these are trivially the same word. To the model they are four unrelated perceptual objects that it must learn, from statistics alone, to treat as one concept. That it succeeds almost all the time is remarkable. That it occasionally fails should surprise no one.

So how does it ever spell anything?

Here a sharp reader should object. Models can spell. Ask GPT-4 to spell strawberry letter by letter and it will happily produce s, t, r, a, w, b, e, r, r, y. If token 73700 contains no letters, where did the letters come from?

Memory. Pure memory. Somewhere in its training data, the model encountered spelling lists, dictionaries, children’s homework, acrostic poems, alphabetization examples, and millions of other texts that incidentally reveal which characters live inside which tokens. It learned an association between the opaque integer and its spelled-out form, the same way you memorized that the opaque symbol 7 is associated with the word seven. The spelling is not perceived. It is recalled.

And recalled facts, unlike perceived ones, fail silently. The model’s memorized spelling knowledge is strong for common tokens and weak for rare ones, strong when the question is phrased like training data and weak when it is phrased like a trick. Counting compounds the problem, because counting requires holding a running tally across steps, and a model answering in a single reflexive burst has nowhere to hold it. This is why the fix turned out to be reasoning models. When a model is allowed to think step by step, it can spell the word out from memory first, externalizing the letters into its own visible output, and then count what it just wrote. The letters become perceivable precisely because the model wrote them down where it can see them. OpenAI’s o1, the model literally codenamed Strawberry, counts the r’s correctly not because it sees letters any better than GPT-4 did, but because it learned to take notes.

The maneuver is an old one. It is what you do when you count the letters in a long word. You do not perceive the answer. You recite and tally.

You don’t read letters either

Human reading is supposed to be the reassuring contrast here. It is the opposite, because the neuroscience of reading is where the strawberry problem stops being a curiosity about chatbots and becomes a window into perception itself.

You do not read letter by letter. Skilled readers fixate on a word for a quarter of a second and recognize it as a unit, and a region of your left ventral visual cortex, the visual word form area, responds to familiar words as whole learned patterns. Psychologists have known since James McKeen Cattell’s experiments of 1886 that literate adults recognize a whole word about as fast as a single letter, and identify a letter more easily inside a word than standing alone, a family of findings now called the word superiority effect: the whole is perceived before, and more easily than, its parts. You have almost certainly seen the internet demonstration in which the interior letters of every word are scrambled and you can raed the pargarpah aynway. The demo is folklore rather than published science and it exaggerates the effect, but the kernel is real. Your reading system binds letters into chunks and reads the chunks.

In other words, you also run a tokenizer. Evolution and childhood literacy built you a compression scheme for text, for the same reason OpenAI built one: perceiving in larger units is radically more efficient, and efficiency is the whole game when compute is scarce, whether the compute is silicon or cortex.

The difference, and it is the difference that matters, is that your tokenizer has an escape hatch. When a word is rare, or foreign, or when someone asks you how many r’s it contains, you can voluntarily drop down a level and process the letters one at a time. Slow, serial, effortful, but available. The whole-word route and the letter-by-letter route coexist in your reading system, and damage that severs the fast route produces a striking clinical syndrome, first described by Joseph Jules Dejerine in 1892 and known today as letter-by-letter reading, in which patients can still read anything but must laboriously spell their way through each word like a first grader. The fast path is a convenience. The slow path is the bedrock.

A language model has no slow path. Tokenization happens outside the network, before perception begins, and the network cannot reach upstream of its own senses. It is, in the most literal architectural sense, a fluent reader with the fallback route cut. It perceives in chunks or not at all. The strawberry meme was never evidence that machines can’t think. It was a lesion study, and what it localized was the boundary of a perceptual system.

The tax collector in the vocabulary

Once you know what to look for, tokenization’s fingerprints show up everywhere, and some of them matter far more than fruit.

Consider arithmetic. The number 2437 might be one token while 2438 is two, split as 243 and 8, depending on which four-digit strings happened to be frequent in the training corpus. Early GPT vocabularies chunked numbers this inconsistently, which meant the model was trying to learn place-value arithmetic over digits it could not reliably individuate. Modern tokenizers force digits into fixed groups of at most three precisely to tame this, and the fix measurably improved math performance. The models did not get smarter. Their perception got cleaner.

Consider language equity, a problem with real invoices attached. BPE vocabularies are trained on corpora dominated by English, so English gets the luxurious single-token words while other scripts get shattered. On the vocabulary that fractured strawberry, the one behind GPT-3.5 and GPT-4, I measured a small set of parallel sentences: the Thai versions cost nearly four times the tokens of their English twins, the Burmese versions more than nine times, the Chinese versions about one and a half. Non-English users of the same API paid more money per idea, exhausted the context window sooner, and got subtly worse reasoning, since every task effectively ran at a lower perceptual resolution. Researchers named it the tokenization tax, a bias baked in below the model, invisible in the weights, imposed by the compression scheme itself. The bill has been shrinking since. The vocabulary OpenAI shipped with GPT-4o is twice the size, and on the same sentences much of the new room went to the world’s other scripts: Chinese now costs no more than English, while Thai still pays close to double and Burmese nearly triple. The tax turns out not to be a law of nature. It is a budget decision, revised with every vocabulary, and the scripts with the least training data still pay the most.

And consider the haunted tokens. A tokenizer’s vocabulary is not learned during training. It is built beforehand, in a separate pass over a separate collection of text, with its own filters and one blunt inclusion rule: whatever recurs often enough earns a slot. The model then trains on a corpus assembled and cleaned by different rules. Two harvests, two filters, and between them a crack opens. In 2023, researchers found what had fallen through it: strings like SolidGoldMagikarp, a defunct Reddit username, frequent enough in the vocabulary’s source text to earn its own token, yet nearly absent from the text the model actually learned from. The result was a token with an ID but almost no learned meaning, a perceptual object the model had a slot for but no experience of. Prompted with these glitch tokens, GPT-3 would insult users, evade, or hallucinate wildly. The popular story was demonic possession. The accurate story is more interesting: these were stimuli from outside the model’s experienced world, arriving through a sensory channel that had never carried signal. Minds do not handle those gracefully. Any minds.

The bitter lesson, again

If tokenization causes this much trouble, why not delete it? Underneath every text file, whatever the language, sits one shared alphabet. Computers store text as bytes, and a byte is eight binary switches with two states each, which makes exactly 256 possible values. Every character in every script resolves into a short run of bytes, one for a Latin letter, up to four for a rare ideogram or an emoji. Feed the model those raw bytes and the vocabulary problem dissolves. Nothing is ever out of vocabulary. With no vocabulary left to build, the separate tokenizer disappears from the pipeline entirely; the two harvests collapse into one, and the crack the haunted tokens fell through closes; the r’s in strawberry sit in the input at last, one byte apiece. Let the network learn its own chunking from scratch. The idea is obvious and people have built it. ByT5 demonstrated byte-level models years ago, and in late 2024 Meta’s Byte Latent Transformer showed a byte-native architecture matching token-based models at scale by learning to dynamically group bytes into patches, spending more compute where the text is surprising and less where it is predictable. Which is exactly what your eyes do, fixating longer on rare words and skipping lightly over common ones.

Andrej Karpathy, who has taught tokenization to more people than anyone alive, has long argued that the whole apparatus is a regrettable stage of history that we will eventually discard, the appendix of the transformer era. His catalog of what it breaks is long, and the strawberry problem sits near the top.

Perhaps he is right and byte-level models win the decade. But tokenization has survived every eulogy so far for a reason: the efficiency argument never went away. Chunked perception is what lets a finite mind afford a large world. Biology reached the same conclusion independently, which is usually a sign that the conclusion is not an accident of engineering fashion but something closer to a law. The interesting future is probably not perception without compression. It is compression the mind can see through when it needs to, a fast route with the slow route intact underneath.

That is what you have. It is what today’s models lack. And it is why a ten-letter fruit could embarrass a trillion-parameter network: not a failure of intelligence, but a reminder that every intelligence, carbon or silicon, thinks only about what its senses agree to deliver.

The philosopher Jakob von Uexküll gave us a word for the slice of reality a creature’s sensory apparatus makes available to it: the Umwelt. The tick’s Umwelt is warmth and butyric acid. The bat’s is echoes. A language model’s Umwelt is a stream of integers from a frozen vocabulary, rich enough to carry Shakespeare and source code, yet with no letters in it anywhere. We keep asking whether these systems understand. The strawberry problem suggests a sharper question, one perception researchers have asked about every mind they have ever studied: understand what, exactly? Show me a mind’s tokenizer, and I will show you the edges of its world.

What the Brain Knew

Perception must compress, but compression must not become a cage. The reading brain keeps two routes open: a fast one for the common case, and a slow one that can still touch the letters when the truth requires it. A mind that wants to know its world all the way down has to be able to see through its own compressions.

---

The Mirror Test is a Robonaissance series. Machines fail, brains explain, and every reflection redraws the map of intelligence.