diff --git a/src/client/game/admin-dialogs.tsx b/src/client/game/admin-dialogs.tsx
new file mode 100644
index 00000000..b6bdc50a
--- /dev/null
+++ b/src/client/game/admin-dialogs.tsx
@@ -0,0 +1,82 @@
+import {
+    Button,
+    Dialog,
+    DialogBody,
+    DialogFooter,
+    NonIdealState,
+} from "@blueprintjs/core";
+import { useState } from "react";
+import { bgColor, buttonColor, textColor } from "../check-dark-mode";
+
+interface DrawDialogProps {
+    dialogText?: string;
+}
+
+/**
+ * Shows a paused dialog that cannot be closed
+ * @param props - dialog text
+ * @returns - pause dialog
+ */
+export function PauseDialog(props: DrawDialogProps) {
+    const [isOpen, setIsOpen] = useState(true);
+    return (
+        <Dialog
+            className={bgColor()}
+            isOpen={isOpen}
+            onClose={() => setIsOpen(false)}
+            canOutsideClickClose={false}
+            canEscapeKeyClose={false}
+        >
+            <DialogBody>
+                <NonIdealState>
+                    <h4 className={textColor()}>
+                        {props.dialogText || "Game Paused"}
+                    </h4>
+                </NonIdealState>
+            </DialogBody>
+        </Dialog>
+    );
+}
+
+interface NotificationDialogProps {
+    dialogText: string;
+}
+
+/**
+ * Shows a closable notification dialog
+ * @param props - dialog text
+ * @returns - notification dialog
+ */
+export function NotificationDialog(props: NotificationDialogProps) {
+    const [isOpen, setIsOpen] = useState(true);
+
+    /** okay button */
+    const actions = (
+        <Button
+            text="Continue"
+            rightIcon="arrow-right"
+            className={buttonColor()}
+            intent="primary"
+            onClick={() => {
+                setIsOpen(false);
+            }}
+        />
+    );
+
+    return (
+        <Dialog
+            className={bgColor()}
+            isOpen={isOpen}
+            onClose={() => setIsOpen(false)}
+            canOutsideClickClose={true}
+            canEscapeKeyClose={true}
+        >
+            <DialogBody>
+                <NonIdealState>
+                    <h4 className={textColor()}>{props.dialogText}</h4>
+                </NonIdealState>
+            </DialogBody>
+            <DialogFooter minimal actions={actions} />
+        </Dialog>
+    );
+}
diff --git a/src/client/game/game.tsx b/src/client/game/game.tsx
index 4938c89f..52fdfc43 100644
--- a/src/client/game/game.tsx
+++ b/src/client/game/game.tsx
@@ -27,6 +27,7 @@ import { NonIdealState, Spinner } from "@blueprintjs/core";
 import { AcceptDrawDialog, OfferDrawDialog } from "./draw-dialog";
 import { bgColor } from "../check-dark-mode";
 import "../colors.css";
+import { NotificationDialog, PauseDialog } from "./admin-dialogs";
 import { PuzzleTipBox } from "../PuzzleTipBox";
 
 /**
@@ -41,6 +42,7 @@ function getMessageHandler(
     setGameInterruptedReason: Dispatch<GameInterruptedReason>,
     setGameEndedReason: Dispatch<GameEndReason>,
     setGameHoldReason: Dispatch<GameHoldReason>,
+    setPaused: Dispatch<boolean>,
 ): MessageHandler {
     return (message) => {
         if (message instanceof MoveMessage) {
@@ -63,6 +65,11 @@ function getMessageHandler(
             setGameEndedReason(message.reason);
         } else if (message instanceof GameHoldMessage) {
             setGameHoldReason(message.reason);
+            if (message.reason === GameHoldReason.GAME_PAUSED) {
+                setPaused(true);
+            } else if (message.reason === GameHoldReason.GAME_UNPAUSED) {
+                setPaused(false);
+            }
         }
     };
 }
@@ -78,6 +85,7 @@ export function Game(): JSX.Element {
     const [gameEndedReason, setGameEndedReason] = useState<GameEndReason>();
     const [gameHoldReason, setGameHoldReason] = useState<GameHoldReason>();
     const [rotation, setRotation] = useState<number>(0);
+    const [paused, setPause] = useState<boolean>(false);
 
     /** send any messages using our defined message handler inside a message socket for handling */
     const sendMessage = useSocket(
@@ -87,6 +95,7 @@ export function Game(): JSX.Element {
             setGameInterruptedReason,
             setGameEndedReason,
             setGameHoldReason,
+            setPause,
         ),
     );
 
