diff --git a/app/header.tsx b/app/header.tsx
index 9ff3ecc..ddf8eeb 100644
--- a/app/header.tsx
+++ b/app/header.tsx
@@ -35,7 +35,7 @@ export default function Header() {
         <span className="ml-2 text-xl font-bold">SurviveTheNight</span>
       </Link>
 
-      <nav className="flex items-center space-x-4">
+      <nav className="flex items-center space-x-4 overflow-x-scroll">
         <Link href="/">
           <Button variant="ghost">Watch</Button>
         </Link>
@@ -54,9 +54,14 @@ export default function Header() {
           </Link>
         )}
         {isAdminQuery && (
-          <Link href="/maps/review">
-            <Button variant="ghost">Review Maps</Button>
+          <>
+           <Link href="/prompts">
+            <Button variant="ghost">Review Prompts</Button>
           </Link>
+           <Link href="/maps/review">
+            <Button variant="ghost">Review Maps</Button>
+          </Link></>
+         
         )}
         {flags?.showTestPage && (
           <Link href="/test">
diff --git a/app/prompts/[promptId]/page.tsx b/app/prompts/[promptId]/page.tsx
new file mode 100644
index 0000000..e3ca053
--- /dev/null
+++ b/app/prompts/[promptId]/page.tsx
@@ -0,0 +1,84 @@
+"use client";
+
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { api } from "@/convex/_generated/api";
+import { useMutation, useQuery } from "convex/react";
+import Link from "next/link";
+import { useRouter } from "next/navigation";
+import { useEffect, useState } from "react";
+
+export default function editPromtPage({
+  params,
+}: {
+  params: { promptId: string };
+}) {
+  const prompt = useQuery(api.prompts.getPromptById, {
+    promptId: params.promptId,
+  });
+  console.log(prompt);
+  const updatePrompt = useMutation(api.prompts.updatePrompt);
+  const isAdmin = useQuery(api.users.isAdmin);
+
+  const [promptName, setPromptName] = useState("");
+  const [promptText, setPromptText] = useState("");
+
+  useEffect(() => {
+    if (prompt) {
+      setPromptName(prompt.promptName);
+      setPromptText(prompt.prompt);
+    }
+  }, [prompt]);
+
+  const handlePromptNameChange = (e: React.ChangeEvent<HTMLInputElement>) => {
+    setPromptName(e.target.value);
+  };
+
+  const handlePromptTextChange = (
+    e: React.ChangeEvent<HTMLTextAreaElement>,
+  ) => {
+    setPromptText(e.target.value);
+  };
+
+  const router = useRouter();
+  const handleSubmit = (e: React.FormEvent<HTMLFormElement>) => {
+    e.preventDefault();
+    if (!prompt) return;
+
+    updatePrompt({ promptId: prompt._id, promptName, prompt: promptText });
+    router.push("/prompts");
+  };
+
+  if (!isAdmin) {
+    redirect("/");
+  }
+
+  return (
+    <div className="container mx-auto min-h-screen pb-24 py-12 gap-8">
+      <form className="py-6 px-6 h-full" onSubmit={handleSubmit}>
+        <div className="flex justify-between mb-4">
+          <h1 className="font-semibold mb-4">Edit your prompt</h1>
+          <div className="flex space-x-4">
+            <Button variant="default">Save</Button>
+            <Link href="/prompts">
+              <Button variant="default">Return</Button>
+            </Link>
+          </div>
+        </div>
+        <div className="flex flex-col items-start space-y-4 min-h-screen h-screen">
+          <Input
+            placeholder="Prompt Name"
+            value={promptName}
+            onChange={handlePromptNameChange}
+          />
+          <textarea
+            placeholder="Prompt"
+            className=" h-full w-full rounded-md border border-input bg-transparent px-3 py-1"
+            value={promptText}
+            onChange={handlePromptTextChange}
+          />
+        </div>
+      </form>
+    </div>
+  );
+}
diff --git a/app/prompts/page.tsx b/app/prompts/page.tsx
new file mode 100644
index 0000000..2b011c5
--- /dev/null
+++ b/app/prompts/page.tsx
@@ -0,0 +1,96 @@
+"use client";
+
+import { Button } from "@/components/ui/button";
+import {
+  Table,
+  TableBody,
+  TableCell,
+  TableHead,
+  TableHeader,
+  TableRow,
+} from "@/components/ui/table";
+import { api } from "@/convex/_generated/api";
+import { useMutation, useQuery } from "convex/react";
+import Link from "next/link";
+import { useRouter, redirect } from "next/navigation";
+
+const Page = () => {
+  const prompts = useQuery(api.prompts.getAllPrompts);
+  const enablePrompt = useMutation(api.prompts.enablePrompt);
+  const deletePrompt = useMutation(api.prompts.deletePrompt);
+  const createPrompt = useMutation(api.prompts.createPrompt);
+
+  const isAdmin = useQuery(api.users.isAdmin);
+
+  const router = useRouter();
+
+  const handleCreatePrompt = async () => {
+    const newPromptId = await createPrompt({
+      promptName: "",
+      prompt: "",
+    });
+    router.push(`/prompts/${newPromptId}`);
+  };
+
+  if (!isAdmin) {
+    redirect("/");
+  }
+
+  return (
+    <div className="container mx-auto min-h-screen py-12 pb-24 gap-8">
+      <div className="flex justify-between mb-4">
+        <h1 className="font-semibold mb-4">Review Prompts</h1>
+        <Button variant="default" onClick={handleCreatePrompt}>
+          Create Prompt
+        </Button>
+      </div>
+      <div className="flex items-center justify-around">
+        <Table>
+          <TableHeader>
+            <TableRow>
+              <TableHead>Prompt Name </TableHead>
+              <TableHead>ID</TableHead>
+              <TableHead>Active</TableHead>
+              <TableHead>Actions</TableHead>
+            </TableRow>
+          </TableHeader>
+          <TableBody>
+            {prompts?.map((row) => (
+              <TableRow key={row._id}>
+                <TableCell>{row.promptName}</TableCell>
+                <TableCell>{row._id}</TableCell>
+                <TableCell>{row.isActive ? "Yes" : "No"}</TableCell>
+                <TableCell className="space-x-4 flex">
+                  <Button
+                    variant="default"
+                    onClick={async () => {
+                      await enablePrompt({ promptId: row._id });
+                    }}
+                  >
+                    Activate
+                  </Button>
+                  <Link
+                    href={`/prompts/${row._id}`}
+                    className="flex items-center"
+                  >
+                    <Button variant="secondary">Edit</Button>
+                  </Link>
+                  <Button
+                    variant="destructive"
+                    onClick={async () => {
+                      await deletePrompt({ promptId: row._id });
+                    }}
+                  >
+                    Delete
+                  </Button>
+                </TableCell>
+              </TableRow>
+            ))}
+          </TableBody>
+        </Table>
+      </div>
+    </div>
+  );
+};
+
+export default Page;
diff --git a/convex/_generated/api.d.ts b/convex/_generated/api.d.ts
index 0b5050f..96013c0 100644
--- a/convex/_generated/api.d.ts
+++ b/convex/_generated/api.d.ts
@@ -26,6 +26,7 @@ import type * as leaderboard from "../leaderboard.js";
 import type * as maps from "../maps.js";
 import type * as models from "../models.js";
 import type * as playerresults from "../playerresults.js";
+import type * as prompts from "../prompts.js";
 import type * as results from "../results.js";
 import type * as scores from "../scores.js";
 import type * as users from "../users.js";
@@ -50,6 +51,7 @@ declare const fullApi: ApiFromModules<{
   maps: typeof maps;
   models: typeof models;
   playerresults: typeof playerresults;
+  prompts: typeof prompts;
   results: typeof results;
   scores: typeof scores;
   users: typeof users;
diff --git a/convex/init.ts b/convex/init.ts
index 93852f5..defa092 100644
--- a/convex/init.ts
+++ b/convex/init.ts
@@ -5,5 +5,6 @@ export default internalMutation({
   handler: async (ctx) => {
     await ctx.runMutation(internal.maps.seedMaps);
     await ctx.runMutation(internal.models.seedModels);
+    await ctx.runMutation(internal.prompts.seedPrompts);
   },
 });
diff --git a/convex/maps.ts b/convex/maps.ts
index 73b0964..78eb4f2 100644
--- a/convex/maps.ts
+++ b/convex/maps.ts
@@ -11,6 +11,7 @@ import { api, internal } from "./_generated/api";
 import { runModel } from "../models";
 import { getAuthUserId } from "@convex-dev/auth/server";
 import { adminMutationBuilder } from "./users";
+import { Prompt } from "./prompts";
 
 const LEVELS = [
   {
@@ -300,9 +301,17 @@ export const playMapAction = internalAction({
       return;
     }
 
+    const activePromptQuery = await ctx.runQuery(api.prompts.getActivePrompt);
+    const activePrompt = activePromptQuery && activePromptQuery.prompt;
+
+    if (!activePrompt) {
+      throw new Error("Active prompt not found");
+    }
+
     const { solution, reasoning, error } = await runModel(
       args.modelId,
       map.grid,
+      activePrompt,
     );
 
     await ctx.runMutation(internal.results.updateResult, {
@@ -322,12 +331,22 @@ export const testMap = action({
   },
   handler: async (ctx, args) => {
     const isAdmin = await ctx.runQuery(api.users.isAdmin);
+    const activePrompt: Prompt  = await ctx.runQuery(api.prompts.getActivePrompt);
+    
 
     if (!isAdmin) {
       throw new Error("Test map is available only for admin");
     }
 
-    return await runModel(args.modelId, args.map);
+    if (!activePrompt) {
+      throw new Error("Active prompt not found");
+    }
+
+    return await runModel(
+      args.modelId,
+      args.map,
+      activePrompt.prompt,
+    );
   },
 });
 
@@ -350,9 +369,16 @@ export const testAIModel = action({
       throw new Error("Map not found");
     }
 
+    const activePrompt: Prompt  = await ctx.runQuery(api.prompts.getActivePrompt);
+
+    if (!activePrompt) {
+      throw new Error("Active prompt not found");
+    }
+
     const { solution, reasoning, error } = await runModel(
       args.modelId,
       map.grid,
+      activePrompt.prompt,
     );
 
     return {
diff --git a/convex/prompts.ts b/convex/prompts.ts
new file mode 100644
index 0000000..a76469e
--- /dev/null
+++ b/convex/prompts.ts
@@ -0,0 +1,186 @@
+import { v } from "convex/values";
+import { internalMutation, mutation, query } from "./_generated/server";
+import { Id } from "./_generated/dataModel";
+
+const defaultPrompt = `
+Your task is to play a game.  We will give you a 2d array of characters that represent the game board.  Before the game starts, you have these two tasks:
+
+1. Place two blocks ("B") in locations which maximize the player's survival.
+2. Place the player ("P") in a location which maximize the player's survival.
+
+# Placing Rules
+- You can not place blocks in locations already used by zombies or rocks.
+- You can not place the player in a location already used by a zombie or rock.
+- You can not place a block over the player or another block.
+- You must place both blocks and the player before starting the game.
+
+# Grid Descriptions
+The 2d Grid is made up of characters, where each character has a meaning.
+" " represents an empty space.
+"Z" represents a zombie.
+"R" represents rocks which zombies can not pass through and path finding will not allow them to go through.
+"P" represents the player, who cannot move. The player's goal is to throw popsickles at zombies before they reach them.
+"B" represents blocks that can be placed before the round begins to hinder the zombies.
+
+# Game Rules
+- The game is turn based.
+- At the start of the turn, the player (P) throws a popsickle at the closest zombie (using euclidean distance).
+- Popsickles deal 1 damage to zombies.
+- A zombie is removed from the game when its health reaches 0.
+- When all zombies are removed, the player wins.
+- If a zombie reaches a player, the player loses.
+
+# Zombie Rules
+- Zombies have 2 health.
+- Zombies can only move horizontally or vertically.
+- Zombies pathfinding will always be in the order of DOWN, LEFT, RIGHT, UP
+- Zombies can't move diagonally.
+- Zombies can't move through rocks.
+- Zombies can't move through each other.
+- Zombies always try to move towards the playing using BFS algorithm.
+
+# Player Rules
+- Players can not move.
+- Players throw one lollipops at the closest zombie at the start of each turn.
+
+# Placement Strategies
+
+- often it's good to wall off between the zombies and players if possible, this will slow the zombies down.
+- You should never put a player directly next to a zombie.
+- You should try to put blocks directly next to players
+- If the player is behind a choke point, blocking the path to the player is the best option.
+
+# Output Format
+
+- Assume a position on the 2d grid is always represented as [ROW, COL].
+- Your output should be a JSON object with the following format:
+
+{
+  "boxCoordinates": [[ROW, COL], [ROW, COL]],
+  "playerCoordinates": [ROW, COL]
+}
+
+## MOST IMPORTANT RULE
+
+- DO NOT TRY TO PUT A BLOCK OR PLAYER IN A LOCATION THAT IS ALREADY OCCUPIED
+
+`;
+
+export type Prompt = {
+  _id: Id<"prompts">;
+  _creationTime: number;
+  promptName: string;
+  prompt: string;
+  isActive: boolean;
+};
+
+export const getActivePrompt = query({
+  args: {},
+  handler: async (ctx): Promise<Prompt> => {
+    const prompt = await ctx.db.query("prompts").withIndex("by_active").first();
+    if (!prompt) {
+      throw new Error("No active prompt found");
+    }
+    return prompt;
+  },
+});
+
+export const getPromptById = query({
+  args: {
+    promptId: v.string(),
+  },
+  handler: async (ctx, args): Promise<Prompt | null> => {
+    const prompt = await ctx.db.query("prompts").filter(q => q.eq(q.field("_id"), args.promptId)).first();
+    return prompt;
+  },
+});
+
+export const getAllPrompts = query({
+  args: {},
+  handler: async (ctx): Promise<Prompt[]> => {
+    const prompts = await ctx.db
+      .query("prompts")
+      .withIndex("by_active")
+      .collect();
+    return prompts;
+  },
+});
+
+export const createPrompt = mutation({
+  args: {
+    promptName: v.string(),
+    prompt: v.string(),
+  },
+  handler: async (ctx, args) => {
+    const newPrompt = await ctx.db.insert("prompts", {
+      promptName: args.promptName,
+      prompt: args.prompt,
+      isActive: false,
+    });
+    return newPrompt;
+  },
+});
+
+export const updatePrompt = mutation({
+  args: {
+    promptId: v.id("prompts"),
+    promptName: v.string(),
+    prompt: v.string(),
+  },
+  handler: async (ctx, args) => {
+    await ctx.db.patch(args.promptId, {
+      prompt: args.prompt,
+      promptName: args.promptName,
+    });
+  },
+});
+
+export const deletePrompt = mutation({
+  args: {
+    promptId: v.id("prompts"),
+  },
+  handler: async (ctx, args) => {
+    await ctx.db.delete(args.promptId);
+  },
+});
+
+export const enablePrompt = mutation({
+  args: {
+    promptId: v.id("prompts"),
+  },
+  handler: async (ctx, args) => {
+    // If there is a currently active prompt, set its isActive field to false
+    const currentActivePrompt = await ctx.db
+      .query("prompts")
+      .filter((q) => q.eq(q.field("isActive"), true))
+      .first();
+
+    if (currentActivePrompt) {
+      await ctx.db.patch(currentActivePrompt._id, { isActive: false });
+    }
+
+    // Then set the new prompt as active
+    const prompt = await ctx.db
+      .query("prompts")
+      .filter((q) => q.eq(q.field("_id"), args.promptId))
+      .first();
+
+    if (!prompt) {
+      throw new Error(`Prompt with ID ${args.promptId} not found`);
+    }
+
+    await ctx.db.patch(prompt._id, { isActive: true });
+  },
+});
+
+export const seedPrompts = internalMutation({
+  args: {},
+  handler: async (ctx) => {
+    // Insert the default prompt into the "prompts" collection and set it as active
+    await ctx.db.insert("prompts", {
+      promptName: "Default Prompt",
+      prompt: defaultPrompt,
+      isActive: true,
+    });
+  },
+});
diff --git a/convex/schema.ts b/convex/schema.ts
index 6cabf20..29f99c1 100644
--- a/convex/schema.ts
+++ b/convex/schema.ts
@@ -19,6 +19,7 @@ export default defineSchema({
   }).index("by_level", ["level"]),
   scores: defineTable({
     modelId: v.string(),
+    promptId: v.id("prompts"),
     score: v.number(),
   }).index("by_modelId", ["modelId"]),
   models: defineTable({
@@ -65,4 +66,9 @@ export default defineSchema({
   admins: defineTable({
     userId: v.id("users"),
   }).index("by_userId", ["userId"]),
+  prompts: defineTable({
+    promptName: v.string(),
+    prompt: v.string(),
+    isActive: v.boolean(),
+  }).index("by_active", ["isActive"]),
 });
diff --git a/convex/scores.ts b/convex/scores.ts
index 92e388b..7f3429d 100644
--- a/convex/scores.ts
+++ b/convex/scores.ts
@@ -1,5 +1,7 @@
 import { v } from "convex/values";
 import { internalMutation } from "./_generated/server";
+import { useQuery } from "convex/react";
+import { api } from "./_generated/api";
 
 export const incrementScore = internalMutation({
   args: {
@@ -11,12 +13,15 @@ export const incrementScore = internalMutation({
       .filter((q) => q.eq(q.field("modelId"), args.modelId))
       .first();
 
-    if (!score) {
+    const activePrompt = useQuery(api.prompts.getActivePrompt);
+
+    if (!score && activePrompt) {
       await ctx.db.insert("scores", {
         modelId: args.modelId,
+        promptId: activePrompt?._id,
         score: 1,
       });
-    } else {
+    } else if (score) {
       await ctx.db.patch(score._id, {
         score: 1,
       });
diff --git a/models/index.ts b/models/index.ts
index 24cec33..8727a9f 100644
--- a/models/index.ts
+++ b/models/index.ts
@@ -14,74 +14,10 @@ export type ModelHandler = (
   reasoning: string;
 }>;
 
-const prompt = `
-
-Your task is to play a game.  We will give you a 2d array of characters that represent the game board.  Before the game starts, you have these two tasks:
-
-1. Place two blocks ("B") in locations which maximize the player's survival.
-2. Place the player ("P") in a location which maximize the player's survival.
-
-# Placing Rules
-- You can not place blocks in locations already used by zombies or rocks.
-- You can not place the player in a location already used by a zombie or rock.
-- You can not place a block over the player or another block.
-- You must place both blocks and the player before starting the game.
-
-# Grid Descriptions
-The 2d Grid is made up of characters, where each character has a meaning.
-" " represents an empty space.
-"Z" represents a zombie.
-"R" represents rocks which zombies can not pass through and path finding will not allow them to go through.
-"P" represents the player, who cannot move. The player's goal is to throw popsickles at zombies before they reach them.
-"B" represents blocks that can be placed before the round begins to hinder the zombies.
-
-# Game Rules
-- The game is turn based.
-- At the start of the turn, the player (P) throws a popsickle at the closest zombie (using euclidean distance).
-- Popsickles deal 1 damage to zombies.
-- A zombie is removed from the game when its health reaches 0.
-- When all zombies are removed, the player wins.
-- If a zombie reaches a player, the player loses.
-
-# Zombie Rules
-- Zombies have 2 health.
-- Zombies can only move horizontally or vertically.
-- Zombies pathfinding will always be in the order of DOWN, LEFT, RIGHT, UP
-- Zombies can't move diagonally.
-- Zombies can't move through rocks.
-- Zombies can't move through each other.
-- Zombies always try to move towards the playing using BFS algorithm.
-
-# Player Rules
-- Players can not move.
-- Players throw one lollipops at the closest zombie at the start of each turn.
-
-# Placement Strategies
-
-- often it's good to wall off between the zombies and players if possible, this will slow the zombies down.
-- You should never put a player directly next to a zombie.
-- You should try to put blocks directly next to players
-- If the player is behind a choke point, blocking the path to the player is the best option.
-
-# Output Format
-
-- Assume a position on the 2d grid is always represented as [ROW, COL].
-- Your output should be a JSON object with the following format:
-
-{
-  "boxCoordinates": [[ROW, COL], [ROW, COL]],
-  "playerCoordinates": [ROW, COL]
-}
-
-## MOST IMPORTANT RULE
-
-- DO NOT TRY TO PUT A BLOCK OR PLAYER IN A LOCATION THAT IS ALREADY OCCUPIED
-
-`;
-
 export async function runModel(
   modelId: string,
   map: string[][],
+  prompt: string,
 ): Promise<{
   solution?: string[][];
   reasoning: string;