The Bitter Lesson Explained: Richard Sutton's 26 Words (2026)

In May 2026, Richard Sutton posted 26 words to X.

He is the person who, with Andrew Barto, built the field of reinforcement learning; who wrote the textbook the field still teaches from; who won the 2024 ACM A.M. Turing Award for it. In 2019 he published a 1,125-word essay called The Bitter Lesson that has functioned, in the words of Andrej Karpathy, as something close to scripture in frontier AI labs.

The 26 words were his own compression of it:

Don't be distracted by human knowledge, as AI has been historically. Instead focus on methods for creating knowledge that scale with computation, like search and learning.

— Richard S. Sutton (@RichardSSutton)

Read that again, because almost everyone who quotes The Bitter Lesson gets it backwards. It does not say use more compute. It does not say algorithms don't matter. It says: prefer methods that create knowledge, and prefer the ones that get better as computation grows rather than as human effort grows.

And here is the part that makes 2026 interesting. The man who wrote it now says the most celebrated AI systems on earth — large language models — are breaking his lesson. Not because they are too simple, but because they stop learning the moment they ship.

TL;DR: The Bitter Lesson (March 13, 2019) says general methods that scale with computation beat hand-built human knowledge, naming search and learning as the two that scale. Sutton now argues LLMs prove and break it: they scaled on internet text, but their weights never change, so they cannot learn from experience. Choose systems that get smarter as they are used.

What Is the Bitter Lesson?

The Bitter Lesson is a 1,125-word essay Richard Sutton published on incompleteideas.net on March 13, 2019. Its claim: across 70 years of AI research, a general method that could absorb more computation always beat a hand-built, knowledge-heavy approach eventually — and the researchers who lost took it badly.

His opening sentence is the whole argument:

"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."

The mechanism he gives is economic, not mathematical. Compute keeps getting cheaper. A researcher optimizing for this year's paper will encode domain knowledge, because that is what pays off this year. A method that merely scales looks worse today and better every year after.

Sutton is careful about which general methods qualify. Only two, in his account, scale arbitrarily:

"The two methods that seem to scale arbitrarily in this way are search and learning."

That pairing matters. Search is not learning. A system that explores possibilities and keeps the good ones is creating knowledge without any weight update at all. Both count. Both scale on compute rather than on staff.

Decoding the 26 words

The phrase most people drop is "methods for creating knowledge." The essay is not anti-knowledge. It is against pre-loading knowledge instead of generating it.

Who Is Richard Sutton?

Richard S. Sutton is the co-creator of modern reinforcement learning and, with Andrew Barto, the 2024 ACM A.M. Turing Award laureate — announced March 5, 2025, with a $1 million prize funded by Google, for "developing the conceptual and algorithmic foundations of reinforcement learning." Their 1998 textbook remains the field's standard reference.

His technical lineage runs through nearly every idea the field now takes for granted.

His career path runs Stanford (BA in psychology, 1978) to UMass Amherst (PhD, 1984, under Andrew Barto), then GTE Laboratories, AT&T's Shannon Laboratory, and — from 2003 — the University of Alberta, which he built into one of the world's centers of reinforcement learning. DeepMind opened its first non-London research office in Edmonton in July 2017 largely because he was there; it closed in January 2023. He joined John Carmack's AGI startup Keen Technologies in September 2023, and left in July 2026 to start his own lab.

There is a detail in his account of arriving in Alberta that explains a lot about the tone of the essay. He moved there during an AI winter while seriously ill with melanoma that had spread to major organs, including his brain; he underwent four surgeries, chemotherapy, and immunotherapy to treat it. The University of Alberta's alumni magazine reports that he told his first class in 2003 that he might not be around to finish the course, but that he would try. He was still there two decades later.

Asked in 2026 why he kept working through it, he reached for a line attributed to Benjamin Franklin — that people do things for one of two reasons, habit or vanity — and picked habit.

He also rejects the framing that he is a contrarian:

"People think I have a radical point of view sometimes... But I don't see it that way at all. I see it as like I'm thinking the ordinary way. It's just everyone else that's thinking a bit weird."

— Richard Sutton, in conversation with Khurram Javed, 2026

The 70-Year Pattern: Four Times the Lesson Was Learned

