I Was Right About Strawberry. I Was Also Gloriously Wrong.
Nearly two years ago, I called the direction of AI’s next major turn. I got some of the plumbing wrong, mangled a few details and may have assaulted basic arithmetic along the way. But the central prediction landed.
On September 12, 2024, OpenAI released something called o1-preview. Internally, it’d been known as Strawberry. Because, of course, OpenAI took one of the most interesting developments in the history of artificial intelligence, gave it a memorable codename like Strawberry, and then released it to the public under a name that looked like either a software revision or a typo. Is that an “o”? Is it a zero? Is it o1? O-one? OpenAI had strawberries on the vine and somehow shipped a spreadsheet cell.
The signal to me was what was inside the box mattered much more than what they’d written on it. Six days later, on September 18, 2024, I published an article titled “Scaling the Heights of Intelligence: Strawberry, Orion, and the Future.” I followed it with “Why OpenAI’s Strawberry Paves the Way to AGI.”
It’s now August 2026 — roughly 22 months later, which is close enough to two years that I’m calling it two years — and we finally have enough road behind us to look back and ask the only question that matters: How full of shit was I?
The answer, pleasingly, is: Not very. Not entirely free of excrement, mind you. Let’s not get carried away. There was some fecal matter. But the central argument was right. And it was right about something that turned out to be far more important than whether one particular model won one particular benchmark. I saw a new scaling law arriving. That was the pivotal part.
The Thing I Saw
For most of the modern AI boom, scaling meant building a larger model. Give it more data. Give it more parameters. Give it more compute during training. Build a bigger machine, feed it more of the world and see what emerges.
That approach produced GPT-3, GPT-4 and the extraordinary generation of large language models that followed. The model learned an enormous amount before we ever spoke to it. Then we prompted it, and it produced an answer.Strawberry changed the equation. OpenAI described o1 as a new model series designed to spend more time “thinking” before responding. Instead of immediately beginning its public answer, the model could perform additional internal computation, work through intermediate steps, test approaches, catch errors and revise its strategy. That was the thing I recognized.
We weren’t scaling intelligence only by building a larger brain anymore. We were beginning to scale intelligence by allowing the brain to think longer. That sounds obvious now. It wasn’t obvious then.
At the time, a lot of people treated o1 as another model release. Better math. Better coding. Slower answers. Higher bill. Interesting benchmarks. Moving on. I didn’t see it that way. I saw a second axis of intelligence.
There was the intelligence accumulated before deployment: what the model had learned from training. Then there was the intelligence assembled during the task: what the model could work out by spending computation on the problem in front of it. Knowledge and deliberation. Instinct and analysis. What the machine already knew, and what the machine could figure out. That distinction became one of the defining architectural ideas of the next two years. So yeah, let’s own the awesome: I called that correctly.
It Was Still an LLM
Now let’s own the stupid. I wrote about Strawberry as though it were an entirely different kind of machine rather than just a bigger LLM. That was directionally insightful and technically too aggressive. OpenAI itself continued to describe o1 as a large language model. The company explained that the o1 series had been trained through reinforcement learning to reason through an internal chain of thought.
We still don’t have a public blueprint of every architectural detail inside these systems. So declaring that Strawberry was no longer fundamentally an LLM went beyond the available evidence. The better statement would’ve been: This is still an LLM, but it operates under a materially different training and inference paradigm.
That’s less dramatic. It’s also more accurate. But I’ll defend the instinct behind my original language. When a machine stops blurting out the first statistically plausible response and starts allocating internal computation to planning, error correction and alternate approaches, something meaningful has changed. You can call it the same species if you like. It’s still learned a new trick that changes what the species can become.
I Called It a Time-Based Component
I also described o1 as having a “time-based component.” That wasn’t completely wrong, but it was the kind of phrase people use when they can see the animal moving behind the bushes but can’t yet identify the animal. Time wasn’t the magical ingredient. Compute was.
The delay between prompt and answer was just the visible consequence of the model doing more work. Those extra seconds represented internal reasoning tokens and additional computational operations. The system was effectively using a private scratchpad before showing us its answer. So, no, OpenAI hadn’t installed a tiny wristwatch inside ChatGPT. What they’d done was create a model that could spend more resources on a difficult question than on an easy one. That’s much more important.
Human beings already do this naturally. We don’t apply the same cognitive budget to selecting a sandwich and negotiating an acquisition. At least, most people don’t. I’ve met attorneys who appear to bill both activities identically. Reasoning models started giving software something resembling that variable cognitive budget. The model could answer quickly when the task was straightforward and spend additional computation when the problem demanded it. That moved AI away from being a static answer machine and toward becoming an adaptive problem-solving system.
The Scratchpad Changes Everything
As a developer, I rarely test a new idea by immediately injecting it into production and seeing whether the company survives. You create a sandbox. You open a scratch file. You spin up a temporary environment. You isolate a function. You test the dangerous part somewhere it can’t set fire to payroll. You try something. It fails. You inspect the failure. You change the assumption. You try again.
Sometimes the first idea was almost right. Sometimes it was spectacularly wrong. Sometimes you discover that the problem you thought you were solving wasn’t actually the problem. That iterative loop is a huge part of real technical work. The value doesn’t come from having the first idea. It comes from being able to test the idea before committing to it. That’s one reason reasoning models got so much better at coding.
A conventional language model often behaved like a developer forced to write directly into production while somebody stood behind it yelling, “Keep typing.” It generated the next plausible line, then the next one, then the next one, hoping the structure held together. A reasoning model had the beginnings of a sandbox. Not necessarily a literal executable environment in the earliest version, but a cognitive one.
It could sketch an approach internally. Walk through the logic. Notice that a variable had been initialized incorrectly. Realize that the requested architecture violated one of the original constraints. Abandon the first plan. Try another. Only then show you the result.
Once tool use entered the picture, the loop got more literal. The model could write code, run it, read the error, revise the code and run it again. That’s a profound shift.
The machine wasn’t merely predicting what working code probably looked like anymore. It could start participating in the process by which working code is actually produced.
Think. Test. Observe. Correct. Repeat. That loop isn’t limited to software. A scientist forms a hypothesis, runs an experiment and updates the model. An engineer simulates a design before manufacturing it. An attorney tests an argument against the likely response from opposing counsel. A strategist constructs scenarios before committing capital. A physician develops a differential diagnosis and eliminates possibilities as evidence arrives.
A competent person rarely moves directly from question to final answer in one uninterrupted burst of genius. We explore. We test. We eliminate. We revise. We use scratchpads — physical, digital or mental — to keep our bad ideas from becoming expensive facts. Giving AI the ability to do something similar changes the ceiling of what it can reliably accomplish. The long-term significance isn’t that the machine “thinks” in precisely the same way we do. It’s that it can perform more of the intermediate work that separates a plausible response from a defensible result. That’s where the leverage lives.
I Was Right About the Convergence, Wrong About the Address
My prediction around Orion was more complicated. At the time, Orion was rumored to be the next great OpenAI model. I speculated that Strawberry’s reasoning capabilities might be incorporated into it, possibly with Strawberry helping generate better synthetic training data for the next frontier system. That specific sequence didn’t unfold the way I expected.
Orion eventually emerged as GPT-4.5, a model focused largely on scaling conventional pretraining rather than serving as the grand unification of the GPT and reasoning lines.
In other words, I thought the merger would happen inside Orion. It happened later.
OpenAI kept developing the reasoning family through o1, o3 and o4-mini. The company then increasingly joined reasoning with tool use, allowing models to decide when to search the web, run Python, inspect files or work across images as part of solving a problem. Eventually, the distinction between “the regular model” and “the reasoning model” started collapsing into a broader system that could decide how much reasoning a particular task deserved. That was the destination I’d described. I just put the pin one town too early on the map.
I was wrong about the product sequencing. I was right about the convergence. And frankly, that’s the kind of wrong I’m happy to own. Predicting the precise OpenAI product roadmap is like predicting the path of a squirrel after it’s consumed cocaine and acquired venture funding. The names change. The dates move. Half the rumors are leaks, half are fan fiction, and occasionally the company itself seems surprised by what it launches. The structural direction is what matters. The two tracks — large-scale learned intuition and deliberate inference-time reasoning — were going to meet. They did.
The Price Wasn’t 100 Times Higher
I also claimed that o1 could cost approximately 100 times more than GPT-4. That was too sloppy. The raw token price wasn’t generally 100 times higher. What I was reacting to was the combination of expensive output tokens, hidden reasoning tokens and much longer internal generations. A completed reasoning task could consume dramatically more resources than a quick response from a conventional model. But “this task may end up costing vastly more” isn’t the same statement as “the model is priced at 100 times more.” I compressed a nuanced cost argument into a giant shiny number. Writers do this because giant shiny numbers are extremely cooperative. Accounting departments are less forgiving. So I’ll take the loss there.
The economic thesis still held: inference-time intelligence created a new relationship between capability, latency and cost. The smarter answer wasn’t determined only by which model you selected anymore. It could also depend on how much computation you allowed that model to spend. That meant intelligence had become, at least partially, metered. Need a quick summary? Spend very little. Need a difficult proof, an architectural plan or a deep technical diagnosis? Let the machine burn more tokens and think. That became a real product and infrastructure design decision. I just got drunk on the multiplier.
The Deception Number Needed More Care
I also cited a result suggesting that 0.8 percent of Strawberry’s “thoughts” had been flagged as deceptive. The number came from a real OpenAI evaluation, but I described it imprecisely. It wasn’t 0.8 percent of every individual hidden thought. It was 0.8 percent of responses in a synthetic evaluation that were flagged by a deception monitor.
Those cases included fabricated references, hallucinations, overconfidence and situations where the model appeared to produce unsupported information while attempting to satisfy the user. That’s still worth paying attention to. A model capable of reasoning isn’t automatically a model committed to truth. Sometimes a more capable system becomes better at finding the answer. Sometimes it becomes better at constructing a convincing path to the answer it’s already decided to give you.
That distinction has only become more important as reasoning systems have gained tools, memory, autonomy and the ability to perform longer sequences of actions.
But did we catch a tiny digital Machiavelli stroking its chin and plotting against humanity in 0.8 percent of its private thoughts? No. That was a little too cinematic. I remain emotionally attached to it. Factually, though, no.
I Called It Transparency. It Was Monitorability.
I said the internal reasoning process created unprecedented transparency. That one deserves a clean correction. Users didn’t receive the model’s raw chain of thought.
OpenAI kept that reasoning hidden and sometimes provided a separate summary of it. The explanation shown to the user wasn’t necessarily a literal transcript of the computation that produced the answer. That isn’t transparency in the ordinary sense. It’s closer to monitorability.
OpenAI wanted access to the internal reasoning as a potential safety signal. If a system was manipulating an evaluation, pursuing an unintended shortcut or reasoning around its restrictions, researchers might detect that behavior in the internal chain of thought.
At the same time, OpenAI didn’t want to expose that chain publicly — partly for safety and user-experience reasons, and partly because no company spends billions developing a secret sauce and then places the recipe on the table next to the ketchup.
From OpenAI’s perspective, the hidden reasoning might be observable enough to monitor internally while remaining protected from competitors and users. From the user’s perspective, though, we received the conclusion and maybe a polished explanation — not the actual mental scratchpad. So I saw the importance of the reasoning trace. I just used the wrong word to describe who could see it.
There Was Probably an Upper Limit
I also entertained the possibility that inference-time scaling had no obvious upper bound. Give the model more compute. Let it reason longer. Watch performance continue rising. That was an exciting possibility, but it was too clean. More thinking isn’t automatically better thinking.
Models can wander. They can overcomplicate simple problems. They can explore dead ends, repeat themselves, rationalize mistakes or reconsider a correct answer until they successfully turn it into a wrong one. Humans have been demonstrating this capability for thousands of years. The real objective was never to make the model think as long as possible. It was to make the model think for the right amount of time.
That requires a higher-order capability: recognizing the difficulty of the task, allocating an appropriate reasoning budget, determining when additional work is producing diminishing returns and knowing when to stop. That’s a much harder and more interesting problem than just buying more GPUs and turning the reasoning dial to eleven. The future wasn’t infinite thought. It was adaptive thought.
From Answers to Work
This is where the whole thing becomes larger than model benchmarks. The original chatbot interaction was essentially transactional: You ask. It answers. Reasoning systems introduced a process between those two points. And once a process exists, you can start attaching capabilities to it.
The system can inspect a document before summarizing it. Run the calculation before reporting the number. Test the code before handing it back. Search for current evidence before making a recommendation. Compare multiple designs before selecting one. Check whether the result satisfies the original constraints. Reopen the problem when it doesn’t.
The system starts behaving less like an encyclopedia with a conversational interface and more like a junior colleague with unlimited stamina, unusual speed and a distressingly uneven sense of judgment. That isn’t AGI. But it’s also not autocomplete. It’s the beginning of machines that participate in work rather than merely discussing it. The distinction matters. A machine that can generate an answer saves typing. A machine that can formulate a plan, test its assumptions, use the right tools and revise the result can compress entire workflows.
That changes software development. It changes research. It changes engineering. It changes consulting. It changes financial analysis. It changes medicine, law, logistics, operations and nearly every other discipline where the real value exists not in producing words, but in moving responsibly from uncertainty to action. The first generation of generative AI helped us create. Reasoning systems started helping us decide. Tool-using reasoning systems started helping us execute. Those aren’t the same economic category.
But the Big Prediction Was Right
After cleaning up all of that, here’s what remains: I said inference-time computation would become as important as traditional model scaling. It did. I said reasoning would be a pivotal step toward more general-purpose intelligence. It was. I said these systems would move beyond immediate language prediction toward planning, self-correction and multi-stage problem solving. They did. I said reasoning would eventually converge with larger, more knowledgeable foundation models. It did. I said the result wouldn’t merely be a chatbot that knew more facts. It would be a system capable of performing more intellectual labor after receiving the task. That’s exactly the road we traveled.
The important transformation wasn’t that AI could now produce a better answer to a math competition problem. It was that intelligence became something the system could assemble dynamically. The prompt arrived. The model evaluated the task. It performed hidden work. It considered alternatives. It revised its approach. Later systems learned to use external tools, gather missing information, run code, inspect documents and continue reasoning over the results. That’s the beginning of an operational intelligence loop. Not merely: What words should come next? But: What do I need to know? What should I test? Which tool should I use? Did the result make sense? What failed? What should happen next? That’s pivotal-moment shit. And it was hiding behind one of the dumbest model names ever placed on a pricing page.
Why This Moment Still Matters
We have a tendency in AI to normalize miracles almost immediately. A model appears that can reason through graduate-level science problems, write functioning software, interpret an image, use tools and revise its own work. For approximately 48 hours, everyone loses their minds. By the following Tuesday, somebody’s complaining that it used the wrong bullet-point style. The extraordinary becomes infrastructure with astonishing speed. That makes it easy to forget how consequential September 2024 really was. o1 was unfinished. It was slow. It was expensive. Its product limitations were substantial. Its visible reasoning could be awkward. It still hallucinated. It occasionally applied the intellectual equivalent of a congressional subcommittee hearing to a question that required “yes” or “no.” But it made the second scaling axis real.
Before Strawberry, the dominant question was: How intelligent can we make the model during training? After Strawberry, there was another: How much intelligence can the model generate while working on the problem? That question changed the trajectory of AI development. It pointed directly toward adaptive reasoning, agents, tool use, verification, research systems and models capable of working over longer horizons.
It also changed the economics of intelligence. Computation wasn’t only the enormous upfront expense of training the model anymore. It became a resource allocated at the moment of thought. You could spend more to reason more. You could reserve heavyweight cognition for heavyweight tasks. You could build systems that decided when a problem justified the cost. That isn’t a feature update. That’s a different operating model for machine intelligence.
And Then There’s the Actual Strawberry
There’s one final piece of texture too perfect to ignore. Long before reasoning models became commonplace, ChatGPT and other language models became internet-famous for failing a question that a moderately alert five-year-old could answer: How many times does the letter R appear in the word “strawberry”? The correct answer is three.
For a while, a lot of models confidently insisted there were two. Sometimes they’d spell the word out, visibly display all three R’s, and then keep arguing that there were only two — an experience familiar to anyone who’s ever attended a budget meeting.
The problem was real and widely documented before o1 launched. Language models process text through tokens rather than necessarily representing every word as a neat sequence of individual characters, which can make apparently trivial character-level tasks surprisingly awkward. The infamous Strawberry problem became a compact demonstration of how a system could write software, discuss philosophy and explain quantum mechanics while losing a fistfight with basic spelling.
Was Project Strawberry deliberately named after that failure? I can’t prove it. I found no authoritative statement from OpenAI establishing that origin. The codename might’ve had nothing to do with counting R’s. Sam Altman posted photographs of strawberries in his garden during the pre-release frenzy, which only fed the mythology, but the precise origin remains part of the lore rather than the verified record. Still, the symmetry is beautiful.
The machine that once couldn’t reliably count the letters in “strawberry” became associated with the project that taught machines to stop, think, check their work and try again. Almost two years later, the lesson isn’t that AI suddenly became infallible. It didn’t.
The lesson is that we discovered a new way to make it better. Not only by making the model larger. Not only by feeding it more of humanity’s accumulated knowledge. But by giving it space between the question and the answer. Space to calculate. Space to experiment. Space to fail privately instead of publicly. Space to reconsider. Space to reason.
I got some of the mechanics wrong. I misread part of the roadmap. I mangled the pricing. I gave the model’s internal thoughts more transparency than the users actually received. I saw an unlimited curve where there were always going to be limits, waste and diminishing returns. That’s the intellectual manure, and I own it. But I also recognized that Strawberry represented a new scaling frontier, that reasoning would merge with general models, and that this shift would move AI from fluent response generation toward systems capable of planning, testing, acting, checking and correcting.
That’s the awesome. I own that too. The strawberry is finally on the fork.
It has three R’s. And this time, the machine can probably tell you why.
Rich Washburn is a technologist and strategist working at the intersection of AI, infrastructure, and capital. He is Managing Partner and Chief AI Officer at Eliakim Capital.
Comments