Teaching My Phone to Play Mahjong

The model has 2,307,140 parameters. On each turn it chooses from 127 possible moves: every tile it could throw, every call it could make, and declaring a win. The game removes the moves that aren’t allowed before it chooses, so it can never make an illegal one. Every version in this article is the same network, the same size and shape (3 residual blocks, width 96). They differ only in how much they’ve played.

I train it with PPO, the method described in the story. The only reward it ever gets is the points paid at the end of a round. Nothing scores a single discard.

Those points count in full for every move in the round, the first discard as much as the last. A lot of reinforcement learning shrinks rewards that arrive later, which is called discounting. That’s needed when a task never ends. A mahjong round ends after about 19.4 decisions, then points change hands, and those points are all that matter. Discounting would teach the model to prefer a small win now over a bigger win four turns later, and the game doesn’t pay that way. AlphaZero, which learned chess and Go by playing itself, scores its games the same way. There is a cost. With nothing to reward along the way, I tried rewarding good defence sixteen different ways, and none of them made a measurable difference.

The chart comes from the training log: 96,096,042 to 735,775,142 decisions, over 38,721 logged iterations and 32,826,560 player episodes. The log ends before the run did, and I haven’t drawn the line past it. The log also records how much the score jumped around between iterations. I left that off: a shaded band would look like uncertainty about strength, when it’s only noise. And 45% of its practice opponents change as it learns, so a rising line can also mean the opponents got easier to beat. This curve can’t show strength at all.

One of the practice bots was broken for the whole project. safety_aware was meant to avoid dangerous tiles, but a flipped sign made it throw the dangerous ones and keep the safe ones. Tested on its own it won 1.9% of rounds and averaged −2.17 points, the weakest player I measured, and it filled 10% of training seats from v8 on. I left it in, so older runs can still be reproduced against the opponents they trained with. Tests use a working defensive bot instead.

Against the version before it, 400M scored +2.433 points a round, range [+1.989, +2.876], over 40,960 rounds where both played the same deals. Against four opponents it had never trained with, it scored +2.476, range [+1.510, +3.466]. That’s the harder test, because a model can learn the habits of practice partners it sees every day. These numbers came from a different test than the one that later failed its audit.

It ran in the browser from 2026-08-10 until 850M replaced it on 2026-09-22, and it played every recorded game on this page. The strongest model goes to the app, and the browser gets the one before it.

Faan is how the rules value a hand: whether it’s allowed to win, and how much it’s worth. Points are what that value turns into. They’re what changes hands at the end of a round, and every number in this article is points, averaged over thousands of simulated rounds. Under the rules I trained with, the cheapest winning hand off someone’s discard moves 8 points from them to the winner.

After 11 days of trusting it, I went back and checked the test. It had two bugs.

The small one: restarting a job should have drawn a fresh random seed, and didn’t. Repeat runs I had counted as separate evidence were partly the same run again.

The expensive one was the margin of error. The test treated every round as independent. But rounds came in blocks that shared the same opponents and seating, so results inside a block moved together. The margin has to be computed over blocks, not rounds. Counting rounds made every range I published 1.6× to 10.8× narrower than it should have been.

In points: at 2,304 rounds, the test could only tell two versions apart if they differed by about 0.86 points a round. Every gap I was asking it about was roughly half that. It answered anyway, and it answered “no difference” every time, which is the only answer it could have given.

Here is the same question put to both tests: did the model improve between 700M and 850M? The old test reads +0.256 [−0.694, +1.243]. The rebuilt one, at 9,216 rounds, reads +0.514 [+0.074, +0.959]. The first range includes zero and settles nothing. The second clears it: the later model is better. Neither model changed between those readings. Only the test did.

The audit also found that a model made by averaging the 400M, 550M and 700M versions had never been tested at all.

It retracts one conclusion: that training past 400M had stopped helping. It does not reach the 400M promotion above or the oracle result below. I measured both on other tests, and both found gaps far too large to be noise.