The essay's evidence is four domains — chess (1997), Go (2016), speech recognition, and computer vision — where the same story played out with different casts. In each, a hand-built, human-knowledge approach led for years, then a general method that absorbed more compute won and kept winning.

His summary of why the pattern repeats is the most quotable line in the essay:

"We have to learn the bitter lesson that building in how we think we think does not work in the long run."

And the closing paragraph — the one that almost nobody quotes, and which turns out to be the seed of everything he argues in 2026:

"The actual contents of minds are tremendously, irredeemably complex... we should build in only the meta-methods that can find and capture this arbitrary complexity... We want AI agents that can discover like we can, not which contain what we have discovered."

Hold onto that sentence. Seven years later it becomes the big world hypothesis.

What the Bitter Lesson Does NOT Say

The essay is quoted more than it is read, and its five most common misreadings have consequences — they get used to justify architecture decisions Sutton never endorsed, including the claim that algorithms or prior knowledge do not matter. In 2026 he corrected each one directly.

That third row is the one worth internalizing. Sutton appears anti-knowledge only because the field over-corrected in the other direction. His actual position is that prior knowledge and new learning are the same substance at different times: what you learned yesterday is your prior today.

Citation capsule. Sutton's own correction, stated in 2026: the Bitter Lesson's axis is compute versus human input, not compute versus data, and not scale versus design. A method qualifies if adding computation improves it without adding people. By that test, a system that improves as your team uses it qualifies; a library of prompts that improves only when a person edits them does not.

The Twist: Sutton Says LLMs Break His Own Lesson

Sutton's 2025-2026 position is that large language models are simultaneously the best and the worst example of the Bitter Lesson ever produced: the clearest case yet of a general method scaling with computation, and, because their weights freeze at release, a return to the same human-data ceiling the essay warned against.

Positive: they scaled with computation more successfully than anything before them. In his phrasing, you could "drink in the internet and scale so much."

Negative: the thing they scale on runs out. "The internet is finite," he says, "and the world is massively bigger than everything we stored on the internet." A method whose ceiling is a human-produced dataset is, by his own definition, a method limited by human knowledge.

But the objection he actually leads with is not about data ceilings. It is four words long.

When an interviewer listed what modern assistants can do — remember things about you, learn in-context, personalize — Sutton's entire rebuttal was:

"Their weights never change."

He refuses to accept context as a substitute for learning:

"You can change the state of the model by giving it more context... But the model is not learning."

This is the sharpest available statement of what separates memory from learning, and it is worth being precise about, because the AI industry uses the two words interchangeably. Storing a fact and retrieving it later is memory. Changing the system that processes facts is learning. Every frontier-model workspace product on the market today, Taskade included, does the first. None do the second in Sutton's sense. The one exception he grants, a deployed model retrained on aggregate usage, is covered in The Honest Version below.

He also puts a number on how much of intelligence language covers:

"All of intelligence is not fluid, capable use of language. There's so much more. It's an important part. It's like 20% or a quarter of intelligence. There's more. We're not done."

What he actually said on the Dwarkesh podcast

The interview that made this argument famous was published on September 26, 2025, under a title Sutton did not choose: "Father of RL thinks LLMs are a dead end." The headline is blunter than his position, but the transcript contains the clearest statements of it he has given.

On what the models are optimizing for:

"Reinforcement learning is about understanding your world, whereas large language models are about mimicking people, doing what people say you should do. They're not about figuring out what to do."

On prediction — the distinction he cares most about:

"They have the ability to predict what a person would say. They don't have the ability to predict what will happen. What we want, to quote Alan Turing, is a machine that can learn from experience."

On goals, which he treats as non-negotiable for intelligence:

"Without a goal, there's no sense of right or wrong or better or worse. Large language models are trying to get by without having a goal or a sense of better or worse. That's just exactly starting in the wrong place."

He grounds that in John McCarthy's definition rather than his own: intelligence is "the computational part of the ability to achieve goals. You have to have goals or you're just a behaving system."

And on the training paradigm itself, an observation that is hard to unhear once you have read it:

"There are no examples of supervised learning. Supervised learning is not something that happens in nature."