@@ -96,6 +105,7 @@ export function Game(): JSX.Element {
         async () => {
             return get("/game-state").then((gameState) => {
                 setChess(new ChessEngine(gameState.position));
+                setPause(gameState.pause);
                 if (gameState.gameEndReason !== undefined) {
                     setGameInterruptedReason(gameState.gameEndReason);
                 }
@@ -137,6 +147,7 @@ export function Game(): JSX.Element {
         gameEndReason !== undefined ?
             <GameEndDialog reason={gameEndReason} side={side} />
         :   null;
+
     const gameOfferDialog =
         gameHoldReason !== undefined ?
             gameHoldReason === GameHoldReason.DRAW_CONFIRMATION ?
@@ -151,11 +162,23 @@ export function Game(): JSX.Element {
             :   null
         :   null;
 
+    const gamePauseDialog = paused ? <PauseDialog /> : null;
+
+    const gameUnpauseDialog =
+        gameHoldReason !== undefined ?
+            gameHoldReason === GameHoldReason.GAME_UNPAUSED ?
+                <NotificationDialog dialogText="Game Unpaused" />
+            :   null
+        :   null;
+
     /** make moves by making a copy of the chessboard and sending the move message */
-    const handleMove = (move: Move): void => {
-        setChess(chess.copy(move));
-        sendMessage(new MoveMessage(move));
-    };
+    const handleMove =
+        !paused ?
+            (move: Move): void => {
+                setChess(chess.copy(move));
+                sendMessage(new MoveMessage(move));
+            }
+        :   () => {}; //send a do-nothing function if game is paused
 
     // return the chessboard wrapper, navbar, and potential end dialog
     return (
@@ -182,6 +205,8 @@ export function Game(): JSX.Element {
                 {gameEndDialog}
                 {gameOfferDialog}
                 {gameAcceptDialog}
+                {gamePauseDialog}
+                {gameUnpauseDialog}
                 <Outlet />
             </div>
         </>
diff --git a/src/common/game-end-reasons.ts b/src/common/game-end-reasons.ts
index 8a20a22a..7b6c67cc 100644
--- a/src/common/game-end-reasons.ts
+++ b/src/common/game-end-reasons.ts
@@ -40,4 +40,6 @@ export enum GameHoldReason {
     DRAW_OFFERED = "draw-offered",
     DRAW_CONFIRMATION = "draw-confirmation",
     DRAW_DENIED = "draw-denied",
+    GAME_PAUSED = "game-paused",
+    GAME_UNPAUSED = "game-unpaused",
 }
diff --git a/src/server/api/api.ts b/src/server/api/api.ts
index 46b15180..8a9154d6 100644
--- a/src/server/api/api.ts
+++ b/src/server/api/api.ts
@@ -20,6 +20,7 @@ import { RegisterWebsocketMessage } from "../../common/message/message";
 import {
     clientManager,
     gameManager,
+    gamePaused,
     setGameManager,
     socketManager,
 } from "./managers";
@@ -59,6 +60,7 @@ import {
 import { tcpServer } from "./tcp-interface";
 import { robotManager } from "../robot/robot-manager";
 import { executor } from "../command/executor";
+import { GameHoldReason } from "../../common/game-end-reasons";
 
 /**
  * Helper function to move all robots from their home positions to their default positions
@@ -184,6 +186,17 @@ apiRouter.get("/client-information", async (req, res) => {
                 ),
             );
         }
+        const robotPos = new Map(
+            oldSave!.robotPos?.map<[string, GridIndices]>((obj) => [
+                obj[1],
+                new GridIndices(
+                    parseInt(obj[0].split(", ")[0]),
+                    parseInt(obj[0].split(", ")[1]),
+                ),
+            ]),
+        );
+        console.log(robotPos);
+        setAllRobotsToDefaultPositions(robotPos);
     }
     /**
      * Note the client currently redirects to home from the game over screen
@@ -556,6 +569,50 @@ apiRouter.get("/get-puzzles", (_, res) => {
     return res.send(out);
 });
 
+/**
+ * Pause the game
+ * Todo: add authentication instead of an exposed pause call
+ */
+apiRouter.get("/pause-game", (_, res) => {
+    gamePaused.flag = true;
+    robotManager.stopAllRobots();
+    socketManager.sendToAll(new GameHoldMessage(GameHoldReason.GAME_PAUSED));
+    return res.send({ message: "success" });
+});
+
+/**
+ * Unpause the game
+ * Todo: add authentication instead of an exposed unpause call
+ */
+apiRouter.get("/unpause-game", async (_, res) => {
+    if (gamePaused.flag) {
+        gamePaused.flag = false;
+        const ids = clientManager.getIds();
+        if (ids) {
+            const oldSave = SaveManager.loadGame(ids[0]);
+            gameManager?.chess.loadFen(oldSave!.oldPos);
+            setAllRobotsToDefaultPositions(
+                new Map(
+                    oldSave!.oldRobotPos?.map<[string, GridIndices]>((obj) => [
+                        obj[1],
+                        new GridIndices(
+                            parseInt(obj[0].split(", ")[0]),
+                            parseInt(obj[0].split(", ")[1]),
+                        ),
+                    ]),
+                ),
+            );
+            socketManager.sendToAll(new SetChessMessage(oldSave!.oldPos));
+        }
+        socketManager.sendToAll(
+            new GameHoldMessage(GameHoldReason.GAME_UNPAUSED),
+        );
+        return res.send({ message: "success" });
+    } else {
+        return res.send({ message: "game not paused" });
+    }
+});
+
 /**
  * sends a drive message through the tcp connection
  *
diff --git a/src/server/api/game-manager.ts b/src/server/api/game-manager.ts
index 158a48e7..0331f467 100644
--- a/src/server/api/game-manager.ts
+++ b/src/server/api/game-manager.ts
@@ -26,12 +26,15 @@ import { SaveManager } from "./save-manager";
 import { materializePath } from "../robot/path-materializer";
 import { DO_SAVES } from "../utils/env";
 import { executor } from "../command/executor";
+import { robotManager } from "../robot/robot-manager";
+import { gamePaused } from "./managers";
 
 type GameState = {
     type?: "puzzle" | "human" | "computer";
     side: Side;
     position: string;
     gameEndReason: GameEndReason | undefined;
+    pause: boolean;
     tooltip?: string;
     aiDifficulty?: number;
     difficulty?: number;
@@ -89,6 +92,7 @@ export abstract class GameManager {
             position: this.chess.pgn,
             gameEndReason: this.getGameEndReason(),
             tooltip: this.tooltip,
+            pause: gamePaused.flag,
         };
     }
 
@@ -143,8 +147,8 @@ export class HumanGameManager extends GameManager {
         );
         const ids = this.clientManager.getIds();
         const currentSave = SaveManager.loadGame(id);
-        // update the internal chess object if it is a move massage
-        if (message instanceof MoveMessage) {
+        // update the internal chess object if it is a move massage and game not paused
+        if (message instanceof MoveMessage && !gamePaused.flag) {
             // Call path materializer and send to bots
             const command = materializePath(message.move);
 
@@ -163,6 +167,8 @@ export class HumanGameManager extends GameManager {
                         this.hostSide,
                         -1,
                         this.chess.pgn,
+                        this.chess.fen,
+                        robotManager.getIndicesToIds(),
                     );
                 } else {
                     SaveManager.saveGame(
@@ -171,6 +177,8 @@ export class HumanGameManager extends GameManager {
                         oppositeSide(this.hostSide),
                         -1,
                         this.chess.pgn,
+                        this.chess.fen,
+                        robotManager.getIndicesToIds(),
                     );
                 }
             }
@@ -265,7 +273,7 @@ export class ComputerGameManager extends GameManager {
      * @returns when the game ends
      */
     public async handleMessage(message: Message, id: string): Promise<void> {
-        if (message instanceof MoveMessage) {
+        if (message instanceof MoveMessage && !gamePaused.flag) {
             // Call path materializer and send to bots for human move
             const command = materializePath(message.move);
 
@@ -281,6 +289,8 @@ export class ComputerGameManager extends GameManager {
                     this.hostSide,
                     this.difficulty,
                     this.chess.pgn,
+                    this.chess.fen,
+                    robotManager.getIndicesToIds(),
                 );
             }
 
@@ -349,7 +359,8 @@ export class PuzzleGameManager extends GameManager {
             //if the move is correct
             if (
                 this.moves[this.moveNumber].from === message.move.from &&
-                this.moves[this.moveNumber].to === message.move.to
+                this.moves[this.moveNumber].to === message.move.to &&
+                !gamePaused.flag
             ) {
                 const command = materializePath(message.move);
 
diff --git a/src/server/api/managers.ts b/src/server/api/managers.ts
index 37804692..fb41e9f1 100644
--- a/src/server/api/managers.ts
+++ b/src/server/api/managers.ts
@@ -9,6 +9,7 @@ import { SocketManager } from "./socket-manager";
 export const socketManager = new SocketManager({});
 export const clientManager = new ClientManager(socketManager);
 export let gameManager: GameManager | null = null;
+export const gamePaused = { flag: false };
 
 export function setGameManager(manager: GameManager) {
     gameManager = manager;
diff --git a/src/server/api/save-manager.ts b/src/server/api/save-manager.ts
index 02f8ec59..c88e93c0 100644
--- a/src/server/api/save-manager.ts
+++ b/src/server/api/save-manager.ts
@@ -19,6 +19,10 @@ export interface iSave {
     hostWhite: boolean;
     aiDifficulty: number;
     game: string;
+    pos: string;
+    robotPos: Array<[string, string]>;
+    oldPos: string;
+    oldRobotPos: Array<[string, string]>;
 }
 
 export class SaveManager {
@@ -27,9 +31,9 @@ export class SaveManager {
      *
      * Finds or creates a save file
      * Save name is host id + client id
-     * Saves include the game start time and save pgn as json
-     *
-     * Input: host id, client id, game pgn
+     * Saves include the game start time and save fen as json
+     * Robots are saved as a map of indices to robots
+     * Input: host id, client id, game fen, robots
      * Output: boolean competed
      */
     public static saveGame(
@@ -38,16 +42,28 @@ export class SaveManager {
         hostSide: Side,
         aiDiff: number,
         pgn: string,
+        fen: string,
+        robots: Map<string, string>,
     ) {
         const day = new Date().getTime();
         const side = hostSide === Side.WHITE;
+        console.log(JSON.stringify(robots));
         const saveContents = {
             host: hostId,
             date: day,
             hostWhite: side,
             aiDifficulty: aiDiff,
             game: pgn,
+            pos: fen,
+            robotPos: Array.from(robots),
+            oldPos: "",
+            oldRobotPos: Array<[string, string]>(),
         };
+        const oldGame = SaveManager.loadGame(hostId + "+" + clientID);
+        if (oldGame && oldGame.pos !== null) {
+            saveContents.oldPos = oldGame.pos;
+            saveContents.oldRobotPos = oldGame.robotPos;
+        }
         return FileManager.writeFile(hostId + "+" + clientID, saveContents);
     }
 
diff --git a/src/server/command/command.ts b/src/server/command/command.ts
index e955bada..7b10d97f 100644
--- a/src/server/command/command.ts
+++ b/src/server/command/command.ts
@@ -1,3 +1,4 @@
+import { gamePaused } from "../api/managers";
 import { robotManager } from "../robot/robot-manager";
 
 /**
@@ -112,7 +113,11 @@ function isReversable(obj): obj is Reversible<typeof obj> {
  */
 export class ParallelCommandGroup extends CommandGroup {
     public async execute(): Promise<void> {
-        const promises = this.commands.map((move) => move.execute());
+        const promises = this.commands
+            .map((move) => {
+                if (!gamePaused.flag) return move.execute();
+            })
+            .filter(Boolean);
         return Promise.all(promises).then(null);
     }
     public async reverse(): Promise<void> {
@@ -132,7 +137,10 @@ export class SequentialCommandGroup extends CommandGroup {
     public async execute(): Promise<void> {
         let promise = Promise.resolve();
         for (const command of this.commands) {
-            promise = promise.then(() => command.execute());
+            promise = promise.then(() => {
+                if (!gamePaused.flag) return command.execute();
+                else return Promise.resolve();
+            });
         }
         return promise;
     }
diff --git a/src/server/command/executor.ts b/src/server/command/executor.ts
index bbde2d69..b34d3f11 100644
--- a/src/server/command/executor.ts
+++ b/src/server/command/executor.ts
@@ -1,3 +1,4 @@
+import { gamePaused } from "../api/managers";
 import type { Command } from "./command";
 
 /**
@@ -18,6 +19,7 @@ export class CommandExecutor {
     constructor() {}
 
     private runningCommands: Command[] = [];
+    private oldCommands: Command[] = [];
 
     private checkRequirements(command: Command) {
         for (const req of command.requirements) {
@@ -41,12 +43,38 @@ export class CommandExecutor {
     public async execute(command: Command): Promise<void> {
         this.checkRequirements(command);
         this.runningCommands.push(command);
-        return command.execute().finally(() => {
-            const index = this.runningCommands.indexOf(command);
-            if (index >= 0) {
-                this.runningCommands.splice(index, 1);
-            }
-        });
+        if (!gamePaused.flag) {
+            return command.execute().finally(() => {
+                this.oldCommands.unshift(command);
+                const index = this.runningCommands.indexOf(command);
+                if (index >= 0) {
+                    this.runningCommands.splice(index, 1);
+                }
+            });
+        }
+    }
+
+    /**
+     * run through the running command list
+     * mainly used to finish the backlog from a paused game
+     * @returns - The command to execute.
+     */
+    public async finishExecution(): Promise<void> {
+        return Promise.all(
+            this.runningCommands.map((command) => {
+                command.execute().finally(() => {
+                    this.oldCommands.unshift(command);
+                    const index = this.runningCommands.indexOf(command);
+                    if (index >= 0) {
+                        this.runningCommands.splice(index, 1);
+                    }
+                });
+            }),
+        ).then();
+    }
+
+    public clearExecution() {
+        this.runningCommands = [];
     }
 
     public getRunningCommands(): ReadonlyArray<Command> {
diff --git a/src/server/robot/robot-manager.ts b/src/server/robot/robot-manager.ts
index fd72e426..32daecfc 100644
--- a/src/server/robot/robot-manager.ts
+++ b/src/server/robot/robot-manager.ts
@@ -99,6 +99,12 @@ export class RobotManager {
         }
         indicesToIds.set(indices.toString(), robotId);
     }
+
+    stopAllRobots() {
+        Array.from(this.idsToRobots.values()).forEach((robot) => {
+            robot.sendStopPacket();
+        });
+    }
 }
 
 export const robotManager = new RobotManager(
diff --git a/src/server/robot/robot.ts b/src/server/robot/robot.ts
index 7540ec82..62556b36 100644
--- a/src/server/robot/robot.ts
+++ b/src/server/robot/robot.ts
@@ -186,4 +186,10 @@ export class Robot {
             timeDeltaMs: timeDeltaMs,
         });
     }
+
+    public async sendStopPacket(): Promise<void> {
+        await this.tunnel!.send({
+            type: PacketType.ESTOP,
+        });
+    }
 }