After 850,004,713 decisions over 51,363 iterations, 850M played 400M over 9,216 rounds on the rebuilt test, against its six opponents (the five bots from the cheating comparison, plus v9.2, the version before 400M), and gained +0.989 points a round, range [+0.546, +1.435]. If I allow for a different set of opponents, the range widens to [+0.308, +1.694], which still clears zero. The previous candidate failed this step.

Then three checks that the gain didn’t come from the particular opponents I picked. Head to head, with only the two versions at the table, it gained +1.117 ± 0.836. One opponent at a time, it came out ahead against 6 of the 6. And leaving any one opponent out of the average keeps the gain between +0.876 and +1.175, so no single opponent carries the result.

Last, the dealer. Training always puts the dealer in the same seat, so a model could learn something that only works from there. This check moves the dealer and re-runs the comparison on a fresh seed, over 40,960 rounds: +1.503 [+1.075, +1.926]. Even the worst dealer seat gains at least +0.511, and the four seats barely differ from each other (χ² 0.56 on 3 degrees of freedom).

I wrote all four checks down before I ran them. Otherwise I could have tried everything and kept whichever comparison looked best.

The two that didn’t make it are why those checks are required. 700M gained +0.475 [+0.029, +0.918] against the same six, which looks like a result until you allow for different opponents, and the range opens to [−0.342, +1.310], including zero. The averaged model gained +0.491 [+0.063, +0.917] against the six, then nothing head to head: +0.593 ± 0.809. Each passed one check and failed the rest. On the chart above, the two look the same.

I stopped this run on 2026-08-13 at 711,154,042 decisions, because the test said it had stopped improving, and restarted it on 2026-08-19. If the restart had quietly started from scratch, the whole line would mean nothing, so it had to prove it was the same run. The stopped run had logged four iterations (42961–42964) after its last save, and the restarted one had to reproduce all four exactly before anything after them counted. It passed 850,004,713 decisions on 2026-08-21, 25.6 hours later. That version ran in the app from 2026-08-21 until h1 replaced it, and in the browser since 2026-09-22. The run kept going to 1.3B decisions; the next section has how that ended.

On identical deals, the average payment across the four versions went 13.375 → 13.456 → 13.851 → 14.365 at 400M, 550M, 700M and 850M. The last step, +0.514, is the biggest, and it falls inside the stretch I had cut off.

I’m not claiming this is the best model the game allows. It was the last version to pass every check at the time, and the curve hadn’t flattened yet. It flattened after a billion. The gain is real but modest: 450 million more decisions bought about one point a round. Of the measurements behind the old “nothing more to gain” argument, cheating against the bots has since been run on every version (last section). Cheating against a copy of itself and the fair search were only run on 400M.

Before training from 1B to 1.3B decisions, I wrote down what would count as progress: a gain over 1B whose range stayed above zero. I expected about +0.74. Over 18,432 paired rounds it read −0.067 [−0.400, +0.265]. The learning rate stayed the same the whole run, so this wasn’t a schedule running out. More training with the same recipe wasn’t going to help.

Next, the flowers. In 10,000 rounds of 850M playing itself, flowers explained 37.4% of the variation in what winning hands paid, and 53.3% of wins scored flower faan. When I hid every flower from the model, its top choice changed in only 4.2% of 12,000 positions. So flowers add a lot of luck to the score and almost nothing to the decisions, and a model trained without them gives up little. I set both thresholds before running either test.

h1 starts from the 1B version and trains for 300,016,656 more decisions with HKMA Classical scoring, which ignores flowers. Nothing else changed. The fair comparison is the 1B → 1.3B stretch: same start, same number of decisions, old scoring. Scored with flowers, the way the app plays, h1 beat it by +0.512 [+0.170, +0.852], and beat 850M by +0.693 [+0.349, +1.027], each over 18,432 paired rounds. The dealer check, on a fresh seed over 40,960 rounds, passed all eight of its conditions: no dealer seat or round wind doing worse than −2.5 points, no illegal moves or scoring failures, no dropped rounds, and no gain that vanishes against opponents it never trained with. Overall h1 gained +2.454 [+2.005, +2.907] against 400M.

