diff --git a/TODO.md b/TODO.md
new file mode 100644
index 0000000000000000000000000000000000000000..d5d1b5df1aa407711ad213e434ee0f9f7c6d305d
--- /dev/null
+++ b/TODO.md
@@ -0,0 +1,10 @@
+- [ ] Folder picker for new projects
+- [ ] Projects should be persisted so they're still visible after closing
+- [ ] Remove model selection from project creation
+- [ ] First message vanishes when thread is created?? Awful ux
+- [ ] Show more clearly when thinking is happening
+
+## Bigger overhauls
+
+- [ ] Markdown rendering
+- [ ] Code block rendering
diff --git a/apps/desktop/src/codexAppServerManager.ts b/apps/desktop/src/codexAppServerManager.ts
index 442bd5314467cc6dc7f1b17aa2003e04a7949f0c..ee099d0ea519cacd42ab92ef8c4a82f66f24a6f0 100644
--- a/apps/desktop/src/codexAppServerManager.ts
+++ b/apps/desktop/src/codexAppServerManager.ts
@@ -5,6 +5,7 @@ import readline from "node:readline";
 
 import type {
   ProviderEvent,
+  ProviderModel,
   ProviderSendTurnInput,
   ProviderSession,
   ProviderSessionStartInput,
@@ -197,7 +198,11 @@ export class CodexAppServerManager extends EventEmitter<CodexAppServerManagerEve
       throw new Error("Session is missing a thread id.");
     }
 
-    const response = await this.sendRequest(context, "turn/start", {
+    const turnStartParams: {
+      threadId: string;
+      input: Array<{ type: "text"; text: string; text_elements: [] }>;
+      model?: string;
+    } = {
       threadId: context.session.threadId,
       input: [
         {
@@ -206,7 +211,16 @@ export class CodexAppServerManager extends EventEmitter<CodexAppServerManagerEve
           text_elements: [],
         },
       ],
-    });
+    };
+    if (input.model) {
+      turnStartParams.model = input.model;
+    }
+
+    const response = await this.sendRequest(
+      context,
+      "turn/start",
+      turnStartParams,
+    );
 
     const turn = this.readObject(this.readObject(response), "turn");
     const turnId = this.readString(turn, "id");
@@ -225,6 +239,177 @@ export class CodexAppServerManager extends EventEmitter<CodexAppServerManagerEve
     };
   }
 
