diff --git a/src/client/api.ts b/src/client/api.ts
index 7f3443c4..d458c158 100644
--- a/src/client/api.ts
+++ b/src/client/api.ts
@@ -9,10 +9,9 @@ import { useQuery } from "@tanstack/react-query";
 /**
  * A wrapper around `useQuery` which causes the wrapped query to be trigged once each time the page renders.
  */
-export function useEffectQuery(
+export function useEffectQuery<T>(
     queryKey: string,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    queryFn: () => Promise<any>,
+    queryFn: () => Promise<T>,
     retry?: boolean | number,
 ) {
     // id guarantees query is the same every time
diff --git a/src/client/game/game-end-dialog.tsx b/src/client/game/game-end-dialog.tsx
index d4c0cfa6..c3fab8c7 100644
--- a/src/client/game/game-end-dialog.tsx
+++ b/src/client/game/game-end-dialog.tsx
@@ -81,10 +81,12 @@ function gameOverIcon(reason: GameEndReason, side: Side) {
     // check which side won
     const whiteWon =
         reason === GameFinishedReason.BLACK_CHECKMATED ||
-        reason === GameInterruptedReason.BLACK_RESIGNED;
+        reason === GameInterruptedReason.BLACK_RESIGNED ||
+        reason === GameFinishedReason.PUZZLE_SOLVED;
     const blackWon =
         reason === GameFinishedReason.WHITE_CHECKMATED ||
-        reason === GameInterruptedReason.WHITE_RESIGNED;
+        reason === GameInterruptedReason.WHITE_RESIGNED ||
+        reason === GameFinishedReason.PUZZLE_SOLVED;
 
     // checks which side is asking and assigns win/lost accordingly
     const won = side === Side.WHITE ? whiteWon : blackWon;
@@ -133,6 +135,8 @@ function gameOverMessage(reason: GameEndReason) {
             return "Checkmate - White Wins";
         case GameFinishedReason.STALEMATE:
             return "Draw - Stalemate";
+        case GameFinishedReason.PUZZLE_SOLVED:
+            return "Puzzle Solved";
         case GameFinishedReason.THREEFOLD_REPETITION:
             return "Draw - Threefold Repetition";
         case GameFinishedReason.INSUFFICIENT_MATERIAL:
diff --git a/src/client/game/game.tsx b/src/client/game/game.tsx
index 88d872ef..c76c51ee 100644
--- a/src/client/game/game.tsx
+++ b/src/client/game/game.tsx
@@ -1,9 +1,11 @@
 import { Dispatch, useState } from "react";
 
 import {
+    GameEndMessage,
     GameFinishedMessage,
     GameHoldMessage,
     GameInterruptedMessage,
+    SetChessMessage,
 } from "../../common/message/game-message";
 import { MoveMessage } from "../../common/message/game-message";
 import {
@@ -35,14 +37,28 @@ function getMessageHandler(
     chess: ChessEngine,
     setChess: Dispatch<ChessEngine>,
     setGameInterruptedReason: Dispatch<GameInterruptedReason>,
+    setGameEndedReason: Dispatch<GameEndReason>,
     setGameHoldReason: Dispatch<GameHoldReason>,
 ): MessageHandler {
     return (message) => {
         if (message instanceof MoveMessage) {
             // Must be a new instance of ChessEngine to trigger UI redraw
-            setChess(chess.copy(message.move));
+            // short wait so the pieces don't teleport into place
+            setTimeout(() => {
+                setChess(chess.copy(message.move));
+            }, 500);
+        } else if (message instanceof SetChessMessage) {
+            const fen = message.chess;
+            if (fen) {
+                setTimeout(() => {
+                    chess.loadFen(fen);
+                    setChess(chess.copy());
+                }, 500);
+            }
         } else if (message instanceof GameInterruptedMessage) {
             setGameInterruptedReason(message.reason);
+        } else if (message instanceof GameEndMessage) {
+            setGameEndedReason(message.reason);
         } else if (message instanceof GameHoldMessage) {
             setGameHoldReason(message.reason);
         }
@@ -57,6 +73,7 @@ export function Game(): JSX.Element {
     const [chess, setChess] = useState(new ChessEngine());
     const [gameInterruptedReason, setGameInterruptedReason] =
         useState<GameInterruptedReason>();
+    const [gameEndedReason, setGameEndedReason] = useState<GameEndReason>();
     const [gameHoldReason, setGameHoldReason] = useState<GameHoldReason>();
     const [rotation, setRotation] = useState<number>(0);
 
@@ -66,6 +83,7 @@ export function Game(): JSX.Element {
             chess,
             setChess,
             setGameInterruptedReason,
+            setGameEndedReason,
             setGameHoldReason,
         ),
     );
@@ -103,7 +121,9 @@ export function Game(): JSX.Element {
     // check if the game has ended or been interrupted
     let gameEndReason: GameEndReason | undefined = undefined;
     const gameFinishedReason = chess.getGameFinishedReason();
-    if (gameFinishedReason !== undefined) {
+    if (gameEndedReason !== undefined) {
+        gameEndReason = gameEndedReason;
+    } else if (gameFinishedReason !== undefined) {
         sendMessage(new GameFinishedMessage(gameFinishedReason));
         gameEndReason = gameFinishedReason;
     } else if (gameInterruptedReason !== undefined) {
@@ -115,7 +135,6 @@ export function Game(): JSX.Element {
         gameEndReason !== undefined ?
             <GameEndDialog reason={gameEndReason} side={side} />
         :   null;
-
     const gameOfferDialog =
         gameHoldReason !== undefined ?
             gameHoldReason === GameHoldReason.DRAW_CONFIRMATION ?
@@ -142,6 +161,8 @@ export function Game(): JSX.Element {
             <NavbarMenu
                 sendMessage={sendMessage}
                 side={side}
+                difficulty={data.difficulty}
+                aiDifficulty={data.aiDifficulty}
                 setRotation={setRotation}
             />
             <div id="body-container" className={bgColor()}>
diff --git a/src/client/game/navbar-menu.tsx b/src/client/game/navbar-menu.tsx
index 9a46c3a0..4c5cc545 100644
--- a/src/client/game/navbar-menu.tsx
+++ b/src/client/game/navbar-menu.tsx
@@ -28,6 +28,8 @@ import "../colors.css";
 interface NavbarMenuProps {
     sendMessage: SendMessage;
     side: Side;
+    difficulty?: string;
+    aiDifficulty?: number;
     setRotation: Dispatch<React.SetStateAction<number>>; //set state type
 }
 
@@ -40,6 +42,20 @@ interface NavbarMenuProps {
 export function NavbarMenu(props: NavbarMenuProps): JSX.Element {
     // Store react router state for game
     const navigate = useNavigate();
+    const difficultyButton =
+        props.difficulty ?
+            <Button minimal disabled text={"rating: " + props.difficulty} />
+        :   null;
+
+    const aiArray = ["Baby", "Beginner", "Intermediate", "Advances"];
+    const aiDifficultyButton =
+        props.aiDifficulty ?
+            <Button
+                minimal
+                disabled
+                text={"AI Difficulty: " + aiArray[props.aiDifficulty]}
+            />
+        :   null;
 
     /** create navbar rotate button */
     const rotateButton =
@@ -54,43 +70,53 @@ export function NavbarMenu(props: NavbarMenuProps): JSX.Element {
                     });
                 }}
             />
-        :   "";
+        :   undefined;
+
+    const resignButton =
+        props.side === Side.SPECTATOR ?
+            undefined
+        :   <Button
+                icon="flag"
+                variant="minimal"
+                text="Resign"
+                intent="danger"
+                onClick={async () => {
+                    props.sendMessage(
+                        new GameInterruptedMessage(
+                            props.side === Side.WHITE ?
+                                GameInterruptedReason.WHITE_RESIGNED
+                            :   GameInterruptedReason.BLACK_RESIGNED,
+                        ),
+                    );
+                }}
+            />;
+
+    const drawButton =
+        props.side === Side.SPECTATOR ?
+            undefined
+        :   <Button
+                icon="pause"
+                variant="minimal"
+                text="Draw"
+                intent="danger"
+                onClick={async () => {
+                    props.sendMessage(
+                        new GameHoldMessage(GameHoldReason.DRAW_CONFIRMATION),
+                    );
+                }}
+            />;
 
     return (
         <Navbar className={bgColor()}>
             <NavbarGroup>
                 <NavbarHeading className={textColor()}>ChessBot</NavbarHeading>
                 <NavbarDivider />
-                <Button
-                    icon="flag"
-                    variant="minimal"
-                    text="Resign"
-                    intent="danger"
-                    onClick={async () => {
-                        props.sendMessage(
-                            new GameInterruptedMessage(
-                                props.side === Side.WHITE ?
-                                    GameInterruptedReason.WHITE_RESIGNED
-                                :   GameInterruptedReason.BLACK_RESIGNED,
-                            ),
-                        );
-                    }}
-                />
-                <Button
-                    icon="pause"
-                    variant="minimal"
-                    text="Draw"
-                    intent="danger"
-                    onClick={async () => {
-                        props.sendMessage(
-                            new GameHoldMessage(
-                                GameHoldReason.DRAW_CONFIRMATION,
-                            ),
-                        );
-                    }}
-                />
+                {resignButton}
+                {drawButton}
             </NavbarGroup>
             <NavbarGroup align="right">
+                {difficultyButton}
+                {aiDifficultyButton}
                 {rotateButton}
                 <Button
                     icon={darkModeIcon()}
diff --git a/src/client/puzzle/puzzle.tsx b/src/client/puzzle/puzzle.tsx
deleted file mode 100644
index ce140fc5..00000000
--- a/src/client/puzzle/puzzle.tsx
+++ /dev/null
@@ -1,8 +0,0 @@
-/**
- * Allows the client to choose a chess puzzle to play
- *
- * @returns puzzle selection
- */
-export function Puzzle() {
-    return <></>;
-}
diff --git a/src/client/puzzle/select-puzzle.tsx b/src/client/puzzle/select-puzzle.tsx
new file mode 100644
index 00000000..228c9af5
--- /dev/null
+++ b/src/client/puzzle/select-puzzle.tsx
@@ -0,0 +1,76 @@
+import { Button, MenuItem } from "@blueprintjs/core";
+import { ItemRenderer, Select } from "@blueprintjs/select";
+import { post } from "../api";
+import { useNavigate } from "react-router-dom";
+import { PuzzleComponents } from "../../server/api/api";
+
+const renderPuzzleOptions: ItemRenderer<string> = (
+    puzzleNumber,
+    { modifiers, handleFocus, handleClick },
+) => {
+    return (
+        <MenuItem
+            key={puzzleNumber}
+            active={modifiers.active}
+            roleStructure="listoption"
+            text={puzzleNumber}
+            onFocus={handleFocus}
+            onClick={handleClick}
+        />
+    );
+};
+
+interface SelectPuzzleProps {
+    puzzles: Record<string, PuzzleComponents>;
+    selectedPuzzle: string | undefined;
+    onPuzzleSelected: (puzzle: string) => void;
+}
+
+export function SelectPuzzle(props: SelectPuzzleProps) {
+    const navigate = useNavigate();
+    const hasSelection = props.selectedPuzzle !== undefined;
+
+    const submit = (
+        <Button
+            text="Play"
+            icon="arrow-right"
+            intent="primary"
+            onClick={async () => {
+                if (props.selectedPuzzle && props.puzzles) {
+                    //convert puzzle to map and send to start puzzles
+                    const puzzle = props.puzzles as Record<
+                        string,
+                        PuzzleComponents
+                    >;
+                    const promise = post("/start-puzzle-game", {
+                        puzzle: JSON.stringify(puzzle[props.selectedPuzzle]),
+                    });
+                    promise.then(() => {
+                        navigate("/game");
+                    });
+                }
+            }}
+        />
+    );
+    return (
+        <>
+            <Select<string>
+                items={[...Object.keys(props.puzzles)]}
+                itemRenderer={renderPuzzleOptions}
+                onItemSelect={props.onPuzzleSelected}
+                filterable={false}
+                popoverProps={{ minimal: true }}
+            >
+                <Button
+                    text={
+                        hasSelection ?
+                            props.selectedPuzzle
+                        :   "Select a puzzle..."
+                    }
+                    endIcon="double-caret-vertical"
+                />
+            </Select>
+            {submit}
+        </>
+    );
+}
diff --git a/src/client/puzzle/setup-puzzle.tsx b/src/client/puzzle/setup-puzzle.tsx
new file mode 100644
index 00000000..031b05d9
--- /dev/null
+++ b/src/client/puzzle/setup-puzzle.tsx
@@ -0,0 +1,40 @@
+import { useState } from "react";
+import { SetupBase } from "../setup/setup-base";
+import { SelectPuzzle } from "./select-puzzle";
+import { NonIdealState, Spinner } from "@blueprintjs/core";
+import { get, useEffectQuery } from "../api";
+import { Navigate } from "react-router-dom";
+import { PuzzleComponents } from "../../server/api/api";
+
+export function SetupPuzzle() {
+    const [selectedPuzzle, setSelectedPuzzle] = useState<string | undefined>();
+
+    //get puzzles from api
+    const { isPending, data, isError } = useEffectQuery(
+        "get-puzzles",
+        async () =>
+            (await get("/get-puzzles")) as Record<string, PuzzleComponents>,
+        false,
+    );
+
+    if (isPending) {
+        return (
+            <NonIdealState
+                icon={<Spinner intent="primary" />}
+                title="Loading..."
+            />
+        );
+    } else if (isError || data === undefined) {
+        return <Navigate to="/home" />;
+    }
+
+    return (
+        <SetupBase>
+            <SelectPuzzle
+                puzzles={data}
+                selectedPuzzle={selectedPuzzle}
+                onPuzzleSelected={setSelectedPuzzle}
+            />
+        </SetupBase>
+    );
+}
diff --git a/src/client/router.tsx b/src/client/router.tsx
index b282a82f..7571293d 100644
--- a/src/client/router.tsx
+++ b/src/client/router.tsx
@@ -2,7 +2,6 @@ import { createBrowserRouter } from "react-router-dom";
 import { Setup } from "./setup/setup";
 import { Debug } from "./debug/debug";
 import { Game } from "./game/game";
-import { Puzzle } from "./puzzle/puzzle";
 import { Lobby } from "./setup/lobby";
 import { Home } from "./home";
 import { Debug2 } from "./debug/debug2";
@@ -33,10 +32,6 @@ export const router = createBrowserRouter([
         path: "/lobby",
         element: <Lobby />,
     },
-    {
-        path: "/puzzle",
-        element: <Puzzle />,
-    },
     {
         path: "/game",
         element: <Game />,
diff --git a/src/client/setup/setup.tsx b/src/client/setup/setup.tsx
index e4070f54..d2809dea 100644
--- a/src/client/setup/setup.tsx
+++ b/src/client/setup/setup.tsx
@@ -10,6 +10,7 @@ import { Dispatch, useState } from "react";
 import { SetupGame } from "./setup-game";
 import { Navigate, useNavigate } from "react-router-dom";
 import { ClientType, GameType } from "../../common/client-types";
+import { SetupPuzzle } from "../puzzle/setup-puzzle";
 import { get, useEffectQuery } from "../api";
 import {
     allSettings,
@@ -68,6 +69,9 @@ export function Setup(): JSX.Element {
                         }
                     />
                 :   null}
+                {setupType === SetupType.PUZZLE ?
+                    <SetupPuzzle />
+                :   null}
             </SetupBase>
         );
     } else {
diff --git a/src/common/chess-engine.ts b/src/common/chess-engine.ts
index 507245f1..3422596a 100644
--- a/src/common/chess-engine.ts
+++ b/src/common/chess-engine.ts
@@ -47,6 +47,12 @@ export class ChessEngine {
         return this.chess.pgn();
     }
 
+    /** undo a move */
+    undo(): Move {
+        const undo = this.chess.undo();
+        return { from: undo?.from, to: undo?.to } as Move;
+    }
+
     /** load a board from history (FEN) */
     loadFen(fen: string) {
         this.chess.load(fen);
diff --git a/src/common/game-end-reasons.ts b/src/common/game-end-reasons.ts
index 6b9099a2..8a20a22a 100644
--- a/src/common/game-end-reasons.ts
+++ b/src/common/game-end-reasons.ts
@@ -18,6 +18,9 @@ export enum GameFinishedReason {
     FIFTY_MOVES = "fifty-moves",
     // chess.js doesn't support the following:
     // FIVEFOLD_REPETITION,
+
+    /** Client solved a puzzle */
+    PUZZLE_SOLVED = "puzzle-solved",
 }
 
 /**
diff --git a/src/common/message/game-message.ts b/src/common/message/game-message.ts
index 1dd6292a..52ce0da4 100644
--- a/src/common/message/game-message.ts
+++ b/src/common/message/game-message.ts
@@ -4,6 +4,7 @@ import {
     GameInterruptedReason,
     GameHoldReason,
     GameFinishedReason,
+    GameEndReason,
 } from "../game-end-reasons";
 
 /**
@@ -39,6 +40,26 @@ export class MoveMessage extends Message {
     }
 }
 
+/**
+ * A message used to broadcast the state of the virtual chessboard
+ * to other connected clients. `chess` is a Forsyth-Edwards
+ * Notation (FEN) string used to represent the state of the chessboard.
+ */
+export class SetChessMessage extends Message {
+    constructor(public readonly chess: string) {
+        super();
+    }
+
+    protected type = MessageType.SET_CHESS;
+
+    protected toObj(): object {
+        return {
+            ...super.toObj(),
+            chess: this.chess,
+        };
+    }
+}
+
 /**
  * A message for starting games
  */
@@ -103,3 +124,18 @@ export class GameHoldMessage extends Message {
         };
     }
 }
+
+export class GameEndMessage extends Message {
+    constructor(public readonly reason: GameEndReason) {
+        super();
+    }
+
+    protected type = MessageType.GAME_ENDED;
+
+    protected toObj(): object {
+        return {
+            ...super.toObj(),
+            reason: this.reason,
+        };
+    }
+}
diff --git a/src/common/message/message.ts b/src/common/message/message.ts
index da3d0c2a..112c6d63 100644
--- a/src/common/message/message.ts
+++ b/src/common/message/message.ts
@@ -18,6 +18,10 @@ export enum MessageType {
      * A two-way message containing a single move.
      */
     MOVE = "move",
+    /**
+     * Sets the client chess engine
+     */
+    SET_CHESS = "set-chess",
     /**
      * A server-client message used to tell player two a game has started.
      */
@@ -36,6 +40,10 @@ export enum MessageType {
      * Indicates the game is finished and should be restarted
      */
     GAME_FINISHED = "game-finished",
+    /**
+     * Indicates the game has ended
+     */
+    GAME_ENDED = "game-ended",
     /**
      * A client-server message containing instructions for manually driving a robot.
      */
diff --git a/src/common/message/parse-message.ts b/src/common/message/parse-message.ts
index 323ab4a5..1c35666d 100644
--- a/src/common/message/parse-message.ts
+++ b/src/common/message/parse-message.ts
@@ -7,6 +7,8 @@ import {
     GameStartedMessage,
     GameHoldMessage,
     GameFinishedMessage,
+    GameEndMessage,
+    SetChessMessage,
 } from "./game-message";
 import { SimulatorUpdateMessage } from "./simulator-message";
 
@@ -30,10 +32,14 @@ export function parseMessage(text: string): Message {
             return new GameFinishedMessage(obj.reason);
         case MessageType.GAME_HELD:
             return new GameHoldMessage(obj.reason);
+        case MessageType.GAME_ENDED:
+            return new GameEndMessage(obj.reason);
         case MessageType.POSITION:
             return new PositionMessage(obj.pgn);
         case MessageType.MOVE:
             return new MoveMessage(obj.move);
+        case MessageType.SET_CHESS:
+            return new SetChessMessage(obj.chess);
         case MessageType.DRIVE_ROBOT:
             return new DriveRobotMessage(
                 obj.id,
diff --git a/src/server/api/api.ts b/src/server/api/api.ts
index 2c1eb7f5..f59e9478 100644
--- a/src/server/api/api.ts
+++ b/src/server/api/api.ts
@@ -4,9 +4,11 @@ import { Router } from "express";
 import { parseMessage } from "../../common/message/parse-message";
 import {
     GameFinishedMessage,
+    GameEndMessage,
     GameHoldMessage,
     GameInterruptedMessage,
     MoveMessage,
+    SetChessMessage,
 } from "../../common/message/game-message";
 import {
     DriveRobotMessage,
@@ -21,11 +23,13 @@ import {
     ComputerGameManager,
     GameManager,
     HumanGameManager,
+    PuzzleGameManager,
 } from "./game-manager";
 import { ChessEngine } from "../../common/chess-engine";
-import { Side } from "../../common/game-types";
+import { Move, Side } from "../../common/game-types";
 import { USE_VIRTUAL_ROBOTS } from "../utils/env";
 import { SaveManager } from "./save-manager";
+import { readFileSync } from "fs";
 
 import { CommandExecutor } from "../command/executor";
 import { VirtualBotTunnel, virtualRobots } from "../simulator";
@@ -60,8 +64,10 @@ export const websocketHandler: WebsocketRequestHandler = (ws, req) => {
         } else if (
             message instanceof GameInterruptedMessage ||
             message instanceof MoveMessage ||
+            message instanceof SetChessMessage ||
             message instanceof GameHoldMessage ||
-            message instanceof GameFinishedMessage
+            message instanceof GameFinishedMessage ||
+            message instanceof GameEndMessage
         ) {
             // TODO: Handle game manager not existing
             await gameManager?.handleMessage(message, req.cookies.id);
@@ -178,6 +184,23 @@ apiRouter.post("/start-human-game", (req, res) => {
     return res.send({ message: "success" });
 });
 
+apiRouter.post("/start-puzzle-game", (req, res) => {
+    //get puzzle components
+    const puzzle = JSON.parse(req.query.puzzle as string) as PuzzleComponents;
+    const fen = puzzle.fen;
+    const moves = puzzle.moves;
+    const difficulty = puzzle.rating;
+    //create game manager
+    gameManager = new PuzzleGameManager(
+        new ChessEngine(),
+        socketManager,
+        fen,
+        moves,
+        difficulty,
+    );
+    return res.send({ message: "success" });
+});
+
 /**
  * Returns all registered robot ids
  */
@@ -237,24 +260,21 @@ apiRouter.get("/get-simulator-robot-state", (_, res) => {
     });
 });
 
+export interface PuzzleComponents {
+    fen: string;
+    moves: Move[];
+    rating: number;
+}
+
 /**
- * Returns a list of available puzzles to play.
+ * Returns a list of available puzzles to play from puzzles.json.
  */
 apiRouter.get("/get-puzzles", (_, res) => {
-    return res.send({
-        puzzles: [
-            {
-                name: "Puzzle 1",
-                id: "puzzleId1",
-                rating: "1200",
-            },
-            {
-                name: "Puzzle 2",
-                id: "puzzleId2",
-                rating: "1400",
-            },
-        ],
-    });
+    const puzzles: Record<string, PuzzleComponents> = JSON.parse(
+        readFileSync("./src/server/api/puzzles.json", "utf-8"),
+    );
+    const out: string = JSON.stringify(puzzles);
+    return res.send(out);
 });
 
 /**
diff --git a/src/server/api/game-manager.ts b/src/server/api/game-manager.ts
index 6709b117..2d7555b6 100644
--- a/src/server/api/game-manager.ts
+++ b/src/server/api/game-manager.ts
@@ -6,13 +6,16 @@ import {
     GameStartedMessage,
     GameHoldMessage,
     GameFinishedMessage,
+    GameEndMessage,
+    SetChessMessage,
 } from "../../common/message/game-message";
 import { SocketManager } from "./socket-manager";
 import { ClientManager } from "./client-manager";
 import { ClientType } from "../../common/client-types";
-import { Side, oppositeSide } from "../../common/game-types";
+import { Move, Side, oppositeSide } from "../../common/game-types";
 import {
     GameEndReason,
+    GameFinishedReason,
     GameHoldReason,
     GameEndReason as GameInterruptedReason,
 } from "../../common/game-end-reasons";
@@ -21,6 +24,14 @@ import { materializePath } from "../robot/path-materializer";
 import { executor } from "./api";
 import { DO_SAVES } from "../utils/env";
 
+type GameState = {
+    side: Side;
+    position: string;
+    gameEndReason: GameEndReason | undefined;
+    aiDifficulty?: number;
+    difficulty?: number;
+};
+
 /**
  * The manager for game communication
  */
@@ -37,7 +48,9 @@ export abstract class GameManager {
         protected hostSide: Side,
         // true if host and client get reversed
         protected reverse: boolean,
-    ) {}
+    ) {
+        socketManager.sendToAll(new GameStartedMessage());
+    }
 
     /** check if game ended */
     public isGameEnded(): boolean {
@@ -56,7 +69,7 @@ export abstract class GameManager {
      * A method which is invoked whenever a game first connects.
      * Should respond with the game's side, position, and whether the game is finished.
      */
-    public getGameState(clientType: ClientType): object {
+    public getGameState(clientType: ClientType): GameState {
         let side: Side;
         if (clientType === ClientType.HOST) {
             side = this.reverse ? oppositeSide(this.hostSide) : this.hostSide;
@@ -87,9 +100,6 @@ export class HumanGameManager extends GameManager {
         protected reverse: boolean,
     ) {
         super(chess, socketManager, hostSide, reverse);
-        // Notify other client the game has started
-        clientManager.sendToClient(new GameStartedMessage());
-        clientManager.sendToSpectators(new GameStartedMessage());
     }
 
     /**
@@ -176,8 +186,6 @@ export class HumanGameManager extends GameManager {
             }
         } else if (message instanceof GameFinishedMessage) {
             // propagate back to both sockets
-            //sendToPlayer(message);
-            //sendToOpponent(message);
             if (ids) {
                 if (currentSave?.host === ids[0])
                     SaveManager.endGame(ids[0], ids[1]);
@@ -208,7 +216,7 @@ export class HumanGameManager extends GameManager {
  */
 export class ComputerGameManager extends GameManager {
     // The minimum amount of time to wait responding with a move.
-    MINIMUM_DELAY = 500;
+    MINIMUM_DELAY = 600;
 
     // Create the game manager
     // if the player is black have the computer make the first move
@@ -235,6 +243,7 @@ export class ComputerGameManager extends GameManager {
      */
     public async handleMessage(message: Message, id: string): Promise<void> {
         if (message instanceof MoveMessage) {
+            this.socketManager.sendToAll(new MoveMessage(message.move));
             this.chess.makeMove(message.move);
             if (DO_SAVES) {
                 SaveManager.saveGame(
@@ -258,7 +267,7 @@ export class ComputerGameManager extends GameManager {
             const elapsedTime = Date.now() - startTime;
             // If elapsed time is less than minimum delay, timeout is set to 1ms
             setTimeout(() => {
-                this.socketManager.sendToSocket(id, new MoveMessage(move));
+                this.socketManager.sendToAll(new MoveMessage(move));
             }, this.MINIMUM_DELAY - elapsedTime);
             if (this.isGameEnded()) {
                 SaveManager.endGame(id, "ai");
@@ -267,7 +276,120 @@ export class ComputerGameManager extends GameManager {
             this.gameInterruptedReason = message.reason;
             SaveManager.endGame(id, "ai");
             // Reflect end game reason back to client
-            this.socketManager.sendToSocket(id, message);
+            this.socketManager.sendToAll(message);
+        }
+    }
+
+    public getGameState(clientType: ClientType): GameState {
+        return {
+            ...super.getGameState(clientType),
+            aiDifficulty: this.difficulty,
+        };
+    }
+}
+
+export class PuzzleGameManager extends GameManager {
+    private moveNumber: number = 0;
+    MINIMUM_DELAY = 600;
+
+    constructor(
+        chess: ChessEngine,
+        socketManager: SocketManager,
+        fen: string,
+        private moves: Move[],
+        protected difficulty: number,
+    ) {
+        super(
+            chess,
+            socketManager,
+            fen.split(" ")[1] === "w" ? Side.WHITE : Side.BLACK,
+            false,
+        );
+        chess.loadFen(fen);
+    }
+
+    public getDifficulty(): number {
+        return this.difficulty;
+    }
+
+    public async handleMessage(message: Message, id: string): Promise<void> {
+        id;
+        if (message instanceof MoveMessage) {
+            //if the move is correct
+            if (
+                this.moves[this.moveNumber].from === message.move.from &&
+                this.moves[this.moveNumber].to === message.move.to
+            ) {
+                const command = materializePath(message.move);
+
+                this.socketManager.sendToAll(new MoveMessage(message.move));
+                this.chess.makeMove(message.move);
+                this.moveNumber++;
+
+                console.log("running executor");
+                console.dir(command, { depth: null });
+                await executor.execute(command);
+                console.log("executor done");
+
+                //if there is another move, make it
+                if (this.moves[this.moveNumber]) {
+                    const command = materializePath(message.move);
+
+                    this.chess.makeMove(this.moves[this.moveNumber]);
+
+                    console.log("running executor");
+                    console.dir(command, { depth: null });
+                    await executor.execute(command);
+                    console.log("executor done");
+                    setTimeout(() => {
+                        this.socketManager.sendToAll(
+                            new MoveMessage(this.moves[this.moveNumber]),
+                        );
+                        this.moveNumber++;
+                    }, this.MINIMUM_DELAY);
+                } else {
+                    this.moveNumber++;
+                }
+            }
+
+            //send an undo message
+            else {
+                this.socketManager.sendToAll(
+                    new SetChessMessage(this.chess.fen),
+                );
+            }
+
+            //send a finished message
+            if (this.isGameEnded()) {
+                const gameEnd = this.getGameEndReason();
+                if (gameEnd) {
+                    this.socketManager.sendToAll(new GameEndMessage(gameEnd));
+                }
+            }
+        } else if (
+            message instanceof (GameInterruptedMessage || GameEndMessage)
+        ) {
+            this.gameInterruptedReason = message.reason;
+            // Reflect end game reason back to client
+            this.socketManager.sendToAll(message);
         }
     }
+
+    public isGameEnded(): boolean {
+        return this.moveNumber >= this.moves.length || super.isGameEnded();
+    }
+
+    public getGameEndReason(): GameEndReason | undefined {
+        if (this.moveNumber >= this.moves.length) {
+            return GameFinishedReason.PUZZLE_SOLVED;
+        }
+        return super.getGameEndReason();
+    }
+
+    public getGameState(clientType: ClientType): GameState {
+        return {
+            ...super.getGameState(clientType),
+            difficulty: this.difficulty,
+        };
+    }
 }
diff --git a/src/server/api/puzzles.json b/src/server/api/puzzles.json
new file mode 100644
index 00000000..52c430a8
--- /dev/null
+++ b/src/server/api/puzzles.json
@@ -0,0 +1,43 @@
+{
+    "Puzzle 1": {
+        "fen": "8/1p3p1k/8/p1p2Kr1/P2pP3/1P1P4/2P5/8 w - - 0 1",
+        "moves": [{ "from": "f5", "to": "g5" }],
+        "rating": 511
+    },
+    "Puzzle 2": {
+        "fen": "5rk1/p5pp/4q3/8/1P1P4/2P4P/P2p1RP1/5RK1 w",
+        "moves": [{ "from": "f2", "to": "f8" }],
+        "rating": 514
+    },
+    "Puzzle 3": {
+        "fen": "8/8/8/8/2Prk1p1/2K5/8/5R2 w - - 0 1",
+        "moves": [
+            { "from": "f1", "to": "e1" },
+            { "from": "e4", "to": "f3" },
+            { "from": "c3", "to": "d4" }
+        ],
+        "rating": 1000
+    },
+    "Puzzle 4": {
+        "fen": "1r3k2/R4p2/5Kp1/1p1Pp3/2p1PbP1/2P2P2/4B3/8 b - - 0 1",
+        "moves": [
+            { "from": "b8", "to": "b6" },
+            { "from": "d5", "to": "d6" },
+            { "from": "b6", "to": "d6" }
+        ],
+        "rating": 1000
+    },
+    "Puzzle 5": {
+        "fen": "r1b3k1/1pq1b1r1/p2p3Q/3Pp3/3p1P2/P2B3P/1PP3P1/1R3RK1 w - - 0 1",
+        "moves": [
+            { "from": "f4", "to": "e5" },
+            { "from": "d6", "to": "e5" },
+            { "from": "d5", "to": "d6" },
+            { "from": "c7", "to": "c6" },
+            { "from": "f1", "to": "f3" },
+            { "from": "c6", "to": "f3" },
+            { "from": "d3", "to": "c4" }
+        ],
+        "rating": 2915
+    }
+}
diff --git a/src/server/robot/path-materializer.ts b/src/server/robot/path-materializer.ts
index e9c17fcb..4fe2a7b0 100644
--- a/src/server/robot/path-materializer.ts
+++ b/src/server/robot/path-materializer.ts
@@ -719,7 +719,3 @@ export function materializePath(move: Move): Command {
         return moveMainPiece(moveToGridMove(move));
     }
 }
-
-export function debugPath(move: Move) {
-    return moveMainPiece(moveToGridMove(move));
-}
diff --git a/src/server/robot/robot-manager.ts b/src/server/robot/robot-manager.ts
index daabf1f4..865988cd 100644
--- a/src/server/robot/robot-manager.ts
+++ b/src/server/robot/robot-manager.ts
@@ -1,5 +1,8 @@
+import { DEGREE } from "../../common/units";
 import { GridIndices } from "./grid-indices";
+import { Position } from "./position";
 import { Robot } from "./robot";
+import config from "../api/bot-server-config.json";
 
 /**
  * Stores robots. Provides utilities for finding them by position.
@@ -36,6 +39,26 @@ export class RobotManager {
         return robot;
     }
 
+    createRobotFromId(robotId: string) {
+        const robot = new Robot(
+            robotId,
+            new GridIndices(
+                config[robotId].homePosition.x,
+                config[robotId].homePosition.y,
+            ),
+            new GridIndices(
+                config[robotId].defaultPosition.x,
+                config[robotId].defaultPosition.y,
+            ),
+            config[robotId].startHeading * DEGREE,
+            new Position(
+                config[robotId].defaultPosition.x,
+                config[robotId].defaultPosition.y,
+            ),
+        );
+        this.addRobot(robot);
+    }
+
     /**
      * Returns `true` if a Robot is at the specified position, and `false` otherwise.
      */