This is one training run, with one random seed. The gain beat the bar I set, +0.50, by only 0.012, so all I can say is that the true gain is somewhere between 0.17 and 0.85. Two more stretches of 40 million decisions each read −0.012 at 340M and −0.234 at 380M against h1, so the gain was a one-time step, not a new climb. The flower example in the story is one recorded hand, rescored; the 37% is the measurement.

The first table gives each opponent’s points against 400M, so a negative number means my model won. One opponent beats it: the dedicated adversary, a separate model I trained to beat the frozen 400M and nothing else. It wins by about a point a round, but it is worse than 400M against every other opponent I tried, giving back about as much as it takes. That’s a weakness in 400M, not a stronger player, and I haven’t tested whether later versions share it.

For oracle guiding, following Suphx, I widened the model’s input with the other players’ hidden tiles, trained with them visible for 40 million decisions, and then played the same model on the same deals with the hidden tiles switched on and off. With them on, it won 27.9% of rounds instead of 27.3%, and threw someone their winning tile in 12.36% instead of 12.39%. It used what it saw to attack a little, and to defend not at all. Suphx’s next step fades the hidden tiles out; I didn’t run it, because there was no habit to keep.

The cheating search sees the other three hands and the order of the wall. This test used 400M, not the newer app model, playing a copy of itself. It won 2,170 rounds against 1,722 for the normal model, and the rounds where it threw someone their winning tile fell from 2,241 to 690. That’s what this particular search gains from seeing hidden tiles. It isn’t the best possible score, or what a fair player could gain. When I split the gain by what the search could see, 61.6% of it only appeared when it knew the hands and the wall together.

The comparison in the story is a separate test. Each version I’ve shipped played the same five bots on the same 9,216 deals per bot, once fair and once cheating, and every deal was played twice more, once under each set of rules: the training rules, which score flowers, and HKMA’s, which don’t. The ranges count blocks of six games that share a shuffle, as the audit above requires. Cheating is worth less here, 1.3 to 2.6 points, because the search assumes everyone plays like the model, and the bots don’t. Each version beats the one before it by a range that clears zero under both scorings; 850M over 400M, for example, is +0.96 [+0.46, +1.45] with flowers. h1 playing fair minus 400M cheating is −0.10 [−0.46, +0.28] under HKMA rules, and −0.74 [−1.24, −0.22] with flowers. At half as many deals, that last range was wide enough to include zero. The full test showed the gap.

I also tried the fair version of the same idea: guess what the others might be holding, play each guess out, and throw whatever does best on average. It only uses what a player at the table could know. It scored −0.382 [−0.920, +0.157]. The range includes zero, so it found nothing. That’s one attempt coming back empty, not proof the idea can’t work.

I also had two language models play against 400M, 96 rounds each. Claude Opus 5 scored −0.08 with interval [−5.23, +5.06]; GPT-5.6 scored −0.92 with interval [−5.62, +3.79]. Both ranges are far too wide to tell either one apart from my model or from each other. The Opus run cost $162.30 for 1,742 valid calls, about $0.093 a decision. This run trained at about 130 million decisions a day. Buying a single training day at that rate would cost about $12,090,000.

They were also slow. Claude Opus 5 averaged 36.2 seconds a decision over 3,176 calls, and GPT-5.6 25.0 seconds over 3,708, both including the trip over the network. My model takes 0.41 milliseconds on a single processor core. I haven’t measured it on a phone yet. Neither lab publishes a parameter count for these models, so I can’t compare sizes. I can only compare the time.