Deep Blue was an IBM machine built for one thing only: to beat the world chess champion in a match at tournament time controls. It did so in May 1997, defeating Garry Kasparov 3½–2½ (Buckner, 2024, p. 51), one year after losing to him 4–2 in Philadelphia (Hsu, 1999). It did not learn from experience in any central way (M. Mitchell, 2019, ch. 9): it was heuristic search on an enormous scale, plus hand-loaded chess knowledge.
How it works
The basic design is the one Claude Shannon proposed in the late 1940s and that Arthur Samuel had already used for checkers: build a game tree rooted at the current position, score the leaf positions with an evaluation function, and propagate those values upward with the minimax algorithm, assuming each player picks what is best for them (M. Mitchell, 2019, ch. 9). Alpha–beta pruning discards branches that cannot change the decision, and quiescence search follows captures beyond the depth limit so as not to evaluate a position in the middle of an exchange (Hsu, 1999).
What set Deep Blue apart was scale. The 1997 version ran on a 30-node IBM RS/6000 SP supercomputer with 480 chips specially designed to generate moves and evaluate positions (M. Campbell et al., 2002). In a typical search, software explored the first eight plies (single moves by one side) and the chips finished the last four; along forcing lines, extensions reached about 40 plies (Hsu, 1999). The system examined on the order of one to two hundred million positions per second (M. Campbell et al., 2002; Buckner, 2024, p. 51).
The evaluation function, etched into the chips, combined more than 8,000 features (material, pawn structure, king safety, control of the center) with weights adjustable in software; the team retuned them between games during the match (Hsu, 1999). There was also a hand-prepared book of about 4,000 opening positions, an "extended book" summarizing a large database of grandmaster games, and databases covering every endgame with five pieces or fewer (M. Campbell et al., 2002). Some weights were tuned with automated tools, but the bulk of the knowledge was written by people.
If its compute stat looks high for a system that is never trained, that is because it measures what it spent while playing, that is, test-time compute: at some 8 trillion operations per second sustained (Hsu, 1999) and about three minutes per move, on the order of 10¹⁵ operations per move (our own estimate).
What changed
Since the pioneers of symbolic AI, chess had been treated as the acid test of intelligence: in 1958 Newell and Simon wrote that a successful chess machine would seem to have "penetrated to the core of human intellectual endeavor" (M. Mitchell, 2019, ch. 9). Deep Blue won without anything like the pattern perception grandmasters play with, and the improvement of chess programs had come mostly from the increase in computer speed (M. Mitchell, 2019, prologue). As Chollet (2021) notes, classic chess programs do not even count as machine learning: their rules are written by the programmer (2021, sec. 1.1.1).
Limits
- A single task. Deep Blue could play chess and nothing else (M. Mitchell, 2019, prologue).
- Combinatorial explosion. Chess offers about 35 possible moves per position on average; Go offers about 250, and nobody had managed to write a good evaluation function for Go. So its method could not cope, and the leap came with AlphaGo, which learns to evaluate (M. Mitchell, 2019, ch. 9).
- Inefficiency. Its victory was read as a triumph of processing speed rather than a display of intelligence: a grandmaster considers very few moves (Buckner, 2024, pp. 51–52).
- Transparency at scale. Every decision can be traced in intelligible terms (piece values, board control), even if the trace runs to millions of positions. When a coding bug made it play a random move in the first game of 1997, the programmers found the fault and fixed it (Buckner, 2024, p. 62).