diff --git a/src-tauri/src/bin/codex_monitor_daemon.rs b/src-tauri/src/bin/codex_monitor_daemon.rs
index 3a2cd0ce3..a37376fe5 100644
--- a/src-tauri/src/bin/codex_monitor_daemon.rs
+++ b/src-tauri/src/bin/codex_monitor_daemon.rs
@@ -1317,6 +1317,25 @@ impl DaemonState {
         .await
     }
 
+    async fn predict_response(
+        &self,
+        workspace_id: String,
+        context: String,
+        model: Option<String>,
+    ) -> Result<String, String> {
+        codex_aux_core::predict_response_core(
+            &self.sessions,
+            &self.workspaces,
+            workspace_id,
+            &context,
+            model,
+            |workspace_id, thread_id| {
+                emit_background_thread_hide(&self.event_sink, workspace_id, thread_id);
+            },
+        )
+        .await
+    }
+
     async fn local_usage_snapshot(
         &self,
         days: Option<u32>,
diff --git a/src-tauri/src/bin/codex_monitor_daemon/rpc/codex.rs b/src-tauri/src/bin/codex_monitor_daemon/rpc/codex.rs
index e55774371..de404488a 100644
--- a/src-tauri/src/bin/codex_monitor_daemon/rpc/codex.rs
+++ b/src-tauri/src/bin/codex_monitor_daemon/rpc/codex.rs
@@ -492,6 +492,23 @@ pub(super) async fn try_handle(
                     .and_then(|value| serde_json::to_value(value).map_err(|err| err.to_string())),
             )
         }
+        "predict_response" => {
+            let workspace_id = match parse_string(params, "workspaceId") {
+                Ok(value) => value,
+                Err(err) => return Some(Err(err)),
+            };
+            let context = match parse_string(params, "context") {
+                Ok(value) => value,
+                Err(err) => return Some(Err(err)),
+            };
+            let model = parse_optional_string(params, "model");
+            Some(
+                state
+                    .predict_response(workspace_id, context, model)
+                    .await
+                    .map(Value::String),
+            )
+        }
         _ => None,
     }
 }
diff --git a/src-tauri/src/codex/mod.rs b/src-tauri/src/codex/mod.rs
index 8bbb7757c..2919d607a 100644
--- a/src-tauri/src/codex/mod.rs
+++ b/src-tauri/src/codex/mod.rs
@@ -992,3 +992,51 @@ pub(crate) async fn generate_agent_description(
     )
     .await
 }
