The Art of Winning an Ancient Game: Why Your Chatbot is Rubbish at Chess

Long before chatbots were writing emails, planning holidays and bluffing their way through homework, a different kind of machine was making people nervous. It didn’t chat. It didn’t joke. It simply sat across a chessboard and made moves.

In 1997, IBM’s Deep Blue defeated world champion Garry Kasparov, turning chess into one of the great public theatres of artificial intelligence. For many people, this was the moment machine intelligence felt real. Yet here’s the odd thing. Decades after computers became superhuman at chess, many chatbots still make a mess of the game. They can explain openings, praise a knight fork and write confidently about strategy, then suggest a move that’s completely illegal. So why can a chatbot write poems, explain physics and draft emails, but still blunder on 64 squares?

Chess and computers have been sparring since the mid-twentieth century, when machines were room-sized and “thinking” meant grinding through possible moves. Early programs were clumsy: they knew the rules, but not the poetry.

By the 1970s and 1980s, engines were searching deeper, pruning weak lines and judging positions more sharply. The public turning point came in 1997, when IBM’s Deep Blue defeated world champion Garry Kasparov. Machine chess was no longer a curiosity. It was a headline.

Modern engines such as Stockfish are stronger still, blending calculation with refined evaluation. Then came AlphaZero, which learned through self-play and produced games that seemed bold, even beautiful. The machine had stopped merely crunching; it had begun to surprise.

A normal computer program follows instructions written in advance. Think of it like a very obedient factory machine: press the right buttons, feed in the right information, and it will do exactly what its program tells it to do. It does not guess, improvise, or fill in gaps. If the instructions are clear, it can be fast and precise; if they are missing, it simply has nowhere to go.

A chatbot works more like a person finishing a sentence. When you ask it something, it looks at the words you used, then works out what words would make sense next. It does this again and again, adding one piece at a time until it has a full answer. It learned how to do this by looking at millions of examples beforehand: questions and answers, stories, facts, arguments, jokes and explanations. So it’s not following a neat list of instructions. It’s making a very fast, educated choice about what should come next.

This is a simplification, but it gets at the important difference: some systems are built to follow formal rules, while chatbots are built to generate likely language.

To play chess well, any system needs to carry out several basic operations, and it needs to get all of them right.

• Keep an exact record of the board: It must know where every piece is, whose turn it is, and whether special moves such as castling, where the king and rook move together, or en passant, a rare pawn capture, are still available.
• Know which moves are legal: It must distinguish between moves that merely look possible and moves that are actually allowed under the rules, including moves that would leave the king in check.
• Calculate possible replies: It must look beyond the next move and consider how the opponent might respond, then how the game could continue after that.
• Evaluate resulting positions: It must judge whether a position is good or bad by considering material, king safety, threats, pawn structure, piece activity, and longer-term chances.
• Choose between competing lines: It must compare different possible sequences of moves and select the one that offers the strongest practical result.
• Update the board accurately: After every move, it must revise the position without losing track of captures, checks, promotions, castling rights, or whose turn comes next.

Of course, this leaves out the psychological side of chess: nerves, bluff, pressure, overconfidence, fatigue, and the little battles of will that unfold when both players are human.

A specialist chess program treats chess as a precise rule-based problem. First, it stores the board as exact data: every square, every piece, whose turn it is, and which special moves are still allowed. Then it generates only legal moves, rather than moves that merely seem plausible.

From there, it begins searching. For each possible move, it imagines the opponent’s replies, then its own replies after that, building a branching tree of future positions. This branching structure is often called a move tree. A chess game is not really one path stretching neatly ahead; it’s a forest of possibilities. Every move creates possible replies, every reply creates replies to those replies, and within just a few turns the number of future positions becomes enormous. A strong engine doesn’t see the whole forest, but it can search much further through it than any human player. It can’t search every possible game to the end, because the number of lines becomes enormous. Therefore, it uses clever pruning: it quickly cuts off lines that look obviously poor, so it doesn’t waste time checking every possible future.

Finally, it scores the positions it reaches. It looks at things such as material, king safety, threats and piece activity, then chooses the move that leads to the strongest position it can find.

A chatbot approaches chess from a different angle. It’s not usually calculating the board like a proper chess engine. Instead, it’s predicting what a sensible chess answer might look like, based on patterns it’s seen in books, games, puzzles and explanations. That means it can talk persuasively about openings, tactics and famous matches. It may even suggest a strong-looking move.

