Dwarkesh Patel Says AI Post-Training Moves to On-the-Job Distillation
Dwarkesh Patel
AI laboratories will transition from static pre-training to dynamic weight updates during deployment via on-policy self-distillation to conquer real-world tasks.
## Background
This episode was published by Dwarkesh Patel on June 26, 2026, as a web and RSS podcast essay titled "The next big breakthrough will be AIs learning on the job." The page description links to the original written piece at dwarkesh.com, acknowledges sponsor Mercury for streamlining business bill pay and invoice processing, and lists timestamps covering topics from RLVR research bets to a forward-looking vision of AI capabilities in 2027.
## TL;DR
Dwarkesh Patel examines why major AI labs are betting heavily on Reinforcement Learning from Verifiable Rewards (RLVR), while analyzing the critical bottlenecks that separate grindable, containerized environments like coding from complex real-world tasks. He highlights the structural inefficiency of ephemeral inference, arguing that long-term model progress requires moving beyond expanding context windows to consolidate on-the-job experience directly into weights. Through mechanisms like On-Policy Self-Distillation (OPSD) and speculative "dreaming," future models will extract high-density signal from sparse real-world data. By 2027, intelligence will compound continuously across global deployments rather than relying solely on static pre-training updates.
## Atmosphere & style
The presentation is intellectually ambitious, analytical, and forward-looking, blending dense technical AI theory with vivid historical analogies. Patel communicates with measured optimism, carefully balancing enthusiasm for emerging paradigms against sharp skepticism regarding infinite generalization. The narrative feels like a deep-dive strategic brief—rigorous, deeply reflective, and urgent as it contemplates a future where models evolve dynamically through real-world deployment.
## Key takeaways
- `00:00` Major AI labs are betting that scaling reinforcement learning across millions of verifiable tasks in thousands of environments will lead to artificial general intelligence.
- `00:00` Models currently suffer from extreme sample inefficiency during pre-training, but advocates view this as an acceptable one-time amortized cost compared to session-level efficiency.
- `00:00` Expanding context windows to massive lengths could allow models to learn during an onboarding period directly in-context without needing continuous weight updates.
- `02:12` Computer use lags behind coding and math because verifiability alone is insufficient; progress requires 'grindable' environments that support parallel, replayable, deterministic rollouts.
- `02:12` Live web environments actively block bot activity, forcing labs to create high-fidelity offline clones of platforms like Gmail or Slack to scale computer use training.
- `05:00` Real-world human domains like business, law, and politics lack reset buttons and fast feedback loops, making it difficult for RLVR to easily generalize to them.
- `08:41` Up to 50% of compute budgets go to inference, yet current architectures waste this experience because session interactions contribute zero long-term updates to base model weights.
- `08:41` Relying purely on expanding Key-Value (KV) caches is parameter-inefficient and unlike human brain memory consolidation, which abstracts concepts rather than storing verbatim transcripts.
- `10:00` On-Policy Self-Distillation (OPSD) uses a context-rich 'teacher' instance of a model to train a 'student' base model, enabling weight updates without requiring external verifiers or causing catastrophic forgetting.
- `10:00` Unlike standard supervised fine-tuning, OPSD applies targeted updates that preserve existing capabilities while consolidating higher-level session insights.
- `15:00` 'Dreaming' (test-time training) would allow models to generate internal simulations of real-world experience, enabling massive rehearsal and learning without needing real-world time to elapse.
- `17:23` By 2027 and 2028, AI progress will shift from static pre-training to continuous on-the-job learning, where models aggregate real-world user interactions into compounding global capabilities.
## Detailed walkthrough
### `00:00` The Big Research Bet on RLVR and Verifiable Environments
Dwarkesh Patel outlines the core hypothesis driving major AI laboratories: if models are trained across millions of verifiable tasks spanning thousands of diverse reinforcement learning (RL) environments, the industry will effectively achieve artificial general intelligence (AGI). Proponents believe this regime produces a resilient problem-solving agent—one capable of making sustained progress on open-ended tasks over weeks despite encountering ambiguity, errors, and missteps. Optimists argue that long-standing critiques of current paradigms, such as extreme data inefficiency or the lack of online continual learning, will simply be "steamrolled" by scaling compute, echoing how traditional natural language processing bottlenecks collapsed under massive pre-training.
While current models may be a million times less sample-efficient than humans during their initial training phases, defenders view this as an acceptable, one-time amortized cost spread over billions of downstream user sessions. What truly matters is the model's intelligence and efficiency *during* a session, which has visibly improved as RL training scales—a reality familiar to anyone using modern AI coding agents. Furthermore, advocates suggest that architectural breakthroughs leading to massive or virtually infinite context windows might bypass the need to constantly update model weights on the job. If six months of employee onboarding can be squeezed directly into the prompt context, in-context learning alone might mimic true competence without requiring perpetual weight updates.
`02:12` Computer Use and the Grindability Bottleneck
Shifting to an intriguing discrepancy in recent AI progress, Patel examines why computer use has lagged significantly behind coding and mathematics. Computer use features highly verifiable outcomes—confirming an Etsy order was delivered, a venue was booked, or taxes were filed. However, verifiability alone is insufficient for rapid RL progress; a domain must also be deeply "grindable." Grindability requires running thousands of parallel, deterministic, and replayable rollouts from identical starting states. In software development, an AI can be placed inside thousands of identical, containerized code repositories to attempt a bug fix simultaneously.
By contrast, running thousands of parallel agents through Amazon's live checkout process to master web navigation quickly triggers anti-bot measures, as "Andy Jassy will find your bots and shut your ass down." Creating offline, high-fidelity clones of services like Slack or Gmail is currently too labor-intensive to scale manually. While using AI to code these environment clones from scratch offers a promising dual-benefit—serving both as a training ground for computer use and as an RL exercise for coding—the current sluggishness highlights a stark rule: without replayable, farmable simulators, sample-inefficient models struggle to make headway.
- **Verifiable vs. Grindable:** Verifiable domains only prove an outcome happened; grindable domains allow parallel, replayable rollouts against deterministic simulators.
- **The Container Advantage:** Coding progress accelerates because software environments can be instanced in isolated containers thousands of times at zero real-world cost.
- **Bot Countermeasures:** Live web environments actively block mass parallel rollouts, forcing labs to build high-fidelity application clones.
`05:00` The Limits of RLVR Generalization in Real-World Domains
The dependence on grindable simulators poses a severe challenge for complex, real-world human skills that cannot be containerized inside a data center. Training an AI to start a successful business, win court cases, execute a profitable trading strategy, or run a political campaign requires interacting with non-stationary, reset-free environments where feedback loops take months or years. Unlike synthetic setups, one cannot perturb an agent's actions slightly across thousands of parallel real-world timelines to isolate what caused a political candidate to win an election.
The central gamble of Reinforcement Learning from Verifiable Rewards (RLVR) is that training on thousands of synthetic, containerized tasks will magically generalize into a broad-spectrum agent. Optimists believe an agent trained purely on verifiable setups could be dropped into 1948 Texas politics and out-maneuver Lyndon B. Johnson, or given $100 million in 2002 to build SpaceX from scratch like Elon Musk. However, Patel expresses skepticism about infinite generalization, pointing to a revealing observation from Anthropic's Dario Amodei regarding context degradation.
> "There's two things. There's the context length you train at, and there's a context length that you serve at. If you train at a small context length and then try to serve at a long context length, like maybe you get these degradations." — Dario Amodei
- **Reset-Free Environments:** Real-world tasks lack a "reset button," preventing the parallel trial-and-errorrollouts essential for standard RL.
- **Sparse Feedback:** Outer-loop real-world verification can take months or years, creating an extreme credit assignment problem.
- **Historical Archetypes:** Labs are betting RLVR agents will generalize to match the tacit strategic skills of figures like Lyndon B. Johnson, Elon Musk, or Sam Walton.
`08:41` Getting Learning Back into the Weights
Even if an AI could accumulate enough in-context experience to perform like Henry Ford or Albert Einstein during an extended session, that learning remains entirely ephemeral unless it can be distilled back into the model's weights. Patel highlights a major structural inefficiency in modern AI infrastructure: roughly 30% to 50% of a lab's compute budget goes toward inference, yet this inference compute contributes zero long-term updates to the underlying model. Consequently, AI models deployed across thousands of enterprises remain completely blind to the valuable tacit knowledge, organizational workflows, and real-world failure modes they encounter every day.
Relying indefinitely on expanding Key-Value (KV) caches is neither parameter-efficient nor reflective of biological intelligence. The human brain maintains no rigid boundary between parameters and activations; human skulls do not expand as memories accrue. Biological learning relies on memory consolidation and abstraction rather than verbatim storage. In fact, individuals with savant-like hyper-photographic recall often struggle with high-level conceptual thinking because they cannot filter out raw data. While gradient updates are notoriously sample-inefficient—demonstrated by Cursor's tab-completion model requiring over 400 million records to learn basic acceptance patterns—true on-the-job adaptation requires a mechanism to consolidate session insights directly into long-term weights.
`10:00` Sponsor Interlude: Mercury
Patel takes a brief interlude to share a practical operational hurdle from running his podcast: handling contractor invoices and bill payments. As his media operation expanded, tracking invoices across disjointed email threads and entering payment details into spreadsheets manually became a significant administrative sink.
He solved this by utilizing Mercury, his primary business banking platform. By providing contractors with a dedicated email address routed directly into Mercury, the platform automatically parses incoming invoice documents. Mercury extracts critical metadata—including contractor names, addresses, due dates, and payment amounts—to generate draft payments for review in a single unified dashboard, streamlining the backend operations of his business.
`10:00` On-Policy Self-Distillation and Loss Function Innovations
Returning to the challenge of updating parameters, Patel argues that model architecture is no longer the main bottleneck for continual learning—the true hurdle lies in the loss function. The goal is updating weights based on a single session's experience without causing catastrophic forgetting or requiring massive data volumes. He highlights **On-Policy Self-Distillation (OPSD)**, a technique discussed during an impromptu lecture with Sasha Rush, as a compelling path forward. Under OPSD, a base model (the student) is trained to match the token predictions of a context-rich instance of itself (the veteran teacher) that has accumulated real-time experience throughout an extended work session.
OPSD holds distinct advantages over standard RLVR and Supervised Fine-Tuning (SFT):
1. **No External Verifier Required:** It does not rely on an external, deterministic reward signal; it simply distills the teacher's in-context reasoning into the base weights.
2. **Dense Supervision:** Unlike RL, which compresses a long trajectory into a single scalar reward, OPSD provides token-by-token probability matching between teacher and student.
3. **Selective Consolidation over Rote Recall:** Standard SFT naively forces a model to memorize every token in a session transcript, whereas OPSD enables the model to consolidate higher-level insights without overwriting its existing base knowledge.
- **Teacher vs. Student:** OPSD uses a context-loaded instance of the model as a "teacher" to guide the base "student" model's weights.
- **SFT Limitations:** Naive Supervised Fine-Tuning causes catastrophic forgetting because it forces the model to memorize raw transcripts rather than selective principles.
- **Targeted Updates:** RL and self-distillation naturally restrict weight updates to relevant decision nodes, preserving the broader foundational capabilities of the base model.
`15:00` Squeezing Signal with OPSD and the Speculative Frontier of "Dreaming"
To address the severe sample efficiency problem, models must extract maximum signal from scarce real-world experience. On-Policy Distillation (OPSD) acts as a targeted surgical tool: rather than "slingshotting" toward a teacher distribution as standard supervised learning does, OPSD updates the model only as much as absolutely necessary to achieve the teacher's actual results on real-world tasks. Beyond OPSD lies an even more speculative idea: "dreaming." If an AI can construct an accurate internal simulation of reality, it can rehearse new skills, test alternative strategies, and reinforce what works—experiencing orders of magnitude more simulated samples within the same wall-clock time.
This concept echoes the history of reinforcement learning. A few years after DeepMind introduced AlphaZero, researchers developed EfficientZero, a model designed for extreme data efficiency. When given just two hours to play an unfamiliar Atari game, EfficientZero could outperform a novice human. While this appeared to surpass human sample efficiency, the reality depended on how compute was measured: for every single step in the physical game, EfficientZero played dozens of simulated games in its head. Similarly, future LLMs might consume far less real-world data by practicing endlessly in self-generated environments, serving as a fourth axis of scaling alongside pre-training, RL, and inference-time compute.
* OPSD preserves supervised learning's core benefit by applying tiny, well-targeted updates from limited real-world data.
* Dreaming—also referred to as test-time training—involves models spending compute to write RL environments and train against them.
* Building a full-world simulation is vastly more difficult than emulating Go or Atari games, making dreaming a highly speculative frontier.
* Instead of typing `/compact` in tools like Cursor, Codex, or Claude to generate a light summary, a developer might hit `/dream` to incinerate massive compute, building and training against a gamified version of what the model observed.
---
`17:23` What 2027 Looks Like: Learning on the Job and Systemic Intelligence
Looking toward 2027 and 2028, a multi-stage paradigm shift emerges for AI capabilities. Reinforcement Learning with Verifiable Rewards (RLVR) provides the foundational push, yielding an agent capable of orientation, strategy trial, and iteration when encountering novel roadblocks off its training distribution. With expanded context windows, an AI could co-work alongside a human for a full week. At the end of that week, the user provides a performance review—a simple thumbs-up or thumbs-down. Upon approval, the base model distills everything learned during that session using OPSD, dreaming, or entirely new techniques, gradually expanding into adjacent non-verifiable domains.
Once this continual learning recipe arrives, the primary driver of AI improvement will no longer be the static pre-training or post-training received before public release. Instead, intelligence will compound dynamically through broad deployment across the economy. AIs will learn continuously on the job, transforming every user interaction into a shared network effect where the model grows smarter not just from your personal history, but from millions of concurrent real-world engagements worldwide.
> "Every time that you interact with an AI, it'll be smarter. Not only because it's been learning from your previous sessions, but also because it's been learning from all its interactions with all the other users in the world. And that's very scary and exciting and different from the way that AI improves right now."
* RLVR acts as the catalyst, creating agents smart enough to be deployed broadly into real-world work environments.
* Successive online updates allow models to incrementally master domains adjacent to their original training data.
* Full essay text and detailed footnotes are available at `dwarkesh.com`.
## Notable quotes
> `05:00` There's two things. There's the context length you train at, and there's a context length that you serve at. If you train at a small context length and then try to serve at a long context length, like maybe you get these degradations. — Dario Amodei
> `17:23` Every time that you interact with an AI, it'll be smarter. Not only because it's been learning from your previous sessions, but also because it's been learning from all its interactions with all the other users in the world. And that's very scary and exciting and different from the way that AI improves right now. — Dwarkesh Patel
## Mentioned
Dwarkesh Patel, Mercury, Etsy, Andy Jassy, Amazon, Slack, Gmail, Lyndon B. Johnson, Elon Musk, SpaceX, Anthropic, Dario Amodei, Henry Ford, Albert Einstein, Cursor, Sasha Rush, DeepMind, AlphaZero, EfficientZero, Atari, Codex, Claude, Sam Walton
Dwarkesh Patel argues that artificial intelligence labs will exhaust the benefits of static training paradigms and must transition toward models that continually consolidate real-world experience directly into their weights.
Grindability and the Limits of Verifiable Simulators (2:12)
Reinforcement Learning from Verifiable Rewards (RLVR) currently accelerates domains like software engineering and mathematics because they are both verifiable and "grindable"—allowing thousands of deterministic, parallel rollouts inside containerized environments. By contrast, real-world tasks like computer use lag because live platforms trigger bot countermeasures, and offline clones of applications like Slack or Gmail are labor-intensive to build. Without isolated, farmable simulators, sample-inefficient reinforcement learning algorithms struggle to make meaningful progress.
More critically, complex human endeavors—such as running a political campaign, launching a company, or litigating a lawsuit—take place in non-stationary, reset-free environments where feedback loops unfold over months or years. Patel expresses skepticism that training strictly inside synthetic, containerized environments will automatically generalize into the strategic mastery demonstrated by historical figures like Lyndon B. Johnson or Elon Musk. Citing Anthropic CEO Dario Amodei's observations on performance degradation between training and serving context lengths, Patel cautions against assuming that synthetic verifiers alone can resolve real-world ambiguity.
The Inefficiency of Ephemeral Inference (8:41)
Patel identifies a major structural inefficiency in modern AI architectures: while 30% to 50% of laboratory compute budgets are expended on inference, none of that compute updates the underlying model weights. Consequently, deployed agents repeatedly encounter enterprise workflows and operational errors without retaining any lasting institutional memory.
Relying permanently on expanding Key-Value (KV) caches to emulate competence through extended context is both parameter-inefficient and biologically unnatural. Patel notes that the human brain relies on memory consolidation and abstraction rather than verbatim storage; individuals with hyper-photographic recall frequently struggle with high-level conceptual reasoning. Because gradient updates remain notoriously sample-inefficient—evidenced by Cursor's tab-completion model requiring over 400 million records to learn basic patterns—true on-the-job adaptation requires distilling session insights directly into long-term weights.
On-Policy Self-Distillation and Simulated Dreaming (10:00)
To update weights from limited data without causing catastrophic forgetting, Patel points to On-Policy Self-Distillation (OPSD). Under OPSD, a context-rich instance of the model acting as an experienced teacher guides a base student model through dense, token-by-token probability matching. Unlike Supervised Fine-Tuning, which forces naive memorization of entire transcripts, or RLVR, which compresses complex trajectories into a single scalar score, OPSD applies targeted updates strictly to critical decision nodes without requiring an external verifier.
Beyond OPSD, Patel explores the speculative frontier of "dreaming" or test-time training, where models spend compute constructing internal simulations to practice skills offline. He draws an analogy to DeepMind's EfficientZero, which matched human performance on Atari games within two hours of real-world play by running dozens of simulated games internally for every physical step taken. If language models can generate and rehearse within their own environments, dreaming could emerge as a fourth scaling axis alongside pre-training, RL, and test-time inference compute.
Continuous Learning and Networked Compounding (17:23)
Looking toward 2027 and 2028, Patel outlines a deployment paradigm where RLVR serves primarily as a foundation, producing agents resilient enough to navigate unfamiliar obstacles. An AI could work alongside a human professional for a week, after which a simple binary evaluation—such as a thumbs-up or thumbs-down—triggers weight distillation via OPSD or simulated dreaming, expanding the system into adjacent, non-verifiable domains.
Under this model, the primary driver of AI improvement would no longer be static pre-release training cycles. Instead, intelligence would compound dynamically across the broader economy. Each user deployment would feed into a collective network effect, allowing models to grow steadily more capable by assimilating the shared experiences of millions of concurrent real-world sessions.
Patel's forecast depends on whether the AI industry can transcend containerized synthetic tasks and solve the credit assignment problem in ambiguous, non-resettable environments. While mechanisms like OPSD and internal dreaming offer plausible paths to update long-term weights, whether models can generate accurate internal world simulations without succumbing to catastrophic forgetting remains an unproven hypothesis.
[5:00] Dario Amodei: There's two things. There's the context length you train at, and there's a context length that you serve at. If you train at a small context length and then try to serve at a long context length, like maybe you get these degradations.
[17:23] Dwarkesh Patel: Every time that you interact with an AI, it'll be smarter. Not only because it's been learning from your previous sessions, but also because it's been learning from all its interactions with all the other users in the world. And that's very scary and exciting and different from the way that AI improves right now.
Original transcript
[0:00] So here's the big research bet that all the labs are making. They think that if we train AIs to accomplish millions of verifiable tasks across thousands of diverse RL environments, then we will have basically built AGI. Because this kind of training will have created a kind of problem-solving agent, the kind of thing that can make progress on open-ended tasks for weeks on end in the face of errors and mistakes and ambiguity. And the people who are optimistic about this vision will say that all these things that we talk about as the fundamental deficits in the current training paradigm, for example, the data inefficiency of these models or the fact that they lack continual learning, these things can just be steamrolled if we just scale training more. And the same way that all the fundamental research problems in natural language processing collapsed when we just threw enough compute into LLMs. So in the previous essay, I talked about how these models are one one millionth a sample efficient as humans. And the people who are in favor of the current training paradigm will say, look, that might be true, but this is only true during training. And training is this one-time cost that is amortized across billions of sessions that a model will experience. And what really matters is how smart and general and sample efficient the model is during a session And this has clearly been improving as we been doing more RL training AI agents are able to solve more and more ambitious problems over longer and longer time spans Anybody who has used these models for coding knows that Similarly, people would say, look, continue learning. This capability I keep harping about where the model's weights get updated based on what is learning from deployment may simply not be necessary because if in-context learning gets so good across longer and longer time horizons, then you don't need to distill back everything the model is learning on the job into the weights. People often say that their employees are not net productive until six months or more of them working on the job. So clearly, online learning is necessary for competence. But what if you could just fit those six months into the context window? There's been tons of architectural innovations that dramatically increase the amount of information or the amount of context that a transformer can store. And why not think with a couple more years of progress, you might have what feels like infinitely large context windows. Okay, so before we discuss this research a bit further, I want to step back and I want to ask a completely tendential question, which I find actually very interesting and confusing about the nature of current AI progress. Why has progress on computer use been so much slower than other domains Computer use is so clearly verifiable You could ask a question like did the desired Etsy item I ordered get delivered Is the venue for an event I'm trying to organize booked? Have my taxes been submitted? So isn't it weird that computer use has been making so much slower progress than coding and math and these other verifiable domains? I'm sure there's many reasons for this. And one of them, of course, is the fact that the modelers are exposed to far less high quality multimodal data during pre-training. But one reason that I think is actually quite underrated by people and which I think reveals the canyon walls against which this river of AI progress will only slowly chip away at is that it is not enough for a domain to be verifiable. It also has to be very grindable in the sense that you have to be able to run lots of parallel rollouts against a deterministic and replayable simulator. And you have to run those rollouts from the same starting point. If you're trying to make a model better at coding, you can define some container that has the software repo with a missing feature that you have tasked the AIs with creating. And then you have a thousand parallel agents that go at the problem, each of which has an identical copy of the container. But this doesn't work with computer use, at least not trivially You can just have a thousand Asians go try the same checkout flow on Amazon to get better at using websites because Andy Chassie will find your bots and shut your ass down You can solve this by making clones of Slack and Gmail and all the other common applications and websites. But at least currently, this is a very labor intensive and unscalable way to build environments. Of course, once AIs get good enough at coding themselves to build these clones with extremely high fidelity, then I'm sure the computer use will make quicker progress than it is right now. And you're also killing two birds with one stone with this kind of procedure because getting AIs to rebuild whole applications from scratch is also a great RL objective for coding. So while computer use itself may soon be solved, its current lethargy is telling us the following. That unless you can build a very replayable training target for a domain, the models will struggle to make much progress. And the reason this is true, of course, the models are incredibly sample inefficient during training. This is a point I was making in my last video essay. So for computer use, we might be able to make up for the sample efficiency deficit by building these farmable deterministic simulators. But for so many other different kinds of skills that we need AIs to have, we simply can't do this. How do we train an AI to get really good at building a business from scratch? How about winning court cases? Or having a profitable day of trading in the markets?
[5:00] a candidate win an election. The rollout here requires interacting with the real world, and you can't recreate it from just within a data center. The outer loop verification here may take months or even years of real world actions to elicit, and you can't re-observe it by perturbing the model's actions slightly in thousands of parallel rollouts to isolate exactly what the model did that actually worked. Now, dealing with such reset-free, non-stationary environments is a known open problem in RL. I'm not pointing out anything new. But I really do want to emphasize that because of the idiosyncratic and sparse nature of data in most domains in the world, you need sample efficiency in order to get proficient. If AIs are to develop all the skills that humans have, and even skills that humans don't have, then they need to be able to learn from information revealed in unstructured, unverifiable, and ambiguous ways from scarce amounts of real-world interaction, because in many domains, the relevant training information simply doesn't exist in any other way. What is the RL environment to make an AI that is as good at politics as Lyndon Johnson, or as good at building a space launch business as Elon Musk? The labs are betting that RLVR will generalize That is that if you train on enough containerized reproducible environments you will develop a very general agent that can make and execute plans and learn rapidly from new information and even pick up new skills all within a single session. If you drop this endlessly RLVRed AI into Texas politics in 1948, it could give you better advice than LBJ about winning the Senate seat. And if you give it $100 million in 2002 and let it cook, it would build SpaceX for you. Now, whether RLVR can generalize this well is an empirical question. If the labs went from spending billions of dollars on RL environments to a trillion dollars, would you get the kind of thing that is a fully human-like general intelligence within the context window? Dario gave a telling quote during our podcast together, which I think hints that RLVR generalization is not infinitely strong. But he was explaining why model performance tends to degrade at long context. He said, there's two things. There's the context length you train at, and there's a context length that you serve at. If you train at a small context length and then try to serve at a long context length, like maybe you get these degradations. Now, maybe I'm reading too much into this, but it seems like he's saying that short horizon RL training doesn't necessarily generalize to long horizon RL performance And if you can generalize from short horizon to long horizon then how are agents supposed to generalize from getting trained at a bunch of white collar tasks to say having the ability to be dropped in the real world and build a business from scratch as well as Sam Walton And even if after enough in-context experience, the AIs could become like Henry Ford or Robert Einstein, all that would be ephemeral and wasted if you couldn't get those learnings back into the weights. Around 30 to 50 percent of a lab's compute goes to inference. and that compute is currently not playing any productive role in helping improve the model. This seems like a huge waste and it's even worse than it sounds because it is only in deployment that the most valuable bits of information which your model could learn from are actually revealed. Things like what's actually happening in the organizations where I'm being used and what are they using me for and what kinds of mistakes do I tend to make in the real world. We've got some genius grad student who's never been allowed to take a real internship and we keep giving it more and more classroom case studies in the form of RL training on environments. It's so bizarre that we have AIs that are broadly deployed through the economy already and are participating in so many different kinds of tasks and are privy to so much domain and organization-specific tacit knowledge and they not able to make use of it But this kind of continual learning requires going back to the weights AIs can just keep building up a bigger and bigger KV cache as they learn from more and more users That's just not scalable. And that's also not how humans do it. There's no clean separation in our brain between parameters and activations. And it's not like some part of your skull keeps expanding as you learn more things through your lifetime. When we learn stuff, there's clearly some kind compression, and this aids our generalization and grogking. There are, in fact, some humans who have this autistics of ant-type ability to recall random tables of numbers or nonsense syllables years later, basically the kind of fidelity information that models have in context. And such sheer volume cripples these humans' ability to understand abstractions and metaphors. Human continual learning is less about having all your observations at the tip of your tongue and more about chiseling the right intuitions and big picture knowledge back into the weights. But the moment you move into the weights, you have to give up on in-context learning sample efficiency. Because gradient updates are super sample inefficient, all of the successfully shipped online learning models have had to learn the exact same thing across millions of users. For example, the cursor tab model online learns by predicting the same exact objective for over 400 million records
[10:00] rest of the day. The objective here being which edits actually got accepted by the user. At least so far, we haven't seen models online learn different kinds of things for different users. Because while a single session may generate more than enough data for a human to learn from, it's not enough to train a more capable AI. Current online learning can work for a very limited number of use cases. But the whole point of continual learning is that the world is very complicated. And each job and company and problem is different. And you need your intelligence to be able to learn the specific information related to a particular deployment, which simply can't be stuffed into some shared training run. These are all the things we're talking about when we talk about on-the-job learning. Things like how does everything in your organization work and fit together, and how to cooperate with all the infrastructure and the other people around you to make progress on some larger project, and what the common failure modes are, and many other things like this. As the podcast has grown, I've had to deal with more and more operational overhead. Take paying bills. In the past, contractors would just email me their invoices. Every few weeks, I'd dig through my inbox, I'd create a folder with all the bills, and I manually pay each one At this point though I just give everybody an email address that goes straight to Mercury which is my banking platform Whenever anybody sends an invoice to that address Mercury automatically downloads it scans it and extracts all the relevant information. Things like the contractor name, address, payment amount, invoice number, and due date, and then uses all of this to create a draft payment. Mercury then stores a list of these drafts for me to review. I just go through this list and double-check that I've been built correctly. I don't know how to track anything or enter any information myself. Mercury does all the fundamental things for your business extremely well, and it puts them all in one place. If you want to learn more, go to Mercury.com. Mercury is a fintech company, not an FDIC-insured bank. Banking services provided through Choice Financial Group and Column NA members FDIC. In this way, sample efficiency and continual learning are actually deeply connected problems. Relatively little data is available to the model on the job. Now, to learn from this data requires sample efficiency. And models can do that in context, but using the fast weights that are built on the fly by attention, which allows for the sample efficiency, but scales very poorly in terms of memory. So we need architectural innovations that allow for some kind of intermediate representation. I talked before about how we already have many different working ideas for this kind of thing from sparse attention to KV cache compaction And every week somebody releases a new paper suggesting some kind of other architectural optimization It doesn't seem to me that architecture is fundamentally what is bottlenecking in continual learning. So perhaps the bottleneck is the loss function. How do we update the weights, aka how do we improve the model itself, based on information that was learned from one particular session? Even here, naively, it seems like there are many ideas that ought to work. A lot of people are talking about this technique called on-policy self-distillation recently. If you want to learn more about it, I recorded a little impromptu Blackboard lecture on my iPhone with Sasha Rush a couple weeks ago, and it's in the link in the description. But to summarize the explanation, the idea is that we encourage the base model to make the same predictions when trying to solve some real-world problem as the model with all the context accumulated after a long session would have made. The whole point of this procedure is to distill what the model learned in a session back into the weights themselves. This is better than RLVR for two reasons. One, OPSD doesn't require us to have some outer loop verifiable reward. We just need a model that can learn the right things within the context window And as long as we have that we can train the base model to match our veteran teacher model which has built up all this experience during the session And two OPSD provides a much denser supervision signal than naive RL Instead of projecting a single reward through the whole trajectory, you can train on the per-token probability discrepancy between the teacher and student. For continued learning, OPSD is also superior to supervised fine-tuning. The most naive version of SFT for this application that you can imagine is just to train the base model to predict all the tokens that are observed during the session. But this takes no sense if you think about it as a learning target. The way you get better at your job is not by recalling the transcript of every single thing that happened every day with perfect fidelity. Rather, it's by consolidating the handful of insights and pieces of knowledge that are actually relevant to you getting better at your job. RL trading doesn't suffer from this failure mode. RL is great at concentrating the update to only what is relevant to getting the outcome right. That's why actually very few parameters are changed during an RL training step. And this is a very important property for continual learning because as you're learning on the job, we don't want to overwrite and forget all the other things that the base model knows. I wrote a post a few months earlier arguing that RL learns much less information per sample than supervised learning. But this may be a good thing rather than...
[15:00] thing. You only change the model as much as is absolutely necessary to achieve the outcome, and no more. OPSD preserves this property of supervised learning, where instead of slingshoting towards a teacher distribution, as supervised learning would have you do, you only extract the knowledge that is necessary for you to achieve the same results of the teacher on actual real-world tasks. OPSD is one way to attack the sample efficiency problem. You take the scarce real-world experience, and you squeeze all the signal into a tiny, well-targeted update. But there's also another, much more speculative idea. Let's call it dreaming. If the AI can build a good simulation of reality against which to rehearse new skills or try alternative strategies and reinforce what actually works, then AIs could experience orders of magnitude more simulated samples in the same wall clock time. Let's go back into history a bit. A couple of years after DeepMind released Alpha zero, a group of researchers trained a model called Efficient Zero. And the whole point of this model is to be very efficient with data. So if this model and a human both got two hours to play against a simulator of an Atari game that they hadn seen before this model would actually probably beat the novice human Does this mean that the model was more sample efficient than the humans Well that was the goal of the training but it depends on how you measure sample efficiency Because for each step in the real game, Efficient Zero is playing dozens of simulated games in its head. In a similar way, future LLMs might be able to consume far less real-world data while practicing endlessly against environments that they build for themselves. The big difference, of course, is that it will be much harder to build a simulation of the whole world than it is to emulate the game of Go. That's why I said this is a much more speculative idea. If it works, it would become a fourth axis of scaling alongside pre-training, RL, and inference time compute. You call it test time training or dreaming. The model spends compute writing up RL environments and then training against them, and it's rehearsing all the skills that will actually be used in production for a specific user. So instead of hitting forward slash compact in codex or cursor or clod, which kindles a small amount of compute to write up a summary, and which gives you the simulacrum of continual learning, you hit forward slash dream. And this incinerates huge amounts of compute to build and train against a video game version of what the model is witnessing in the real world So what might continual learning look like by 2027 or 2028 And how do we get there Here one scenario All of this RLVR training is producing an agent that can get its bearings when it thrown at an unfamiliar problem, and it can try different strategies, and it can iterate when it hits a roadblock. This is the crucial thing that RLVR has given you, an AI that is at least competent enough to start getting some real world experience if you could learn from it. And once you have that, you send it out into the world to do real work, even on projects that are off the trading distribution. Now, let's say at this point, the effective context lengths have expanded such that AIs can jam and co-work with you for a full week of wall clock time. At the end of a week, you give it a thumbs up or a thumbs down. Give it a work review. And if you give it a thumbs up, the base model distills everything that the AI learned during the session. And it may use OPSD, it may use dreaming, it may use some other technique that we aren't even aware of, or it'll use a combination of all of the above. And once it does so, the AI starts getting better domains that are adjacent to what it was explicitly trained to beforehand with our LVR training. And in the next round after that it can get better at things that are adjacent to what it had previously online learned In this way the gamut of AI skills and knowledge and capabilities can expand far beyond the verifiable domains that the model was originally trained against before it was deployed. Just as pre-training created a base intelligence that was smart enough to become a competent agent with enough RLVR on top, so RLVR has created an agent that is competent enough to be actually broadly deployed in the world and from this broad deployment to learn on the job once the training recipe for continual learning actually arrives. By this point, the main way that AIs get better is not from the training they have received before they are released to the public. Rather, it's from all this experience that they'll be accumulating from being broadly deployed in the economy and engaging in so many different kinds of tasks. Every time that you interact with an AI, it'll be smarter. Not only because it's been learning from your previous sessions, but also because it's been learning from all its interactions with all the other users in the world. And that's very scary and exciting and different from the way that AI improves right now. This was an aeration of a blog post that I also released on my website at dwarkash.com. Go there if you want to read all the footnotes or if you want to sign up so you can find out when I release the next blog post. Otherwise, I'll see you on the next episode.