+
+#[tauri::command]
+pub(crate) async fn predict_response(
+    workspace_id: String,
+    context: String,
+    model: Option<String>,
+    state: State<'_, AppState>,
+    app: AppHandle,
+) -> Result<String, String> {
+    if remote_backend::is_remote_mode(&*state).await {
+        let mut payload = json!({ "workspaceId": workspace_id, "context": context });
+        if let Some(ref model_id) = model {
+            payload.as_object_mut().unwrap().insert("model".to_string(), json!(model_id));
+        }
+        let value = remote_backend::call_remote(
+            &*state,
+            app,
+            "predict_response",
+            payload,
+        )
+        .await?;
+        return serde_json::from_value(value).map_err(|err| err.to_string());
+    }
+
+    crate::shared::codex_aux_core::predict_response_core(
+        &state.sessions,
+        &state.workspaces,
+        workspace_id,
+        &context,
+        model,
+        |workspace_id, thread_id| {
+            let _ = app.emit(
+                "app-server-event",
+                AppServerEvent {
+                    workspace_id: workspace_id.to_string(),
+                    message: json!({
+                        "method": "codex/backgroundThread",
+                        "params": {
+                            "threadId": thread_id,
+                            "action": "hide"
+                        }
+                    }),
+                },
+            );
+        },
+    )
+    .await
+}
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index c57bcd9a6..4e4f2e118 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -199,6 +199,7 @@ pub fn run() {
             codex::generate_commit_message,
             codex::generate_run_metadata,
             codex::generate_agent_description,
+            codex::predict_response,
             codex::resume_thread,
             codex::thread_live_subscribe,
             codex::thread_live_unsubscribe,
diff --git a/src-tauri/src/shared/codex_aux_core.rs b/src-tauri/src/shared/codex_aux_core.rs
index 12f985ade..539cd9e1c 100644
--- a/src-tauri/src/shared/codex_aux_core.rs
+++ b/src-tauri/src/shared/codex_aux_core.rs
@@ -398,6 +398,7 @@ pub(crate) async fn run_background_prompt_core<F>(
     workspace_id: String,
     prompt: String,
     model: Option<&str>,
+    max_tokens: Option<u32>,
     on_hide_thread: F,
     timeout_error: &str,
     turn_error_fallback: &str,
@@ -472,6 +473,9 @@ where
     if let Some(model_id) = model {
         turn_params["model"] = json!(model_id);
     }
+    if let Some(max) = max_tokens {
+        turn_params["maxTokens"] = json!(max);
+    }
     let turn_result = session
         .send_request_for_workspace(&workspace_id, "turn/start", turn_params)
         .await;
@@ -580,6 +584,7 @@ where
         workspace_id,
         prompt,
         model,
+        None,
         on_hide_thread,
         "Timeout waiting for commit message generation",
         "Unknown error during commit message generation",
@@ -609,6 +614,7 @@ where
         workspace_id,
         metadata_prompt,
         None,
+        None,
         on_hide_thread,
         "Timeout waiting for metadata generation",
         "Unknown error during metadata generation",
@@ -618,6 +624,51 @@ where
     parse_run_metadata_value(&response)
 }
 
+pub(crate) fn build_predict_response_prompt(context: &str) -> String {
+    format!(
+        "Predict the user's next message in a coding conversation. \
+Only suggest something when the assistant is clearly asking a question, \
+offering options, requesting confirmation, or there is an obvious natural follow-up. \
+If the assistant just delivered a result (code, explanation, completed task) with no \
+question or choice, output NONE.\n\
+When you do predict, be extremely concise — a few words or a short phrase. \
+Examples: \"yes\", \"do it\", \"use async instead\", \"add tests for that\". \
+Output ONLY the predicted text or NONE, nothing else.\n\n\
+Context:\n{context}"
+    )
+}
+
+pub(crate) async fn predict_response_core<F>(
+    sessions: &Mutex<HashMap<String, Arc<WorkspaceSession>>>,
+    workspaces: &Mutex<HashMap<String, WorkspaceEntry>>,
+    workspace_id: String,
+    context: &str,
+    model: Option<String>,
+    on_hide_thread: F,
+) -> Result<String, String>
+where
+    F: Fn(&str, &str),
+{
+    let cleaned_context = context.trim();
+    if cleaned_context.is_empty() {
+        return Err("Context is required.".to_string());
+    }
+
+    let prompt = build_predict_response_prompt(cleaned_context);
+    run_background_prompt_core(
+        sessions,
+        workspaces,
+        workspace_id,
+        prompt,
+        model.as_deref(),
+        Some(30),
+        on_hide_thread,
+        "Timeout waiting for response prediction",
+        "Unknown error during response prediction",
+    )
+    .await
+}
+
 pub(crate) async fn generate_agent_description_core<F>(
     sessions: &Mutex<HashMap<String, Arc<WorkspaceSession>>>,
     workspaces: &Mutex<HashMap<String, WorkspaceEntry>>,
@@ -640,6 +691,7 @@ where
         workspace_id,
         prompt,
         None,
+        None,
         on_hide_thread,
         "Timeout waiting for agent configuration generation",
         "Unknown error during agent configuration generation",
@@ -652,8 +704,8 @@ where
 #[cfg(test)]
 mod tests {
     use super::{
-        build_commit_message_prompt_for_diff, parse_agent_description_value,
-        parse_run_metadata_value,
+        build_commit_message_prompt_for_diff, build_predict_response_prompt,
+        parse_agent_description_value, parse_run_metadata_value,
     };
 
     #[test]
@@ -723,4 +775,17 @@ mod tests {
         );
         assert_eq!(parsed.developer_instructions, "");
     }
+
+    #[test]
+    fn build_predict_response_prompt_includes_context() {
+        let prompt = build_predict_response_prompt("User: hello\n\nAssistant: hi there");
+        assert!(prompt.contains("User: hello"));
+        assert!(prompt.contains("Assistant: hi there"));
+    }
+
+    #[test]
+    fn build_predict_response_prompt_instructs_none_for_no_followup() {
+        let prompt = build_predict_response_prompt("some context");
+        assert!(prompt.contains("NONE"));
+    }
 }
diff --git a/src-tauri/src/types.rs b/src-tauri/src/types.rs
index cbb8afbaa..f65abfcfb 100644
--- a/src-tauri/src/types.rs
+++ b/src-tauri/src/types.rs
@@ -578,6 +578,11 @@ pub(crate) struct AppSettings {
         rename = "experimentalAppsEnabled"
     )]
     pub(crate) experimental_apps_enabled: bool,
+    #[serde(
+        default = "default_prompt_suggestions_enabled",
+        rename = "promptSuggestionsEnabled"
+    )]
+    pub(crate) prompt_suggestions_enabled: bool,
     #[serde(default = "default_personality", rename = "personality")]
     pub(crate) personality: String,
     #[serde(default = "default_dictation_enabled", rename = "dictationEnabled")]
@@ -931,6 +936,10 @@ fn default_experimental_apps_enabled() -> bool {
     false
 }
 
+fn default_prompt_suggestions_enabled() -> bool {
+    false
+}
+
 fn default_personality() -> String {
     "friendly".to_string()
 }