However, chess is unforgiving. One illegal move, one missed check, one invented variation, and the whole answer collapses. The habits that make a chatbot fluent – prediction, generalisation and filling in gaps – are often a bad fit for chess. The game rewards strict accuracy. A chatbot, unless connected to a chess engine, is often only performing the idea of chess rather than actually playing it. It might, for example, recommend a move that sounds like something from a real chess lesson, even though the piece cannot legally move there.

So why do chatbots and chess engines produce such different results at the same game? Well, because although they appear to be playing the same game, they’re doing very different things underneath. Let’s compare how they handle each element.

Remembering the Board

The first difference is not intelligence, but memory. A chess engine holds the position as a set of exact facts: this piece is on this square, this side is to move, these castling rights still exist. A chatbot is dealing with a running description of the game instead, so the board can become foggy as the exchange continues. A captured piece may linger in the conversation, a pawn move may be forgotten, or the turn order may drift. In chess, that’s fatal. The game depends on one shared, unchanging position, and the engine has that position in its hands; the chatbot may only have a story about it.

Legal Moves

Legality is where the gap becomes especially sharp. In a chess engine, a move is either allowed by the position or it’s not, and the system checks that before the move ever reaches the screen. With a chatbot, the danger is that legality can be mistaken for fluency. A move can be written in convincing notation, wrapped in a sensible-looking explanation, and still be impossible: perhaps the king is left in check, perhaps a piece is blocked, perhaps castling is no longer available. The notation may look like chess, but the board is the judge.

Calculation

The difference in calculation is the difference between following consequences and describing them. A chess engine works through possible futures, one position after another, testing replies and counter-replies before choosing a line. A chatbot can produce the surface of that process: “White wins a pawn”, “Black has pressure”, “the knight fork decides the game.” Sometimes that will be right. However, unless it’s actually tracking the position and checking the sequence, the analysis may be built on a move that could never happen. It’s fluent chess talk, not necessarily chess calculation.

Evaluation

When a position has to be judged, a chess engine and a chatbot aren’t really measuring the same thing. The engine’s verdict is tied to the exact board and to a structured comparison of material, threats, king safety, activity and future tactics. A chatbot’s judgement is usually broader and more verbal: one side has space, one king looks exposed, a piece seems badly placed. That can be helpful for explanation, especially for readers who want the idea rather than a number. But chess is often decided by one concrete detail, and a general impression can miss the move that changes the whole evaluation.

Explanation

Explanation is the one category where the chatbot can look more impressive than the stronger player. A chess engine may find the best move and still present it coldly, as a score and a string of notation. It knows what works, but not always how to make that knowledge feel clear. A chatbot is usually better at translating chess into ordinary language: why a square is weak, why a trade helps, why an attack is dangerous. The catch is obvious. A clear explanation is only valuable if the chess underneath it is sound; otherwise, it’s a polished account of a mistake.

The obvious solution is not to make chatbots pretend harder. It’s to give them tools. A chatbot connected to a real chess engine can become much more useful, because the engine handles legality, calculation, and evaluation while the chatbot handles explanation.

That pairing makes sense. The engine can say, in effect, “this move is best.” The chatbot can explain why: because it wins a trapped knight, stops a checkmate threat, improves the rook, or helps a dangerous pawn march towards promotion. One system calculates; the other translates.

This is already how many powerful AI systems work best: not as one magical brain, but as a collection of specialised parts. For chess, that means a rules-aware board, a proper engine, and a language layer that knows when to stop bluffing.

Chess exposes the gap between sounding clever and being correct. It punishes vague memory, hand-wavy planning, and confident nonsense. That makes it a superb test for artificial intelligence, because it asks a blunt question: can the system keep track of a structured world and act within its rules?

Recent chess benchmarks – tests used to compare how well different AI systems perform – have been designed precisely to probe those weaknesses. Some models perform better than others, but chess remains awkward because it combines memory, rules, planning, and precision in one small arena. The lesson isn’t that chatbots are useless. It’s that fluency isn’t the same as mastery. A beautiful sentence cannot rescue an illegal move.

So, why is your chatbot rubbish at chess? Because chess asks for a machine that can remember, verify, calculate, and obey strict rules over time. A chatbot, at heart, is built to handle language. It can describe brilliance without always performing it.

That doesn’t make the technology unimpressive. In some ways, it makes it more interesting. Chess reveals both the magic and the limits: the eloquent answer, the bold plan, the impossible bishop. On the ancient board, the chatbot isn’t a grandmaster. It’s a talkative apprentice, still learning that in chess, unlike conversation, every square has consequences.