timmyburn/hexo-mantis-selfplay

mantis Hex Tac Toe self-play

Every game the mantis bot played in training, across all its runs and ablations (September–October 2026), plus its evaluation games against other bots. The net mantis ships is in the code repo under the same licence.

Config	Rows	Size	One row is
games (default)	967,488	165 MB	a self-play game (81.0M positions in all)
eval	203,082	21 MB	an evaluation game against another bot or an earlier mantis net
search_stats	14,243,529	1.30 GB	one searched position: visits, priors and values of the moves considered
policy_targets	15,968,943	1.35 GB	the policy target a full-search move was trained on
runs	26	< 1 MB	a run: parent, network, search budget, full config

Quick start

from datasets import load_dataset

repo = "timmyburn/hexo-mantis-selfplay"
games = load_dataset(repo, "games", split="train")                                  # everything
run14 = load_dataset(repo, data_files="data/games/run14.parquet", split="train")   # one run

Every table has one file per run (data/<table>/<run_id>.parquet), so one run loads without the rest.

Which part for what

• Strongest play: the end of run14 (say step >= 300_000) and of run15 (step >= 100_000). The net mantis ships is the average of run14's last saves (step 372k); run15's averaged net scored 50 % against it head-to-head.
• Training a policy: policy_targets joined to games (example below). Use these rather than the played moves: three moves in four got only a fast search, and the search samples its move with exploration noise.
• Training a value: games.result for every position, or root_value in policy_targets / search_stats.
• Search behaviour: search_stats (1 game in 8 from run8 on, every searched move of the eval games).
• Strength over training: eval, against six, strix and sealbot_d5, by step.
• Ablations: compare runs; the table under Runs and ablations says what each one changed.

The game and the conventions

Hex Tac Toe is played on an unbounded hexagonal grid. P1 opens with one stone, then each player places two stones per turn, P2 first. Six in a row along one of the three hex axes wins. Self-play calls a draw at 256 stones (0.6 % of games).

• Coordinates are axial (q, r); the three line directions are (1, 0), (0, 1) and (1, -1).
• ply indexes moves: ply 0 is P1's single stone, plies 1–2 are P2's, 3–4 P1's, and so on. A row at ply k is about the position before moves[k], i.e. the stones moves[:k].
• Values are in [-1, 1] from the side to move's point of view: +1 means the player about to place wins.
• result is p1, p2 or draw.

def player(ply):                       # +1 = P1, -1 = P2: who places moves[ply]
    return 1 if ply == 0 or (ply - 1) // 2 % 2 == 1 else -1

def board_before(moves, ply):          # {(q, r): +1 / -1}
    return {(m["q"], m["r"]): player(k) for k, m in enumerate(moves[:ply])}

def makes_six(board, q, r):            # did the stone at (q, r) complete six in a row?
    p = board[(q, r)]
    for dq, dr in ((1, 0), (0, 1), (1, -1)):
        n = 1
        for s in (1, -1):
            k = 1
            while board.get((q + s * k * dq, r + s * k * dr)) == p:
                n, k = n + 1, k + 1
        if n >= 6:
            return True
    return False

Example: one policy-training sample

games = load_dataset(repo, data_files="data/games/run14.parquet", split="train")
targets = load_dataset(repo, data_files="data/policy_targets/run14.parquet", split="train")
moves = dict(zip(games["game_id"], games["moves"]))

t = targets[0]
board = board_before(moves[t["game_id"]], t["ply"])           # the position
to_move = player(t["ply"])                                    # whose turn it is
policy = {(c["q"], c["r"]): c["prob"] for c in t["policy"]}   # target on up to 16 candidates
# t["tail_mass"] is the rest of the target, for every other legal cell

How the games were made

mantis is an AlphaZero-style bot: a graph neural network over the stones plus Gumbel search. In self-play one net plays both sides. Each move draws its budget at random: a full search of 320 simulations with probability 0.25, otherwise a fast search of 64. Only full-search moves train the policy. In run11a2 and run12–run15 a tactics solver proves forced wins; once a win is proven, the rest of the game is played from the proof without search (marked decided up to run13 and tail from run14 on).

Things to know before training on it:

• Both sides are the same net, so the positions follow its own style.
• Early runs (run6–run8, the shakedowns) are much weaker than the late ones. Filter by run_id and step.
• step is the training step of the net that played. -1 means a run's starting net, before its first update. A run can continue its parent's step counter, so compare steps within one run only.
• policy_targets covers 84 % of full-search moves. The targets come from replay-buffer snapshots saved at checkpoints, and a stretch of play that passed through the buffer between two snapshots is lost. Coverage is 85–93 % for most runs and lower for run15 (77 %), run7 (63 %) and run8 (43 %).

Runs and ablations

