diff --git a/src/App.tsx b/src/App.tsx
index dbed6f47f..a9e402281 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -1,4 +1,4 @@
-import { useState, useEffect, useCallback, useRef } from "react";
+import { useEffect, useCallback, useRef } from "react";
 import "./styles/globals.css";
 import { useApp } from "./contexts/AppContext";
 import type { WorkspaceSelection } from "./components/ProjectSidebar";
@@ -22,13 +22,12 @@ import { CommandPalette } from "./components/CommandPalette";
 import { buildCoreSources, type BuildSourcesParams } from "./utils/commands/sources";
 
 import type { ThinkingLevel } from "./types/thinking";
-import type { RuntimeConfig } from "./types/runtime";
 import { CUSTOM_EVENTS } from "./constants/events";
 import { isWorkspaceForkSwitchEvent } from "./utils/workspaceFork";
-import { getThinkingLevelKey, getRuntimeKey } from "./constants/storage";
+import { getThinkingLevelKey } from "./constants/storage";
 import type { BranchListResult } from "./types/ipc";
 import { useTelemetry } from "./hooks/useTelemetry";
-import { parseRuntimeString } from "./utils/chatCommands";
+import { useWorkspaceModal } from "./hooks/useWorkspaceModal";
 
 const THINKING_LEVELS: ThinkingLevel[] = ["off", "low", "medium", "high"];
 
@@ -46,15 +45,6 @@ function AppInner() {
     selectedWorkspace,
     setSelectedWorkspace,
   } = useApp();
-  const [workspaceModalOpen, setWorkspaceModalOpen] = useState(false);
-  const [workspaceModalProject, setWorkspaceModalProject] = useState<string | null>(null);
-  const [workspaceModalProjectName, setWorkspaceModalProjectName] = useState<string>("");
-  const [workspaceModalBranches, setWorkspaceModalBranches] = useState<string[]>([]);
-  const [workspaceModalDefaultTrunk, setWorkspaceModalDefaultTrunk] = useState<string | undefined>(
-    undefined
-  );
-  const [workspaceModalLoadError, setWorkspaceModalLoadError] = useState<string | null>(null);
-  const workspaceModalProjectRef = useRef<string | null>(null);
 
   // Auto-collapse sidebar on mobile by default
   const isMobile = typeof window !== "undefined" && window.innerWidth <= 768;