His point is that no animal is ever handed a labeled correct answer for what its muscles should do. Feedback exists everywhere in nature; labeled targets do not. The reaction to the episode was substantial — Karpathy publicly described the Bitter Lesson's status in frontier labs as near-scriptural, and much of the commentary concluded that Sutton and his interviewer were partly talking past each other about what the word "learning" means.

The Big World Hypothesis

The big world hypothesis is the claim that the world is massively more complex than any agent inside it, formalized by Khurram Javed and Sutton at a Reinforcement Learning Conference workshop in 2024. Their proof is one line: the world contains many other agents, each too complex for any single model to capture.

If you are an agent of a given complexity, and the world contains other agents of comparable complexity, then you cannot possibly model the world — you cannot even model one of your peers.

Sutton's own framing of the consequence:

"Because the world is massively complex, there's no way you can do anything like anything that might claim to be optimal or perfect. You're going to be imperfect, and you have to have approximations, and those approximations will be severe. And so, because of that, that is ultimately the reason why we have to continue learning."

The third consequence is the one with the most direct product implication. Asked whether the end state is one enormous mind that does everything, Sutton answered: "It's a single design." Not a single mind. Javed finished the thought — if two systems are equally complex, neither can model the other, so it "would always be multiple systems that are learning from their own experience."

That is an argument, from first principles, that the future is many specialized learners with their own histories, not one universal model that knows your business.

Why "just generate synthetic data" is not the fix

Asked whether synthetic data generation counts as a general method that leverages computation, Sutton's answer was four words: "No, that's just a big mistake." The reasoning comes in three parts, and it is the single most useful section of his 2026 remarks for anyone choosing an AI strategy.

Pushed on self-driving cars trained largely in simulation, Javed did not deny it works — he relocated the cost: "How many engineers were involved in building that simulation, and are we ready to say that the only problems worth solving are those where we can hire a large team of engineers to first make a simulation?"

Their resolution is precise, and it is not anti-simulation:

"The agents should learn from simulators — but simulators they make themselves."

Why Models Stop Learning: Plasticity and Forgetting

Networks do not merely fail to learn new things during deployment. Trained continually, they progressively lose the capacity to learn at all — a result Sutton and colleagues published in Nature (vol. 632, pp. 768–774) on August 21, 2024 under the title "Loss of plasticity in deep continual learning."

The finding is stark. On a continual ImageNet classification setup, accuracy fell from roughly 89% on an early task to about 77% by the 2,000th task — worse than what a simple linear network achieves. Standard deep-learning methods, applied to a continuing stream of tasks, degrade until they perform no better than a shallow network.

The ability to learn is not a fixed property of the architecture. It is a resource that gets consumed.

The naive fix — update the model on each new example as it arrives — produces catastrophic forgetting. Javed's description:

"If you say I'm going to take one sample and then update my whole model with that one sample, you will run into this problem that now all of the previous knowledge in the model is impacted negatively... it just completely destroys your prior knowledge in a very destructive way."

The workaround the industry actually uses is to batch: collect the same signal from very many users, then apply one update. Sutton grants that this counts as real continual learning where it is done — a code-completion model whose weights genuinely update from aggregate usage qualifies. But Javed names precisely what it cannot do:

"Imagine I want to teach this model something specific. I don't want to fight with 100,000 other people about what they want to teach their models. I want to teach my model something very specific, and I want to do it to my version of the model."

That sentence is a product requirement written by a research scientist. It is also, almost word for word, why per-team AI memory exists as a category.

   THE BATCH APPROACH                    THE STREAM PROBLEM
   ─────────────────                     ──────────────────
   100,000 users                         1 workspace
        │                                     │
        ▼                                     ▼
   aggregate signal                      single stream of
   into one big batch                    experience, no peers
        │                                     │
        ▼                                     ▼
   one safe update                       naive update →
   to shared weights                     destroys prior knowledge
        │                                     │
        ▼                                     ▼
   ✓ works for what                      ✗ no mechanism today
     EVERYONE needs                        for what YOU need

The Cure: Step Sizes and Generate-and-Test

Asked whether continual learning is blocked by infrastructure or by algorithms, Javed was unambiguous: "absolutely an algorithmic gap." The prescription has two halves — step-size optimization and generate-and-test — and both translate surprisingly well outside of neural networks, into any system that has to keep updating without erasing what it already knows.