Run	Self-play games	What it is
run6	38,730	first run, from a behaviour-cloned net
run7	84,773	restart from the same behaviour-cloned net
run8	55,438	from run7 @ 42k
run11a2	253,327	run11, from run8 @ 45k; the longest run (593k steps), learning rate restarted at 174k
run11a1	18,311	run11 arm without the value-mask redraw (value_mask_redraw_p 0 instead of 0.125)
run11a3	16,718	run11 arm: half the training steps per game (1.2 instead of 2.4)
run11a4	18,636	run11 arm: as a3, with fast searches of 32 simulations over 8 candidates
run11fresh	67,698	the run11 recipe from scratch, no warm start
run12	135,908	from a distilled net twice as wide (hidden 256 instead of 128)
run13	73,950	from run12 @ 240k
run14	82,356	from run12 @ 240k; source of the net mantis ships
run15	69,530	a 6-layer net (4 before)
twin_plain, twin_tactics, twin_tactics2, twin_tactics3	20,001	tactics solver in self-play: off (twin_plain) vs on (three runs from successive rounds of the study)
dt1r1a, dt1r1b	2,440	proven-win endings: old handling (decided) vs new (tail)
reg1-gen	6,576	games from one fixed net (step 45k) for a value-regularisation study
shakedown*, run10	23,096	pipeline shakedowns; run10 stopped at the start

runs has the details per run: parent checkpoint and its hash, reinitialised heads, network size (null for run6–run8, whose configs predate the field), search budgets, step range, first and last shard hour (UTC), and the path of its full resolved config under configs/.

Column reference

games

Column	Type	Meaning
run_id	string	the run (see runs)
stage	string	run, or preflight for the short check run before a launch
game_id	string	unique id
step	int32	training step of the net that played
seed, worker_id	int64, int16	the run's seed and the self-play worker
served_sims	int16	the full-search budget
plies	int16	stones placed
result	string	p1, p2 or draw
termination	string	six_in_a_row or ply_cap
moves	list<{q, r}>	every stone, in order
move_arms	list	per move: full, fast, decided or tail; null for 52k early games (run6, first shakedowns)
move_sims	list	simulations spent per move (0 for decided / tail)
has_search_stats	bool	the game is in search_stats

eval

The game columns of games (without move_arms, move_sims, worker_id), plus:

Column	Type	Meaning
channel	string	external (another bot), promotion (gate against the previous best mantis net) or random_floor
opponent	string	six (116k games), strix (39k), sealbot_d5 (27k), anchor (16k, the previous best mantis net), random (5k)
candidate_seat	int8	1 if the mantis net being evaluated played P1, -1 if P2
step	int32	training step of the mantis net being evaluated
tactics_on	bool	it played with the tactics solver
phase, game_index	string, int32	the evaluation round's phase, and the game's index in it
game_id	string	the round's id plus a short hash of the moves (round ids repeat across reruns)

termination is win, ply_cap or forfeit. Run id frontier1 is a strength-frontier study plus later head-to-head matches between mantis nets.

search_stats

Column	Type	Meaning
channel, run_id, game_id, ply		join keys to games / eval
searcher	string	eval only: candidate (the net being evaluated) or opponent (the gate's previous net)
root_value	float32	the position's value after search
root_raw	float32	the network's own value before search (self-play)
search_value	float32	the value target the run trained on (self-play, from run11 on)
children	list<{q, r, visits, prior, value}>	the moves the search visited: visit count, network prior, and Q value (prior and value: self-play only)

Visit counts can add up to more than the budget when the search reused a subtree from the previous move.

policy_targets

Column	Type	Meaning
run_id, game_id, ply		join keys to games
policy	list<{q, r, prob}>	the search's improved policy over the candidate moves it sampled (up to 16)
tail_mass	float32	probability left for every other legal move; the trainer spread it in proportion to the network's prior
root_value	float32	the position's value after search; null for rows saved before the field existed (run6–run8, early run11)

Processing and validation

• Built from the run mirrors. 19 % of the raw records were duplicate copies; each game appears once. Throughput benchmarks (a4_*, pi_*, perf3b_*, startpath_*, p4_*; 9,430 games) are left out.
• Every game was replayed through the mantis engine: every move legal, no six before the last stone, every result matching the final position, and every searched child and policy cell legal where it stands. The move played is among a policy target's listed moves in 99.5 % of rows.
• manifest.json has the per-file counts, the exclusions and the validation tallies.

Licence and citation

MIT, like the code and the weights.

@misc{mantis_selfplay_2026,
  title  = {mantis Hex Tac Toe self-play},
  author = {TimmyBurn},
  year   = {2026},
  url    = {https://huggingface.co/datasets/timmyburn/hexo-mantis-selfplay}
}