+  async listModels(cwd?: string): Promise<ProviderModel[]> {
+    const child = spawn("codex", ["app-server"], {
+      cwd,
+      env: process.env,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    const output = readline.createInterface({ input: child.stdout });
+    const pending = new Map<PendingRequestKey, PendingRequest>();
+    let nextRequestId = 1;
+    let exited = false;
+    let exitError: Error | null = null;
+
+    const cleanup = () => {
+      for (const request of pending.values()) {
+        clearTimeout(request.timeout);
+      }
+      pending.clear();
+      output.close();
+      if (!child.killed) {
+        child.kill();
+      }
+    };
+
+    const writeMessage = (message: unknown) => {
+      if (!child.stdin.writable) {
+        throw new Error("Cannot write to codex app-server stdin.");
+      }
+      child.stdin.write(`${JSON.stringify(message)}\n`);
+    };
+
+    const sendRequest = async <TResponse>(
+      method: string,
+      params: unknown,
+      timeoutMs = 20_000,
+    ): Promise<TResponse> => {
+      if (exited) {
+        throw (
+          exitError ??
+          new Error("codex app-server exited before request could be sent.")
+        );
+      }
+
+      const id = nextRequestId;
+      nextRequestId += 1;
+
+      const result = await new Promise<unknown>((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          pending.delete(String(id));
+          reject(new Error(`Timed out waiting for ${method}.`));
+        }, timeoutMs);
+
+        pending.set(String(id), {
+          timeout,
+          resolve,
+          reject,
+          method,
+        });
+        writeMessage({ id, method, params });
+      });
+
+      return result as TResponse;
+    };
+
+    output.on("line", (line) => {
+      let parsed: unknown;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        return;
+      }
+
+      if (this.isResponse(parsed)) {
+        const key = String(parsed.id);
+        const request = pending.get(key);
+        if (!request) {
+          return;
+        }
+
+        clearTimeout(request.timeout);
+        pending.delete(key);
+
+        if (parsed.error?.message) {
+          request.reject(
+            new Error(
+              `${request.method} failed: ${String(parsed.error.message)}`,
+            ),
+          );
+          return;
+        }
+
+        request.resolve(parsed.result);
+        return;
+      }
+
+      if (this.isServerRequest(parsed)) {
+        writeMessage({
+          id: parsed.id,
+          error: {
+            code: -32601,
+            message: `Unsupported server request: ${parsed.method}`,
+          },
+        });
+      }
+    });
+
+    child.on("error", (error) => {
+      exited = true;
+      exitError = error;
+      for (const request of pending.values()) {
+        clearTimeout(request.timeout);
+        request.reject(error);
+      }
+      pending.clear();
+    });
+
+    child.on("exit", (code, signal) => {
+      exited = true;
+      if (!exitError && code !== 0) {
+        exitError = new Error(
+          `codex app-server exited (code=${code ?? "null"}, signal=${signal ?? "null"}).`,
+        );
+      }
+      for (const request of pending.values()) {
+        clearTimeout(request.timeout);
+        request.reject(
+          exitError ??
+            new Error("codex app-server exited before request completed."),
+        );
+      }
+      pending.clear();
+    });
+
+    try {
+      await sendRequest("initialize", {
+        clientInfo: {
+          name: "codething_desktop",
+          title: "CodeThing Desktop",
+          version: "0.1.0",
+        },
+        capabilities: {
+          experimentalApi: false,
+        },
+      });
+
+      writeMessage({ method: "initialized" });
+
+      const deduped = new Map<string, ProviderModel>();
+      let cursor: string | null = null;
+
+      while (true) {
+        const response = await sendRequest<unknown>("model/list", {
+          cursor,
+          limit: 100,
+        });
+        const parsed = this.parseModelListResponse(response);
+        for (const model of parsed.models) {
+          deduped.set(model.model, model);
+        }
+
+        if (!parsed.nextCursor) {
+          break;
+        }
+        cursor = parsed.nextCursor;
+      }
+
+      return Array.from(deduped.values());
+    } finally {
+      cleanup();
+    }
+  }
+
   async interruptTurn(sessionId: string, turnId?: string): Promise<void> {
     const context = this.requireSession(sessionId);
     const effectiveTurnId = turnId ?? context.session.activeTurnId;
@@ -622,6 +807,66 @@ export class CodexAppServerManager extends EventEmitter<CodexAppServerManagerEve
     };
   }
 
