How to Register Your AG Champion

Quick start for guests

Takes about 15 minutes. A guest account needs no email and no password. Guest games are unrated and are played against other guests only. More about guests: Just Want to Try It? Play as a Guest.

1. Sign in with Hugging Face as a guest Choose Continue with Hugging Face. The platform only receives your public Hugging Face username. If you have no Hugging Face account, create one at huggingface.co first.
2. Create a public model repo on Hugging Face On Hugging Face, create a new Model repo and keep it Public. Do not use -- in its name. See How to create a repo below.
3. Get the bot code and save it in your repo Copy the starter code, or use an AI prompt (Chess or Breakthrough). Save the code in your repo as NAME_OF_ALGO_FILE.py. NAME_OF_ALGO_FILE.py is a name you choose, for example my_bot.py. It must end in .py and have no spaces. Use the same name everywhere. Then add a second file named config_model.json that gives your file name under "entrypoint": see Config files. The AI prompts write this file for you. See How to add a file below.
4. Paste your repo ID on the Gladiator tab Open the Gladiator tab on your Profile. Paste your repo ID (for example your-username/my-bot) in the model repo field for your game and save it. Leave the data repo empty.
5. Wait about a minute for the check, then play The platform checks your code in a sandbox. A sandbox is a locked box on the platform's servers where your bot runs. When the check passes, go to the Lobby and play, or watch your bot play ShiRi, the platform's own AI opponent. If it fails, the Gladiator tab shows why: see Model check failed.

Next: Starter code or Build your bot with an AI assistant

Starter code (Chess)

This is a complete bot for Chess. It plays random legal moves, so it is not strong. It is a good first test to see that your setup works. You can improve it later.

NAME_OF_ALGO_FILE.py is a name you choose, for example my_bot.py. It must end in .py and have no spaces. Use the same name everywhere.

You tell the platform which file to run by writing its name in config_model.json under "entrypoint". See Config files. For Breakthrough, use the AI prompt, or see the Breakthrough starter under Move format in Step 3.

# NAME_OF_ALGO_FILE.py - at the root of your model repo
import random

import chess


def load(ctx):
    # Called once. ctx.data_dir is None if no data files are available.
    state = {"opening_book": None}
    if ctx.data_dir is not None:
        book = ctx.data_dir / "opening_book.txt"
        if book.exists():
            state["opening_book"] = book.read_text(encoding="utf-8").splitlines()
    return state


def get_move(state, fen, player):
    # Return one legal move in UCI notation, for example "e2e4".
    board = chess.Board(fen)
    legal = list(board.legal_moves)
    if not legal:
        return ""
    # ---- replace this with your real model ----
    return random.choice(legal).uci()

Build your bot with an AI assistant

You do not have to write the code yourself. These prompts work with any AI assistant.

1. Choose a file name that ends in .py, for example my_bot.py. In each prompt, replace [YOUR FILE NAME] with that name before you send it. In the Fix it prompt, also replace each [PASTE HERE].
2. Click Copy on the prompt for your game.
3. Paste it into the AI assistant and send it.
4. Save the code the assistant gives you in your repo with the file name you chose. Save the config_model.json file it gives you too.
5. If the check fails, copy the message from the Gladiator tab and use the Fix it prompt.

I am a complete beginner. Please write a Chess bot for the Artificial Gladiator League (AGL) website.

FILE NAME
The file name is [YOUR FILE NAME] (for example my_bot.py). Return ONE complete file with exactly that name. Do not use any other file name.

THE CONTRACT
The file must define these two functions:
1. load(ctx) runs ONCE, when the bot starts. It returns "state". State can be any Python object, for example a dict.
   ctx.model_dir and ctx.data_dir are read-only folders (pathlib.Path). ctx.data_dir can be None.
2. get_move(state, fen, player) is called on EVERY move.
   - state is what load returned.
   - fen is the board position, written as FEN text.
   - player is "w" or "b". It is the side to move.
   - Return the move as a plain string. Never return a list, a dict or JSON.

MOVE FORMAT
Use UCI notation, for example e2e4. For a promotion add the piece letter, for example e7e8q. Do NOT use SAN such as Nf3.

LIMITS OF THE PLATFORM
The bot runs in a locked box (a sandbox) with these limits:
- No network. Do not use requests or urllib.
- Only these libraries exist: python-chess (import chess), numpy and torch (CPU only). Do not use any other third-party library.
- Files are read-only, except the folder /tmp.
- 512 MB of memory and 1 CPU.
- One move may take at most 30 seconds. Keep your search time under about 5 seconds per move.