1. Step-size optimization — one learning rate per weight

"Every weight in your network has to have a separate step size. So some will move fast, some will move slow. And you will have to meta-learn the step sizes for each weight. Most of your network will have weights that have tiny step sizes. So when you train on a new example, they don't get destroyed. Learning happens just to the right places."

The insight generalizes past neural networks: not everything you know should update at the same speed. Some facts are near-permanent. Some expire this week. A system with one update rate for everything will either forget its foundations or refuse to absorb anything new.

   ONE STEP SIZE FOR EVERYTHING          PER-FACT STEP SIZES
   ────────────────────────────          ───────────────────
   "last thing said wins"                 frozen  ████████░░  policy, brand, values
                                          slow    █████░░░░░  process, conventions
   ┌──────────────────────────┐           medium  ███░░░░░░░  ownership, account state
   │ one offhand remark can   │           fast    █░░░░░░░░░  this week's blockers
   │ overwrite a company      │
   │ policy learned months    │           new information moves the
   │ ago                      │           fast layers freely and the
   └──────────────────────────┘           frozen layer almost never

2. Generate-and-test — keep injecting variety

The second half is stranger and more interesting. Gradient descent alone, Sutton argues, cannot sustain learning indefinitely:

"Gradients are a very slow process. You only move in a direction if you know it's the helpful one... You need something that just proposes a bunch of new units."

Their algorithm is continual backpropagation — ordinary backpropagation plus a continuous trickle of freshly randomized units:

"Backprop only has random weights at the beginning of time. And then as you go on, all that randomness, all that variety from the randomness, gets used up. With continual backprop, we keep injecting a bit of randomness, a bit of generate-and-test — and the operation of backprop is the tester."

Generate proposes. Testing disposes. A system that only reinforces what it already contains eventually calcifies, because the variety it started with gets used up. This is the same structural pattern behind every effective agentic design pattern: generation without a verifier is noise, and verification without generation is stasis.

One honest limitation they volunteer: you cannot retrofit this onto an existing model. "These algorithms meta-learn how to learn," Javed notes, so a system has to be built with them from the start — it is learning the knowledge and learning how to learn simultaneously.

The Alberta Plan, OaK, and Oak Lab

Sutton is not only diagnosing. The research agenda — the 12-step Alberta Plan, published in August 2022 — is public, the architecture it names is called OaK, and as of July 2026 the lab built to run it, Oak Lab, exists — staffed deliberately small by design.

The Alberta Plan (August 2022, with Michael Bowling and Patrick Pilarski) breaks the work into 12 steps. Step two is continual deep learning, which Sutton calls "almost the most important, because it unlocks everything else." Step eleven is named "Prototype-AI III: Oak" — which means the architecture his 2026 lab is named after was already written into the roadmap four years earlier. This is not a pivot. It is a plan being executed on schedule.

The back half of the plan concerns abstraction, with a caveat he states carefully:

"I don't mean get the right abstractions, because no one can say what the right abstractions are. That depends on the world that you're in. Your agent would have to learn the correct abstractions for whatever world it's in."

OaK — Options and Knowledge — is the architecture, presented as a keynote at the Reinforcement Learning Conference in 2025. "Options" are temporally extended actions, the framework Sutton co-authored back in 1999; "Knowledge" is what the agent learns about what happens when it runs them. Three design principles govern it: domain generality (nothing built in for a specific problem), experiential learning (knowledge grows at runtime, not design time), and open-endedness.

Sutton names the one thing nobody in the field has done:

"The ability we don't see in our field yet is the ability to learn a model and then plan with the model. We can do the math things and we can do AlphaGo, because in games we know the model... But if we have to learn the models — there are no instances of learning the model and then planning with the model in our field."

Javed's illustration of where abstractions come from is the best in the interview, and it is not technical at all:

"If you ask elite athletes about how they do certain things, they would have weird niche terminologies for doing very specific things... Sometimes they don't even have a name for it if they're just doing it alone. So how did they come up with those abstractions?"

Every team you have ever worked on did this. You invented words for your own processes. Nobody handed them to you.

