Real Game AI, Not a Chatbot
Every "AI" in a product now seems to mean a large language model. The AI that plays against you here doesn't — it's classical game-tree search: minimax, expectimax, breadth-first search. That's a deliberate engineering choice, and it's the difference between an opponent that's provably correct and instant and one that's plausible and slow.
· 6 min read · every number here is from our own re-runnable benchmark
"Why Not Just Use an LLM?"
It's a fair question in 2026 — you could prompt a model with the board and ask for a move. The reason we don't is that a language model is trained to predict the next token of text, not to search a game tree. It can explain tic-tac-toe strategy fluently and still play a losing move, because fluent text and optimal play are different objectives. Winning a solved game is a search problem, and we already have exact, fast algorithms for it.
The three engines behind the site — minimax with alpha-beta pruning for tic-tac-toe, expectimax for 2048, and breadth-first search for Color Lines — are textbook, deterministic, and run in well under a millisecond in a browser tab. The full mechanics are in Six Games, Three Classic Algorithms; this post is about why that beats a language model for the job.
Search vs. a Language Model, Point by Point
| Game-tree search (ours) | A language model | |
|---|---|---|
| How a move is chosen | Search the game tree and return a specific legal move. | Predict the next tokens of text; the "move" is whatever it writes. |
| Determinism | Same board → same move, every single time. | Sampling is probabilistic; the move can change run to run. |
| Legality | Only legal moves are ever generated — the rules produce them. | Can emit an illegal or malformed move; needs a validation layer. |
| Latency | Sub-millisecond, on the player’s own device. | An API round-trip: network plus inference, well beyond a frame. |
| Correctness guarantee | Minimax is provably optimal for tic-tac-toe — 0 losses is testable. | No optimality guarantee; strength is empirical and prompt-dependent. |
| Cost & offline | Free, offline, no key, no rate limit. | Hosted model or paid API; needs connectivity. |
Every row above is an architectural difference — how each system decides on a move — not a quoted benchmark. The only measured numbers in this post are ours, below.
The Payoff: A Strength Number You Can Actually Pin Down
Because the engines are deterministic, we can put an exact figure on how strong they are — run the shipped code headlessly, hundreds of times, and count. That's much harder to do for a model whose output shifts with sampling and phrasing. Here's the 2048 solver's measured ceiling across 250 self-play games:
2048 reach-rate ladder, 250 self-play games
69.6% of games reach the 2048 tile, 30% reach 4096, and none of the 250 reached 8192 — the honest ceiling of a corner-snake expectimax search at ~0.5 ms/move. It's a number, with error bars you could compute, precisely because the same board always drives the same search.
Tic-tac-toe is the cleaner case: full-depth minimax is provably optimal, so "unbeatable" is a theorem, not a vibe. Across 1,200 self-play games — 1,000 against a random player, 200 against a perfect copy of itself — it lost none. Alpha-beta pruning is what keeps full depth cheap: at the opening move it explores 36,528 nodes instead of 549,945, a 93% cut, resolving in about 0.3 ms. A language model asked the same question would spend a network round-trip and hundreds of millions of parameters to produce a move it can't prove is right.
Every figure here comes from the shipped game code run headlessly, and the harness is public and seeded — run it yourself → to reproduce the reach-rate ladder and the node counts.
The Right Tool, Not the Trendy One
None of this is anti-LLM. Language models are extraordinary at language — and a couple of tools here that are language tasks could genuinely use one. But a board game with fixed rules and a finite tree is exactly the problem classical search was invented for. Reaching for an LLM there would trade a proof for a probability, a sub-millisecond local move for a server round-trip, and a free offline game for an API bill.
So the games stay deterministic, provable, instant, and free to run — no key, no backend, nothing leaving your device. That's not the AI that's in the headlines. It's the AI that wins the game.
Related reading: the algorithm mechanics are in Six Games, Three Classic Algorithms, how each strength number is proven before it ships is in How We Benchmark a Game AI, and the per-move performance is in Search Inside One Browser Tab.
Play Against the Search
Try to beat full-depth minimax at tic-tac-toe, or watch expectimax chase a corner-snake board in 2048. No model, no server — just search.