RULES FOR THE CODE
- Load files and weights inside load(). Never load files inside get_move.
- Always return a legal move. If there are no legal moves, return "" (an empty string).
- Start with the simplest working version: pick a random legal move, and prefer captures when there are any.
- Add short comments that a beginner can read.

WHAT TO RETURN
1. The complete file [YOUR FILE NAME] in one block.
2. A small file named config_model.json with the fields "entrypoint" and "files". The value of "entrypoint" is [YOUR FILE NAME]. The value of "files" is a list that contains [YOUR FILE NAME].
3. Three plain sentences that explain how I can improve the bot later.

Breakthrough rules in short. The position is a FEN-like string (text that describes the board) with rank 8 first. A rank is a row of the board. W is a white piece, B is a black piece, and digits are empty squares. A piece moves one square forward: straight onto an empty square, or diagonally onto an empty square or an enemy piece. White moves toward rank 8, black toward rank 1, and a player who reaches the last rank wins.

I am a complete beginner. Please write a Breakthrough bot for the Artificial Gladiator League (AGL) website.

FILE NAME
The file name is [YOUR FILE NAME] (for example my_bot.py). Return ONE complete file with exactly that name. Do not use any other file name.

THE GAME
Breakthrough is played on an 8 by 8 board. Files are a to h, from left to right. Ranks are 1 to 8.
The position is a FEN-like string. Rank 8 comes first. W is a white piece, B is a black piece, digits are empty squares, and the side to move is at the end.
The start position is: BBBBBBBB/BBBBBBBB/8/8/8/8/WWWWWWWW/WWWWWWWW w
White moves toward rank 8. Black moves toward rank 1.
A piece moves one square forward. It can go straight, only onto an empty square. It can go diagonally, onto an empty square or onto an enemy piece.
A player wins by reaching the last rank.

THE CONTRACT
The file must define these two functions:
1. load(ctx) runs ONCE, when the bot starts. It returns "state". State can be any Python object, for example a dict.
   ctx.model_dir and ctx.data_dir are read-only folders (pathlib.Path). ctx.data_dir can be None.
2. get_move(state, fen, player) is called on EVERY move.
   - state is what load returned.
   - fen is the position, written as the FEN-like string described above.
   - player is "w" or "b". It is the side to move.
   - Return the move as a plain string. Never return a list, a dict or JSON.

MOVE FORMAT
Exactly 4 characters: the square you move from, then the square you move to. Examples: a2a3 and b2c3.

LIMITS OF THE PLATFORM
The bot runs in a locked box (a sandbox) with these limits:
- No network. Do not use requests or urllib.
- Only these libraries exist: python-chess, numpy and torch (CPU only). Do not use any other third-party library.
- Files are read-only, except the folder /tmp.
- 512 MB of memory and 1 CPU.
- One move may take at most 30 seconds. Keep your search time under about 5 seconds per move.

RULES FOR THE CODE
- Load files and weights inside load(). Never load files inside get_move.
- Always return a legal move. If there are no legal moves, return "" (an empty string).
- Start with the simplest working version: write a real legal-move generator for the rules above, and pick a random legal move. Use only the Python standard library for this first version.
- Add short comments that a beginner can read.

WHAT TO RETURN
1. The complete file [YOUR FILE NAME] in one block.
2. A small file named config_model.json with the fields "entrypoint" and "files". The value of "entrypoint" is [YOUR FILE NAME]. The value of "files" is a list that contains [YOUR FILE NAME].
3. Three plain sentences that explain how I can improve the bot later.

I am a complete beginner. My bot for the Artificial Gladiator League (AGL) website does not work. Please fix it.

GAME: [PASTE HERE: Chess or Breakthrough]
FILE NAME: [YOUR FILE NAME] (for example my_bot.py)

THE ERROR MESSAGE (from the Gladiator tab or the Diagnostics tab):
[PASTE HERE]

MY CURRENT CODE:
[PASTE HERE]

WHAT I WANT YOU TO DO
1. First, explain the cause of the problem in plain language. Use short sentences and no jargon.
2. Then return the FULL fixed file with the name [YOUR FILE NAME]. Do not return only the lines that changed.
3. If config_model.json must change too, return the full fixed config_model.json. Its "entrypoint" must be [YOUR FILE NAME] and its "files" list must contain [YOUR FILE NAME].
4. End with one short sentence that tells me what to do next.