Oak Lab, announced in July 2026, is where this gets built. Sutton co-founded it with Javed, his former PhD student. The long-horizon target: roughly a trillion parameters, learning and planning in real time, on about 20 watts — the power budget of a human brain. Sutton concedes today's memory technology cannot store a trillion parameters in 20 W, then does the arithmetic out loud: five to ten years is about two orders of magnitude of hardware improvement, so the bar today is roughly 2,000 W. Javed thinks the right algorithm beats that now.

They are deliberately hiring almost nobody:

"It doesn't make sense to become large very quickly, because everyone we hire has to come to see what we see. And not everyone sees that."

"The Era of Experience"

The most concrete statement of where Sutton thinks this all goes came in April 2025, in a paper written with David Silver — the DeepMind researcher behind AlphaGo — titled "Welcome to the Era of Experience." It is a preprint of a chapter for the MIT Press book Designing an Intelligence.

Their thesis: AI has moved through an era of simulation and then an era of human data, and the second one is running out.

"While imitating humans is enough to reproduce many human capabilities to a competent level, this approach in isolation has not and likely cannot achieve superhuman intelligence across many important topics and tasks... The pace of progress driven solely by supervised learning from human data is demonstrably slowing."

The paper names four specific shifts that define the next era, and they read as a design brief:

Their evidence that the shift already started is AlphaProof, the formal-mathematics system: it trained on roughly a hundred thousand human-written formal proofs, then generated a hundred million more through continual interaction with a proof-checking system. The human corpus was the seed. The experience stream was the crop.

Notice what makes that work, because it is the transferable part: the proof checker is a source of ground truth that costs nothing to consult and cannot be argued with. Wherever your system has a real verifier — a test that passes, a payment that clears, an automation run that either fired or did not — you have the same ingredient.

Why the big labs will not do this first

Javed's answer is a textbook incumbent's dilemma, and it is the strategic core of the whole enterprise:

"We are stuck in a local minimum. If we want to move towards these new kinds of algorithms, it is almost impossible that things will not get worse before they get better... And these big labs are so locked into a product that it is not possible for them to pursue a path where things get worse first."

What This Actually Means If You Build With AI

Here is the part every other explainer skips. The Bitter Lesson is usually presented as a lab-strategy argument, but it is also a buying and building guide: run one test — does this capability improve with usage, or only when a person edits it — against every tool in your stack.

The test: does this thing get better as it is used, or only when a person works on it?

Row four is the only one that changes on its own, and it is the only layer any product actually controls. Sutton would not call it learning, and he would be right. But it is the layer where his advice — prefer methods that create knowledge and scale without more human input — is actionable today, by anyone, without a research lab.

The Honest Version: No Workspace Product Changes Weights

No frontier-model workspace product performs continual learning in Sutton's sense. That includes Taskade, along with any assistant, agent platform, or memory vendor built on a frontier model: none of them update weights from use, because memory lives in the workspace, not in the weights.

Sutton does count one case as real continual learning: a deployed model, such as a code-completion tool, that gets retrained on aggregate usage across many users. That update is not driven by any single team's work, so it is not what a workspace product does. When a company says its AI "learns from your team," what is happening is that information is stored outside the model and fed back in.

That is memory, not learning. The distinction matters because it sets honest expectations:

The last row is the one that separates products. Storage is easy. Deciding what is worth keeping, keeping it correct, and putting it back at the right moment is the hard part — and it is a design problem, not a model problem. Sutton's two mechanisms map onto it almost perfectly: some facts should barely move (step sizes), and a system should keep proposing new structure and letting reality test it (generate-and-test).

Workspace DNA: Continual Learning at the Layer You Control

Taskade's architecture — called Workspace DNA — is built around the one loop the big world hypothesis says you need: Memory feeds Intelligence, Intelligence triggers Execution, and Execution writes back new Memory, so the system's knowledge stays tuned to where you actually are instead of going stale.

The loop is the point. A prompt library does not close — someone has to edit it. A workspace where agents read the projects your team maintains, and automations write results back into those same projects, closes by construction.

Here is the same loop as an interaction, over two conversations weeks apart:

Nothing in that diagram changes a model weight. Everything in it changes what the model reasons over — and from the user's chair, the difference is invisible in the best way.

What each layer does in practice

