In March 2019, reinforcement-learning pioneer Rich Sutton published an essay of barely a thousand words that became one of the most cited pieces of writing in modern AI. Its thesis was blunt:

"The biggest lesson that can be read from 70 years of AI research is that general methods that leverage computation are ultimately the most effective, and by a large margin."

Sutton's bitter lesson is that clever, hand-engineered, domain-specific knowledge keeps losing to general methods that simply throw more computation at the problem. The pattern had repeated for decades: computer chess researchers who encoded human strategy were humiliated in 1997 when Deep Blue defeated Kasparov with massive, deep search. Speech recognition, computer vision, and eventually Go all followed the same script — the search-based, compute-hungry approach won, and the cleverness-based approach became a footnote.

Now it's 2026, and the lesson has been taught a second time — in a form Sutton could not quite have predicted. The frontier labs stopped asking only "how much compute can we spend training?" and started asking "how much compute can we spend thinking?" And once again, compute beat cleverness.

The training-compute era, in brief#

The deep learning boom that began around 2012 was the bitter lesson playing out in real time. ImageNet showed that data at scale mattered more than hand-crafted vision features. Then came the transformer and the scaling-laws era: Kaplan and Hoffmann's scaling laws formalized what practitioners already suspected — model performance improves predictably with more parameters, more data, and more training FLOPs. The winning recipe was simple to describe, even if brutally expensive to execute: build bigger clusters, collect more data, train longer.

By early 2025, though, pre-training gains were visibly flattening: GPT-4.5, described at launch as OpenAI's largest model, improved over GPT-4o without the dramatic leap of the GPT-3 to GPT-4 transition. The industry's central bet — that each new generation would simply be bigger — was running into its own limits. It looked, briefly, like cleverness might get its revenge.

It didn't. It just moved to a different axis.

The sequel: scaling compute at test time#

In September 2024, OpenAI released o1, and the field's mental model of where performance comes from changed overnight. Instead of answering in a single forward pass, o1 generated a long hidden chain of thought — hundreds or thousands of reasoning tokens — before producing its answer. The model could decompose problems, try approaches, verify intermediate steps, backtrack from dead ends, and correct its own errors. On competition math (AIME 2024), it leapt from the ~13% range of GPT-4o into the mid-70s — a jump that no incremental scaling of a non-reasoning model could have produced.

The decisive part was that the improvement came from spending more compute at inference time. OpenAI's API even exposed a reasoning_effort parameter, letting users dial "low," "medium," or "high" thinking — directly trading tokens for correctness. Longer thinking, better answers. Sound familiar? It's the bitter lesson's core claim restated: a general mechanism that leverages computation wins. Only now the computation is spent after training, per question, at deployment.

The research community quickly formalized this. Snell and colleagues' 2024 paper on scaling LLM test-time compute optimally ("Scaling LLM Test-Time Compute Optimally can be More Effective than Scaling Model Parameters," arXiv:2408.03314) showed that under FLOPs-matched conditions, a smaller model with optimized test-time compute — best-of-N sampling combined with verifier-guided beam search and sequential revision — could match or exceed a model with roughly 14× more parameters. In other words: on a fixed compute budget, spending the FLOPs on thinking can beat spending them on a bigger brain. That's not a tweak to the bitter lesson. That's a second verse.

OpenAI's o3, announced in December 2024, pushed further, achieving near-human performance on mathematical competition problems and dramatically advancing on ARC-AGI, the abstract-reasoning benchmark designed to resist memorization. And the ecosystem moved with it: Anthropic's Claude 3.7 Sonnet shipped developer-controlled "extended thinking" with customizable thinking budgets, and Google's Gemini line added dynamic thinking modes that adjust reasoning effort to task complexity.

DeepSeek-R1: the lesson goes open source#

The most important confirmation came from an unexpected direction. In January 2025, the Chinese lab DeepSeek released R1, an open-weights reasoning model that matched o1-class performance — and crucially, showed how.

