Audio · 2026-05-15 · 6 moments

Eric Jang – Building AlphaGo from scratch

AlphaGo is still the cleanest worked example of the primitives of intelligence: search, learning from experience, and self-play. ✦ AI generated

Apple Podcasts ↗

timeline · colored by role

Claim◆

A ten-layer neural network can amortize and approximate an almost intractable search problem to very high fidelity — a breakthrough most people still don't fully appreciate, and one that hints our theoretical notions of computational hardness may be incomplete in practice.

Eric Jang argues AlphaGo's core breakthrough — compressing an intractable Go search into a 10-layer forward pass — is more profound than commonly recognized, and that the same phenomenon underlies AlphaFold and may complicate our understanding of NP-hardness.

transcript

Eric Jang: 10 steps of neural network parallelized distributed-representation thinking is able to amortize and approximate to very high fidelity a nearly intractable search problem. This was a breakthrough that I think most people don’t even fully comprehend today, how profound that accomplishment is.

explains mechanism · 1

Mechanism◆

MCTS-based training works because it never asks the network to directly chase a win/loss signal — instead, for every single action taken, search produces a strictly better relabeled target, giving one clean supervision signal per action instead of a noisy win-rate credit-assignment problem.

Eric Jang explains the central mechanism of AlphaGo's self-play training: MCTS doesn't reward winning trajectories directly but instead relabels every action with a searched, provably-better action, sidestepping the credit-assignment problem that plagues naive win/loss reinforcement.

transcript

Eric Jang: Importantly, what it is doing is saying: for every action we took, we did a pretty exhaustive search on MCTS to see if we could do better, and we’re going to make every action that we took better by having the policy network predict that outcome instead. This is a very nice idea because you have one supervision target for every single action. The variance of your learning signal is very low compared to the alternative naive RL thing.

Fact

Being first to achieve a result always costs vastly more compute than reproducing it later, because followers can lean on tricks like distillation and other crutches the original team didn't have.

Eric Jang notes he rebuilt a strong Go bot for about $10K in rented compute — versus AlphaGo Zero's roughly 3E23 FLOPS — because being first to solve a problem is inherently far more expensive than catching up once someone else has already solved it.

transcript

Eric Jang: The compute required to be the first to do something is always much larger than the compute it takes to catch up. It’s the same story playing out in LLMs. Once someone else has done it, you can use tricks like distillation. You can use all sorts of crutches to bootstrap your way to success.

Mechanism

MCTS works cleanly for Go because value estimation is concrete and the action space is revisitable enough for visit-count-based exploration bonuses to mean something, but that same PUCT-style heuristic likely doesn't transfer to LLM reasoning where token sequences are too vast and open-ended to revisit.

Eric Jang explains why MCTS doesn't straightforwardly port to LLMs: Go's concrete value estimates and bounded, revisitable action space let PUCT prune the tree effectively, but language's combinatorially vast action space undermines the same exploration heuristic.

transcript

Eric Jang: But there are two things that make MCTS very simple for Go. Value estimation is concrete. You can determine it for real, and then you can use it to truncate depth, as you said. The breadth is also determined. What’s critical is that the action selection algorithm, where you iteratively visit and grow the tree, is well suited for the size and depth of problem that Go is.

Mechanism

RL's inefficiency is best understood as bits-per-FLOP, which decomposes into samples-per-FLOP (which falls as trajectories get longer) times bits-per-sample (which is far lower for RL's win/loss signal than for a supervised learning label).

Dwarkesh Patel lays out a framework showing RL is doubly inefficient compared to supervised learning: fewer samples per FLOP as horizons lengthen, and far fewer bits of signal extracted per sample since a binary win/loss carries much less information than a full label distribution.

transcript

Dwarkesh Patel: You can think of bits per FLOP as samples per FLOP times bits per sample. What I mentioned a second ago is that the samples per FLOP go down as RL becomes more long-horizon. But this kind of naive RL is also terrible from a bits-per-sample perspective, at least compared to supervised learning.

Claim

Current LLM coding agents are already very good at open-ended hyperparameter and architecture search — rewriting data loaders, spotting small gradients, tuning constraints — turning what used to be grid search into flexible, grad-student-like experimentation.

Eric Jang says the models he used (Opus 4.6/4.7) go well beyond traditional grid search, autonomously diagnosing issues like small gradients and rewriting code (data augmentation, optimization constraints) to squeeze out performance gains, though they still struggle to choose which experiment to run next.

transcript

Eric Jang: The really cool thing that automated coding can do now is search a much more open-ended set of problems. It can say, “I’ve identified that the gradients are small in this layer, so let me change it up here. Let me rewrite the code so the data loader has a new augmentation I came up with. Let’s try to find the best way to fit the constraints of the optimization problem.” You end up with this much more flexible, high-level, almost grad-student-like ability to just grind a performance metric.

Highlight slides

AlphaGo's Hidden Breakthrough✦ from: A ten-layer neural network can amortize and approximate an almost intractable search problem to very high fidelity — a breakthrough most people still don't fully appreciate, and one that hints our theoretical notions of computational hardness may be incomplete in practice.MCTS Sidesteps the Credit-Assignment Problem✦ from: MCTS-based training works because it never asks the network to directly chase a win/loss signal — instead, for every single action taken, search produces a strictly better relabeled target, giving one clean supervision signal per action instead of a noisy win-rate credit-assignment problem.A Broader Pattern✦ from: A ten-layer neural network can amortize and approximate an almost intractable search problem to very high fidelity — a breakthrough most people still don't fully appreciate, and one that hints our theoretical notions of computational hardness may be incomplete in practice.Naive RL vs. Search-Based Relabeling✦ from: MCTS-based training works because it never asks the network to directly chase a win/loss signal — instead, for every single action taken, search produces a strictly better relabeled target, giving one clean supervision signal per action instead of a noisy win-rate credit-assignment problem.Why It Matters✦ from: A ten-layer neural network can amortize and approximate an almost intractable search problem to very high fidelity — a breakthrough most people still don't fully appreciate, and one that hints our theoretical notions of computational hardness may be incomplete in practice.

Related episodes

Article · Import AI

A ten-layer neural network can amortize and approximate an almost intractable search problem to very high fidelity — a breakthrough most people still don't fully appreciate, and one that hints our theoretical notions of computational hardness may be incomplete in practice.

MCTS-based training works because it never asks the network to directly chase a win/loss signal — instead, for every single action taken, search produces a strictly better relabeled target, giving one clean supervision signal per action instead of a noisy win-rate credit-assignment problem.

Being first to achieve a result always costs vastly more compute than reproducing it later, because followers can lean on tricks like distillation and other crutches the original team didn't have.

RL's inefficiency is best understood as bits-per-FLOP, which decomposes into samples-per-FLOP (which falls as trajectories get longer) times bits-per-sample (which is far lower for RL's win/loss signal than for a supervised learning label).

Current LLM coding agents are already very good at open-ended hyperparameter and architecture search — rewriting data loaders, spotting small gradients, tuning constraints — turning what used to be grid search into flexible, grad-student-like experimentation.

Import AI 464: Fables writes GPU kernels; AI automation; and analog computation

Quoting Josh W. Comeau

Import AI 462: Superpersuasion; self-sustaining AI; paths to ASI