@@ -1165,6 +1174,7 @@ impl Default for AppSettings {
                 default_pause_queued_messages_when_response_required(),
             unified_exec_enabled: true,
             experimental_apps_enabled: false,
+            prompt_suggestions_enabled: false,
             personality: default_personality(),
             dictation_enabled: false,
             dictation_model_id: default_dictation_model_id(),
@@ -1327,6 +1337,7 @@ mod tests {
         assert!(settings.pause_queued_messages_when_response_required);
         assert!(settings.unified_exec_enabled);
         assert!(!settings.experimental_apps_enabled);
+        assert!(!settings.prompt_suggestions_enabled);
         assert_eq!(settings.personality, "friendly");
         assert!(!settings.dictation_enabled);
         assert_eq!(settings.dictation_model_id, "base");
diff --git a/src/App.tsx b/src/App.tsx
index 750410cd8..bdf0893dd 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -88,6 +88,7 @@ import { useComposerMenuActions } from "@/features/composer/hooks/useComposerMen
 import { useComposerEditorState } from "@/features/composer/hooks/useComposerEditorState";
 import { useComposerController } from "@app/hooks/useComposerController";
 import { useComposerInsert } from "@app/hooks/useComposerInsert";
+import { usePredictedResponse } from "@/features/composer/hooks/usePredictedResponse";
 import { useRenameThreadPrompt } from "@threads/hooks/useRenameThreadPrompt";
 import { useWorktreePrompt } from "@/features/workspaces/hooks/useWorktreePrompt";
 import { useClonePrompt } from "@/features/workspaces/hooks/useClonePrompt";
@@ -1514,6 +1515,16 @@ function MainApp() {
     onDraftChange: showWorkspaceHome ? setWorkspacePrompt : handleDraftChange,
     textareaRef: showWorkspaceHome ? workspaceHomeTextareaRef : composerInputRef,
   });
+  const { ghostText, acceptPrediction } = usePredictedResponse({
+    workspaceId: activeWorkspaceId,
+    threadId: activeThreadId,
+    composerText: activeDraft,
+    disabled: isReviewing || !appSettings.promptSuggestionsEnabled,
+    isProcessing,
+    items: activeItems,
+    models,
+  });
+
   const RECENT_THREAD_LIMIT = 8;
   const { recentThreadInstances, recentThreadsUpdatedAt } = useMemo(() => {
     if (!activeWorkspaceId) {
@@ -2444,6 +2455,8 @@ function MainApp() {
     dictationHint,
     onDismissDictationHint: clearDictationHint,
     composerContextActions,
+    ghostText,
+    onAcceptGhostText: acceptPrediction,
     composerSendLabel,
     showComposer,
     plan: activePlan,
diff --git a/src/features/composer/components/Composer.tsx b/src/features/composer/components/Composer.tsx
index 85c483868..400ed356c 100644
--- a/src/features/composer/components/Composer.tsx
+++ b/src/features/composer/components/Composer.tsx
@@ -139,6 +139,8 @@ type ComposerProps = {
   onReviewPromptUpdateCustomInstructions?: (value: string) => void;
   onReviewPromptConfirmCustom?: () => Promise<void>;
   onFileAutocompleteActiveChange?: (active: boolean) => void;
+  ghostText?: string | null;
+  onAcceptGhostText?: () => string | null;
   contextActions?: {
     id: string;
     label: string;
@@ -241,6 +243,8 @@ export const Composer = memo(function Composer({
   onReviewPromptUpdateCustomInstructions,
   onReviewPromptConfirmCustom,
   onFileAutocompleteActiveChange,
+  ghostText = null,
+  onAcceptGhostText,
   contextActions = [],
 }: ComposerProps) {
   const [text, setText] = useState(draftText);
@@ -684,6 +688,7 @@ export const Composer = memo(function Composer({
       ) : null}
       <ComposerInput
         text={text}
+        ghostText={ghostText}
         disabled={disabled}
         sendLabel={effectiveSendLabel}
         canStop={canStop}
@@ -791,6 +796,30 @@ export const Composer = memo(function Composer({
             applyTextInsertion(nextText, nextCursor);
             return;
           }
+          if (
+            event.key === "Tab" &&
+            !event.shiftKey &&
+            !suggestionsOpen &&
+            !isProcessing &&
+            !text.trim() &&
+            ghostText &&
+            onAcceptGhostText
+          ) {
+            const accepted = onAcceptGhostText();
+            if (accepted) {
+              event.preventDefault();
+              setComposerText(accepted);
+              requestAnimationFrame(() => {
+                const ta = textareaRef.current;
+                if (ta) {
+                  ta.selectionStart = accepted.length;
+                  ta.selectionEnd = accepted.length;
+                  ta.focus();
+                }
+              });
+              return;
+            }
+          }
           if (reviewPromptOpen && onReviewPromptKeyDown) {
             const handled = onReviewPromptKeyDown(event);
             if (handled) {
diff --git a/src/features/composer/components/ComposerInput.tsx b/src/features/composer/components/ComposerInput.tsx
index 6b9f43212..944c2fe40 100644
--- a/src/features/composer/components/ComposerInput.tsx
+++ b/src/features/composer/components/ComposerInput.tsx
@@ -35,6 +35,7 @@ import { getFileTypeIconUrl } from "../../../utils/fileTypeIcons";
 
 type ComposerInputProps = {
   text: string;
+  ghostText?: string | null;
   disabled: boolean;
   sendLabel: string;
   canStop: boolean;
@@ -137,6 +138,7 @@ const fileTitle = (path: string) => {
 
 export function ComposerInput({
   text,
+  ghostText = null,
   disabled,
   sendLabel,
   canStop,
@@ -494,24 +496,41 @@ export function ComposerInput({
               </PopoverSurface>
             )}
           </div>
-          <textarea
-            ref={textareaRef}
-            placeholder={
-              disabled
-                ? "Review in progress. Chat will re-enable when it completes."
-                : "Ask Codex to do something..."
-            }
-            value={text}
-            onChange={handleTextareaChange}
-            onSelect={handleTextareaSelect}
-            disabled={disabled}
-            onKeyDown={onKeyDown}
-            onDragOver={handleDragOver}
-            onDragEnter={handleDragEnter}
-            onDragLeave={handleDragLeave}
-            onDrop={handleDrop}
-            onPaste={handleTextareaPaste}
-          />
+          <div className="composer-textarea-wrapper">
+            <textarea
+              ref={textareaRef}
+              aria-label="Ask Codex to do something"
+              value={text}
+              onChange={handleTextareaChange}
+              onSelect={handleTextareaSelect}
+              disabled={disabled}
+              onKeyDown={onKeyDown}
+              onDragOver={handleDragOver}
+              onDragEnter={handleDragEnter}
+              onDragLeave={handleDragLeave}
+              onDrop={handleDrop}
+              onPaste={handleTextareaPaste}
+            />
+            {!text && (
+              <div
+                className={`composer-placeholder ${ghostText ? "composer-placeholder-hidden" : ""}`}
+                aria-hidden
+              >
+                {disabled
+                  ? "Review in progress. Chat will re-enable when it completes."
+                  : "Ask Codex to do something..."}
+              </div>
+            )}
+            {!text && (
+              <div
+                className={`composer-ghost-text ${ghostText ? "composer-ghost-text-visible" : ""}`}
+                aria-hidden
+              >
+                {ghostText}
+                {ghostText && <span className="composer-ghost-text-hint">Tab</span>}
+              </div>
+            )}
+          </div>
         </div>
         {isDictationBusy && (
           <DictationWaveform
diff --git a/src/features/composer/hooks/usePredictedResponse.test.ts b/src/features/composer/hooks/usePredictedResponse.test.ts
new file mode 100644
index 000000000..f3fbf278e
--- /dev/null
+++ b/src/features/composer/hooks/usePredictedResponse.test.ts
@@ -0,0 +1,317 @@
+/** @vitest-environment jsdom */
+import React, { act } from "react";
+import { createRoot } from "react-dom/client";
+import { describe, expect, it, vi, beforeEach } from "vitest";
+import type { ConversationItem, ModelOption } from "../../../types";
+import { usePredictedResponse } from "./usePredictedResponse";
+
+const mockPredictResponse = vi.fn<(workspaceId: string, context: string, model?: string) => Promise<string>>();
+
+vi.mock("../../../services/tauri", () => ({
+  predictResponse: (...args: [string, string, string | undefined]) =>
+    mockPredictResponse(...args),
+}));
+
+type HookResult = ReturnType<typeof usePredictedResponse>;
+
+type Props = Parameters<typeof usePredictedResponse>[0];
+
+type RenderedHook = {
+  result: HookResult;
+  rerender: (next: Partial<Props>) => void;
+  unmount: () => void;
+};
+
+function createDeferred<T>() {
+  let resolve: ((value: T) => void) | undefined;
+  let reject: ((reason?: unknown) => void) | undefined;
+  const promise = new Promise<T>((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return {
+    promise,
+    resolve: (value: T) => resolve?.(value),
+    reject: (reason?: unknown) => reject?.(reason),
+  };
+}
+
+function makeModel(overrides: Partial<ModelOption> = {}): ModelOption {
+  return {
+    id: "model-1",
+    model: "default-model",
+    displayName: "Default Model",
+    description: "",
+    supportedReasoningEfforts: [],
+    defaultReasoningEffort: null,
+    isDefault: true,
+    ...overrides,
+  };
+}
+
+function makeMessage(
+  role: "user" | "assistant",
+  text: string,
+): ConversationItem {
+  return { id: crypto.randomUUID(), kind: "message", role, text };
+}
+
+const defaultProps: Props = {
+  workspaceId: "ws-1",
+  threadId: "thread-1",
+  composerText: "",
+  disabled: false,
+  isProcessing: false,
+  items: [makeMessage("assistant", "What should I do next?")],
+  models: [makeModel()],
+};
+
+function renderHook(initial?: Partial<Props>): RenderedHook {
+  let props: Props = { ...defaultProps, ...initial };
+  let result: HookResult | undefined;
+
+  function Test() {
+    result = usePredictedResponse(props);
+    return null;
+  }
+
+  const container = document.createElement("div");
+  document.body.appendChild(container);
+  const root = createRoot(container);
+
+  act(() => {
+    root.render(React.createElement(Test));
+  });
+
+  return {
+    get result() {
+      if (!result) throw new Error("Hook not rendered");
+      return result;
+    },
+    rerender: (next: Partial<Props>) => {
+      props = { ...props, ...next };
+      act(() => {
+        root.render(React.createElement(Test));
+      });
+    },
+    unmount: () => {
+      act(() => root.unmount());
+      container.remove();
+    },
+  };
+}
+
+beforeEach(() => {
+  mockPredictResponse.mockReset();
+});
+
+describe("usePredictedResponse", () => {
+  it("triggers prediction on isProcessing true → false", async () => {
+    mockPredictResponse.mockResolvedValue("do it");
+
+    const hook = renderHook({ isProcessing: true });
+    expect(hook.result.ghostText).toBeNull();
+
+    await act(async () => {
+      hook.rerender({ isProcessing: false });
+    });
+
+    expect(mockPredictResponse).toHaveBeenCalledOnce();
+    expect(hook.result.ghostText).toBe("do it");
+    hook.unmount();
+  });
+
+  it("does not trigger when isProcessing stays false", () => {
+    const hook = renderHook({ isProcessing: false });
+    hook.rerender({ isProcessing: false });
+    expect(mockPredictResponse).not.toHaveBeenCalled();
+    hook.unmount();
+  });
+
+  it("filters out NONE responses", async () => {
+    mockPredictResponse.mockResolvedValue("NONE");
+
+    const hook = renderHook({ isProcessing: true });
+    await act(async () => {
+      hook.rerender({ isProcessing: false });
+    });
+
+    expect(hook.result.ghostText).toBeNull();
+    hook.unmount();
+  });
+
+  it("filters out case-variant none responses", async () => {
+    mockPredictResponse.mockResolvedValue("  None  ");
+
+    const hook = renderHook({ isProcessing: true });
+    await act(async () => {
+      hook.rerender({ isProcessing: false });
+    });
+
+    expect(hook.result.ghostText).toBeNull();
+    hook.unmount();
+  });
+
+  it("dismisses ghost text when user types", async () => {
+    mockPredictResponse.mockResolvedValue("yes");
+
+    const hook = renderHook({ isProcessing: true });
+    await act(async () => {
+      hook.rerender({ isProcessing: false });
+    });
+    expect(hook.result.ghostText).toBe("yes");
+
+    hook.rerender({ composerText: "h" });
+    expect(hook.result.ghostText).toBeNull();
+    hook.unmount();
+  });
+
+  it("resets state on thread change", async () => {
+    mockPredictResponse.mockResolvedValue("yes");
+
+    const hook = renderHook({ isProcessing: true });
+    await act(async () => {
+      hook.rerender({ isProcessing: false });
+    });
+    expect(hook.result.ghostText).toBe("yes");
+
+    hook.rerender({ threadId: "thread-2" });
+    expect(hook.result.ghostText).toBeNull();
+    hook.unmount();
+  });
+
+  it("resets state on workspace change", async () => {
+    mockPredictResponse.mockResolvedValue("yes");
+
+    const hook = renderHook({ isProcessing: true });
+    await act(async () => {
+      hook.rerender({ isProcessing: false });
+    });
+    expect(hook.result.ghostText).toBe("yes");
+
+    hook.rerender({ workspaceId: "ws-2" });
+    expect(hook.result.ghostText).toBeNull();
+    hook.unmount();
+  });
+
+  it("does not fire prediction after thread switch during processing", async () => {
+    const hook = renderHook({ isProcessing: true });
+
+    // Switch thread and stop processing in the same render — wasProcessingRef
+    // was reset by the thread-change effect so the true→false transition
+    // should not be detected.
+    hook.rerender({ threadId: "thread-2", isProcessing: false });
+
+    expect(mockPredictResponse).not.toHaveBeenCalled();
+    hook.unmount();
+  });
+
+  it("acceptPrediction returns text and clears ghost", async () => {
+    mockPredictResponse.mockResolvedValue("run tests");
+
+    const hook = renderHook({ isProcessing: true });
+    await act(async () => {
+      hook.rerender({ isProcessing: false });
+    });
+    expect(hook.result.ghostText).toBe("run tests");
+
+    let accepted: string | null = null;
+    act(() => {
+      accepted = hook.result.acceptPrediction();
+    });
+    expect(accepted).toBe("run tests");
+    expect(hook.result.ghostText).toBeNull();
+    hook.unmount();
+  });
+
+  it("picks spark model over mini", () => {
+    mockPredictResponse.mockResolvedValue("yes");
+    const models = [
+      makeModel({ id: "m-1", model: "gpt-mini-2", displayName: "Mini" }),
+      makeModel({ id: "m-2", model: "spark-v1", displayName: "Spark" }),
+    ];
+
+    const hook = renderHook({ isProcessing: true, models });
+    act(() => {
+      hook.rerender({ isProcessing: false, models });
+    });
+
+    expect(mockPredictResponse).toHaveBeenCalledWith("ws-1", expect.any(String), "m-2");
+    hook.unmount();
+  });
+
+  it("falls back to mini when no spark available", () => {
+    mockPredictResponse.mockResolvedValue("yes");
+    const models = [
+      makeModel({ id: "m-1", model: "gpt-mini-2", displayName: "Mini" }),
+      makeModel({ id: "m-3", model: "large-v4", displayName: "Large" }),
+    ];
+
+    const hook = renderHook({ isProcessing: true, models });
+    act(() => {
+      hook.rerender({ isProcessing: false, models });
+    });
+
+    expect(mockPredictResponse).toHaveBeenCalledWith("ws-1", expect.any(String), "m-1");
+    hook.unmount();
+  });
+
+  it("passes undefined model when no spark or mini available", () => {
+    mockPredictResponse.mockResolvedValue("yes");
+    const models = [
+      makeModel({ id: "m-1", model: "large-v4", displayName: "Large" }),
+    ];
+
+    const hook = renderHook({ isProcessing: true, models });
+    act(() => {
+      hook.rerender({ isProcessing: false, models });
+    });
+
+    expect(mockPredictResponse).toHaveBeenCalledWith("ws-1", expect.any(String), undefined);
+    hook.unmount();
+  });
+
+  it("does not trigger when disabled", () => {
+    const hook = renderHook({ isProcessing: true, disabled: true });
+    hook.rerender({ isProcessing: false, disabled: true });
+    expect(mockPredictResponse).not.toHaveBeenCalled();
+    hook.unmount();
+  });
+
+  it("does not trigger with empty items", () => {
+    const hook = renderHook({ isProcessing: true, items: [] });
+    hook.rerender({ isProcessing: false, items: [] });
+    expect(mockPredictResponse).not.toHaveBeenCalled();
+    hook.unmount();
+  });
+
+  it("does not trigger prediction when composer already has draft text", () => {
+    const hook = renderHook({ isProcessing: true, composerText: "draft" });
+    hook.rerender({ isProcessing: false, composerText: "draft" });
+    expect(mockPredictResponse).not.toHaveBeenCalled();
+    hook.unmount();
+  });
+
+  it("invalidates in-flight prediction when typing dismisses suggestion", async () => {
+    const deferred = createDeferred<string>();
+    mockPredictResponse.mockReturnValueOnce(deferred.promise);
+
+    const hook = renderHook({ isProcessing: true, composerText: "" });
+    await act(async () => {
+      hook.rerender({ isProcessing: false, composerText: "" });
+    });
+
+    expect(mockPredictResponse).toHaveBeenCalledOnce();
+    hook.rerender({ composerText: "typing" });
+    expect(hook.result.ghostText).toBeNull();
+
+    await act(async () => {
+      deferred.resolve("stale suggestion");
+      await deferred.promise;
+    });
+
+    hook.rerender({ composerText: "" });
+    expect(hook.result.ghostText).toBeNull();
+    hook.unmount();
+  });
+});
diff --git a/src/features/composer/hooks/usePredictedResponse.ts b/src/features/composer/hooks/usePredictedResponse.ts
new file mode 100644
index 000000000..4383aa77c
--- /dev/null
+++ b/src/features/composer/hooks/usePredictedResponse.ts
@@ -0,0 +1,196 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import type { ConversationItem, ModelOption } from "../../../types";
+import { predictResponse } from "../../../services/tauri";
+
+type PredictionState = "idle" | "loading" | "ready" | "dismissed";
+
+type UsePredictedResponseOptions = {
+  workspaceId: string | null;
+  threadId: string | null;
+  composerText: string;
+  disabled: boolean;
+  isProcessing: boolean;
+  items: ConversationItem[];
+  models: ModelOption[];
+};
+
+function pickFastModelId(models: ModelOption[]): string | undefined {
+  const keywords = ["spark", "mini"] as const;
+  for (const keyword of keywords) {
+    for (let i = models.length - 1; i >= 0; i--) {
+      const m = models[i];
+      const haystack = `${m.model} ${m.displayName}`.toLowerCase();
+      if (haystack.includes(keyword)) {
+        return m.id;
+      }
+    }
+  }
+  return undefined;
+}
+
+type UsePredictedResponseResult = {
+  ghostText: string | null;
+  acceptPrediction: () => string | null;
+  dismissPrediction: () => void;
+};
+
+function lastParagraph(text: string): string {
+  const paragraphs = text.split(/\n\s*\n/).filter((p) => p.trim());
+  const para = paragraphs.length
+    ? paragraphs[paragraphs.length - 1].trim()
+    : text.trim();
+  return para.length > 2000 ? para.slice(0, 2000) : para;
+}
+
+function buildContextFromItems(items: ConversationItem[]): string {
+  const recent = items.slice(-5);
+  return recent
+    .map((item) => {
+      if (item.kind === "message") {
+        const role = item.role === "user" ? "User" : "Assistant";
+        return `${role}: ${lastParagraph(item.text)}`;
+      }
+      if (item.kind === "diff") {
+        return `Assistant: [Applied changes to ${item.title}]`;
+      }
+      if (item.kind === "tool") {
+        return `Assistant: [Used tool: ${item.toolType}]`;
+      }
+      return null;
+    })
+    .filter(Boolean)
+    .join("\n\n");
+}
+
+export function usePredictedResponse({
+  workspaceId,
+  threadId,
+  composerText,
+  disabled,
+  isProcessing,
+  items,
+  models,
+}: UsePredictedResponseOptions): UsePredictedResponseResult {
+  const [state, setState] = useState<PredictionState>("idle");
+  const [prediction, setPrediction] = useState<string | null>(null);
+  const requestCounterRef = useRef(0);
+  const wasProcessingRef = useRef(false);
+
+  // Reset on thread or workspace change
+  useEffect(() => {
+    setState("idle");
+    setPrediction(null);
+    requestCounterRef.current += 1;
+    wasProcessingRef.current = false;
+  }, [threadId, workspaceId]);
+
+  // Disabling predictions should immediately clear any in-flight or ready suggestion state.
+  useEffect(() => {
+    if (!disabled) {
+      return;
+    }
+    requestCounterRef.current += 1;
+    setState("idle");
+    setPrediction(null);
+  }, [disabled]);
+
+  // Track isProcessing transitions: true → false triggers prediction
+  useEffect(() => {
+    const wasProcessing = wasProcessingRef.current;
+    wasProcessingRef.current = isProcessing;
+
+    if (!wasProcessing || isProcessing) {
+      // New turn started — cancel any in-flight prediction
+      if (isProcessing && (state === "loading" || state === "ready")) {
+        requestCounterRef.current += 1;
+        setState("idle");
+        setPrediction(null);
+      }
+      return;
+    }
+
+    // Turn just completed
+    if (
+      disabled ||
+      composerText.length > 0 ||
+      !workspaceId ||
+      !threadId ||
+      items.length === 0
+    ) {
+      return;
+    }
+
+    const lastItem = items[items.length - 1];
+    const isAssistantTurn =
+      lastItem &&
+      (lastItem.kind !== "message" || lastItem.role === "assistant");
+    if (!isAssistantTurn) {
+      return;
+    }
+
+    const context = buildContextFromItems(items);
+    if (!context.trim()) {
+      return;
+    }
+
+    const currentRequest = ++requestCounterRef.current;
+    setState("loading");
+    setPrediction(null);
+
+    const fastModel = pickFastModelId(models);
+    predictResponse(workspaceId, context, fastModel).then(
+      (result) => {
+        if (requestCounterRef.current !== currentRequest) {
+          return;
+        }
+        const trimmed = result.trim();
+        if (trimmed && trimmed.toUpperCase() !== "NONE") {
+          setPrediction(trimmed);
+          setState("ready");
+        } else {
+          setState("idle");
+        }
+      },
+      () => {
+        if (requestCounterRef.current !== currentRequest) {
+          return;
+        }
+        setState("idle");
+      },
+    );
+  }, [isProcessing, disabled, composerText, workspaceId, threadId, items, models, state]);
+
+  // Dismiss when user starts typing
+  useEffect(() => {
+    if (composerText.length > 0 && (state === "ready" || state === "loading")) {
+      requestCounterRef.current += 1;
+      setState("dismissed");
+      setPrediction(null);
+    }
+  }, [composerText, state]);
+
+  const ghostText =
+    state === "ready" && prediction && composerText.length === 0
+      ? prediction
+      : null;
+
+  const acceptPrediction = useCallback((): string | null => {
+    if (state !== "ready" || !prediction) {
+      return null;
+    }
+    setState("dismissed");
+    const accepted = prediction;
+    setPrediction(null);
+    return accepted;
+  }, [state, prediction]);
+
+  const dismissPrediction = useCallback(() => {
+    if (state === "ready" || state === "loading") {
+      requestCounterRef.current += 1;
+      setState("dismissed");
+      setPrediction(null);
+    }
+  }, [state]);
+
+  return { ghostText, acceptPrediction, dismissPrediction };
+}
diff --git a/src/features/layout/hooks/layoutNodes/buildPrimaryNodes.tsx b/src/features/layout/hooks/layoutNodes/buildPrimaryNodes.tsx
index 81a1c5c00..2c5cd115c 100644
--- a/src/features/layout/hooks/layoutNodes/buildPrimaryNodes.tsx
+++ b/src/features/layout/hooks/layoutNodes/buildPrimaryNodes.tsx
@@ -186,6 +186,8 @@ export function buildPrimaryNodes(options: LayoutNodesOptions): PrimaryLayoutNod
       dictationHint={options.dictationHint}
       onDismissDictationHint={options.onDismissDictationHint}
       contextActions={options.composerContextActions}
+      ghostText={options.ghostText}
+      onAcceptGhostText={options.onAcceptGhostText}
       reviewPrompt={options.reviewPrompt}
       onReviewPromptClose={options.onReviewPromptClose}
       onReviewPromptShowPreset={options.onReviewPromptShowPreset}
diff --git a/src/features/layout/hooks/layoutNodes/types.ts b/src/features/layout/hooks/layoutNodes/types.ts
index 7b24d5b35..fc49951e3 100644
--- a/src/features/layout/hooks/layoutNodes/types.ts
+++ b/src/features/layout/hooks/layoutNodes/types.ts
@@ -474,6 +474,8 @@ export type LayoutNodesOptions = {
   dictationHint: string | null;
   onDismissDictationHint: () => void;
   composerContextActions: ComposerContextAction[];
+  ghostText: string | null;
+  onAcceptGhostText: () => string | null;
   showComposer: boolean;
   composerSendLabel?: string;
   plan: TurnPlan | null;
diff --git a/src/features/settings/components/SettingsView.test.tsx b/src/features/settings/components/SettingsView.test.tsx
index e8d5a7e03..1e8a77b9a 100644
--- a/src/features/settings/components/SettingsView.test.tsx
+++ b/src/features/settings/components/SettingsView.test.tsx
@@ -125,6 +125,7 @@ const baseSettings: AppSettings = {
   pauseQueuedMessagesWhenResponseRequired: true,
   unifiedExecEnabled: true,
   experimentalAppsEnabled: false,
+  promptSuggestionsEnabled: false,
   personality: "friendly",
   dictationEnabled: false,
   dictationModelId: "base",
@@ -1427,6 +1428,29 @@ describe("SettingsView Features", () => {
     });
   });
 
+  it("toggles prompt suggestions in experimental features", async () => {
+    const onUpdateAppSettings = vi.fn().mockResolvedValue(undefined);
+    renderFeaturesSection({
+      onUpdateAppSettings,
+      appSettings: { promptSuggestionsEnabled: false },
+    });
+
+    const promptSuggestionsTitle = screen.getByText(
+      "Prompt suggestions after agent turns",
+    );
+    const promptSuggestionsRow = promptSuggestionsTitle.closest(".settings-toggle-row");
+    expect(promptSuggestionsRow).not.toBeNull();
+
+    const toggle = within(promptSuggestionsRow as HTMLElement).getByRole("button");
+    fireEvent.click(toggle);
+
+    await waitFor(() => {
+      expect(onUpdateAppSettings).toHaveBeenCalledWith(
+        expect.objectContaining({ promptSuggestionsEnabled: true }),
+      );
+    });
+  });
+
   it("shows fallback description when Codex omits feature description", async () => {
     renderFeaturesSection({
       experimentalFeaturesResponse: {
diff --git a/src/features/settings/components/sections/SettingsFeaturesSection.tsx b/src/features/settings/components/sections/SettingsFeaturesSection.tsx
index 89f6a25b2..a6dd1957c 100644
--- a/src/features/settings/components/sections/SettingsFeaturesSection.tsx
+++ b/src/features/settings/components/sections/SettingsFeaturesSection.tsx
@@ -185,6 +185,29 @@ export function SettingsFeaturesSection({
       <div className="settings-subsection-subtitle">
         Preview and under-development features.
       </div>
+      <div className="settings-toggle-row">
+        <div>
+          <div className="settings-toggle-title">
+            Prompt suggestions after agent turns
+          </div>
+          <div className="settings-toggle-subtitle">
+            Show a ghost-text follow-up suggestion when an agent response completes.
+          </div>
+        </div>
+        <button
+          type="button"
+          className={`settings-toggle ${appSettings.promptSuggestionsEnabled ? "on" : ""}`}
+          onClick={() =>
+            void onUpdateAppSettings({
+              ...appSettings,
+              promptSuggestionsEnabled: !appSettings.promptSuggestionsEnabled,
+            })
+          }
+          aria-pressed={appSettings.promptSuggestionsEnabled}
+        >
+          <span className="settings-toggle-knob" />
+        </button>
+      </div>
       {experimentalFeatures.map((feature) => (
         <div className="settings-toggle-row" key={feature.name}>
           <div>
diff --git a/src/features/settings/hooks/useAppSettings.test.ts b/src/features/settings/hooks/useAppSettings.test.ts
index c6eb4221e..2a0360be4 100644
--- a/src/features/settings/hooks/useAppSettings.test.ts
+++ b/src/features/settings/hooks/useAppSettings.test.ts
@@ -71,6 +71,7 @@ describe("useAppSettings", () => {
     expect(result.current.settings.backendMode).toBe("local");
     expect(result.current.settings.dictationModelId).toBe("base");
     expect(result.current.settings.interruptShortcut).toBeTruthy();
+    expect(result.current.settings.promptSuggestionsEnabled).toBe(false);
   });
 
   it("persists settings via updateAppSettings and updates local state", async () => {
diff --git a/src/features/settings/hooks/useAppSettings.ts b/src/features/settings/hooks/useAppSettings.ts
index e4dafaccc..b4527d4ff 100644
--- a/src/features/settings/hooks/useAppSettings.ts
+++ b/src/features/settings/hooks/useAppSettings.ts
@@ -189,6 +189,7 @@ function buildDefaultSettings(): AppSettings {
     pauseQueuedMessagesWhenResponseRequired: true,
     unifiedExecEnabled: true,
     experimentalAppsEnabled: false,
+    promptSuggestionsEnabled: false,
     personality: "friendly",
     dictationEnabled: false,
     dictationModelId: "base",
diff --git a/src/services/tauri.ts b/src/services/tauri.ts
index 07919a72f..8a77c33ab 100644
--- a/src/services/tauri.ts
+++ b/src/services/tauri.ts
@@ -1088,6 +1088,14 @@ export async function getAppBuildType(): Promise<AppBuildType> {
   return invoke<AppBuildType>("app_build_type");
 }
 
+export async function predictResponse(
+  workspaceId: string,
+  context: string,
+  model?: string,
+): Promise<string> {
+  return invoke<string>("predict_response", { workspaceId, context, model });
+}
+
 export async function sendNotification(
   title: string,
   body: string,
diff --git a/src/styles/composer.css b/src/styles/composer.css
index be1f4d6f7..152c03d37 100644
--- a/src/styles/composer.css
+++ b/src/styles/composer.css
@@ -318,10 +318,85 @@
   font-size: 14px;
   -webkit-app-region: no-drag;
   overflow-y: hidden;
+  position: relative;
+  z-index: 0;
 }
 
 .composer textarea:focus {
   outline: none;
+  background: transparent;
+}
+
+.composer-textarea-wrapper {
+  position: relative;
+  flex: 1;
+  min-width: 0;
+}
+
+.composer-placeholder {
+  position: absolute;
+  top: 0;
+  left: 0;
+  right: 0;
+  padding: 8px 4px;
+  font-size: 14px;
+  pointer-events: none;
+  color: var(--text-faint);
+  white-space: pre-wrap;
+  overflow: hidden;
+  line-height: inherit;
+  font-family: inherit;
+  z-index: 1;
+  opacity: 1;
+  transform: translateY(0);
+  transition: opacity 200ms ease-out, transform 200ms ease-out;
+}
+
+.composer-placeholder-hidden {
+  opacity: 0;
+  transform: translateY(-2px);
+}
+
+.composer-ghost-text {
+  position: absolute;
+  top: 0;
+  left: 0;
+  right: 0;
+  padding: 8px 4px;
+  font-size: 14px;
+  pointer-events: none;
+  color: var(--text-fainter);
+  white-space: pre-wrap;
+  overflow: hidden;
+  line-height: inherit;
+  font-family: inherit;
+  z-index: 1;
+  opacity: 0;
+  transform: translateY(2px);
+  transition: opacity 250ms ease-out, transform 250ms ease-out;
+}
+
+.composer-ghost-text-visible {
+  opacity: 0.5;
+  transform: translateY(0);
+}
+
+.composer-ghost-text-hint {
+  display: inline-block;
+  margin-left: 8px;
+  font-size: 10px;
+  padding: 1px 5px;
+  border-radius: 3px;
+  background: var(--surface-card);
+  border: 1px solid var(--border-muted);
+  color: var(--text-muted);
+  opacity: 0;
+  vertical-align: middle;
+  transition: opacity 350ms ease-out;
+}
+
+.composer-ghost-text-visible .composer-ghost-text-hint {
+  opacity: 0.7;
 }
 
 .composer-action {
diff --git a/src/types.ts b/src/types.ts
index 6eebb7ebf..1d4765573 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -257,6 +257,7 @@ export type AppSettings = {
   pauseQueuedMessagesWhenResponseRequired: boolean;
   unifiedExecEnabled: boolean;
   experimentalAppsEnabled: boolean;
+  promptSuggestionsEnabled: boolean;
   personality: PersonalityPreference;
   dictationEnabled: boolean;
   dictationModelId: string;