THE RULES THE FIXED CODE MUST FOLLOW
- The file defines load(ctx) and get_move(state, fen, player). load(ctx) runs ONCE and returns "state". get_move is called on EVERY move. player is "w" or "b". get_move returns a plain string. Never a list, a dict or JSON.
- Chess moves use UCI notation, for example e2e4, or e7e8q for a promotion. Not SAN such as Nf3.
- Breakthrough moves are exactly 4 characters: the square you move from, then the square you move to, for example a2a3 or b2c3.
- Breakthrough rules: the position is a FEN-like string with rank 8 first, W for white pieces, B for black pieces, digits for empty squares and the side to move at the end. The start position is BBBBBBBB/BBBBBBBB/8/8/8/8/WWWWWWWW/WWWWWWWW w. White moves toward rank 8, black toward rank 1. A piece moves one square forward: straight onto an empty square, or diagonally onto an empty square or an enemy piece. A player wins by reaching the last rank.
- Limits: no network (do not use requests or urllib). Only python-chess, numpy and torch (CPU only) exist. Files are read-only, except the folder /tmp. 512 MB of memory, 1 CPU. One move may take at most 30 seconds, so keep the search under about 5 seconds.
- Load files and weights inside load(). Never load files inside get_move.
- Always return a legal move. If there are no legal moves, return "" (an empty string).
- Keep short comments that a beginner can read.

Want ratings and tournaments? Create a full account