@@ -70,6 +60,13 @@ function AppInner() {
   // Get workspace store for command palette
   const workspaceStore = useWorkspaceStoreRaw();
 
+  // Workspace modal management
+  const workspaceModal = useWorkspaceModal({
+    createWorkspace,
+    setSelectedWorkspace,
+    telemetry,
+  });
+
   // Wrapper for setSelectedWorkspace that tracks telemetry
   const handleWorkspaceSwitch = useCallback(
     (newWorkspace: WorkspaceSelection | null) => {
@@ -175,108 +172,6 @@ function AppInner() {
     [removeProject, selectedWorkspace, setSelectedWorkspace]
   );
 
-  const handleAddWorkspace = useCallback(async (projectPath: string) => {
-    const projectName = projectPath.split("/").pop() ?? projectPath.split("\\").pop() ?? "project";
-
-    workspaceModalProjectRef.current = projectPath;
-    setWorkspaceModalProject(projectPath);
-    setWorkspaceModalProjectName(projectName);
-    setWorkspaceModalBranches([]);
-    setWorkspaceModalDefaultTrunk(undefined);
-    setWorkspaceModalLoadError(null);
-    setWorkspaceModalOpen(true);
-
-    try {
-      const branchResult = await window.api.projects.listBranches(projectPath);
-
-      // Guard against race condition: only update state if this is still the active project
-      if (workspaceModalProjectRef.current !== projectPath) {
-        return;
-      }
-
-      const sanitizedBranches = Array.isArray(branchResult?.branches)
-        ? branchResult.branches.filter((branch): branch is string => typeof branch === "string")
-        : [];
-
-      const recommended =
-        typeof branchResult?.recommendedTrunk === "string" &&
-        sanitizedBranches.includes(branchResult.recommendedTrunk)
-          ? branchResult.recommendedTrunk
-          : sanitizedBranches[0];
-
-      setWorkspaceModalBranches(sanitizedBranches);
-      setWorkspaceModalDefaultTrunk(recommended);
-      setWorkspaceModalLoadError(null);
-    } catch (err) {
-      console.error("Failed to load branches for modal:", err);
-      const message = err instanceof Error ? err.message : "Unknown error";
-      setWorkspaceModalLoadError(
-        `Unable to load branches automatically: ${message}. You can still enter the trunk branch manually.`
-      );
-    }
-  }, []);
-
-  // Memoize callbacks to prevent LeftSidebar/ProjectSidebar re-renders
-  const handleAddProjectCallback = useCallback(() => {
-    void addProject();
-  }, [addProject]);
-
-  const handleAddWorkspaceCallback = useCallback(
-    (projectPath: string) => {
-      void handleAddWorkspace(projectPath);
-    },
-    [handleAddWorkspace]
-  );
-
-  const handleRemoveProjectCallback = useCallback(
-    (path: string) => {
-      void handleRemoveProject(path);
-    },
-    [handleRemoveProject]
-  );
-
-  const handleCreateWorkspace = async (
-    branchName: string,
-    trunkBranch: string,
-    runtime?: string
-  ) => {
-    if (!workspaceModalProject) return;
-
-    console.assert(
-      typeof trunkBranch === "string" && trunkBranch.trim().length > 0,
-      "Expected trunk branch to be provided by the workspace modal"
-    );
-
-    // Parse runtime config if provided
-    let runtimeConfig: RuntimeConfig | undefined;
-    if (runtime) {
-      try {
-        runtimeConfig = parseRuntimeString(runtime, branchName);
-      } catch (err) {
-        console.error("Failed to parse runtime config:", err);
-        throw err; // Let modal handle the error
-      }
-    }
-
-    const newWorkspace = await createWorkspace(
-      workspaceModalProject,
-      branchName,
-      trunkBranch,
-      runtimeConfig
-    );
-    if (newWorkspace) {
-      // Track workspace creation
-      telemetry.workspaceCreated(newWorkspace.workspaceId);
-      setSelectedWorkspace(newWorkspace);
-
-      // Save runtime preference for this project if provided
-      if (runtime) {
-        const runtimeKey = getRuntimeKey(workspaceModalProject);
-        localStorage.setItem(runtimeKey, runtime);
-      }
-    }
-  };
-
   const handleGetSecrets = useCallback(async (projectPath: string) => {
     return await window.api.projects.secrets.get(projectPath);
   }, []);
@@ -425,13 +320,13 @@ function AppInner() {
     }
   }, []);
 
-  const registerParamsRef = useRef<BuildSourcesParams | null>(null);
+  const registerParamsRef = useRef<BuildSourcesParams>({} as BuildSourcesParams);
 
   const openNewWorkspaceFromPalette = useCallback(
     (projectPath: string) => {
-      void handleAddWorkspace(projectPath);
+      void workspaceModal.openModal(projectPath);
     },
-    [handleAddWorkspace]
+    [workspaceModal]
   );
 
   const getBranchesForProject = useCallback(
@@ -514,8 +409,7 @@ function AppInner() {
 
   useEffect(() => {
     const unregister = registerSource(() => {
-      const params = registerParamsRef.current;
-      if (!params) return [];
+      const params: BuildSourcesParams = registerParamsRef.current;
 
       // Compute streaming models here (only when command palette opens)
       const allStates = workspaceStore.getAllStates();
@@ -615,14 +509,38 @@ function AppInner() {
       );
   }, [projects, setSelectedWorkspace, setWorkspaceMetadata]);
 
+  // Handle open new workspace modal event
+  useEffect(() => {
+    const handleOpenNewWorkspaceModal = (e: Event) => {
+      const customEvent = e as CustomEvent<{
+        projectPath: string;
+        startMessage?: string;
+        model?: string;
+        error?: string;
+      }>;
+      const { projectPath, startMessage, model, error } = customEvent.detail;
+      void workspaceModal.openModal(projectPath, { startMessage, model, error });
+    };
+
+    window.addEventListener(
+      CUSTOM_EVENTS.OPEN_NEW_WORKSPACE_MODAL,
+      handleOpenNewWorkspaceModal as EventListener
+    );
+    return () =>
+      window.removeEventListener(
+        CUSTOM_EVENTS.OPEN_NEW_WORKSPACE_MODAL,
+        handleOpenNewWorkspaceModal as EventListener
+      );
+  }, [workspaceModal]);
+
   return (
     <>
       <div className="bg-bg-dark flex h-screen overflow-hidden [@media(max-width:768px)]:flex-col">
         <LeftSidebar
           onSelectWorkspace={handleWorkspaceSwitch}
-          onAddProject={handleAddProjectCallback}
-          onAddWorkspace={handleAddWorkspaceCallback}
-          onRemoveProject={handleRemoveProjectCallback}
+          onAddProject={() => void addProject()}
+          onAddWorkspace={(path) => void workspaceModal.openModal(path)}
+          onRemoveProject={(path) => void handleRemoveProject(path)}
           lastReadTimestamps={lastReadTimestamps}
           onToggleUnread={onToggleUnread}
           collapsed={sidebarCollapsed}
@@ -674,24 +592,18 @@ function AppInner() {
             workspaceId: selectedWorkspace?.workspaceId,
           })}
         />
-        {workspaceModalOpen && workspaceModalProject && (
+        {workspaceModal.state.isOpen && workspaceModal.state.projectPath && (
           <NewWorkspaceModal
-            isOpen={workspaceModalOpen}
-            projectName={workspaceModalProjectName}
-            projectPath={workspaceModalProject}
-            branches={workspaceModalBranches}
-            defaultTrunkBranch={workspaceModalDefaultTrunk}
-            loadErrorMessage={workspaceModalLoadError}
-            onClose={() => {
-              workspaceModalProjectRef.current = null;
-              setWorkspaceModalOpen(false);
-              setWorkspaceModalProject(null);
-              setWorkspaceModalProjectName("");
-              setWorkspaceModalBranches([]);
-              setWorkspaceModalDefaultTrunk(undefined);
-              setWorkspaceModalLoadError(null);
-            }}
-            onAdd={handleCreateWorkspace}
+            isOpen={workspaceModal.state.isOpen}
+            projectName={workspaceModal.state.projectName}
+            projectPath={workspaceModal.state.projectPath}
+            branches={workspaceModal.state.branches}
+            defaultTrunkBranch={workspaceModal.state.defaultTrunk}
+            loadErrorMessage={workspaceModal.state.loadError}
+            initialStartMessage={workspaceModal.state.startMessage}
+            initialModel={workspaceModal.state.model}
+            onClose={workspaceModal.closeModal}
+            onAdd={workspaceModal.handleCreate}
           />
         )}
         <DirectorySelectModal />
diff --git a/src/components/NewWorkspaceModal.tsx b/src/components/NewWorkspaceModal.tsx
index 9b1d7e51f..534e157ba 100644
--- a/src/components/NewWorkspaceModal.tsx
+++ b/src/components/NewWorkspaceModal.tsx
@@ -12,8 +12,16 @@ interface NewWorkspaceModalProps {
   branches: string[];
   defaultTrunkBranch?: string;
   loadErrorMessage?: string | null;
+  initialStartMessage?: string;
+  initialModel?: string;
   onClose: () => void;
-  onAdd: (branchName: string, trunkBranch: string, runtime?: string) => Promise<void>;
+  onAdd: (
+    branchName: string,
+    trunkBranch: string,
+    runtime?: string,
+    startMessage?: string,
+    model?: string
+  ) => Promise<void>;
 }
 
 // Shared form field styles
@@ -27,11 +35,14 @@ const NewWorkspaceModal: React.FC<NewWorkspaceModalProps> = ({
   branches,
   defaultTrunkBranch,
   loadErrorMessage,
+  initialStartMessage,
+  initialModel,
   onClose,
   onAdd,
 }) => {
   const [branchName, setBranchName] = useState("");
   const [trunkBranch, setTrunkBranch] = useState(defaultTrunkBranch ?? branches[0] ?? "");
+  const [startMessage, setStartMessage] = useState(initialStartMessage ?? "");
   const [isLoading, setIsLoading] = useState(false);
   const [error, setError] = useState<string | null>(null);
   const infoId = useId();
@@ -41,10 +52,22 @@ const NewWorkspaceModal: React.FC<NewWorkspaceModalProps> = ({
   const [runtimeOptions, setRuntimeOptions] = useNewWorkspaceOptions(projectPath);
   const { runtimeMode, sshHost, getRuntimeString } = runtimeOptions;
 
+  // Reset form to initial state
+  const resetForm = () => {
+    setBranchName("");
+    setTrunkBranch(defaultTrunkBranch ?? branches[0] ?? "");
+    setRuntimeOptions(RUNTIME_MODE.LOCAL, "");
+    setStartMessage("");
+  };
+
   useEffect(() => {
     setError(loadErrorMessage ?? null);
   }, [loadErrorMessage]);
 
+  useEffect(() => {
+    setStartMessage(initialStartMessage ?? "");
+  }, [initialStartMessage]);
+
   useEffect(() => {
     const fallbackTrunk = defaultTrunkBranch ?? branches[0] ?? "";
     setTrunkBranch((current) => {
@@ -63,9 +86,7 @@ const NewWorkspaceModal: React.FC<NewWorkspaceModalProps> = ({
   }, [branches, defaultTrunkBranch, hasBranches]);
 
   const handleCancel = () => {
-    setBranchName("");
-    setTrunkBranch(defaultTrunkBranch ?? branches[0] ?? "");
-    setRuntimeOptions(RUNTIME_MODE.LOCAL, "");
+    resetForm();
     setError(loadErrorMessage ?? null);
     onClose();
   };
@@ -104,11 +125,16 @@ const NewWorkspaceModal: React.FC<NewWorkspaceModalProps> = ({
     try {
       // Get runtime string from hook helper
       const runtime = getRuntimeString();
+      const trimmedStartMessage = startMessage.trim();
 
-      await onAdd(trimmedBranchName, normalizedTrunkBranch, runtime);
-      setBranchName("");
-      setTrunkBranch(defaultTrunkBranch ?? branches[0] ?? "");
-      setRuntimeOptions(RUNTIME_MODE.LOCAL, "");
+      await onAdd(
+        trimmedBranchName,
+        normalizedTrunkBranch,
+        runtime,
+        trimmedStartMessage || undefined,
+        initialModel
+      );
+      resetForm();
       onClose();
     } catch (err) {
       const message = err instanceof Error ? err.message : "Failed to create workspace";
@@ -243,6 +269,19 @@ const NewWorkspaceModal: React.FC<NewWorkspaceModalProps> = ({
           </div>
         )}
 
+        {initialStartMessage && (
+          <div className="[&_label]:text-foreground [&_textarea]:bg-modal-bg [&_textarea]:border-border-medium [&_textarea]:focus:border-accent mb-5 [&_label]:mb-2 [&_label]:block [&_label]:text-sm [&_textarea]:min-h-[80px] [&_textarea]:w-full [&_textarea]:resize-y [&_textarea]:rounded [&_textarea]:border [&_textarea]:px-3 [&_textarea]:py-2 [&_textarea]:text-sm [&_textarea]:text-white [&_textarea]:focus:outline-none [&_textarea]:disabled:cursor-not-allowed [&_textarea]:disabled:opacity-60">
+            <label htmlFor="startMessage">Start Message (optional):</label>
+            <textarea
+              id="startMessage"
+              value={startMessage}
+              onChange={(event) => setStartMessage(event.target.value)}
+              disabled={isLoading}
+              placeholder="Enter a message to send after creating the workspace..."
+            />
+          </div>
+        )}
+
         <ModalInfo id={infoId}>
           <p>This will create a workspace at:</p>
           <code className="block break-all">
@@ -259,6 +298,7 @@ const NewWorkspaceModal: React.FC<NewWorkspaceModalProps> = ({
               {formatNewCommand(
                 branchName.trim(),
                 trunkBranch.trim() || undefined,
+                startMessage.trim() || undefined,
                 getRuntimeString()
               )}
             </div>
diff --git a/src/constants/events.ts b/src/constants/events.ts
index 9f91f2e59..e8900be15 100644
--- a/src/constants/events.ts
+++ b/src/constants/events.ts
@@ -46,6 +46,12 @@ export const CUSTOM_EVENTS = {
    * Detail: { commandId: string }
    */
   EXECUTE_COMMAND: "cmux:executeCommand",
+
+  /**
+   * Event to open the new workspace modal with initial data
+   * Detail: { projectPath: string, startMessage?: string, model?: string, error?: string }
+   */
+  OPEN_NEW_WORKSPACE_MODAL: "cmux:openNewWorkspaceModal",
 } as const;
 
 /**
diff --git a/src/hooks/useWorkspaceModal.ts b/src/hooks/useWorkspaceModal.ts
new file mode 100644
index 000000000..87b7d680c
--- /dev/null
+++ b/src/hooks/useWorkspaceModal.ts
@@ -0,0 +1,184 @@
+import { useState, useCallback, useRef } from "react";
+import type { RuntimeConfig } from "@/types/runtime";
+import { getRuntimeKey } from "@/constants/storage";
+import { parseRuntimeString } from "@/utils/chatCommands";
+import type { WorkspaceSelection } from "@/components/ProjectSidebar";
+
+interface WorkspaceModalState {
+  isOpen: boolean;
+  projectPath: string | null;
+  projectName: string;
+  branches: string[];
+  defaultTrunk: string | undefined;
+  loadError: string | null;
+  startMessage: string | undefined;
+  model: string | undefined;
+}
+
+const INITIAL_STATE: WorkspaceModalState = {
+  isOpen: false,
+  projectPath: null,
+  projectName: "",
+  branches: [],
+  defaultTrunk: undefined,
+  loadError: null,
+  startMessage: undefined,
+  model: undefined,
+};
+
+interface UseWorkspaceModalOptions {
+  createWorkspace: (
+    projectPath: string,
+    branchName: string,
+    trunkBranch: string,
+    runtimeConfig?: RuntimeConfig
+  ) => Promise<WorkspaceSelection>;
+  setSelectedWorkspace: (workspace: WorkspaceSelection) => void;
+  telemetry: {
+    workspaceCreated: (workspaceId: string) => void;
+  };
+}
+
+export function useWorkspaceModal({
+  createWorkspace,
+  setSelectedWorkspace,
+  telemetry,
+}: UseWorkspaceModalOptions) {
+  const [state, setState] = useState<WorkspaceModalState>(INITIAL_STATE);
+  const projectRef = useRef<string | null>(null);
+
+  const openModal = useCallback(
+    async (
+      projectPath: string,
+      initialData?: { startMessage?: string; model?: string; error?: string }
+    ) => {
+      const projectName =
+        projectPath.split("/").pop() ?? projectPath.split("\\").pop() ?? "project";
+
+      projectRef.current = projectPath;
+      setState({
+        isOpen: true,
+        projectPath,
+        projectName,
+        branches: [],
+        defaultTrunk: undefined,
+        loadError: initialData?.error ?? null,
+        startMessage: initialData?.startMessage,
+        model: initialData?.model,
+      });
+
+      try {
+        const branchResult = await window.api.projects.listBranches(projectPath);
+
+        // Guard against race condition: only update state if this is still the active project
+        if (projectRef.current !== projectPath) {
+          return;
+        }
+
+        const sanitizedBranches = Array.isArray(branchResult?.branches)
+          ? branchResult.branches.filter((branch): branch is string => typeof branch === "string")
+          : [];
+
+        const recommended =
+          typeof branchResult?.recommendedTrunk === "string" &&
+          sanitizedBranches.includes(branchResult.recommendedTrunk)
+            ? branchResult.recommendedTrunk
+            : sanitizedBranches[0];
+
+        setState((prev) => ({
+          ...prev,
+          branches: sanitizedBranches,
+          defaultTrunk: recommended,
+          loadError: null,
+        }));
+      } catch (err) {
+        console.error("Failed to load branches for modal:", err);
+        const message = err instanceof Error ? err.message : "Unknown error";
+        setState((prev) => ({
+          ...prev,
+          loadError: `Unable to load branches automatically: ${message}. You can still enter the trunk branch manually.`,
+        }));
+      }
+    },
+    []
+  );
+
+  const closeModal = useCallback(() => {
+    projectRef.current = null;
+    setState(INITIAL_STATE);
+  }, []);
+
+  const handleCreate = useCallback(
+    async (
+      branchName: string,
+      trunkBranch: string,
+      runtime?: string,
+      startMessage?: string,
+      model?: string
+    ) => {
+      if (!state.projectPath) return;
+
+      console.assert(
+        typeof trunkBranch === "string" && trunkBranch.trim().length > 0,
+        "Expected trunk branch to be provided by the workspace modal"
+      );
+
+      // Parse runtime config if provided
+      let runtimeConfig: RuntimeConfig | undefined;
+      if (runtime) {
+        try {
+          runtimeConfig = parseRuntimeString(runtime, branchName);
+        } catch (err) {
+          console.error("Failed to parse runtime config:", err);
+          throw err; // Let modal handle the error
+        }
+      }
+
+      const newWorkspace = await createWorkspace(
+        state.projectPath,
+        branchName,
+        trunkBranch,
+        runtimeConfig
+      );
+      if (newWorkspace) {
+        // Track workspace creation
+        telemetry.workspaceCreated(newWorkspace.workspaceId);
+        setSelectedWorkspace(newWorkspace);
+
+        // Save runtime preference for this project if provided
+        if (runtime) {
+          const runtimeKey = getRuntimeKey(state.projectPath);
+          localStorage.setItem(runtimeKey, runtime);
+        }
+
+        // Send start message if provided
+        if (startMessage) {
+          // Build send message options - use provided model or default
+          const { buildSendMessageOptions } = await import("@/hooks/useSendMessageOptions");
+          const sendOptions = buildSendMessageOptions(newWorkspace.workspaceId);
+
+          if (model) {
+            sendOptions.model = model;
+          }
+
+          // Defer until React finishes rendering and WorkspaceStore subscribes
+          requestAnimationFrame(() => {
+            void window.api.workspace.sendMessage(
+              newWorkspace.workspaceId,
+              startMessage,
+              sendOptions
+            );
+          });
+        }
+      }
+    },
+    [state.projectPath, createWorkspace, telemetry, setSelectedWorkspace]
+  );
+
+  return {
+    state,
+    openModal,
+    closeModal,
+    handleCreate,
+  };
+}
diff --git a/src/utils/chatCommands.ts b/src/utils/chatCommands.ts
index 710bcb7a9..443172f37 100644
--- a/src/utils/chatCommands.ts
+++ b/src/utils/chatCommands.ts
@@ -70,6 +70,7 @@ export interface CreateWorkspaceOptions {
   trunkBranch?: string;
   runtime?: string;
   startMessage?: string;
+  model?: string;
   sendMessageOptions?: SendMessageOptions;
 }
 
@@ -130,12 +131,13 @@ export async function createNewWorkspace(
 
   // If there's a start message, defer until React finishes rendering and WorkspaceStore subscribes
   if (options.startMessage && options.sendMessageOptions) {
+    const sendOptions = { ...options.sendMessageOptions };
+    // Apply model override if provided
+    if (options.model) {
+      sendOptions.model = options.model;
+    }
     requestAnimationFrame(() => {
-      void window.api.workspace.sendMessage(
-        result.metadata.id,
-        options.startMessage!,
-        options.sendMessageOptions
-      );
+      void window.api.workspace.sendMessage(result.metadata.id, options.startMessage!, sendOptions);
     });
   }
 
@@ -302,11 +304,26 @@ export async function handleNewCommand(
 ): Promise<CommandHandlerResult> {
   const { workspaceId, sendMessageOptions, setInput, setIsSending, setToast } = context;
 
+  // Get workspace info to extract projectPath (needed for both cases)
+  const workspaceInfo = await window.api.workspace.getInfo(workspaceId);
+  if (!workspaceInfo) {
+    setToast({
+      id: Date.now().toString(),
+      type: "error",
+      message: "Failed to get workspace info",
+    });
+    return { clearInput: false, toastShown: true };
+  }
+
   // Open modal if no workspace name provided
   if (!parsed.workspaceName) {
     setInput("");
-    const event = new CustomEvent(CUSTOM_EVENTS.EXECUTE_COMMAND, {
-      detail: { commandId: "ws:new" },
+    const event = new CustomEvent(CUSTOM_EVENTS.OPEN_NEW_WORKSPACE_MODAL, {
+      detail: {
+        projectPath: workspaceInfo.projectPath,
+        startMessage: parsed.startMessage,
+        model: parsed.model,
+      },
     });
     window.dispatchEvent(event);
     return { clearInput: true, toastShown: false };
@@ -316,31 +333,30 @@ export async function handleNewCommand(
   setIsSending(true);
 
   try {
-    // Get workspace info to extract projectPath
-    const workspaceInfo = await window.api.workspace.getInfo(workspaceId);
-    if (!workspaceInfo) {
-      throw new Error("Failed to get workspace info");
-    }
-
     const createResult = await createNewWorkspace({
       projectPath: workspaceInfo.projectPath,
       workspaceName: parsed.workspaceName,
       trunkBranch: parsed.trunkBranch,
       runtime: parsed.runtime,
       startMessage: parsed.startMessage,
+      model: parsed.model,
       sendMessageOptions,
     });
 
     if (!createResult.success) {
       const errorMsg = createResult.error ?? "Failed to create workspace";
       console.error("Failed to create workspace:", errorMsg);
-      setToast({
-        id: Date.now().toString(),
-        type: "error",
-        title: "Create Failed",
-        message: errorMsg,
+      // Open modal with error and preserve data
+      const event = new CustomEvent(CUSTOM_EVENTS.OPEN_NEW_WORKSPACE_MODAL, {
+        detail: {
+          projectPath: workspaceInfo.projectPath,
+          startMessage: parsed.startMessage,
+          model: parsed.model,
+          error: errorMsg,
+        },
       });
-      return { clearInput: false, toastShown: true };
+      window.dispatchEvent(event);
+      return { clearInput: true, toastShown: false };
     }
 
     setToast({
@@ -352,13 +368,17 @@ export async function handleNewCommand(
   } catch (error) {
     const errorMsg = error instanceof Error ? error.message : "Failed to create workspace";
     console.error("Create error:", error);
-    setToast({
-      id: Date.now().toString(),
-      type: "error",
-      title: "Create Failed",
-      message: errorMsg,
+    // Open modal with error and preserve data
+    const event = new CustomEvent(CUSTOM_EVENTS.OPEN_NEW_WORKSPACE_MODAL, {
+      detail: {
+        projectPath: workspaceInfo.projectPath,
+        startMessage: parsed.startMessage,
+        model: parsed.model,
+        error: errorMsg,
+      },
     });
-    return { clearInput: false, toastShown: true };
+    window.dispatchEvent(event);
+    return { clearInput: true, toastShown: false };
   } finally {
     setIsSending(false);
   }
diff --git a/src/utils/slashCommands/new.test.ts b/src/utils/slashCommands/new.test.ts
index d0f46bdb9..f7a9a4876 100644
--- a/src/utils/slashCommands/new.test.ts
+++ b/src/utils/slashCommands/new.test.ts
@@ -8,6 +8,7 @@ describe("/new command", () => {
       workspaceName: undefined,
       trunkBranch: undefined,
       startMessage: undefined,
+      model: undefined,
     });
   });
 
@@ -18,6 +19,7 @@ describe("/new command", () => {
       workspaceName: "feature-branch",
       trunkBranch: undefined,
       startMessage: undefined,
+      model: undefined,
     });
   });
 
@@ -28,6 +30,7 @@ describe("/new command", () => {
       workspaceName: "feature-branch",
       trunkBranch: "main",
       startMessage: undefined,
+      model: undefined,
     });
   });
 
@@ -38,6 +41,7 @@ describe("/new command", () => {
       workspaceName: "feature-branch",
       trunkBranch: undefined,
       startMessage: "Start implementing feature X",
+      model: undefined,
     });
   });
 
@@ -48,6 +52,7 @@ describe("/new command", () => {
       workspaceName: "feature-branch",
       trunkBranch: "main",
       startMessage: "Start implementing feature X",
+      model: undefined,
     });
   });
 
@@ -58,6 +63,7 @@ describe("/new command", () => {
       workspaceName: "feature-branch",
       trunkBranch: undefined,
       startMessage: "Line 1\nLine 2\nLine 3",
+      model: undefined,
     });
   });
 
@@ -68,6 +74,7 @@ describe("/new command", () => {
       workspaceName: undefined,
       trunkBranch: undefined,
       startMessage: undefined,
+      model: undefined,
     });
   });
 
@@ -78,6 +85,7 @@ describe("/new command", () => {
       workspaceName: "my feature",
       trunkBranch: undefined,
       startMessage: undefined,
+      model: undefined,
     });
   });
 
@@ -88,6 +96,7 @@ describe("/new command", () => {
       workspaceName: undefined,
       trunkBranch: undefined,
       startMessage: undefined,
+      model: undefined,
     });
   });
 
@@ -98,6 +107,7 @@ describe("/new command", () => {
       workspaceName: "feature-branch",
       trunkBranch: "release/v1.0",
       startMessage: undefined,
+      model: undefined,
     });
   });
 
@@ -108,6 +118,62 @@ describe("/new command", () => {
       workspaceName: "feature-branch",
       trunkBranch: "main",
       startMessage: undefined,
+      model: undefined,
+    });
+  });
+
+  it("should parse /new with -m flag (model)", () => {
+    const result = parseCommand("/new feature-branch -m sonnet");
+    expect(result).toEqual({
+      type: "new",
+      workspaceName: "feature-branch",
+      trunkBranch: undefined,
+      startMessage: undefined,
+      model: "anthropic:claude-sonnet-4-5", // Resolves abbreviation
+    });
+  });
+
+  it("should parse /new with -m flag (full model name)", () => {
+    const result = parseCommand("/new feature-branch -m anthropic:claude-opus-4-1");
+    expect(result).toEqual({
+      type: "new",
+      workspaceName: "feature-branch",
+      trunkBranch: undefined,
+      startMessage: undefined,
+      model: "anthropic:claude-opus-4-1",
+    });
+  });
+
+  it("should parse /new with both -t and -m flags", () => {
+    const result = parseCommand("/new feature-branch -t main -m haiku");
+    expect(result).toEqual({
+      type: "new",
+      workspaceName: "feature-branch",
+      trunkBranch: "main",
+      startMessage: undefined,
+      model: "anthropic:claude-haiku-4-5", // Resolves abbreviation
+    });
+  });
+
+  it("should parse /new with -m, -t, and start message", () => {
+    const result = parseCommand("/new feature-branch -m sonnet -t main\nImplement feature X");
+    expect(result).toEqual({
+      type: "new",
+      workspaceName: "feature-branch",
+      trunkBranch: "main",
+      startMessage: "Implement feature X",
+      model: "anthropic:claude-sonnet-4-5",
+    });
+  });
+
+  it("should return undefined workspaceName for unknown flag with -m", () => {
+    const result = parseCommand("/new feature-branch -m sonnet -x invalid");
+    expect(result).toEqual({
+      type: "new",
+      workspaceName: undefined,
+      trunkBranch: undefined,
+      startMessage: undefined,
+      model: undefined,
     });
   });
 });
diff --git a/src/utils/slashCommands/registry.ts b/src/utils/slashCommands/registry.ts
index 9e16651c7..65e433fa5 100644
--- a/src/utils/slashCommands/registry.ts
+++ b/src/utils/slashCommands/registry.ts
@@ -493,7 +493,7 @@ const forkCommandDefinition: SlashCommandDefinition = {
 const newCommandDefinition: SlashCommandDefinition = {
   key: "new",
   description:
-    "Create new workspace with optional trunk branch and runtime. Use -t <branch> to specify trunk, -r <runtime> for remote execution (e.g., 'ssh hostname' or 'ssh user@host'). Add start message on lines after the command.",
+    "Create new workspace with optional trunk branch, model, and runtime. Use -t <branch> to specify trunk, -m <model> to set initial model, -r <runtime> for remote execution (e.g., 'ssh hostname' or 'ssh user@host'). Add start message on lines after the command.",
   handler: ({ rawInput }): ParsedCommand => {
     const {
       tokens: firstLineTokens,
@@ -503,7 +503,7 @@ const newCommandDefinition: SlashCommandDefinition = {
 
     // Parse flags from first line using minimist
     const parsed = minimist(firstLineTokens, {
-      string: ["t", "r"],
+      string: ["t", "m", "r"],
       unknown: (arg: string) => {
         // Unknown flags starting with - are errors
         if (arg.startsWith("-")) {
@@ -515,7 +515,7 @@ const newCommandDefinition: SlashCommandDefinition = {
 
     // Check for unknown flags - return undefined workspaceName to open modal
     const unknownFlags = firstLineTokens.filter(
-      (token) => token.startsWith("-") && token !== "-t" && token !== "-r"
+      (token) => token.startsWith("-") && token !== "-t" && token !== "-m" && token !== "-r"
     );
     if (unknownFlags.length > 0) {
       return {
@@ -524,6 +524,7 @@ const newCommandDefinition: SlashCommandDefinition = {
         trunkBranch: undefined,
         runtime: undefined,
         startMessage: undefined,
+        model: undefined,
       };
     }
 
@@ -535,6 +536,7 @@ const newCommandDefinition: SlashCommandDefinition = {
         trunkBranch: undefined,
         runtime: undefined,
         startMessage: undefined,
+        model: undefined,
       };
     }
 
@@ -549,6 +551,7 @@ const newCommandDefinition: SlashCommandDefinition = {
         trunkBranch: undefined,
         runtime: undefined,
         startMessage: undefined,
+        model: undefined,
       };
     }
 
@@ -564,12 +567,21 @@ const newCommandDefinition: SlashCommandDefinition = {
       runtime = parsed.r.trim();
     }
 
+    // Handle -m (model) flag: resolve abbreviation if present, otherwise use as-is
+    let model: string | undefined;
+    if (parsed.m !== undefined && typeof parsed.m === "string" && parsed.m.trim().length > 0) {
+      const modelInput = parsed.m.trim();
+      // Check if it's an abbreviation
+      model = MODEL_ABBREVIATIONS[modelInput] ?? modelInput;
+    }
+
     return {
       type: "new",
       workspaceName,
       trunkBranch,
       runtime,
       startMessage: remainingLines,
+      model,
     };
   },
 };
diff --git a/src/utils/slashCommands/types.ts b/src/utils/slashCommands/types.ts
index 408fc2a8b..1bd9aa15a 100644
--- a/src/utils/slashCommands/types.ts
+++ b/src/utils/slashCommands/types.ts
@@ -29,6 +29,7 @@ export type ParsedCommand =
       trunkBranch?: string;
       runtime?: string;
       startMessage?: string;
+      model?: string;
     }
   | { type: "unknown-command"; command: string; subcommand?: string }
   | null;