+  private parseModelListResponse(response: unknown): {
+    models: ProviderModel[];
+    nextCursor: string | null;
+  } {
+    const object = this.readObject(response);
+    if (!object) {
+      throw new Error("model/list response was not an object.");
+    }
+
+    const data = object.data;
+    if (!Array.isArray(data)) {
+      throw new Error("model/list response missing data array.");
+    }
+
+    const models: ProviderModel[] = [];
+    for (const entry of data) {
+      const item = this.readObject(entry);
+      if (!item) {
+        continue;
+      }
+
+      const model = this.readString(item, "model");
+      if (!model) {
+        continue;
+      }
+
+      const id = this.readString(item, "id") ?? model;
+      const displayName = this.readString(item, "displayName") ?? model;
+      const description = this.readString(item, "description");
+      const isDefault =
+        typeof item.isDefault === "boolean" ? item.isDefault : undefined;
+      const rawUpgrade = item.upgrade;
+      const upgrade =
+        typeof rawUpgrade === "string"
+          ? rawUpgrade
+          : rawUpgrade === null
+            ? null
+            : undefined;
+
+      models.push({
+        id,
+        model,
+        displayName,
+        ...(description ? { description } : {}),
+        ...(isDefault === undefined ? {} : { isDefault }),
+        ...(upgrade === undefined ? {} : { upgrade }),
+      });
+    }
+
+    const rawCursor = object.nextCursor;
+    const nextCursor =
+      typeof rawCursor === "string"
+        ? rawCursor
+        : rawCursor === null || rawCursor === undefined
+          ? null
+          : null;
+
+    return { models, nextCursor };
+  }
+
   private isServerRequest(value: unknown): value is JsonRpcRequest {
     if (!value || typeof value !== "object") {
       return false;
diff --git a/apps/desktop/src/main.ts b/apps/desktop/src/main.ts
index b86e04cd89ad9069c532b9fa12c784507c46bae5..dcafe2d74b716a08825d53503c4456b4f7bd2c70 100644
--- a/apps/desktop/src/main.ts
+++ b/apps/desktop/src/main.ts
@@ -139,6 +139,15 @@ function registerIpcHandlers(): void {
   ipcMain.handle(IPC_CHANNELS.providerSessionList, async () => {
     return providerManager.listSessions();
   });
+
+  ipcMain.handle(
+    IPC_CHANNELS.providerModelList,
+    async (_event, payload: unknown) => {
+      return providerManager.listModels(
+        payload as Parameters<typeof providerManager.listModels>[0],
+      );
+    },
+  );
 }
 
 async function runTerminalCommand(
diff --git a/apps/desktop/src/preload.ts b/apps/desktop/src/preload.ts
index 9c44b6ef95241ddcde451fc9694bd5aaf2de0572..42d043f1f88a941bc201d6c8fac106b167de6698 100644
--- a/apps/desktop/src/preload.ts
+++ b/apps/desktop/src/preload.ts
@@ -41,6 +41,8 @@ const nativeApi: NativeApi = {
     stopSession: (input) =>
       ipcRenderer.invoke(IPC_CHANNELS.providerSessionStop, input),
     listSessions: () => ipcRenderer.invoke(IPC_CHANNELS.providerSessionList),
+    listModels: (input) =>
+      ipcRenderer.invoke(IPC_CHANNELS.providerModelList, input),
     onEvent: (callback) => {
       const listener = (_event: Electron.IpcRendererEvent, payload: unknown) =>
         callback(payload as Parameters<typeof callback>[0]);
diff --git a/apps/desktop/src/providerManager.ts b/apps/desktop/src/providerManager.ts
index 2a9f37bcb2013647a86bd0b20d554037bb8f854b..69c3cec17228f6b5c1dc10dbe5e38782cc18819d 100644
--- a/apps/desktop/src/providerManager.ts
+++ b/apps/desktop/src/providerManager.ts
@@ -3,12 +3,15 @@ import { EventEmitter } from "node:events";
 import {
   type ProviderEvent,
   type ProviderInterruptTurnInput,
+  type ProviderListModelsInput,
+  type ProviderModel,
   type ProviderSendTurnInput,
   type ProviderSession,
   type ProviderSessionStartInput,
   type ProviderStopSessionInput,
   type ProviderTurnStartResult,
   providerInterruptTurnInputSchema,
+  providerListModelsInputSchema,
   providerSendTurnInputSchema,
   providerSessionStartInputSchema,
   providerStopSessionInputSchema,
@@ -63,6 +66,17 @@ export class ProviderManager extends EventEmitter<ProviderManagerEvents> {
     return this.codex.listSessions();
   }
 
+  async listModels(
+    raw: ProviderListModelsInput = {},
+  ): Promise<ProviderModel[]> {
+    const input = providerListModelsInputSchema.parse(raw);
+    if (input.provider !== "codex") {
+      throw new Error(`Provider '${input.provider}' is not implemented yet.`);
+    }
+
+    return this.codex.listModels(input.cwd);
+  }
+
   stopAll(): void {
     this.codex.stopAll();
   }
diff --git a/apps/renderer/src/components/ChatView.tsx b/apps/renderer/src/components/ChatView.tsx
index dc4388df321bab0d40697942eaee78d9180602a0..d76ea9316ff2e3c4ee53db77395d79c9fb6a5a46 100644
--- a/apps/renderer/src/components/ChatView.tsx
+++ b/apps/renderer/src/components/ChatView.tsx
@@ -1,22 +1,54 @@
-import { type FormEvent, useEffect, useMemo, useRef, useState } from "react";
+import type { ProviderModel } from "@acme/contracts";
+import {
+  type FormEvent,
+  type KeyboardEvent,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+} from "react";
 
 import { derivePhase, formatTimestamp, readNativeApi } from "../session-logic";
 import { useStore } from "../store";
 
+const DEFAULT_MODEL = "gpt-5.2-codex";
+
 export default function ChatView() {
   const { state, dispatch } = useStore();
   const api = useMemo(() => readNativeApi(), []);
   const [prompt, setPrompt] = useState("");
   const [isSending, setIsSending] = useState(false);
   const [isConnecting, setIsConnecting] = useState(false);
+  const [isModelMenuOpen, setIsModelMenuOpen] = useState(false);
+  const [isLoadingModels, setIsLoadingModels] = useState(false);
+  const [modelLoadError, setModelLoadError] = useState<string | null>(null);
+  const [availableModels, setAvailableModels] = useState<ProviderModel[]>([]);
   const messagesEndRef = useRef<HTMLDivElement>(null);
   const textareaRef = useRef<HTMLTextAreaElement>(null);
+  const modelMenuRef = useRef<HTMLDivElement>(null);
 
   const activeThread = state.threads.find((t) => t.id === state.activeThreadId);
   const activeProject = state.projects.find(
     (p) => p.id === activeThread?.projectId,
   );
+  const selectedModel =
+    activeThread?.model || activeProject?.model || DEFAULT_MODEL;
   const phase = derivePhase(activeThread?.session ?? null);
+  const modelOptions = useMemo(() => {
+    const deduped = new Map<string, ProviderModel>();
+    for (const model of availableModels) {
+      deduped.set(model.model, model);
+    }
+    if (!deduped.has(selectedModel)) {
+      deduped.set(selectedModel, {
+        id: selectedModel,
+        model: selectedModel,
+        displayName: selectedModel,
+        description: "Current model for this thread.",
+      });
+    }
+    return Array.from(deduped.values());
+  }, [availableModels, selectedModel]);
 
   // Auto-scroll on new messages
   const messageCount = activeThread?.messages.length ?? 0;
@@ -34,6 +66,67 @@ export default function ChatView() {
     ta.style.height = `${Math.min(ta.scrollHeight, 200)}px`;
   }, [prompt]);
 
+  useEffect(() => {
+    if (!isModelMenuOpen) return;
+
+    const handleClickOutside = (event: MouseEvent) => {
+      if (!modelMenuRef.current) return;
+      if (
+        event.target instanceof Node &&
+        !modelMenuRef.current.contains(event.target)
+      ) {
+        setIsModelMenuOpen(false);
+      }
+    };
+
+    window.addEventListener("mousedown", handleClickOutside);
+    return () => {
+      window.removeEventListener("mousedown", handleClickOutside);
+    };
+  }, [isModelMenuOpen]);
+
+  useEffect(() => {
+    if (!api || !state.activeThreadId) return;
+
+    let cancelled = false;
+
+    const loadModels = async () => {
+      setIsLoadingModels(true);
+      setModelLoadError(null);
+      try {
+        const models = await api.providers.listModels(
+          activeProject?.cwd ? { cwd: activeProject.cwd } : undefined,
+        );
+        if (cancelled) return;
+
+        const sorted = [...models].sort((a, b) => {
+          if ((a.isDefault ?? false) && !(b.isDefault ?? false)) return -1;
+          if ((b.isDefault ?? false) && !(a.isDefault ?? false)) return 1;
+          return a.displayName.localeCompare(b.displayName);
+        });
+        setAvailableModels(sorted);
+      } catch (err) {
+        if (cancelled) return;
+        setAvailableModels([]);
+        setModelLoadError(
+          err instanceof Error
+            ? err.message
+            : "Could not load available models from Codex.",
+        );
+      } finally {
+        if (!cancelled) {
+          setIsLoadingModels(false);
+        }
+      }
+    };
+
+    void loadModels();
+
+    return () => {
+      cancelled = true;
+    };
+  }, [api, activeProject?.cwd, state.activeThreadId]);
+
   const ensureSession = async (): Promise<boolean> => {
     if (!api || !activeThread || !activeProject) return false;
     if (activeThread.session && activeThread.session.status !== "closed")
@@ -44,7 +137,7 @@ export default function ChatView() {
       const session = await api.providers.startSession({
         provider: "codex",
         cwd: activeProject.cwd || undefined,
-        model: activeProject.model || undefined,
+        model: selectedModel || undefined,
       });
       dispatch({
         type: "UPDATE_SESSION",
@@ -105,7 +198,11 @@ export default function ChatView() {
 
     setIsSending(true);
     try {
-      await api.providers.sendTurn({ sessionId, input: trimmed });
+      await api.providers.sendTurn({
+        sessionId,
+        input: trimmed,
+        model: selectedModel || undefined,
+      });
     } catch (err) {
       dispatch({
         type: "SET_ERROR",
@@ -125,7 +222,17 @@ export default function ChatView() {
     });
   };
 
-  const onKeyDown = (e: React.KeyboardEvent<HTMLTextAreaElement>) => {
+  const onModelSelect = (model: string) => {
+    if (!activeThread) return;
+    dispatch({
+      type: "SET_THREAD_MODEL",
+      threadId: activeThread.id,
+      model,
+    });
+    setIsModelMenuOpen(false);
+  };
+
+  const onKeyDown = (e: KeyboardEvent<HTMLTextAreaElement>) => {
     if (e.key === "Enter" && !e.shiftKey) {
       e.preventDefault();
       void onSend(e as unknown as FormEvent);
@@ -255,10 +362,10 @@ export default function ChatView() {
           onSubmit={onSend}
           className="mx-auto flex max-w-3xl items-end gap-2"
         >
-          <div className="relative flex-1">
+          <div className="flex-1 rounded-2xl border border-white/[0.1] bg-[#121214] px-3 py-3">
             <textarea
               ref={textareaRef}
-              className="w-full resize-none rounded-xl border border-white/[0.1] bg-white/[0.04] px-4 py-3 pr-12 font-mono text-sm text-[#e0e0e0] placeholder:text-[#a0a0a0]/30 focus:border-white/20 focus:outline-none"
+              className="w-full resize-none bg-transparent px-1 pb-1 font-mono text-sm text-[#e0e0e0] placeholder:text-[#a0a0a0]/30 focus:outline-none"
               rows={1}
               value={prompt}
               onChange={(e) => setPrompt(e.target.value)}
@@ -270,11 +377,78 @@ export default function ChatView() {
               }
               disabled={isSending || isConnecting}
             />
-            {activeProject && (
-              <span className="absolute right-3 bottom-2 text-[9px] text-[#a0a0a0]/25">
-                {activeProject.model}
-              </span>
-            )}
+            <div className="mt-2 flex items-center justify-between gap-2">
+              <div className="relative" ref={modelMenuRef}>
+                <button
+                  type="button"
+                  className="inline-flex items-center gap-2 rounded-full border border-white/[0.1] bg-white/[0.04] px-3 py-1.5 text-xs text-[#d8d8d8] transition-colors duration-150 hover:bg-white/[0.08]"
+                  onClick={() => setIsModelMenuOpen((open) => !open)}
+                >
+                  <span className="max-w-[180px] truncate">
+                    {selectedModel}
+                  </span>
+                  <span className="text-[10px] text-[#a0a0a0]/70">▼</span>
+                </button>
+                {isModelMenuOpen && (
+                  <div className="absolute bottom-full left-0 z-20 mb-2 w-[340px] rounded-2xl border border-white/[0.1] bg-[#1b1b1d]/95 p-2 shadow-[0_16px_40px_rgba(0,0,0,0.55)] backdrop-blur">
+                    <p className="px-2 py-1 text-[11px] text-[#a0a0a0]/70">
+                      Select model
+                    </p>
+                    <div className="max-h-72 overflow-y-auto">
+                      {modelOptions.map((model) => {
+                        const isSelected = model.model === selectedModel;
+                        return (
+                          <button
+                            key={model.id}
+                            type="button"
+                            className={`mb-0.5 flex w-full items-start justify-between gap-2 rounded-xl px-2 py-2 text-left transition-colors duration-150 ${
+                              isSelected
+                                ? "bg-white/[0.08] text-white"
+                                : "text-[#d4d4d4] hover:bg-white/[0.05]"
+                            }`}
+                            onClick={() => onModelSelect(model.model)}
+                          >
+                            <span className="min-w-0">
+                              <span className="block truncate text-sm">
+                                {model.displayName}
+                              </span>
+                              {model.description && (
+                                <span className="block pt-0.5 text-[10px] text-[#a0a0a0]/65">
+                                  {model.description}
+                                </span>
+                              )}
+                            </span>
+                            <span
+                              className={`pt-0.5 text-sm ${
+                                isSelected ? "text-white" : "text-transparent"
+                              }`}
+                            >
+                              ✓
+                            </span>
+                          </button>
+                        );
+                      })}
+                    </div>
+                    {isLoadingModels && (
+                      <p className="px-2 pt-2 text-[10px] text-[#a0a0a0]/60">
+                        Refreshing available models...
+                      </p>
+                    )}
+                    {modelLoadError && (
+                      <p className="px-2 pt-2 text-[10px] text-amber-200/80">
+                        Could not load full model list from Codex:{" "}
+                        {modelLoadError}
+                      </p>
+                    )}
+                  </div>
+                )}
+              </div>
+              {activeProject && (
+                <span className="text-[10px] text-[#a0a0a0]/35">
+                  {activeProject.name}
+                </span>
+              )}
+            </div>
           </div>
           {phase === "running" ? (
             <button
diff --git a/apps/renderer/src/components/Sidebar.tsx b/apps/renderer/src/components/Sidebar.tsx
index 2a28cf7898358074c141b8ba61077a346a044515..a998d2208494caed63d85e62184737c6833af11d 100644
--- a/apps/renderer/src/components/Sidebar.tsx
+++ b/apps/renderer/src/components/Sidebar.tsx
@@ -2,6 +2,8 @@ import { useState } from "react";
 import { useStore } from "../store";
 import type { Project } from "../types";
 
+const DEFAULT_MODEL = "gpt-5.2-codex";
+
 function formatRelativeTime(iso: string): string {
   const diff = Date.now() - new Date(iso).getTime();
   const minutes = Math.floor(diff / 60_000);
@@ -16,7 +18,7 @@ export default function Sidebar() {
   const { state, dispatch } = useStore();
   const [addingProject, setAddingProject] = useState(false);
   const [newCwd, setNewCwd] = useState("");
-  const [newModel, setNewModel] = useState("gpt-5.1-codex");
+  const [newModel, setNewModel] = useState(DEFAULT_MODEL);
 
   const handleAddProject = () => {
     const cwd = newCwd.trim();
@@ -26,12 +28,12 @@ export default function Sidebar() {
       id: crypto.randomUUID(),
       name,
       cwd,
-      model: newModel.trim() || "gpt-5.1-codex",
+      model: newModel.trim() || DEFAULT_MODEL,
       expanded: true,
     };
     dispatch({ type: "ADD_PROJECT", project });
     setNewCwd("");
-    setNewModel("gpt-5.1-codex");
+    setNewModel(DEFAULT_MODEL);
     setAddingProject(false);
   };
 
@@ -42,6 +44,9 @@ export default function Sidebar() {
         id: crypto.randomUUID(),
         projectId,
         title: "New thread",
+        model:
+          state.projects.find((p) => p.id === projectId)?.model ??
+          DEFAULT_MODEL,
         session: null,
         messages: [],
         events: [],
@@ -183,7 +188,7 @@ export default function Sidebar() {
           />
           <input
             className="mb-2 w-full rounded-md border border-white/[0.1] bg-white/[0.04] px-2 py-1.5 font-mono text-xs text-[#e0e0e0] placeholder:text-[#a0a0a0]/30 focus:border-white/30 focus:outline-none"
-            placeholder="model (default: gpt-5.1-codex)"
+            placeholder={`model (default: ${DEFAULT_MODEL})`}
             value={newModel}
             onChange={(e) => setNewModel(e.target.value)}
             onKeyDown={(e) => {
diff --git a/apps/renderer/src/store.ts b/apps/renderer/src/store.ts
index c9b7c0443b46cded9b8c1b88ffe01e687dd2bca4..2686ff4f2b41863489a0b9b5b30e7a496bd777fc 100644
--- a/apps/renderer/src/store.ts
+++ b/apps/renderer/src/store.ts
@@ -27,7 +27,8 @@ type Action =
   | { type: "UPDATE_SESSION"; threadId: string; session: ProviderSession }
   | { type: "PUSH_USER_MESSAGE"; threadId: string; id: string; text: string }
   | { type: "SET_ERROR"; threadId: string; error: string | null }
-  | { type: "SET_THREAD_TITLE"; threadId: string; title: string };
+  | { type: "SET_THREAD_TITLE"; threadId: string; title: string }
+  | { type: "SET_THREAD_MODEL"; threadId: string; model: string };
 
 // ── State ────────────────────────────────────────────────────────────
 
@@ -160,6 +161,15 @@ function reducer(state: AppState, action: Action): AppState {
         })),
       };
 
+    case "SET_THREAD_MODEL":
+      return {
+        ...state,
+        threads: updateThread(state.threads, action.threadId, (t) => ({
+          ...t,
+          model: action.model,
+        })),
+      };
+
     default:
       return state;
   }
diff --git a/apps/renderer/src/types.ts b/apps/renderer/src/types.ts
index 1d49ed567ac7b05b9586dfb3171d9d9ef8ba4cf6..bac168ae7daf4ff809d77f55748ae6f6baf23487 100644
--- a/apps/renderer/src/types.ts
+++ b/apps/renderer/src/types.ts
@@ -22,6 +22,7 @@ export interface Thread {
   id: string;
   projectId: string;
   title: string;
+  model: string;
   session: ProviderSession | null;
   messages: ChatMessage[];
   events: ProviderEvent[];
diff --git a/packages/contracts/src/ipc.ts b/packages/contracts/src/ipc.ts
index ee8ab264e1536ec73c8e63b3a93b86db1ae04b2a..5fcbe3c90f38185d5680d977fd7dfc732cdea5eb 100644
--- a/packages/contracts/src/ipc.ts
+++ b/packages/contracts/src/ipc.ts
@@ -2,6 +2,8 @@ import type { AgentConfig, AgentExit, OutputChunk } from "./agent";
 import type {
   ProviderEvent,
   ProviderInterruptTurnInput,
+  ProviderListModelsInput,
+  ProviderModel,
   ProviderSendTurnInput,
   ProviderSession,
   ProviderSessionStartInput,
@@ -27,6 +29,7 @@ export const IPC_CHANNELS = {
   providerTurnInterrupt: "provider:turn:interrupt",
   providerSessionStop: "provider:session:stop",
   providerSessionList: "provider:session:list",
+  providerModelList: "provider:model:list",
   providerEvent: "provider:event",
 } as const;
 
@@ -57,6 +60,7 @@ export interface NativeApi {
     interruptTurn: (input: ProviderInterruptTurnInput) => Promise<void>;
     stopSession: (input: ProviderStopSessionInput) => Promise<void>;
     listSessions: () => Promise<ProviderSession[]>;
+    listModels: (input?: ProviderListModelsInput) => Promise<ProviderModel[]>;
     onEvent: (callback: (event: ProviderEvent) => void) => () => void;
   };
 }
diff --git a/packages/contracts/src/provider.test.ts b/packages/contracts/src/provider.test.ts
index 9dd4fd9c33cb87ff4ec0e47d9f6196c51f629866..43e8dde97bca2821e167e8ef763ef6ad59e652a1 100644
--- a/packages/contracts/src/provider.test.ts
+++ b/packages/contracts/src/provider.test.ts
@@ -2,6 +2,7 @@ import { describe, expect, it } from "vitest";
 
 import {
   providerEventSchema,
+  providerListModelsInputSchema,
   providerSendTurnInputSchema,
   providerSessionStartInputSchema,
 } from "./provider";
@@ -16,12 +17,21 @@ describe("providerSessionStartInputSchema", () => {
 });
 
 describe("providerSendTurnInputSchema", () => {
-  it("trims input text", () => {
+  it("trims input text and optional model", () => {
     const parsed = providerSendTurnInputSchema.parse({
       sessionId: "sess_1",
       input: "  summarize this repo  ",
+      model: "  gpt-5.2-codex  ",
     });
     expect(parsed.input).toBe("summarize this repo");
+    expect(parsed.model).toBe("gpt-5.2-codex");
+  });
+});
+
+describe("providerListModelsInputSchema", () => {
+  it("defaults provider to codex", () => {
+    const parsed = providerListModelsInputSchema.parse({});
+    expect(parsed.provider).toBe("codex");
   });
 });
 
diff --git a/packages/contracts/src/provider.ts b/packages/contracts/src/provider.ts
index 6dcbf7b4544c77634ae23bffc0ed6061e18210f9..a094d7bb445272699139f9daeed126993f3a7cfa 100644
--- a/packages/contracts/src/provider.ts
+++ b/packages/contracts/src/provider.ts
@@ -47,6 +47,7 @@ export const providerSessionStartInputSchema = z.object({
 export const providerSendTurnInputSchema = z.object({
   sessionId: z.string().min(1),
   input: z.string().trim().min(1).max(120_000),
+  model: z.string().trim().min(1).optional(),
 });
 
 export const providerTurnStartResultSchema = z.object({
@@ -63,6 +64,20 @@ export const providerStopSessionInputSchema = z.object({
   sessionId: z.string().min(1),
 });
 
+export const providerModelSchema = z.object({
+  id: z.string().min(1),
+  model: z.string().min(1),
+  displayName: z.string().min(1),
+  description: z.string().min(1).optional(),
+  isDefault: z.boolean().optional(),
+  upgrade: z.string().min(1).nullable().optional(),
+});
+
+export const providerListModelsInputSchema = z.object({
+  provider: providerKindSchema.default("codex"),
+  cwd: z.string().min(1).optional(),
+});
+
 export const providerEventKindSchema = z.enum([
   "session",
   "notification",
@@ -105,5 +120,9 @@ export type ProviderInterruptTurnInput = z.input<
 export type ProviderStopSessionInput = z.input<
   typeof providerStopSessionInputSchema
 >;
+export type ProviderModel = z.infer<typeof providerModelSchema>;
+export type ProviderListModelsInput = z.input<
+  typeof providerListModelsInputSchema
+>;
 export type ProviderEventKind = z.infer<typeof providerEventKindSchema>;
 export type ProviderEvent = z.infer<typeof providerEventSchema>;