A full account gives you rated games, an Elo rating (a number for your bot's strength) and tournaments. It needs more setup than a guest account: a Gated model repo (only accounts you approve can read it) and a verification file. For tournaments you also need 30 rated games first.

Read these rules first: Repo access, Tournament qualification (30 rated games) and Version pinning.

The 7 steps at a glance

This is the shortest path from nothing to a working, registered AG Champion with a full account. The steps below use the same numbers and the same order. Do them one after the other.

1. Create your accountFill in the registration form and activate your account by email.
2. Create your Hugging Face reposStart from the working example, make your model repo Gated, and approve ArtificialGladiatorLeague.
3. Write your AG ChampionEdit the example code. Add config_model.json with "entrypoint" set to your file name.
4. Register your reposOpen the Gladiator tab on your Profile, enter your model repo, and click the gold button Save and verify.
5. Prove you own your reposAdd AGL_VERIFY.txt with the code shown on the Gladiator tab, then click Verify Ownership.
6. Run DiagnosticsOpen the Diagnostics tab and click Run diagnostics. Fix what it reports and run it again until it says RESULT: your model works correctly.
7. Play and competePlay rated games in the Lobby and enter tournaments. The Lobby is labelled "Hatzar Grutaot" in the menu. This is Hebrew (חצר גרוטאות) and means "Scrapyard". The name was coined by Malka Haas.

Next step: Step 1: Create your account

What to do

1. Enter a Username, a Password (more than 8 characters), the same password again in Confirm Password, and your Email.
2. Enter your AG (Artificial Gladiator) Name. This is the display name of your AG Champion.
3. Choose your Country of residence. Tick the confirmation boxes and the box that accepts the Terms of Service and Privacy Policy.
4. Click Create Account.

Where

The registration page.

How you know it worked

A Check your email page appears. Click the activation link in the email to activate your account.

If it fails

The email does not arrive: The activation email did not arrive.

Next step: Step 2: Create your Hugging Face repos

A repo is a folder of files stored on Hugging Face. You need a model repo, and optionally a data repo. What each one holds is explained in Your two repos.
Guest accounts use Public repos instead; the Gated requirements below apply to registered accounts.

What to do

1. Create your model repo. The easiest way is to start from the starter code: see Start from a working example below.
2. Make the model repo Gated: open the repo's Settings and enable Access Requests.
3. Approve ArtificialGladiatorLeague in the repo's Access settings. Do this before Step 4, because saving your repo fails until you have approved it. The yellow button Open Access Settings on the Gladiator tab opens that page as soon as you have typed your repo ID there.
4. Optional: if your AG Champion reads data files, create a data repo and make it Public.

Where

On Hugging Face, in your own account: the repo's Settings page.

How you know it worked

Your model repo exists in your Hugging Face account and is set to Gated. The platform checks this when you save the repo in Step 4.

If it fails

My repo is rejected

If you get stuck

1. Check that the model repo is in your own Hugging Face account.
2. Open the repo's Settings and check that Access Requests is on.
3. Open the repo's Access settings and check that ArtificialGladiatorLeague is approved.
4. Check that you typed the repo as username/repo-name. A Space URL is rejected.
5. Still rejected? Read the message on the Gladiator tab, then open My repo is rejected.

Start from a working example

1. Create a new model repo in your own Hugging Face account (see How to do this on Hugging Face above).
2. In the repo, click Add file and create a new file named NAME_OF_ALGO_FILE.py (a name you choose, for example my_bot.py).
3. Paste the starter code into it and commit. A commit saves your change in the repo.
4. Add a second file named config_model.json that gives your file name under "entrypoint" (see Config files).
5. Make your repo Gated (Settings, Access Requests).

You edit the code in Step 3. To read more example code, you can open the repos at https://huggingface.co/chaim-duchovny.

your-username/my-bot/
    |-- config_model.json    (names your code file under "entrypoint")
    |-- NAME_OF_ALGO_FILE.py (your AI code: load / get_move)
    |-- utils.py             (optional helper modules)
    |-- requirements.txt     (optional, for your own reference; not installed by the platform)
    `-- AGL_VERIFY.txt       (added in Step 5)

your-username/my-bot-data/
    |-- config_data.json     (optional, see Config files)
    |-- opening_book.txt     (any data files your load() reads)
    `-- AGL_VERIFY.txt       (added in Step 5)

Next step: Step 3: Write your AG Champion

Your AG Champion is Python code that receives a board position and returns a legal move string. The logic inside is entirely up to you. You can also build it with an AI assistant. The platform downloads your code and runs it in a sandbox (a locked box on its own servers), so you need no external hosting or always-on server.

What to do

1. In your model repo, edit the entry-point file so that it defines load(ctx) and get_move(state, fen, player) (see below). Choose a file name, written here as NAME_OF_ALGO_FILE.py. It is a name you choose, for example my_bot.py. It must end in .py and have no spaces. Use the same name everywhere.
2. Add config_model.json and write your file name in it under "entrypoint". See Config files in the Advanced section.
3. Save your files as UTF-8. The platform also tolerates common Windows encodings (cp1255, cp1252) and reports a warning when it has to fall back.

Where

In your model repo on Hugging Face, on the main branch.

How you know it worked

Steps 5 and 6 show the result. The platform runs the model check on your code when you verify ownership, and Diagnostics repeats it.

If it fails

Model check failed, Invalid move returned, Data files not loading

The contract: load(ctx) and get_move(state, fen, player)

Your entry-point file must define both functions. There is no other interface. A working Chess example is in the starter code.

• state = load(ctx) is called once when your AG Champion is loaded. Open your weights, opening books and other files here and return whatever you want to keep. It is passed back to you as state.
• ctx.model_dir and ctx.data_dir are real, read-only folders (pathlib.Path) that hold your model repo files and your data repo files. ctx.data_dir is None when no data files are available. The platform never opens your data files for you. Read them yourself inside load().
• move = get_move(state, fen, player) is called for every move. fen is the position, written as FEN text. player is "w" or "b" (the side to move). Return the move as a plain string.

You tell the platform which file to run by writing its name in config_model.json under "entrypoint". See Config files.

Move format

# NAME_OF_ALGO_FILE.py
# Breakthrough starter bot. It plays a random legal move.
import random

FILES = "abcdefgh"  # file a is the left column, file h is the right column


def parse_board(fen):
    # Turn the position text into a dict: {(file_number, rank): piece}.
    # file_number is 0 for a, 1 for b, ... 7 for h. rank is 1 to 8.
    board = {}
    rows = fen.split()[0].split("/")  # the first row of the text is rank 8
    for row_index, row in enumerate(rows):
        rank = 8 - row_index
        file_number = 0
        for ch in row:
            if ch.isdigit():
                file_number += int(ch)  # a digit means that many empty squares
            else:
                board[(file_number, rank)] = ch  # "W" or "B"
                file_number += 1
    return board


def legal_moves(board, player):
    me = "W" if player == "w" else "B"
    step = 1 if me == "W" else -1  # white moves up (toward rank 8), black moves down
    moves = []
    for (f, r), piece in board.items():
        if piece != me:
            continue
        nr = r + step  # the rank one square forward
        if nr < 1 or nr > 8:
            continue
        # Straight forward: only onto an empty square.
        if (f, nr) not in board:
            moves.append(FILES[f] + str(r) + FILES[f] + str(nr))
        # Diagonally forward: onto an empty square or an enemy piece.
        for nf in (f - 1, f + 1):
            if 0 <= nf <= 7 and board.get((nf, nr)) != me:
                moves.append(FILES[f] + str(r) + FILES[nf] + str(nr))
    return moves


def load(ctx):
    return {}  # nothing to load in this simple bot


def get_move(state, fen, player):
    # Return "from-square" + "to-square", for example "a2a3".
    moves = legal_moves(parse_board(fen), player)
    if not moves:
        return ""
    return random.choice(moves)  # replace this with your real model

Next step: Step 4: Register your repos

On the Gladiator tab, each game (Chess, Breakthrough) has its own card with numbered steps (Enter repo, Approve platform account, Add AGL_VERIFY.txt, Verify). A line at the top of the tab tells you the next step.

What to do

1. In Hugging Face Model Repo, type or paste your model repo as username/my-AG. You may paste a full huggingface.co link: it is converted to username/my-AG. A Space URL (*.hf.space or huggingface.co/spaces/...) is rejected.
2. In Hugging Face Data Repo, enter username/my-AG-data. Leave it blank if you do not use a data repo. For Chess, the field is filled in for you with owner/chess-data as soon as you type your model repo. If you do not have that repo, delete the text. Otherwise saving fails because the repo is not found.
3. Click the gold button Save and verify.

Where

The Gladiator tab on your Profile, in the card for your game.

How you know it worked

The platform shows a unique 32-character verification code on the Gladiator tab, with the buttons Copy file name and Copy code. You need this code in Step 5. If you clicked Save and verify, a red message that AGL_VERIFY.txt was not found in your repo also appears. That is expected at this point, because you add the file in Step 5.

If it fails

My repo is rejected

Next step: Step 5: Prove you own your repos

Before your AG Champion can play, you must prove that you own the repos. You do this with a small file that contains the verification code the platform gave you in Step 4.

What to do

1. On Hugging Face, create a file named AGL_VERIFY.txt at the root of your model repo (main branch). It must contain exactly the verification code. Surrounding whitespace or a trailing newline is ignored.
2. If you also set a data repo, add the same file with the same code to the root of the data repo.
3. On the Gladiator tab, click Verify Ownership. It is shown as Re-check Ownership once you are verified.

Where

The file goes into your repo on Hugging Face. The buttons Copy file name and Copy code on the Gladiator tab give you the file name and the code. The Verify Ownership button is on the same tab.

How you know it worked

The platform account reads the file from each repo. When the model repo and the data repo (if set) both match, you are verified.

The platform then immediately runs the model check. If it passes, the platform pins the commit as your approved version. To pin means to record its SHA, the unique ID of that commit.

If it fails

Ownership verification failed, Model check failed

Next step: Step 6: Run Diagnostics

The Diagnostics tab on your Profile checks a registered AG Champion from start to finish and tells you in plain language what to fix. It can take a few minutes, because the last check runs your AG Champion in the sandbox.

What to do

1. Open the Diagnostics tab.
2. Pick the game.
3. Click Run diagnostics.
4. Read the report and fix what it reports. Run it again.

Where

The Diagnostics tab on your Profile.

How you know it worked

The report ends with RESULT: your model works correctly.

If it fails

Diagnostics says the model or data files are not on the server yet, Diagnostics says the sandbox is unavailable, Model check failed

Next step: Step 7: Play and compete

What to do

• Quick match: go to the Lobby and challenge another player. Your AG Champion plays automatically in real time.
• Practice against ShiRi: let your AG Champion play the platform's AI opponent, with no rating risk. See Try your AG Champion against ShiRi.
• Tournament: first play 30 rated games in the Lobby. Then open a tournament and click Register or Join. When the tournament asks players to ready up, mark yourself Ready. The platform schedules and runs all matches automatically. The qualification rule is explained in Tournament qualification.

Where

The Lobby for quick matches. The Lobby is labelled "Hatzar Grutaot" in the menu. This is Hebrew (חצר גרוטאות) and means "Scrapyard". The name was coined by Malka Haas. Use the tournaments page for tournaments. For how tournaments run, see How tournaments work.

How you know it worked

Your AG Champion plays its moves on its own. Results of rated games update your Elo. For how each move is generated, see During a game.

If it fails

I cannot join a tournament, Move timed out, or random moves are played for my AG Champion, Disqualified: SHA mismatch

Try your AG Champion against ShiRi

ShiRi is an AI opponent built into the platform. It is the fastest way to see your AG Champion play: you do not need another player, and nothing is rated. Your AG Champion plays ShiRi and you only watch. You do not move any pieces. More about ShiRi: Playing against ShiRi.

What to do

1. Open Playing against ShiRi in the "Hatzar Grutaot" menu, or click Play against ShiRi on the home page.
2. Choose the game (Chess or Breakthrough), the colour ShiRi plays (White, Black or Random), the time control (minutes per side and increment, as in Create Lobby Game), and the time per move for your AI and for ShiRi (3, 5, 8, 12 or 15 seconds each).
3. Click Start Game. Click Stop to end the game early.

Before you start

You need your own AG Champion for the game you choose, with its repo saved on your Profile and its model check passed. As a guest, wait until the Gladiator tab says your model is ready. Until then the page shows "Preparing your model..." and the game does not start. Full accounts must also have proved ownership.

Where

Playing against ShiRi. You must be logged in.

How you know it worked

The board shows your AG Champion's name on one side and ShiRi on the other, and the moves appear one after another. When the game ends, the page shows the result and the reason. The game is not saved and does not change your Elo.

If it fails

• "You don't have a ... model of your own yet": register your repo first (see Step 4 or the guest quick start).
• Your AG Champion forfeits: in a ShiRi game no random move is played for you. If your code returns no move, an illegal move, or is too slow, it forfeits, and the page tells you which. Fix it using Move timed out and Model check failed.
• Your AG Champion loses on time: each side has a clock (the minutes per side you chose, plus the increment after every move), and only one clock runs at a time. Yours runs from the moment ShiRi moves until your AG Champion moves, including the wait that the "your AI thinking" setting adds. Choose more minutes, or a shorter AI thinking time, if your clock runs low.
• "Cancelled because of a platform problem": this is not your fault. No result is recorded. Try again later.

Next: Advanced

Advanced

Config files

Two small JSON files describe your repos: config_model.json for your model repo, and config_data.json for your data repo if you use one. You tell the platform which file to run by writing its name in config_model.json under "entrypoint". NAME_OF_ALGO_FILE.py in the example below stands for the file name you chose: replace it with your own name, and use the same name everywhere. The Repo File Status panel on the Gladiator tab and the Diagnostics tab also read files from config_model.json (model repo) and, if you use a data repo, from config_data.json (data repo). They report a problem when a file cannot be read or lists no files.

config_model.json (root of the model repo)

{
  "schema_version": 1,
  "entrypoint": "NAME_OF_ALGO_FILE.py",
  "data_files": ["opening_book.txt"],
  "requirements": ["numpy", "python-chess"],
  "files": ["NAME_OF_ALGO_FILE.py"]
}

config_data.json (root of the data repo, only if you use one)

{
  "files": ["opening_book.txt"]
}

files lists every file that must exist in the data repo. It is read from the main branch and is used by the Repo File Status panel and by Diagnostics, which report a problem if the file is missing or lists no files. Keep it consistent with data_files in config_model.json.

# test_bot.py - put it in the same folder as NAME_OF_ALGO_FILE.py
        from pathlib import Path
        from types import SimpleNamespace

        import NAME_OF_ALGO_FILE as bot  # your file name, without .py

        # A simple stand-in for what the platform gives to load().
        ctx = SimpleNamespace(model_dir=Path("."), data_dir=None)
        state = bot.load(ctx)

        # Chess sample position (the start position).
        # For Breakthrough use: "BBBBBBBB/BBBBBBBB/8/8/8/8/WWWWWWWW/WWWWWWWW w"
        fen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"
        print(bot.get_move(state, fen, "w"))

Best practices

• Load everything in load(). Load models, weights and opening books inside load(ctx), which runs once. Never read files inside get_move: that time is spent on every move and counts against your clock and the move timeout.
• Stay well under the move time limit. Budget your search depth or inference time below the limit in Sandbox limits. If your AG Champion is too slow, random moves are played for it (see When a move fails).
• Keep it lightweight. Keep your dependencies minimal and avoid anything that expects internet connectivity. If you like, note the versions you tested with in your repo's requirements.txt for your own reference.
• Return a plain string in the right format. Always return a legal move as a plain string, in the format shown under Move format. Anything else is treated as no move.
• Test before tournaments. Run Diagnostics, then play several quick matches in the Lobby to confirm your AG Champion responds correctly at game speed before you enter a tournament. The 30-game qualification window is the ideal calibration period.

Troubleshooting

Find the symptom, open it, and follow the fix. The steps above link here when something goes wrong.

Frequently asked questions

More answers about games, time limits and thinking time are in the FAQ on How it works.