The paper behind it, "DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning" (arXiv:2501.12948), describes one of the cleanest empirical results of the decade. The team started with a base model and applied pure reinforcement learning — no supervised fine-tuning on human-written reasoning traces, just a simple rule-based reward (right answer, correct format) via an algorithm called GRPO. The resulting model, DeepSeek-R1-Zero, spontaneously developed long chain-of-thought behaviors the researchers never explicitly taught it: self-verification, reflection, backtracking. They called it the "aha moment" — reasoning capabilities emerging from optimization pressure alone, rather than from human-engineered demonstration data.

The final DeepSeek-R1 added a small cold-start phase and multi-stage RL, and the numbers speak plainly: 79.8% Pass@1 on AIME 2024 (slightly ahead of OpenAI's o1), 97.3% on MATH-500, and a 2,029 Elo rating on Codeforces — better than 96.3% of human competitors. And the weights were released freely.

Consider what this means through Sutton's lens. Nobody hand-crafted R1's reasoning strategy. Nobody encoded mathematical problem-solving heuristics, backtracking rules, or verification procedures. The method was general — reinforcement learning with verifiable rewards — and it scaled with computation: more RL rollouts, longer thinking at inference, better performance. The clever approach (curating exquisite human reasoning demonstrations, engineering clever prompting schemes) was the shortcut that felt productive in the short term; the general, compute-hungry approach won in the long run. Seven years after the essay, the pattern held again.

Why the sequel is genuinely new#

One caveat: inference scaling isn't just the old lesson recycled. Test-time compute changes the economics of AI in ways training compute never did:

  • Capability becomes fungible per-query. For a trained model, capability is baked in at release. With inference scaling, the same model can be a cheap fast responder or an expensive deep thinker. Capability is now a dial, not a fixed property — priced by the token.
  • The feedback loop is tighter. Training a frontier model takes months and a data center. Giving a model more thinking time requires a config change. The iteration cycle on inference-time algorithms is measured in days, and the compute needed is accessible to labs and startups that will never train a foundation model.
  • The scaling wall may have moved, not disappeared. Inference scaling has its own diminishing returns — each extra order of magnitude of thinking buys less than the last, and some problem classes resist brute-force reasoning entirely. Snell et al.'s own analysis emphasizes compute-optimal allocation: the question is no longer just "more compute?" but "training or inference?"

That last point is where the real 2026 debate lives. The emerging synthesis is that there are now (at least) three scaling axes — pre-training compute, post-training/RL compute, and test-time compute — and the frontier is about optimal allocation across all three. The bitter lesson didn't say cleverness never matters; Sutton himself noted the approaches need not conflict. What it said is that general, compute-leveraging methods dominate in the long run.

What to watch next#

A few open questions will determine whether the 2026 edition ages as well as the original:

  1. How far does test-time scaling go? It's unclear where inference-scaling curves saturate, and whether current "reasoning" is mostly search-like exploitation of verifier-rich domains (math, code) rather than general intelligence. Open-ended reasoning remains harder to verify, and verifiers are the fuel the whole engine burns.
  2. Can efficiency invert the lesson? Distillation of R1-style reasoning into small models (the R1-Distill family reached down to 1.5B parameters) shows that once compute finds a capability, clever compression spreads it. The bitter lesson governs discovery; cleverness still has a role in distribution.
  3. Who owns the compute? The 2019 essay leaned on Moore's law — falling cost per unit of computation. In 2026, the dominant term isn't transistor density but data-center buildout and power availability. The lesson now runs through energy markets and chip supply chains as much as through algorithms. A constraint on raw compute — whether from power, capital, or policy — would be the first true external brake on the bitter lesson's mechanism.

The takeaway#

Sutton's essay ended with a prescription: "We should stop trying to find simple ways to think about the contents of minds... and instead accept the bitter lesson." The 2019 audience needed to hear that hand-tuned heuristics were losing. The 2026 warning is narrower: don't mistake inference-time scaling for cleverness either. Chain-of-thought prompting, thinking budgets, verifier ensembles — these aren't tricks that outsmart the bitter lesson. They're its latest instruments.

Compute won in 1997 with chess, in 2012 with vision, in 2017 with Go, and through 2024 with training scale. Since late 2024, it's been winning again — one reasoning token at a time, after the model is already trained. The lesson wasn't about training. It was never about training. It was about computation, full stop — and it's still bitter.