In 2017, DeepMind’s AlphaZero shocked the world by mastering chess, Go, and shogi—not by studying human games, but by playing itself. Within hours, it surpassed decades of human expertise and engine refinement. The algorithm didn’t just learn; it reinvented the rules of learning itself.

At its core, AlphaZero is a paradox: an AI that starts with zero knowledge, zero data, and zero human input, yet ends up outperforming everything that came before it. How? The answer lies in a deceptively simple loop: self-play, reinforcement learning, and a neural network that rewires itself based on its own mistakes.

The Illusion of Simplicity

AlphaZero’s training process looks like magic. Start with a blank neural network. Have it play millions of games against itself. Gradually, it gets better—first beating weak opponents, then stronger ones, until it’s superhuman. But the magic isn’t in the outcome; it’s in the mechanism.

The video you might have seen (linked above) breaks this down using Connect 4, a game simple enough to visualize but complex enough to reveal AlphaZero’s inner workings. The neural network doesn’t just evaluate board positions; it learns to see patterns in them, much like a human might recognize a fork in chess or a ladder in Go. The difference? It does this at a scale and speed no human can match.

How Self-Play Beats Human Data

Most AI systems learn from human-generated data. Think of image recognition models trained on labeled photos or language models fed billions of words. This is supervised learning, and it’s powerful—but limited. It can only ever be as good as the data it’s trained on.

AlphaZero, by contrast, uses reinforcement learning. It doesn’t need human games or labeled data. Instead, it generates its own training data by playing against itself, using a technique called Monte Carlo Tree Search (MCTS) to explore possible moves. The key insight? The AI doesn’t just exploit what it knows; it explores what it doesn’t.

Here’s how it works in practice:

The Neural Network Under the Hood

AlphaZero’s neural network isn’t just evaluating board positions—it’s deconstructing them. In Connect 4, for example, the board is represented as a 6x7 grid, but the network processes it as a stack of feature planes: one for empty squares, one for the AI’s pieces, one for the opponent’s pieces, and so on. This is similar to how image recognition models process RGB channels.

The network then applies convolutional filters to these feature planes. Each filter is a small grid (e.g., 4x4) that slides across the board, scanning for patterns. The weights in these filters aren’t hand-coded; they’re learned through self-play. Over time, the network discovers which patterns matter—like a diagonal threat in Connect 4—and assigns them higher weights.

The Limits of Self-Play

AlphaZero’s success is undeniable, but it’s not without caveats. For one, it’s computationally expensive. Training AlphaZero for chess required thousands of TPUs (Google’s specialized AI chips) and millions of self-play games. Most researchers don’t have access to those resources.

Second, AlphaZero’s learning is narrow. It excels at games with clear rules and perfect information (like chess or Go), but struggles in domains with noise, uncertainty, or incomplete information. Real-world problems—like robotics or medical diagnosis—don’t fit neatly into its framework.