Agents are grounded in any file or link you connect, and their instructions, tools, and memory can be updated as your process changes — the practical version of "tuned to the part of the world you're in." Start from a working setup in the Community Gallery, or describe what you need and let Taskade Genesis build the projects, agents, and automations together.

Build a Living Bitter Lesson Tracker

The fastest way to internalize this framework is to run it against your own stack: score every AI capability you use from 1 (human-bottlenecked) to 5 (scales on its own). You can build the tracker itself in Taskade Genesis with one prompt:

"Build a tracker for evaluating our AI tools. Each row is a capability with columns for whether it improves with usage, who has to maintain it, how often it goes stale, and a Bitter Lesson score from 1 to 5. Add an agent that reviews new entries and flags anything that only improves when a person edits it, plus a monthly automation that asks the owner of each low-scoring row whether it is still worth keeping."

That single description produces a database, an agent grounded in it, and an automation that keeps it current — the whole loop, not a spreadsheet. Here is the scorecard it should encode:

A stack that scores mostly 1s is not broken. It is capped — capped by how many hours your team can spend maintaining it. That cap is exactly what the Bitter Lesson says will lose over time.

Sutton and the Bitter Lesson: Full Timeline

The clearest way to see the pattern is start to finish: 19 dated milestones from Sutton's 1983 actor-critic work with Barto to Oak Lab's July 2026 founding, each one a step in the same argument playing out in his own career.

Frequently Asked Questions

Related Reading

• Types of Memory in AI Agents — episodic, semantic, and working memory in production agent systems
• How to Train AI Agents on Your Own Living Knowledge — the practical version of the state layer
• Long-Term Memory Is Live — how a workspace remembers across sessions
• Workspace DNA Architecture — the Memory, Intelligence, Execution loop in depth
• AI World Models Explained — JEPA, inference scaling, and learning a model to plan with
• The History of AI Agents — from SHRDLU to the modern agent loop
• How Do Large Language Models Work? — transformers from attention to generation
• How LLMs Got Hands — the history of tool use and function calling
• The 21 Agentic Design Patterns — generate-and-test, reflection, and the rest
• What Is Agentic Engineering? — Karpathy's framing of the shift
• Metacognitive AI — agents that monitor their own thinking
• What Is Grokking in AI? — when models suddenly learn
• Context Engineering for Teams — making the context window carry your team's reality
• Best Practices for Training AI Agents With Knowledge — connecting sources that stay current
• Anthropic and Claude History — the lab, the models, the timeline
• AI Agent Error Recovery — what agents do when the world disagrees with them
• Reinforcement Learning (wiki) — the field Sutton and Barto built
• Scaling Laws (wiki) — the empirical curves behind the compute argument
• Persistent Memory (wiki) — how memory persists between sessions

🧬 Before you go... Sutton's point is that intelligence comes from a loop that never stops running. Taskade Genesis builds that loop at the layer you control — one prompt becomes projects that hold your memory, AI agents that reason over it, and automations that act and write results back.

• 🚀 AI App Builder: Describe an outcome, get a working app with data, agents, and automations wired together.
• 🤖 Custom AI Agents: Agents with custom tools, slash commands, and persistent memory, grounded in your projects.
• 🔄 Automations: 100+ bidirectional integrations, so execution results land back in your workspace as new memory.
• 🧬 Workspace DNA: Memory feeds Intelligence. Intelligence triggers Execution. Execution creates Memory.

Ready to build a system that gets better as you use it? Start free →

Resources

1. The Bitter Lesson — Rich Sutton, March 13, 2019
2. ACM A.M. Turing Award 2024 — Barto and Sutton
3. Loss of plasticity in deep continual learning — Nature, August 21, 2024
4. The Alberta Plan for AI Research — arXiv:2208.11173
5. The Big World Hypothesis — Javed and Sutton
6. The Era of Experience — Silver and Sutton
7. Richard Sutton on the Dwarkesh Podcast, September 26, 2025
8. Rich Sutton and Khurram Javed: Why AI Models Stop Learning
9. Oak Lab launch coverage — BetaKit, July 2026
10. Richard S. Sutton — Wikipedia

▲ ■ ● Memory. Intelligence. Execution. The loop is the lesson.