diff --git a/main.js b/main.js
index eeeed4445..426c74a3a 100644
--- a/main.js
+++ b/main.js
@@ -740,13 +740,30 @@ async function startApp() {
     debugLogger.debug("Parakeet startup init error (non-fatal)", { error: err.message });
   });
 
-  if (process.env.REASONING_PROVIDER === "local" && process.env.LOCAL_REASONING_MODEL) {
+  // TODO: drop legacy REASONING_PROVIDER / LOCAL_REASONING_MODEL fallbacks after 2 releases.
+  const cleanupProvider = process.env.CLEANUP_PROVIDER || process.env.REASONING_PROVIDER;
+  const cleanupLocalModel =
+    process.env.LOCAL_CLEANUP_MODEL || process.env.LOCAL_REASONING_MODEL;
+  if (cleanupProvider === "local" && cleanupLocalModel) {
     const modelManager = require("./src/helpers/modelManagerBridge").default;
-    modelManager.prewarmServer(process.env.LOCAL_REASONING_MODEL).catch((err) => {
+    modelManager.prewarmServer(cleanupLocalModel).catch((err) => {
       debugLogger.debug("llama-server pre-warm error (non-fatal)", { error: err.message });
     });
   }
 
+  if (
+    process.env.DICTATION_AGENT_PROVIDER === "local" &&
+    process.env.LOCAL_DICTATION_AGENT_MODEL &&
+    process.env.LOCAL_DICTATION_AGENT_MODEL !== cleanupLocalModel
+  ) {
+    const modelManager = require("./src/helpers/modelManagerBridge").default;
+    modelManager.prewarmServer(process.env.LOCAL_DICTATION_AGENT_MODEL).catch((err) => {
+      debugLogger.debug("dictation-agent llama-server pre-warm error (non-fatal)", {
+        error: err.message,
+      });
+    });
+  }
+
   // Auto-download diarization models if binary is available
   if (
     diarizationManager.getBinaryPath() &&
diff --git a/src/components/ControlPanel.tsx b/src/components/ControlPanel.tsx
index e2596715a..724980716 100644
--- a/src/components/ControlPanel.tsx
+++ b/src/components/ControlPanel.tsx
@@ -79,7 +79,7 @@ export default function ControlPanel() {
   const {
     useLocalWhisper,
     localTranscriptionProvider,
-    useReasoningModel,
+    useCleanupModel,
     setUseLocalWhisper,
     setCloudTranscriptionMode,
   } = useSettings();
@@ -242,7 +242,7 @@ export default function ControlPanel() {
           if (status?.gpuInfo.hasNvidiaGpu && !status.downloaded) results.cuda = true;
         } catch {}
       }
-      if (useReasoningModel) {
+      if (useCleanupModel) {
         try {
           const [gpu, vulkan] = await Promise.all([
             window.electronAPI?.detectVulkanGpu?.(),
@@ -254,7 +254,7 @@ export default function ControlPanel() {
       setGpuAccelAvailable(results);
     };
     detect();
-  }, [useLocalWhisper, localTranscriptionProvider, useReasoningModel, gpuBannerDismissed]);
+  }, [useLocalWhisper, localTranscriptionProvider, useCleanupModel, gpuBannerDismissed]);
 
   useEffect(() => {
     const cleanup = window.electronAPI?.onNavigateToMeetingNote?.((data) => {
@@ -447,17 +447,17 @@ export default function ControlPanel() {
           let finalTranscription = result.transcription;
 
           // Apply AI reasoning if enabled
-          if (useReasoningModel) {
+          if (useCleanupModel) {
             try {
               const [
                 { default: ReasoningService },
-                { getEffectiveReasoningModel, isCloudReasoningMode },
+                { getEffectiveCleanupModel, isCloudCleanupMode },
               ] = await Promise.all([
                 import("../services/ReasoningService"),
                 import("../stores/settingsStore"),
               ]);
-              const model = getEffectiveReasoningModel();
-              const isCloud = isCloudReasoningMode();
+              const model = getEffectiveCleanupModel();
+              const isCloud = isCloudCleanupMode();
               if (model || isCloud) {
                 const agentName = localStorage.getItem("agentName") || null;
                 const reasonedText = await ReasoningService.processText(rawText, model, agentName);
@@ -493,7 +493,7 @@ export default function ControlPanel() {
         });
       }
     },
-    [toast, t, useReasoningModel]
+    [toast, t, useCleanupModel]
   );
 
   const handleUpdateClick = async () => {
@@ -791,7 +791,7 @@ export default function ControlPanel() {
                 setShowCloudMigrationBanner={setShowCloudMigrationBanner}
                 aiCTADismissed={aiCTADismissed}
                 setAiCTADismissed={setAiCTADismissed}
-                useReasoningModel={useReasoningModel}
+                useCleanupModel={useCleanupModel}
                 copyToClipboard={copyToClipboard}
                 deleteTranscription={deleteTranscription}
                 clearAllTranscriptions={clearAllTranscriptions}
diff --git a/src/components/HistoryView.tsx b/src/components/HistoryView.tsx
index 7fe6acfd1..a1b2f222f 100644
--- a/src/components/HistoryView.tsx
+++ b/src/components/HistoryView.tsx
@@ -19,7 +19,7 @@ interface HistoryViewProps {
   setShowCloudMigrationBanner: (show: boolean) => void;
   aiCTADismissed: boolean;
   setAiCTADismissed: (dismissed: boolean) => void;
-  useReasoningModel: boolean;
+  useCleanupModel: boolean;
   copyToClipboard: (text: string) => void;
   deleteTranscription: (id: number) => void;
   clearAllTranscriptions: () => void;
@@ -36,7 +36,7 @@ export default function HistoryView({
   setShowCloudMigrationBanner,
   aiCTADismissed,
   setAiCTADismissed,
-  useReasoningModel,
+  useCleanupModel,
   copyToClipboard,
   deleteTranscription,
   clearAllTranscriptions,
@@ -111,7 +111,7 @@ export default function HistoryView({
           </div>
         )}
 
-        {!useReasoningModel && !aiCTADismissed && (
+        {!useCleanupModel && !aiCTADismissed && (
           <div className="mb-3 relative rounded-lg border border-primary/20 bg-primary/5 dark:bg-primary/10 p-3">
             <button
               onClick={() => {
diff --git a/src/components/SettingsPage.tsx b/src/components/SettingsPage.tsx
index b758569cb..e232357a4 100644
--- a/src/components/SettingsPage.tsx
+++ b/src/components/SettingsPage.tsx
@@ -29,7 +29,6 @@ import {
   BookOpen,
   Copy,
   Trash2,
-  Building2,
   MessageSquare,
   FileAudio,
   Wand2,
@@ -63,8 +62,6 @@ import { useClipboard } from "../hooks/useClipboard";
 import { useUpdater } from "../hooks/useUpdater";
 
 import PromptStudio from "./ui/PromptStudio";
-import ReasoningModelSelector from "./ReasoningModelSelector";
-import EnterpriseSection from "./EnterpriseSection";
 import { ProviderTabs } from "./ui/ProviderTabs";
 import { HotkeyInput } from "./ui/HotkeyInput";
 import { useHotkeyRegistration } from "../hooks/useHotkeyRegistration";
@@ -76,8 +73,10 @@ import { ActivationModeSelector } from "./ui/ActivationModeSelector";
 import LinuxPttSetupInfo from "./ui/LinuxPttSetupInfo";
 import { Toggle } from "./ui/toggle";
 import DeveloperSection from "./DeveloperSection";
-import AgentModeSettings from "./settings/AgentModeSettings";
-import { MeetingReasoningPanel, MeetingTranscriptionPanel } from "./settings/MeetingSettings";
+import ChatAgentSettings from "./settings/ChatAgentSettings";
+import DictationAgentSettings from "./settings/DictationAgentSettings";
+import InferenceConfigEditor from "./settings/InferenceConfigEditor";
+import { MeetingTranscriptionPanel } from "./settings/MeetingSettings";
 import LanguageSelector from "./ui/LanguageSelector";
 import { Skeleton } from "./ui/skeleton";
 import { Progress } from "./ui/progress";
@@ -395,32 +394,8 @@ function TranscriptionSection({
 }
 
 interface AiModelsSectionProps {
-  isSignedIn: boolean;
-  startOnboarding: () => void;
-  cloudReasoningMode: string;
-  setCloudReasoningMode: (mode: string) => void;
-  useReasoningModel: boolean;
-  setUseReasoningModel: (value: boolean) => void;
-  reasoningModel: string;
-  setReasoningModel: (model: string) => void;
-  reasoningProvider: string;
-  setReasoningProvider: (provider: string) => void;
-  cloudReasoningBaseUrl: string;
-  setCloudReasoningBaseUrl: (url: string) => void;
-  openaiApiKey: string;
-  setOpenaiApiKey: (key: string) => void;
-  anthropicApiKey: string;
-  setAnthropicApiKey: (key: string) => void;
-  geminiApiKey: string;
-  setGeminiApiKey: (key: string) => void;
-  groqApiKey: string;
-  setGroqApiKey: (key: string) => void;
-  customReasoningApiKey: string;
-  setCustomReasoningApiKey: (key: string) => void;
-  reasoningMode: InferenceMode;
-  setReasoningMode: (mode: InferenceMode) => void;
-  remoteReasoningUrl: string;
-  setRemoteReasoningUrl: (url: string) => void;
+  useCleanupModel: boolean;
+  setUseCleanupModel: (value: boolean) => void;
   toast: (opts: {
     title: string;
     description: string;
@@ -429,91 +404,19 @@ interface AiModelsSectionProps {
   }) => void;
 }
 
-function AiModelsSection({
-  isSignedIn,
-  startOnboarding,
-  cloudReasoningMode,
-  setCloudReasoningMode,
-  useReasoningModel,
-  setUseReasoningModel,
-  reasoningModel,
-  setReasoningModel,
-  reasoningProvider,
-  setReasoningProvider,
-  cloudReasoningBaseUrl,
-  setCloudReasoningBaseUrl,
-  openaiApiKey,
-  setOpenaiApiKey,
-  anthropicApiKey,
-  setAnthropicApiKey,
-  geminiApiKey,
-  setGeminiApiKey,
-  groqApiKey,
-  setGroqApiKey,
-  customReasoningApiKey,
-  setCustomReasoningApiKey,
-  reasoningMode,
-  setReasoningMode,
-  remoteReasoningUrl,
-  setRemoteReasoningUrl,
-  toast,
-}: AiModelsSectionProps) {
-  const { t } = useTranslation();
+const CLEANUP_MODE_TOAST_KEY: Record<InferenceMode, string> = {
+  openwhispr: "switchedCloud",
+  providers: "switchedProviders",
+  local: "switchedLocal",
+  "self-hosted": "switchedSelfHosted",
+  enterprise: "switchedEnterprise",
+};
 
-  const aiModes: InferenceModeOption[] = [
-    {
-      id: "openwhispr",
-      label: t("settingsPage.aiModels.modes.openwhispr"),
-      description: t("settingsPage.aiModels.modes.openwhisprDesc"),
-      icon: <Cloud className="w-4 h-4" />,
-      disabled: !isSignedIn,
-      badge: !isSignedIn ? t("common.freeAccountRequired") : undefined,
-    },
-    {
-      id: "providers",
-      label: t("settingsPage.aiModels.modes.providers"),
-      description: t("settingsPage.aiModels.modes.providersDesc"),
-      icon: <Key className="w-4 h-4" />,
-    },
-    {
-      id: "local",
-      label: t("settingsPage.aiModels.modes.local"),
-      description: t("settingsPage.aiModels.modes.localDesc"),
-      icon: <Cpu className="w-4 h-4" />,
-    },
-    {
-      id: "self-hosted",
-      label: t("settingsPage.aiModels.modes.selfHosted"),
-      description: t("settingsPage.aiModels.modes.selfHostedDesc"),
-      icon: <Network className="w-4 h-4" />,
-    },
-    {
-      id: "enterprise",
-      label: t("settingsPage.aiModels.modes.enterprise"),
-      description: t("settingsPage.aiModels.modes.enterpriseDesc"),
-      icon: <Building2 className="w-4 h-4" />,
-    },
-  ];
-
-  const handleReasoningModeSelect = (mode: InferenceMode) => {
-    if (mode === "openwhispr" && !isSignedIn) {
-      startOnboarding();
-      return;
-    }
-    if (mode === reasoningMode) return;
-    setReasoningMode(mode);
-    setCloudReasoningMode(mode === "openwhispr" ? "openwhispr" : "byok");
-    if (mode === "openwhispr" || mode === "self-hosted" || mode === "enterprise") {
-      window.electronAPI?.llamaServerStop?.();
-    }
+function AiModelsSection({ useCleanupModel, setUseCleanupModel, toast }: AiModelsSectionProps) {
+  const { t } = useTranslation();
 
-    const toastKey = {
-      openwhispr: "switchedCloud",
-      providers: "switchedProviders",
-      local: "switchedLocal",
-      "self-hosted": "switchedSelfHosted",
-      enterprise: "switchedEnterprise",
-    }[mode];
+  const handleCleanupModeChange = (mode: InferenceMode) => {
+    const toastKey = CLEANUP_MODE_TOAST_KEY[mode];
     toast({
       title: t(`settingsPage.aiModels.toasts.${toastKey}.title`),
       description: t(`settingsPage.aiModels.toasts.${toastKey}.description`),
@@ -522,29 +425,6 @@ function AiModelsSection({
     });
   };
 
-  const renderReasoningSelector = (mode?: "cloud" | "local") => (
-    <ReasoningModelSelector
-      reasoningModel={reasoningModel}
-      setReasoningModel={setReasoningModel}
-      localReasoningProvider={reasoningProvider}
-      setLocalReasoningProvider={setReasoningProvider}
-      cloudReasoningBaseUrl={cloudReasoningBaseUrl}
-      setCloudReasoningBaseUrl={setCloudReasoningBaseUrl}
-      openaiApiKey={openaiApiKey}
-      setOpenaiApiKey={setOpenaiApiKey}
-      anthropicApiKey={anthropicApiKey}
-      setAnthropicApiKey={setAnthropicApiKey}
-      geminiApiKey={geminiApiKey}
-      setGeminiApiKey={setGeminiApiKey}
-      groqApiKey={groqApiKey}
-      setGroqApiKey={setGroqApiKey}
-      customReasoningApiKey={customReasoningApiKey}
-      setCustomReasoningApiKey={setCustomReasoningApiKey}
-      setReasoningMode={setReasoningMode}
-      mode={mode}
-    />
-  );
-
   return (
     <div className="space-y-4">
       <SettingsPanel>
@@ -553,38 +433,14 @@ function AiModelsSection({
             label={t("settingsPage.aiModels.enableTextCleanup")}
             description={t("settingsPage.aiModels.enableTextCleanupDescription")}
           >
-            <Toggle checked={useReasoningModel} onChange={setUseReasoningModel} />
+            <Toggle checked={useCleanupModel} onChange={setUseCleanupModel} />
           </SettingsRow>
         </SettingsPanelRow>
       </SettingsPanel>
 
-      {useReasoningModel && (
+      {useCleanupModel && (
         <>
-          <InferenceModeSelector
-            modes={aiModes}
-            activeMode={reasoningMode}
-            onSelect={handleReasoningModeSelect}
-          />
-
-          {reasoningMode === "providers" && renderReasoningSelector("cloud")}
-          {reasoningMode === "local" && renderReasoningSelector("local")}
-
-          {reasoningMode === "self-hosted" && (
-            <SelfHostedPanel
-              service="reasoning"
-              url={remoteReasoningUrl}
-              onUrlChange={setRemoteReasoningUrl}
-            />
-          )}
-
-          {reasoningMode === "enterprise" && (
-            <EnterpriseSection
-              currentProvider={reasoningProvider}
-              reasoningModel={reasoningModel}
-              setReasoningModel={setReasoningModel}
-              setLocalReasoningProvider={setReasoningProvider}
-            />
-          )}
+          <InferenceConfigEditor scope="dictationCleanup" onModeChange={handleCleanupModeChange} />
           <GpuDeviceSelector purpose="intelligence" />
         </>
       )}
@@ -593,10 +449,15 @@ function AiModelsSection({
 }
 
 type SpeechTab = "dictation" | "noteRecording";
-type LlmTab = "dictationCleanup" | "noteFormatting" | "chatIntelligence";
+type LlmTab = "dictationCleanup" | "dictationAgent" | "noteFormatting" | "chatIntelligence";
 
 const SPEECH_TABS: SpeechTab[] = ["dictation", "noteRecording"];
-const LLM_TABS: LlmTab[] = ["dictationCleanup", "noteFormatting", "chatIntelligence"];
+const LLM_TABS: LlmTab[] = [
+  "dictationCleanup",
+  "dictationAgent",
+  "noteFormatting",
+  "chatIntelligence",
+];
 
 function useSubTab<T extends string>(storageKey: string, options: readonly T[], initial?: T) {
   const [tab, setTab] = useLocalStorage<T>(storageKey, initial ?? options[0]);
@@ -651,11 +512,13 @@ function SpeechToTextTabs({
 function LlmsTabs({
   initialTab,
   renderDictationCleanup,
+  renderDictationAgent,
   renderNoteFormatting,
   renderChatIntelligence,
 }: {
   initialTab?: LlmTab;
   renderDictationCleanup: () => React.ReactNode;
+  renderDictationAgent: () => React.ReactNode;
   renderNoteFormatting: () => React.ReactNode;
   renderChatIntelligence: () => React.ReactNode;
 }) {
@@ -664,6 +527,7 @@ function LlmsTabs({
 
   const subTabs = [
     { id: "dictationCleanup", name: t("settingsPage.llms.tabs.dictationCleanup") },
+    { id: "dictationAgent", name: t("settingsPage.llms.tabs.dictationAgent") },
     { id: "noteFormatting", name: t("settingsPage.llms.tabs.noteFormatting") },
     { id: "chatIntelligence", name: t("settingsPage.llms.tabs.chatIntelligence") },
   ];
@@ -680,11 +544,13 @@ function LlmsTabs({
         onSelect={(id) => setTab(id as LlmTab)}
         renderIcon={(id) => {
           if (id === "dictationCleanup") return <Wand2 className="w-3.5 h-3.5" />;
+          if (id === "dictationAgent") return <Sparkles className="w-3.5 h-3.5" />;
           if (id === "noteFormatting") return <BookOpen className="w-3.5 h-3.5" />;
           return <MessageSquare className="w-3.5 h-3.5" />;
         }}
       />
       {tab === "dictationCleanup" && renderDictationCleanup()}
+      {tab === "dictationAgent" && renderDictationAgent()}
       {tab === "noteFormatting" && renderNoteFormatting()}
       {tab === "chatIntelligence" && renderChatIntelligence()}
     </div>
@@ -780,10 +646,7 @@ export default function SettingsPage({
     cloudTranscriptionProvider,
     cloudTranscriptionModel,
     cloudTranscriptionBaseUrl,
-    cloudReasoningBaseUrl,
-    useReasoningModel,
-    reasoningModel,
-    reasoningProvider,
+    useCleanupModel,
     openaiApiKey,
     anthropicApiKey,
     geminiApiKey,
@@ -804,10 +667,7 @@ export default function SettingsPage({
     setCloudTranscriptionProvider,
     setCloudTranscriptionModel,
     setCloudTranscriptionBaseUrl,
-    setCloudReasoningBaseUrl,
-    setUseReasoningModel,
-    setReasoningModel,
-    setReasoningProvider,
+    setUseCleanupModel,
     setOpenaiApiKey,
     setAnthropicApiKey,
     setGeminiApiKey,
@@ -815,27 +675,19 @@ export default function SettingsPage({
     setMistralApiKey,
     customTranscriptionApiKey,
     setCustomTranscriptionApiKey,
-    customReasoningApiKey,
-    setCustomReasoningApiKey,
     setDictationKey,
     meetingKey,
     setMeetingKey,
     autoLearnCorrections,
     setAutoLearnCorrections,
     updateTranscriptionSettings,
-    updateReasoningSettings,
+    updateCleanupSettings,
     cloudTranscriptionMode,
     setCloudTranscriptionMode,
-    cloudReasoningMode,
-    setCloudReasoningMode,
     transcriptionMode,
     setTranscriptionMode,
     remoteTranscriptionUrl,
     setRemoteTranscriptionUrl,
-    reasoningMode,
-    setReasoningMode,
-    remoteReasoningUrl,
-    setRemoteReasoningUrl,
     audioCuesEnabled,
     setAudioCuesEnabled,
     pauseMediaOnDictation,
@@ -868,8 +720,8 @@ export default function SettingsPage({
     setNoteFilesPath,
   } = useSettings();
 
-  const agentKey = useSettingsStore((s) => s.agentKey);
-  const setAgentKey = useSettingsStore((s) => s.setAgentKey);
+  const chatAgentKey = useSettingsStore((s) => s.chatAgentKey);
+  const setChatAgentKey = useSettingsStore((s) => s.setChatAgentKey);
   const meetingAudioDetection = useSettingsStore((s) => s.meetingAudioDetection);
   const setMeetingAudioDetection = useSettingsStore((s) => s.setMeetingAudioDetection);
 
@@ -1046,11 +898,11 @@ export default function SettingsPage({
         hotkey,
         {
           "settingsPage.general.meetingHotkey.title": meetingKey,
-          "agentMode.settings.hotkey": agentKey,
+          "agentMode.settings.hotkey": chatAgentKey,
         },
         t
       ),
-    [meetingKey, agentKey, t]
+    [meetingKey, chatAgentKey, t]
   );
 
   const validateMeetingHotkey = useCallback(
@@ -1059,11 +911,11 @@ export default function SettingsPage({
         hotkey,
         {
           "settingsPage.general.hotkey.title": dictationKey,
-          "agentMode.settings.hotkey": agentKey,
+          "agentMode.settings.hotkey": chatAgentKey,
         },
         t
       ),
-    [dictationKey, agentKey, t]
+    [dictationKey, chatAgentKey, t]
   );
 
   const validateAgentHotkey = useCallback(
@@ -3169,8 +3021,8 @@ EOF`,
               <SettingsPanel>
                 <SettingsPanelRow>
                   <HotkeyInput
-                    value={agentKey}
-                    onChange={setAgentKey}
+                    value={chatAgentKey}
+                    onChange={setChatAgentKey}
                     validate={validateAgentHotkey}
                   />
                 </SettingsPanelRow>
@@ -3231,7 +3083,7 @@ EOF`,
             initialTab={initialSubTab as LlmTab | undefined}
             renderChatIntelligence={() => (
               <div className="space-y-6">
-                <AgentModeSettings />
+                <ChatAgentSettings />
 
                 <div className="border-t border-border/40 pt-6 space-y-5">
                   <SectionHeader
@@ -3334,34 +3186,10 @@ EOF`,
             renderDictationCleanup={() => (
               <div className="space-y-6">
                 <AiModelsSection
-                  isSignedIn={isSignedIn ?? false}
-                  startOnboarding={startOnboarding}
-                  cloudReasoningMode={cloudReasoningMode}
-                  setCloudReasoningMode={setCloudReasoningMode}
-                  useReasoningModel={useReasoningModel}
-                  setUseReasoningModel={(value) => {
-                    updateReasoningSettings({ useReasoningModel: value });
+                  useCleanupModel={useCleanupModel}
+                  setUseCleanupModel={(value) => {
+                    updateCleanupSettings({ useCleanupModel: value });
                   }}
-                  reasoningModel={reasoningModel}
-                  setReasoningModel={setReasoningModel}
-                  reasoningProvider={reasoningProvider}
-                  setReasoningProvider={setReasoningProvider}
-                  cloudReasoningBaseUrl={cloudReasoningBaseUrl}
-                  setCloudReasoningBaseUrl={setCloudReasoningBaseUrl}
-                  openaiApiKey={openaiApiKey}
-                  setOpenaiApiKey={setOpenaiApiKey}
-                  anthropicApiKey={anthropicApiKey}
-                  setAnthropicApiKey={setAnthropicApiKey}
-                  geminiApiKey={geminiApiKey}
-                  setGeminiApiKey={setGeminiApiKey}
-                  groqApiKey={groqApiKey}
-                  setGroqApiKey={setGroqApiKey}
-                  customReasoningApiKey={customReasoningApiKey}
-                  setCustomReasoningApiKey={setCustomReasoningApiKey}
-                  reasoningMode={reasoningMode}
-                  setReasoningMode={setReasoningMode}
-                  remoteReasoningUrl={remoteReasoningUrl}
-                  setRemoteReasoningUrl={setRemoteReasoningUrl}
                   toast={toast}
                 />
 
@@ -3374,7 +3202,8 @@ EOF`,
                 </div>
               </div>
             )}
-            renderNoteFormatting={() => <MeetingReasoningPanel />}
+            renderDictationAgent={() => <DictationAgentSettings />}
+            renderNoteFormatting={() => <InferenceConfigEditor scope="noteFormatting" />}
           />
         );
 
diff --git a/src/components/chat/useChatStreaming.ts b/src/components/chat/useChatStreaming.ts
index 0760f860c..6bf926910 100644
--- a/src/components/chat/useChatStreaming.ts
+++ b/src/components/chat/useChatStreaming.ts
@@ -94,14 +94,14 @@ export function useChatStreaming({
       setAgentState("thinking");
 
       const settings = getSettings();
-      const agentMode = settings.agentInferenceMode || "openwhispr";
-      const isCloudAgent = agentMode === "openwhispr" && settings.isSignedIn;
-      const isLanAgent = agentMode === "self-hosted" && !!settings.remoteAgentUrl;
+      const chatAgentMode = settings.chatAgentMode || "openwhispr";
+      const isCloudAgent = chatAgentMode === "openwhispr" && settings.isSignedIn;
+      const isLanAgent = chatAgentMode === "self-hosted" && !!settings.chatAgentRemoteUrl;
       const isLocalProvider = !["openai", "groq", "custom", "anthropic", "gemini"].includes(
-        settings.agentProvider
+        settings.chatAgentProvider
       );
       const localModelCanUseTool =
-        isLocalProvider && estimateModelSizeB(settings.agentModel) >= LOCAL_TOOL_MIN_PARAMS_B;
+        isLocalProvider && estimateModelSizeB(settings.chatAgentModel) >= LOCAL_TOOL_MIN_PARAMS_B;
       const supportsTools = isCloudAgent || !isLocalProvider || localModelCanUseTool;
 
       let registry: ToolRegistry | null = null;
@@ -187,9 +187,9 @@ export function useChatStreaming({
           const aiTools = registry?.toAISDKFormat();
           stream = ReasoningService.processTextStreamingAI(
             llmMessages,
-            settings.agentModel,
-            settings.agentProvider,
-            { systemPrompt, lanUrl: isLanAgent ? settings.remoteAgentUrl : undefined },
+            settings.chatAgentModel,
+            settings.chatAgentProvider,
+            { systemPrompt, lanUrl: isLanAgent ? settings.chatAgentRemoteUrl : undefined },
             aiTools
           );
         }
diff --git a/src/components/notes/NotesOnboarding.tsx b/src/components/notes/NotesOnboarding.tsx
index 8af6a921c..b13f233c1 100644
--- a/src/components/notes/NotesOnboarding.tsx
+++ b/src/components/notes/NotesOnboarding.tsx
@@ -34,13 +34,13 @@ export default function NotesOnboarding({ onComplete }: NotesOnboardingProps) {
   const [isSaving, setIsSaving] = useState(false);
   const [justCreated, setJustCreated] = useState(false);
 
-  const reasoningModel = useSettingsStore((s) => s.reasoningModel);
-  const setReasoningModel = useSettingsStore((s) => s.setReasoningModel);
-  const reasoningProvider = useSettingsStore((s) => s.reasoningProvider);
-  const setReasoningProvider = useSettingsStore((s) => s.setReasoningProvider);
-  const setReasoningMode = useSettingsStore((s) => s.setReasoningMode);
-  const cloudReasoningBaseUrl = useSettingsStore((s) => s.cloudReasoningBaseUrl);
-  const setCloudReasoningBaseUrl = useSettingsStore((s) => s.setCloudReasoningBaseUrl);
+  const cleanupModel = useSettingsStore((s) => s.cleanupModel);
+  const setCleanupModel = useSettingsStore((s) => s.setCleanupModel);
+  const cleanupProvider = useSettingsStore((s) => s.cleanupProvider);
+  const setCleanupProvider = useSettingsStore((s) => s.setCleanupProvider);
+  const setCleanupMode = useSettingsStore((s) => s.setCleanupMode);
+  const cleanupCloudBaseUrl = useSettingsStore((s) => s.cleanupCloudBaseUrl);
+  const setCleanupCloudBaseUrl = useSettingsStore((s) => s.setCleanupCloudBaseUrl);
   const openaiApiKey = useSettingsStore((s) => s.openaiApiKey);
   const setOpenaiApiKey = useSettingsStore((s) => s.setOpenaiApiKey);
   const anthropicApiKey = useSettingsStore((s) => s.anthropicApiKey);
@@ -49,8 +49,8 @@ export default function NotesOnboarding({ onComplete }: NotesOnboardingProps) {
   const setGeminiApiKey = useSettingsStore((s) => s.setGeminiApiKey);
   const groqApiKey = useSettingsStore((s) => s.groqApiKey);
   const setGroqApiKey = useSettingsStore((s) => s.setGroqApiKey);
-  const customReasoningApiKey = useSettingsStore((s) => s.customReasoningApiKey);
-  const setCustomReasoningApiKey = useSettingsStore((s) => s.setCustomReasoningApiKey);
+  const cleanupCustomApiKey = useSettingsStore((s) => s.cleanupCustomApiKey);
+  const setCleanupCustomApiKey = useSettingsStore((s) => s.setCleanupCustomApiKey);
 
   const { alertDialog, hideAlertDialog } = useDialogs();
   const {
@@ -169,12 +169,12 @@ export default function NotesOnboarding({ onComplete }: NotesOnboardingProps) {
                 </p>
 
                 <ReasoningModelSelector
-                  reasoningModel={reasoningModel}
-                  setReasoningModel={setReasoningModel}
-                  localReasoningProvider={reasoningProvider}
-                  setLocalReasoningProvider={setReasoningProvider}
-                  cloudReasoningBaseUrl={cloudReasoningBaseUrl}
-                  setCloudReasoningBaseUrl={setCloudReasoningBaseUrl}
+                  reasoningModel={cleanupModel}
+                  setReasoningModel={setCleanupModel}
+                  localReasoningProvider={cleanupProvider}
+                  setLocalReasoningProvider={setCleanupProvider}
+                  cloudReasoningBaseUrl={cleanupCloudBaseUrl}
+                  setCloudReasoningBaseUrl={setCleanupCloudBaseUrl}
                   openaiApiKey={openaiApiKey}
                   setOpenaiApiKey={setOpenaiApiKey}
                   anthropicApiKey={anthropicApiKey}
@@ -183,9 +183,9 @@ export default function NotesOnboarding({ onComplete }: NotesOnboardingProps) {
                   setGeminiApiKey={setGeminiApiKey}
                   groqApiKey={groqApiKey}
                   setGroqApiKey={setGroqApiKey}
-                  customReasoningApiKey={customReasoningApiKey}
-                  setCustomReasoningApiKey={setCustomReasoningApiKey}
-                  setReasoningMode={setReasoningMode}
+                  customReasoningApiKey={cleanupCustomApiKey}
+                  setCustomReasoningApiKey={setCleanupCustomApiKey}
+                  setReasoningMode={setCleanupMode}
                 />
               </div>
             )}
diff --git a/src/components/notes/PersonalNotesView.tsx b/src/components/notes/PersonalNotesView.tsx
index 53443793b..c0ba0ccfb 100644
--- a/src/components/notes/PersonalNotesView.tsx
+++ b/src/components/notes/PersonalNotesView.tsx
@@ -46,7 +46,7 @@ import ActionPicker from "./ActionPicker";
 import ActionManagerDialog from "./ActionManagerDialog";
 import AddNotesToFolderDialog from "./AddNotesToFolderDialog";
 import { useActionProcessing } from "../../hooks/useActionProcessing";
-import { useSettingsStore, selectIsCloudReasoningMode } from "../../stores/settingsStore";
+import { useSettingsStore, selectIsCloudCleanupMode } from "../../stores/settingsStore";
 import { useFolderManagement } from "../../hooks/useFolderManagement";
 import { useNoteDragAndDrop } from "../../hooks/useNoteDragAndDrop";
 import { cn } from "../lib/utils";
@@ -116,8 +116,8 @@ export default function PersonalNotesView({
     setSyncedNoteIdState(id);
   };
   const { toast } = useToast();
-  const isCloudMode = useSettingsStore(selectIsCloudReasoningMode);
-  const effectiveModelId = useSettingsStore((s) => s.reasoningModel);
+  const isCloudMode = useSettingsStore(selectIsCloudCleanupMode);
+  const effectiveModelId = useSettingsStore((s) => s.cleanupModel);
   const noteFilesEnabled = useSettingsStore((s) => s.noteFilesEnabled);
   const fileManagerName = navigator.platform.startsWith("Mac")
     ? "Finder"
diff --git a/src/components/notes/UploadAudioView.tsx b/src/components/notes/UploadAudioView.tsx
index 5e498b33f..79ea4aecf 100644
--- a/src/components/notes/UploadAudioView.tsx
+++ b/src/components/notes/UploadAudioView.tsx
@@ -31,7 +31,7 @@ import { useUsage } from "../../hooks/useUsage";
 import { useSettings } from "../../hooks/useSettings";
 import { withSessionRefresh } from "../../lib/neonAuth";
 import { getAllReasoningModels } from "../../models/ModelRegistry";
-import { useSettingsStore, selectIsCloudReasoningMode } from "../../stores/settingsStore";
+import { useSettingsStore, selectIsCloudCleanupMode } from "../../stores/settingsStore";
 import { generateNoteTitle } from "../../utils/generateTitle";
 
 const TranscriptionModelPicker = React.lazy(() => import("../TranscriptionModelPicker"));
@@ -121,11 +121,11 @@ export default function UploadAudioView({ onNoteCreated, onOpenSettings }: Uploa
     updateTranscriptionSettings,
   } = useSettings();
 
-  const isCloudReasoning = useSettingsStore(selectIsCloudReasoningMode);
-  const effectiveReasoningModel = useSettingsStore((s) =>
-    selectIsCloudReasoningMode(s) ? "" : s.reasoningModel
+  const isCloudCleanup = useSettingsStore(selectIsCloudCleanupMode);
+  const effectiveCleanupModel = useSettingsStore((s) =>
+    selectIsCloudCleanupMode(s) ? "" : s.cleanupModel
   );
-  const useReasoningModel = useSettingsStore((s) => s.useReasoningModel);
+  const useCleanupModel = useSettingsStore((s) => s.useCleanupModel);
 
   const isOpenWhisprCloud =
     isSignedIn && cloudTranscriptionMode === "openwhispr" && !useLocalWhisper;
@@ -264,11 +264,9 @@ export default function UploadAudioView({ onNoteCreated, onOpenSettings }: Uploa
   };
 
   const generateTitle = async (text: string): Promise<string> => {
-    if (!useReasoningModel) return "";
-    const model = isCloudReasoning
-      ? ""
-      : effectiveReasoningModel || getAllReasoningModels()[0]?.value;
-    if (!model && !isCloudReasoning) return "";
+    if (!useCleanupModel) return "";
+    const model = isCloudCleanup ? "" : effectiveCleanupModel || getAllReasoningModels()[0]?.value;
+    if (!model && !isCloudCleanup) return "";
     return generateNoteTitle(text, model);
   };
 
diff --git a/src/components/settings/AgentModeSettings.tsx b/src/components/settings/AgentModeSettings.tsx
deleted file mode 100644
index 31cbcf808..000000000
--- a/src/components/settings/AgentModeSettings.tsx
+++ /dev/null
@@ -1,205 +0,0 @@
-import { useCallback } from "react";
-import { useTranslation } from "react-i18next";
-import { Cloud, Key, Cpu, Network, Building2 } from "lucide-react";
-import { useSettingsStore } from "../../stores/settingsStore";
-import { Toggle } from "../ui/toggle";
-import {
-  SettingsRow,
-  SettingsPanel,
-  SettingsPanelRow,
-  SectionHeader,
-  InferenceModeSelector,
-} from "../ui/SettingsSection";
-import type { InferenceModeOption } from "../ui/SettingsSection";
-import ReasoningModelSelector from "../ReasoningModelSelector";
-import EnterpriseSection from "../EnterpriseSection";
-import SelfHostedPanel from "../SelfHostedPanel";
-import type { InferenceMode } from "../../types/electron";
-import { modelRegistry, isEnterpriseProvider } from "../../models/ModelRegistry";
-
-function isProviderValidForMode(provider: string, mode: InferenceMode): boolean {
-  switch (mode) {
-    case "providers":
-      return modelRegistry.getCloudProviders().some((p) => p.id === provider);
-    case "local":
-      return modelRegistry.getAllProviders().some((p) => p.id === provider);
-    case "enterprise":
-      return isEnterpriseProvider(provider);
-    default:
-      return true;
-  }
-}
-
-export default function AgentModeSettings() {
-  const { t } = useTranslation();
-  const {
-    agentEnabled,
-    setAgentEnabled,
-    agentModel,
-    setAgentModel,
-    agentProvider,
-    setAgentProvider,
-    agentSystemPrompt,
-    setAgentSystemPrompt,
-    cloudAgentMode,
-    setCloudAgentMode,
-    agentInferenceMode,
-    setAgentInferenceMode,
-    remoteAgentUrl,
-    setRemoteAgentUrl,
-    isSignedIn,
-    openaiApiKey,
-    setOpenaiApiKey,
-    anthropicApiKey,
-    setAnthropicApiKey,
-    geminiApiKey,
-    setGeminiApiKey,
-    groqApiKey,
-    setGroqApiKey,
-    customReasoningApiKey,
-    setCustomReasoningApiKey,
-    cloudReasoningBaseUrl,
-    setCloudReasoningBaseUrl,
-  } = useSettingsStore();
-
-  const startOnboarding = useCallback(() => {
-    localStorage.setItem("pendingCloudMigration", "true");
-    localStorage.setItem("onboardingCurrentStep", "0");
-    localStorage.removeItem("onboardingCompleted");
-    window.location.reload();
-  }, []);
-
-  const agentModes: InferenceModeOption[] = [
-    {
-      id: "openwhispr",
-      label: t("agentMode.settings.modes.openwhispr"),
-      description: t("agentMode.settings.modes.openwhisprDesc"),
-      icon: <Cloud className="w-4 h-4" />,
-      disabled: !isSignedIn,
-      badge: !isSignedIn ? t("common.freeAccountRequired") : undefined,
-    },
-    {
-      id: "providers",
-      label: t("agentMode.settings.modes.providers"),
-      description: t("agentMode.settings.modes.providersDesc"),
-      icon: <Key className="w-4 h-4" />,
-    },
-    {
-      id: "local",
-      label: t("agentMode.settings.modes.local"),
-      description: t("agentMode.settings.modes.localDesc"),
-      icon: <Cpu className="w-4 h-4" />,
-    },
-    {
-      id: "self-hosted",
-      label: t("agentMode.settings.modes.selfHosted"),
-      description: t("agentMode.settings.modes.selfHostedDesc"),
-      icon: <Network className="w-4 h-4" />,
-    },
-    {
-      id: "enterprise",
-      label: t("agentMode.settings.modes.enterprise"),
-      description: t("agentMode.settings.modes.enterpriseDesc"),
-      icon: <Building2 className="w-4 h-4" />,
-    },
-  ];
-
-  const handleAgentModeSelect = (mode: InferenceMode) => {
-    if (mode === "openwhispr" && !isSignedIn) {
-      startOnboarding();
-      return;
-    }
-    if (mode === agentInferenceMode) return;
-    setAgentInferenceMode(mode);
-    setCloudAgentMode(mode === "openwhispr" ? "openwhispr" : "byok");
-    if (!isProviderValidForMode(agentProvider, mode)) {
-      setAgentProvider("");
-      setAgentModel("");
-    }
-    if (mode === "openwhispr" || mode === "self-hosted" || mode === "enterprise") {
-      window.electronAPI?.llamaServerStop?.();
-    }
-  };
-
-  const renderModelSelector = (mode?: "cloud" | "local") => (
-    <ReasoningModelSelector
-      reasoningModel={agentModel}
-      setReasoningModel={setAgentModel}
-      localReasoningProvider={agentProvider}
-      setLocalReasoningProvider={setAgentProvider}
-      cloudReasoningBaseUrl={cloudReasoningBaseUrl}
-      setCloudReasoningBaseUrl={setCloudReasoningBaseUrl}
-      openaiApiKey={openaiApiKey}
-      setOpenaiApiKey={setOpenaiApiKey}
-      anthropicApiKey={anthropicApiKey}
-      setAnthropicApiKey={setAnthropicApiKey}
-      geminiApiKey={geminiApiKey}
-      setGeminiApiKey={setGeminiApiKey}
-      groqApiKey={groqApiKey}
-      setGroqApiKey={setGroqApiKey}
-      customReasoningApiKey={customReasoningApiKey}
-      setCustomReasoningApiKey={setCustomReasoningApiKey}
-      setReasoningMode={setAgentInferenceMode}
-      mode={mode}
-    />
-  );
-
-  return (
-    <div className="space-y-6">
-      <SettingsPanel>
-        <SettingsPanelRow>
-          <SettingsRow
-            label={t("agentMode.settings.enabled")}
-            description={t("agentMode.settings.enabledDescription")}
-          >
-            <Toggle checked={agentEnabled} onChange={setAgentEnabled} />
-          </SettingsRow>
-        </SettingsPanelRow>
-      </SettingsPanel>
-
-      {agentEnabled && (
-        <>
-          <InferenceModeSelector
-            modes={agentModes}
-            activeMode={agentInferenceMode}
-            onSelect={handleAgentModeSelect}
-          />
-
-          {agentInferenceMode === "providers" && renderModelSelector("cloud")}
-          {agentInferenceMode === "local" && renderModelSelector("local")}
-
-          {agentInferenceMode === "self-hosted" && (
-            <SelfHostedPanel
-              service="reasoning"
-              url={remoteAgentUrl}
-              onUrlChange={setRemoteAgentUrl}
-            />
-          )}
-
-          {agentInferenceMode === "enterprise" && (
-            <EnterpriseSection
-              currentProvider={agentProvider}
-              reasoningModel={agentModel}
-              setReasoningModel={setAgentModel}
-              setLocalReasoningProvider={setAgentProvider}
-            />
-          )}
-
-          <div>
-            <SectionHeader
-              title={t("agentMode.settings.systemPrompt")}
-              description={t("agentMode.settings.systemPromptDescription")}
-            />
-            <textarea
-              value={agentSystemPrompt}
-              onChange={(e) => setAgentSystemPrompt(e.target.value)}
-              placeholder={t("agentMode.settings.systemPromptPlaceholder")}
-              rows={4}
-              className="w-full text-xs bg-transparent border border-border/50 rounded-md px-3 py-2 resize-y focus:outline-none focus:ring-2 focus:ring-ring/40 focus:border-primary/30 placeholder:text-muted-foreground/50"
-            />
-          </div>
-        </>
-      )}
-    </div>
-  );
-}
diff --git a/src/components/settings/ChatAgentSettings.tsx b/src/components/settings/ChatAgentSettings.tsx
new file mode 100644
index 000000000..4b1c07a45
--- /dev/null
+++ b/src/components/settings/ChatAgentSettings.tsx
@@ -0,0 +1,48 @@
+import { useTranslation } from "react-i18next";
+import { useSettingsStore } from "../../stores/settingsStore";
+import { Toggle } from "../ui/toggle";
+import { SettingsRow, SettingsPanel, SettingsPanelRow, SectionHeader } from "../ui/SettingsSection";
+import InferenceConfigEditor from "./InferenceConfigEditor";
+
+export default function ChatAgentSettings() {
+  const { t } = useTranslation();
+  const chatAgentEnabled = useSettingsStore((s) => s.chatAgentEnabled);
+  const setChatAgentEnabled = useSettingsStore((s) => s.setChatAgentEnabled);
+  const chatAgentPrompt = useSettingsStore((s) => s.customPrompts.chatAgent);
+  const setCustomPrompt = useSettingsStore((s) => s.setCustomPrompt);
+
+  return (
+    <div className="space-y-6">
+      <SettingsPanel>
+        <SettingsPanelRow>
+          <SettingsRow
+            label={t("agentMode.settings.enabled")}
+            description={t("agentMode.settings.enabledDescription")}
+          >
+            <Toggle checked={chatAgentEnabled} onChange={setChatAgentEnabled} />
+          </SettingsRow>
+        </SettingsPanelRow>
+      </SettingsPanel>
+
+      {chatAgentEnabled && (
+        <>
+          <InferenceConfigEditor scope="chatIntelligence" />
+
+          <div>
+            <SectionHeader
+              title={t("agentMode.settings.systemPrompt")}
+              description={t("agentMode.settings.systemPromptDescription")}
+            />
+            <textarea
+              value={chatAgentPrompt}
+              onChange={(e) => setCustomPrompt("chatAgent", e.target.value)}
+              placeholder={t("agentMode.settings.systemPromptPlaceholder")}
+              rows={4}
+              className="w-full text-xs bg-transparent border border-border/50 rounded-md px-3 py-2 resize-y focus:outline-none focus:ring-2 focus:ring-ring/40 focus:border-primary/30 placeholder:text-muted-foreground/50"
+            />
+          </div>
+        </>
+      )}
+    </div>
+  );
+}
diff --git a/src/components/settings/DictationAgentSettings.tsx b/src/components/settings/DictationAgentSettings.tsx
new file mode 100644
index 000000000..bc76dbc74
--- /dev/null
+++ b/src/components/settings/DictationAgentSettings.tsx
@@ -0,0 +1,31 @@
+import { useTranslation } from "react-i18next";
+import { SettingsPanel, SettingsPanelRow, SectionHeader } from "../ui/SettingsSection";
+import PromptStudio from "../ui/PromptStudio";
+import InferenceConfigEditor from "./InferenceConfigEditor";
+
+export default function DictationAgentSettings() {
+  const { t } = useTranslation();
+
+  return (
+    <div className="space-y-6">
+      <SettingsPanel>
+        <SettingsPanelRow>
+          <SectionHeader
+            title={t("dictationAgent.title")}
+            description={t("dictationAgent.description")}
+          />
+        </SettingsPanelRow>
+      </SettingsPanel>
+
+      <InferenceConfigEditor scope="dictationAgent" />
+
+      <div className="border-t border-border/40 pt-6">
+        <SectionHeader
+          title={t("dictationAgent.prompt.title")}
+          description={t("dictationAgent.prompt.description")}
+        />
+        <PromptStudio kind="dictationAgent" />
+      </div>
+    </div>
+  );
+}
diff --git a/src/components/settings/InferenceConfigEditor.tsx b/src/components/settings/InferenceConfigEditor.tsx
new file mode 100644
index 000000000..e1f3c6563
--- /dev/null
+++ b/src/components/settings/InferenceConfigEditor.tsx
@@ -0,0 +1,187 @@
+import { useCallback } from "react";
+import { useTranslation } from "react-i18next";
+import { Cloud, Key, Cpu, Network, Building2 } from "lucide-react";
+import {
+  useSettingsStore,
+  selectResolvedLLMConfig,
+  setResolvedLLMConfig,
+} from "../../stores/settingsStore";
+import { InferenceModeSelector } from "../ui/SettingsSection";
+import type { InferenceModeOption } from "../ui/SettingsSection";
+import ReasoningModelSelector from "../ReasoningModelSelector";
+import EnterpriseSection from "../EnterpriseSection";
+import SelfHostedPanel from "../SelfHostedPanel";
+import type { InferenceMode } from "../../types/electron";
+import type { InferenceScope } from "../../config/inferenceScopes";
+import { modelRegistry, isEnterpriseProvider } from "../../models/ModelRegistry";
+
+function isProviderValidForMode(provider: string, mode: InferenceMode): boolean {
+  switch (mode) {
+    case "providers":
+      return modelRegistry.getCloudProviders().some((p) => p.id === provider);
+    case "local":
+      return modelRegistry.getAllProviders().some((p) => p.id === provider);
+    case "enterprise":
+      return isEnterpriseProvider(provider);
+    default:
+      return true;
+  }
+}
+
+const MODE_LABEL_PREFIX: Record<InferenceScope, string> = {
+  dictationCleanup: "settingsPage.aiModels.modes",
+  noteFormatting: "settingsPage.aiModels.modes",
+  dictationAgent: "dictationAgent.modes",
+  chatIntelligence: "agentMode.settings.modes",
+};
+
+function startCloudOnboarding() {
+  localStorage.setItem("pendingCloudMigration", "true");
+  localStorage.setItem("onboardingCurrentStep", "0");
+  localStorage.removeItem("onboardingCompleted");
+  window.location.reload();
+}
+
+interface InferenceConfigEditorProps {
+  scope: InferenceScope;
+  onModeChange?: (mode: InferenceMode) => void;
+}
+
+export default function InferenceConfigEditor({ scope, onModeChange }: InferenceConfigEditorProps) {
+  const { t } = useTranslation();
+  const config = useSettingsStore((s) => selectResolvedLLMConfig(s, scope));
+  const isSignedIn = useSettingsStore((s) => s.isSignedIn);
+
+  const openaiApiKey = useSettingsStore((s) => s.openaiApiKey);
+  const setOpenaiApiKey = useSettingsStore((s) => s.setOpenaiApiKey);
+  const anthropicApiKey = useSettingsStore((s) => s.anthropicApiKey);
+  const setAnthropicApiKey = useSettingsStore((s) => s.setAnthropicApiKey);
+  const geminiApiKey = useSettingsStore((s) => s.geminiApiKey);
+  const setGeminiApiKey = useSettingsStore((s) => s.setGeminiApiKey);
+  const groqApiKey = useSettingsStore((s) => s.groqApiKey);
+  const setGroqApiKey = useSettingsStore((s) => s.setGroqApiKey);
+
+  const prefix = MODE_LABEL_PREFIX[scope];
+  const modes: InferenceModeOption[] = [
+    {
+      id: "openwhispr",
+      label: t(`${prefix}.openwhispr`),
+      description: t(`${prefix}.openwhisprDesc`),
+      icon: <Cloud className="w-4 h-4" />,
+      disabled: !isSignedIn,
+      badge: !isSignedIn ? t("common.freeAccountRequired") : undefined,
+    },
+    {
+      id: "providers",
+      label: t(`${prefix}.providers`),
+      description: t(`${prefix}.providersDesc`),
+      icon: <Key className="w-4 h-4" />,
+    },
+    {
+      id: "local",
+      label: t(`${prefix}.local`),
+      description: t(`${prefix}.localDesc`),
+      icon: <Cpu className="w-4 h-4" />,
+    },
+    {
+      id: "self-hosted",
+      label: t(`${prefix}.selfHosted`),
+      description: t(`${prefix}.selfHostedDesc`),
+      icon: <Network className="w-4 h-4" />,
+    },
+    {
+      id: "enterprise",
+      label: t(`${prefix}.enterprise`),
+      description: t(`${prefix}.enterpriseDesc`),
+      icon: <Building2 className="w-4 h-4" />,
+    },
+  ];
+
+  const setField = useCallback(
+    <K extends keyof Omit<typeof config, "scope">>(field: K) =>
+      (value: NonNullable<(typeof config)[K]>) => {
+        setResolvedLLMConfig(scope, { [field]: value });
+      },
+    [scope]
+  );
+
+  const handleModeSelect = useCallback(
+    (mode: InferenceMode) => {
+      if (mode === "openwhispr" && !isSignedIn) {
+        startCloudOnboarding();
+        return;
+      }
+      if (mode === config.mode) return;
+
+      const patch: Parameters<typeof setResolvedLLMConfig>[1] = {
+        mode,
+        cloudMode: mode === "openwhispr" ? "openwhispr" : "byok",
+      };
+      if (!isProviderValidForMode(config.provider, mode)) {
+        patch.provider = "";
+        patch.model = "";
+      }
+      setResolvedLLMConfig(scope, patch);
+
+      if (mode === "openwhispr" || mode === "self-hosted" || mode === "enterprise") {
+        window.electronAPI?.llamaServerStop?.();
+      }
+
+      onModeChange?.(mode);
+    },
+    [scope, config.mode, config.provider, isSignedIn, onModeChange]
+  );
+
+  const setMode = setField("mode");
+  const setProvider = setField("provider");
+  const setModel = setField("model");
+
+  const renderModelSelector = (mode?: "cloud" | "local") => (
+    <ReasoningModelSelector
+      reasoningModel={config.model}
+      setReasoningModel={setModel}
+      localReasoningProvider={config.provider}
+      setLocalReasoningProvider={setProvider}
+      cloudReasoningBaseUrl={config.cloudBaseUrl ?? ""}
+      setCloudReasoningBaseUrl={setField("cloudBaseUrl")}
+      openaiApiKey={openaiApiKey}
+      setOpenaiApiKey={setOpenaiApiKey}
+      anthropicApiKey={anthropicApiKey}
+      setAnthropicApiKey={setAnthropicApiKey}
+      geminiApiKey={geminiApiKey}
+      setGeminiApiKey={setGeminiApiKey}
+      groqApiKey={groqApiKey}
+      setGroqApiKey={setGroqApiKey}
+      customReasoningApiKey={config.customApiKey ?? ""}
+      setCustomReasoningApiKey={setField("customApiKey")}
+      setReasoningMode={setMode}
+      mode={mode}
+    />
+  );
+
+  return (
+    <div className="space-y-3">
+      <InferenceModeSelector modes={modes} activeMode={config.mode} onSelect={handleModeSelect} />
+
+      {config.mode === "providers" && renderModelSelector("cloud")}
+      {config.mode === "local" && renderModelSelector("local")}
+
+      {config.mode === "self-hosted" && (
+        <SelfHostedPanel
+          service="reasoning"
+          url={config.remoteUrl ?? ""}
+          onUrlChange={setField("remoteUrl")}
+        />
+      )}
+
+      {config.mode === "enterprise" && (
+        <EnterpriseSection
+          currentProvider={config.provider}
+          reasoningModel={config.model}
+          setReasoningModel={setModel}
+          setLocalReasoningProvider={setProvider}
+        />
+      )}
+    </div>
+  );
+}
diff --git a/src/components/settings/MeetingSettings.tsx b/src/components/settings/MeetingSettings.tsx
index 28cb0acc7..e35549245 100644
--- a/src/components/settings/MeetingSettings.tsx
+++ b/src/components/settings/MeetingSettings.tsx
@@ -1,13 +1,11 @@
 import { useCallback } from "react";
 import { useTranslation } from "react-i18next";
-import { Cloud, Key, Cpu, Network, Building2 } from "lucide-react";
+import { Cloud, Key, Cpu, Network } from "lucide-react";
 import { useSettingsStore } from "../../stores/settingsStore";
 import { InferenceModeSelector, SettingsRow } from "../ui/SettingsSection";
 import type { InferenceModeOption } from "../ui/SettingsSection";
 import { Toggle } from "../ui/toggle";
 import TranscriptionModelPicker from "../TranscriptionModelPicker";
-import ReasoningModelSelector from "../ReasoningModelSelector";
-import EnterpriseSection from "../EnterpriseSection";
 import SelfHostedPanel from "../SelfHostedPanel";
 import type { InferenceMode } from "../../types/electron";
 
@@ -178,129 +176,3 @@ export function MeetingTranscriptionPanel() {
     </div>
   );
 }
-
-export function MeetingReasoningPanel() {
-  const { t } = useTranslation();
-  const startOnboarding = useStartOnboarding();
-
-  const {
-    isSignedIn,
-    meetingReasoningMode,
-    setMeetingReasoningMode,
-    meetingReasoningProvider,
-    setMeetingReasoningProvider,
-    meetingReasoningModel,
-    setMeetingReasoningModel,
-    setMeetingCloudReasoningMode,
-    meetingCloudReasoningBaseUrl,
-    setMeetingCloudReasoningBaseUrl,
-    meetingRemoteReasoningUrl,
-    setMeetingRemoteReasoningUrl,
-    openaiApiKey,
-    setOpenaiApiKey,
-    anthropicApiKey,
-    setAnthropicApiKey,
-    geminiApiKey,
-    setGeminiApiKey,
-    groqApiKey,
-    setGroqApiKey,
-    customReasoningApiKey,
-    setCustomReasoningApiKey,
-  } = useSettingsStore();
-
-  const aiModes: InferenceModeOption[] = [
-    {
-      id: "openwhispr",
-      label: t("settingsPage.aiModels.modes.openwhispr"),
-      description: t("settingsPage.aiModels.modes.openwhisprDesc"),
-      icon: <Cloud className="w-4 h-4" />,
-      disabled: !isSignedIn,
-      badge: !isSignedIn ? t("common.freeAccountRequired") : undefined,
-    },
-    {
-      id: "providers",
-      label: t("settingsPage.aiModels.modes.providers"),
-      description: t("settingsPage.aiModels.modes.providersDesc"),
-      icon: <Key className="w-4 h-4" />,
-    },
-    {
-      id: "local",
-      label: t("settingsPage.aiModels.modes.local"),
-      description: t("settingsPage.aiModels.modes.localDesc"),
-      icon: <Cpu className="w-4 h-4" />,
-    },
-    {
-      id: "self-hosted",
-      label: t("settingsPage.aiModels.modes.selfHosted"),
-      description: t("settingsPage.aiModels.modes.selfHostedDesc"),
-      icon: <Network className="w-4 h-4" />,
-    },
-    {
-      id: "enterprise",
-      label: t("settingsPage.aiModels.modes.enterprise"),
-      description: t("settingsPage.aiModels.modes.enterpriseDesc"),
-      icon: <Building2 className="w-4 h-4" />,
-    },
-  ];
-
-  const handleReasoningModeSelect = (mode: InferenceMode) => {
-    if (mode === "openwhispr" && !isSignedIn) {
-      startOnboarding();
-      return;
-    }
-    if (mode === meetingReasoningMode) return;
-    setMeetingReasoningMode(mode);
-    setMeetingCloudReasoningMode(mode === "openwhispr" ? "openwhispr" : "byok");
-  };
-
-  const renderReasoningSelector = (mode?: "cloud" | "local") => (
-    <ReasoningModelSelector
-      reasoningModel={meetingReasoningModel}
-      setReasoningModel={setMeetingReasoningModel}
-      localReasoningProvider={meetingReasoningProvider}
-      setLocalReasoningProvider={setMeetingReasoningProvider}
-      cloudReasoningBaseUrl={meetingCloudReasoningBaseUrl}
-      setCloudReasoningBaseUrl={setMeetingCloudReasoningBaseUrl}
-      openaiApiKey={openaiApiKey}
-      setOpenaiApiKey={setOpenaiApiKey}
-      anthropicApiKey={anthropicApiKey}
-      setAnthropicApiKey={setAnthropicApiKey}
-      geminiApiKey={geminiApiKey}
-      setGeminiApiKey={setGeminiApiKey}
-      groqApiKey={groqApiKey}
-      setGroqApiKey={setGroqApiKey}
-      customReasoningApiKey={customReasoningApiKey}
-      setCustomReasoningApiKey={setCustomReasoningApiKey}
-      setReasoningMode={setMeetingReasoningMode}
-      mode={mode}
-    />
-  );
-
-  return (
-    <div className="space-y-3">
-      <InferenceModeSelector
-        modes={aiModes}
-        activeMode={meetingReasoningMode}
-        onSelect={handleReasoningModeSelect}
-      />
-
-      {meetingReasoningMode === "providers" && renderReasoningSelector("cloud")}
-      {meetingReasoningMode === "local" && renderReasoningSelector("local")}
-      {meetingReasoningMode === "self-hosted" && (
-        <SelfHostedPanel
-          service="reasoning"
-          url={meetingRemoteReasoningUrl}
-          onUrlChange={setMeetingRemoteReasoningUrl}
-        />
-      )}
-      {meetingReasoningMode === "enterprise" && (
-        <EnterpriseSection
-          currentProvider={meetingReasoningProvider}
-          reasoningModel={meetingReasoningModel}
-          setReasoningModel={setMeetingReasoningModel}
-          setLocalReasoningProvider={setMeetingReasoningProvider}
-        />
-      )}
-    </div>
-  );
-}
diff --git a/src/components/ui/PromptStudio.tsx b/src/components/ui/PromptStudio.tsx
index 63dde076c..e5956778d 100644
--- a/src/components/ui/PromptStudio.tsx
+++ b/src/components/ui/PromptStudio.tsx
@@ -1,4 +1,4 @@
-import { useState, useEffect } from "react";
+import { useState } from "react";
 import { useTranslation } from "react-i18next";
 import { Button } from "./button";
 import { Textarea } from "./textarea";
@@ -19,11 +19,12 @@ import { useAgentName } from "../../utils/agentName";
 import ReasoningService from "../../services/ReasoningService";
 import { getModelProvider } from "../../models/ModelRegistry";
 import logger from "../../utils/logger";
-import { UNIFIED_SYSTEM_PROMPT } from "../../config/prompts";
-import { useSettingsStore, selectIsCloudReasoningMode } from "../../stores/settingsStore";
+import { getDefaultPromptText, type PromptKind } from "../../config/prompts";
+import { useSettingsStore, selectIsCloudCleanupMode } from "../../stores/settingsStore";
 
 interface PromptStudioProps {
   className?: string;
+  kind?: PromptKind;
 }
 
 type ProviderConfig = {
@@ -41,27 +42,14 @@ const PROVIDER_CONFIG: Record<string, ProviderConfig> = {
   custom: {
     label: "Custom endpoint",
     apiKeyStorageKey: "openaiApiKey",
-    baseStorageKey: "cloudReasoningBaseUrl",
+    baseStorageKey: "cleanupCloudBaseUrl",
   },
   local: { label: "Local" },
 };
 
-function getCurrentPrompt(): string {
-  const customPrompt = localStorage.getItem("customUnifiedPrompt");
-  if (customPrompt) {
-    try {
-      return JSON.parse(customPrompt);
-    } catch {
-      return UNIFIED_SYSTEM_PROMPT;
-    }
-  }
-  return UNIFIED_SYSTEM_PROMPT;
-}
-
-export default function PromptStudio({ className = "" }: PromptStudioProps) {
+export default function PromptStudio({ className = "", kind = "cleanup" }: PromptStudioProps) {
   const { t } = useTranslation();
   const [activeTab, setActiveTab] = useState<"current" | "edit" | "test">("current");
-  const [editedPrompt, setEditedPrompt] = useState(UNIFIED_SYSTEM_PROMPT);
   const [testText, setTestText] = useState(() => t("promptStudio.defaultTestInput"));
   const [testResult, setTestResult] = useState("");
   const [isLoading, setIsLoading] = useState(false);
@@ -69,38 +57,19 @@ export default function PromptStudio({ className = "" }: PromptStudioProps) {
 
   const { alertDialog, showAlertDialog, hideAlertDialog } = useDialogs();
   const { agentName } = useAgentName();
+  const uiLanguage = useSettingsStore((s) => s.uiLanguage);
 
-  const effectiveModel = useSettingsStore((s) => s.reasoningModel);
-  const isCloudMode = useSettingsStore(selectIsCloudReasoningMode);
-  const useReasoningModel = useSettingsStore((s) => s.useReasoningModel);
-  const reasoningModel = useSettingsStore((s) => s.reasoningModel);
-
-  useEffect(() => {
-    const legacyPrompts = localStorage.getItem("customPrompts");
-    if (legacyPrompts && !localStorage.getItem("customUnifiedPrompt")) {
-      try {
-        const parsed = JSON.parse(legacyPrompts);
-        if (parsed.agent) {
-          localStorage.setItem("customUnifiedPrompt", JSON.stringify(parsed.agent));
-          localStorage.removeItem("customPrompts");
-        }
-      } catch (e) {
-        logger.error("Failed to migrate legacy custom prompts", { error: e }, "prompts");
-      }
-    }
+  const isCloudMode = useSettingsStore(selectIsCloudCleanupMode);
+  const useCleanupModel = useSettingsStore((s) => s.useCleanupModel);
+  const cleanupModel = useSettingsStore((s) => s.cleanupModel);
 
-    const customPrompt = localStorage.getItem("customUnifiedPrompt");
-    if (customPrompt) {
-      try {
-        setEditedPrompt(JSON.parse(customPrompt));
-      } catch (error) {
-        logger.error("Failed to load custom prompt", { error }, "prompts");
-      }
-    }
-  }, []);
+  const customPrompt = useSettingsStore((s) => s.customPrompts[kind]);
+  const setCustomPrompt = useSettingsStore((s) => s.setCustomPrompt);
+  const defaultPrompt = getDefaultPromptText(kind, uiLanguage);
+  const [editedPrompt, setEditedPrompt] = useState(customPrompt || defaultPrompt);
 
   const savePrompt = () => {
-    localStorage.setItem("customUnifiedPrompt", JSON.stringify(editedPrompt));
+    setCustomPrompt(kind, editedPrompt);
     showAlertDialog({
       title: t("promptStudio.dialogs.saved.title"),
       description: t("promptStudio.dialogs.saved.description"),
@@ -108,8 +77,8 @@ export default function PromptStudio({ className = "" }: PromptStudioProps) {
   };
 
   const resetToDefault = () => {
-    setEditedPrompt(UNIFIED_SYSTEM_PROMPT);
-    localStorage.removeItem("customUnifiedPrompt");
+    setEditedPrompt(defaultPrompt);
+    setCustomPrompt(kind, "");
     showAlertDialog({
       title: t("promptStudio.dialogs.reset.title"),
       description: t("promptStudio.dialogs.reset.description"),
@@ -129,47 +98,47 @@ export default function PromptStudio({ className = "" }: PromptStudioProps) {
     setTestResult("");
 
     try {
-      const reasoningProvider = isCloudMode
+      const cleanupProvider = isCloudMode
         ? "openwhispr"
-        : reasoningModel
-          ? getModelProvider(reasoningModel)
+        : cleanupModel
+          ? getModelProvider(cleanupModel)
           : "openai";
 
       logger.debug(
         "PromptStudio test starting",
         {
-          useReasoningModel,
+          useCleanupModel,
           isCloudMode,
-          reasoningModel,
-          reasoningProvider,
+          cleanupModel,
+          cleanupProvider,
           testTextLength: testText.length,
           agentName,
         },
         "prompt-studio"
       );
 
-      if (!useReasoningModel) {
+      if (!useCleanupModel) {
         setTestResult(t("promptStudio.test.disabledReasoning"));
         return;
       }
 
-      if (!isCloudMode && !reasoningModel) {
+      if (!isCloudMode && !cleanupModel) {
         setTestResult(t("promptStudio.test.noModelSelected"));
         return;
       }
 
       if (!isCloudMode) {
-        const providerConfig = PROVIDER_CONFIG[reasoningProvider] || {
-          label: reasoningProvider.charAt(0).toUpperCase() + reasoningProvider.slice(1),
+        const providerConfig = PROVIDER_CONFIG[cleanupProvider] || {
+          label: cleanupProvider.charAt(0).toUpperCase() + cleanupProvider.slice(1),
         };
 
         if (providerConfig.baseStorageKey) {
-          const baseUrl = (useSettingsStore.getState().cloudReasoningBaseUrl || "").trim();
+          const baseUrl = (useSettingsStore.getState().cleanupCloudBaseUrl || "").trim();
           if (!baseUrl) {
             setTestResult(
               t("promptStudio.test.baseUrlMissing", {
                 provider:
-                  reasoningProvider === "custom"
+                  cleanupProvider === "custom"
                     ? t("promptStudio.test.customEndpoint")
                     : providerConfig.label,
               })
@@ -179,20 +148,15 @@ export default function PromptStudio({ className = "" }: PromptStudioProps) {
         }
       }
 
-      const modelToUse = isCloudMode ? effectiveModel || "auto" : reasoningModel;
-
-      const currentCustomPrompt = localStorage.getItem("customUnifiedPrompt");
-      localStorage.setItem("customUnifiedPrompt", JSON.stringify(editedPrompt));
+      const modelToUse = isCloudMode ? cleanupModel || "auto" : cleanupModel;
 
+      const previous = customPrompt;
+      setCustomPrompt(kind, editedPrompt);
       try {
         const result = await ReasoningService.processText(testText, modelToUse, agentName, {});
         setTestResult(result);
       } finally {
-        if (currentCustomPrompt) {
-          localStorage.setItem("customUnifiedPrompt", currentCustomPrompt);
-        } else {
-          localStorage.removeItem("customUnifiedPrompt");
-        }
+        setCustomPrompt(kind, previous);
       }
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
@@ -204,7 +168,8 @@ export default function PromptStudio({ className = "" }: PromptStudioProps) {
   };
 
   const isAgentAddressed = testText.toLowerCase().includes(agentName.toLowerCase());
-  const isCustomPrompt = getCurrentPrompt() !== UNIFIED_SYSTEM_PROMPT;
+  const isCustomPrompt = customPrompt.length > 0;
+  const currentPrompt = customPrompt || defaultPrompt;
 
   const tabs = [
     { id: "current" as const, label: t("promptStudio.tabs.view"), icon: Eye },
@@ -285,7 +250,7 @@ export default function PromptStudio({ className = "" }: PromptStudioProps) {
                   )}
                 </div>
                 <Button
-                  onClick={() => copyText(getCurrentPrompt())}
+                  onClick={() => copyText(currentPrompt)}
                   variant="ghost"
                   size="sm"
                   className="h-7 px-2 text-xs"
@@ -304,7 +269,7 @@ export default function PromptStudio({ className = "" }: PromptStudioProps) {
               </div>
               <div className="bg-muted/30 dark:bg-surface-raised/30 border border-border/30 rounded-lg p-4 max-h-80 overflow-y-auto">
                 <pre className="text-xs font-mono text-muted-foreground whitespace-pre-wrap leading-relaxed">
-                  {getCurrentPrompt().replace(/\{\{agentName\}\}/g, agentName)}
+                  {currentPrompt.replace(/\{\{agentName\}\}/g, agentName)}
                 </pre>
               </div>
             </div>
@@ -359,26 +324,26 @@ export default function PromptStudio({ className = "" }: PromptStudioProps) {
         {/* ── Test Tab ── */}
         {activeTab === "test" &&
           (() => {
-            const reasoningProvider = isCloudMode
+            const cleanupProvider = isCloudMode
               ? "openwhispr"
-              : reasoningModel
-                ? getModelProvider(reasoningModel)
+              : cleanupModel
+                ? getModelProvider(cleanupModel)
                 : "openai";
-            const providerConfig = PROVIDER_CONFIG[reasoningProvider] || {
-              label: reasoningProvider.charAt(0).toUpperCase() + reasoningProvider.slice(1),
+            const providerConfig = PROVIDER_CONFIG[cleanupProvider] || {
+              label: cleanupProvider.charAt(0).toUpperCase() + cleanupProvider.slice(1),
             };
 
             const displayModel = isCloudMode
               ? t("promptStudio.test.openwhisprCloud")
-              : reasoningModel || t("promptStudio.test.none");
+              : cleanupModel || t("promptStudio.test.none");
             const displayProvider =
-              reasoningProvider === "custom"
+              cleanupProvider === "custom"
                 ? t("promptStudio.test.customEndpoint")
                 : providerConfig.label;
 
             return (
               <div className="divide-y divide-border/40 dark:divide-border-subtle">
-                {!useReasoningModel && (
+                {!useCleanupModel && (
                   <div className="px-5 py-4">
                     <div className="rounded-lg border border-warning/20 bg-warning/5 dark:bg-warning/10 px-4 py-3">
                       <div className="flex items-start gap-2.5">
@@ -449,7 +414,7 @@ export default function PromptStudio({ className = "" }: PromptStudioProps) {
                 <div className="px-5 py-4">
                   <Button
                     onClick={testPrompt}
-                    disabled={!testText.trim() || isLoading || !useReasoningModel}
+                    disabled={!testText.trim() || isLoading || !useCleanupModel}
                     size="sm"
                     className="w-full"
                   >
diff --git a/src/config/agentDetection.ts b/src/config/agentDetection.ts
new file mode 100644
index 000000000..3bbcb054c
--- /dev/null
+++ b/src/config/agentDetection.ts
@@ -0,0 +1,68 @@
+function levenshteinDistance(a: string, b: string): number {
+  const m = a.length;
+  const n = b.length;
+  if (m === 0) return n;
+  if (n === 0) return m;
+
+  let prev = Array.from({ length: n + 1 }, (_, i) => i);
+  let curr = new Array<number>(n + 1);
+
+  for (let i = 1; i <= m; i++) {
+    curr[0] = i;
+    for (let j = 1; j <= n; j++) {
+      curr[j] =
+        a[i - 1] === b[j - 1] ? prev[j - 1] : 1 + Math.min(prev[j - 1], prev[j], curr[j - 1]);
+    }
+    [prev, curr] = [curr, prev];
+  }
+
+  return prev[n];
+}
+
+function maxEditsForLength(len: number): number {
+  if (len <= 4) return 0;
+  if (len <= 6) return 1;
+  return 2;
+}
+
+export function detectAgentName(transcript: string, agentName: string): boolean {
+  const name = agentName.trim();
+  if (!name || name.length < 2) return false;
+
+  const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  if (new RegExp(`\\b${escaped}\\b`, "i").test(transcript)) return true;
+
+  const nameLower = name.toLowerCase().replace(/\s+/g, "");
+  const words = transcript
+    .split(/\s+/)
+    .map((w) => w.replace(/[.,!?;:'"()]/g, "").toLowerCase())
+    .filter(Boolean);
+
+  for (let i = 0; i < words.length - 1; i++) {
+    if (words[i] + words[i + 1] === nameLower) return true;
+  }
+
+  const maxEdits = maxEditsForLength(nameLower.length);
+  if (maxEdits === 0) return false;
+
+  for (const word of words) {
+    if (
+      Math.abs(word.length - nameLower.length) <= maxEdits &&
+      levenshteinDistance(word, nameLower) <= maxEdits
+    ) {
+      return true;
+    }
+  }
+
+  for (let i = 0; i < words.length - 1; i++) {
+    const combined = words[i] + words[i + 1];
+    if (
+      Math.abs(combined.length - nameLower.length) <= maxEdits &&
+      levenshteinDistance(combined, nameLower) <= maxEdits
+    ) {
+      return true;
+    }
+  }
+
+  return false;
+}
diff --git a/src/config/inferenceScopes.ts b/src/config/inferenceScopes.ts
new file mode 100644
index 000000000..ceda65286
--- /dev/null
+++ b/src/config/inferenceScopes.ts
@@ -0,0 +1,71 @@
+import type { SettingsState } from "../stores/settingsStore";
+
+export interface InferenceScopeStoreKeys {
+  mode: keyof SettingsState;
+  provider: keyof SettingsState;
+  model: keyof SettingsState;
+  cloudMode?: keyof SettingsState;
+  cloudBaseUrl?: keyof SettingsState;
+  remoteType?: keyof SettingsState;
+  remoteUrl?: keyof SettingsState;
+  customApiKey?: keyof SettingsState;
+}
+
+export interface InferenceScopeDefinition {
+  storeKeys: InferenceScopeStoreKeys;
+  fallbackScope?: string;
+}
+
+export const INFERENCE_SCOPES = {
+  dictationCleanup: {
+    storeKeys: {
+      mode: "cleanupMode",
+      provider: "cleanupProvider",
+      model: "cleanupModel",
+      cloudMode: "cleanupCloudMode",
+      cloudBaseUrl: "cleanupCloudBaseUrl",
+      remoteType: "cleanupRemoteType",
+      remoteUrl: "cleanupRemoteUrl",
+      customApiKey: "cleanupCustomApiKey",
+    },
+  },
+  dictationAgent: {
+    storeKeys: {
+      mode: "dictationAgentMode",
+      provider: "dictationAgentProvider",
+      model: "dictationAgentModel",
+      cloudMode: "dictationAgentCloudMode",
+      cloudBaseUrl: "dictationAgentCloudBaseUrl",
+      remoteType: "dictationAgentRemoteType",
+      remoteUrl: "dictationAgentRemoteUrl",
+      customApiKey: "dictationAgentCustomApiKey",
+    },
+    fallbackScope: "dictationCleanup",
+  },
+  noteFormatting: {
+    storeKeys: {
+      mode: "noteFormattingMode",
+      provider: "noteFormattingProvider",
+      model: "noteFormattingModel",
+      cloudMode: "noteFormattingCloudMode",
+      cloudBaseUrl: "noteFormattingCloudBaseUrl",
+      remoteType: "noteFormattingRemoteType",
+      remoteUrl: "noteFormattingRemoteUrl",
+      customApiKey: "noteFormattingCustomApiKey",
+    },
+    fallbackScope: "dictationCleanup",
+  },
+  chatIntelligence: {
+    storeKeys: {
+      mode: "chatAgentMode",
+      provider: "chatAgentProvider",
+      model: "chatAgentModel",
+      cloudMode: "chatAgentCloudMode",
+      cloudBaseUrl: "chatAgentCloudBaseUrl",
+      remoteType: "chatAgentRemoteType",
+      remoteUrl: "chatAgentRemoteUrl",
+    },
+  },
+} as const satisfies Record<string, InferenceScopeDefinition>;
+
+export type InferenceScope = keyof typeof INFERENCE_SCOPES;
diff --git a/src/config/prompts.ts b/src/config/prompts.ts
index 677a32550..190abf558 100644
--- a/src/config/prompts.ts
+++ b/src/config/prompts.ts
@@ -1,95 +1,13 @@
 import promptData from "./promptData.json";
-import i18n, { normalizeUiLanguage } from "../i18n";
-import { en as enPrompts, type PromptBundle } from "../locales/prompts";
-import { getLanguageInstruction } from "../utils/languageSupport";
+import { resolvePrompt, type ResolvePromptOptions } from "./prompts/index";
+import { detectAgentName } from "./agentDetection";
+
+export { resolvePrompt, getDefaultPromptText } from "./prompts/index";
+export { PROMPT_KINDS, PROMPT_KIND_LIST, type PromptKind } from "./prompts/registry";
+export { detectAgentName } from "./agentDetection";
 
 export const CLEANUP_PROMPT = promptData.CLEANUP_PROMPT;
 export const FULL_PROMPT = promptData.FULL_PROMPT;
-/** @deprecated Use FULL_PROMPT — kept for PromptStudio compat */
-export const UNIFIED_SYSTEM_PROMPT = promptData.FULL_PROMPT;
-
-function getPromptBundle(uiLanguage?: string): PromptBundle {
-  const locale = normalizeUiLanguage(uiLanguage || "en");
-  const t = i18n.getFixedT(locale, "prompts");
-
-  return {
-    cleanupPrompt: t("cleanupPrompt", { defaultValue: enPrompts.cleanupPrompt }),
-    fullPrompt: t("fullPrompt", { defaultValue: enPrompts.fullPrompt }),
-    dictionarySuffix: t("dictionarySuffix", { defaultValue: enPrompts.dictionarySuffix }),
-  };
-}
-
-function levenshteinDistance(a: string, b: string): number {
-  const m = a.length;
-  const n = b.length;
-  if (m === 0) return n;
-  if (n === 0) return m;
-
-  let prev = Array.from({ length: n + 1 }, (_, i) => i);
-  let curr = new Array<number>(n + 1);
-
-  for (let i = 1; i <= m; i++) {
-    curr[0] = i;
-    for (let j = 1; j <= n; j++) {
-      curr[j] =
-        a[i - 1] === b[j - 1] ? prev[j - 1] : 1 + Math.min(prev[j - 1], prev[j], curr[j - 1]);
-    }
-    [prev, curr] = [curr, prev];
-  }
-
-  return prev[n];
-}
-
-function maxEditsForLength(len: number): number {
-  if (len <= 4) return 0;
-  if (len <= 6) return 1;
-  return 2;
-}
-
-function detectAgentName(transcript: string, agentName: string): boolean {
-  const name = agentName.trim();
-  if (!name || name.length < 2) return false;
-
-  // Layer 1: Exact word-boundary match
-  const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  if (new RegExp(`\\b${escaped}\\b`, "i").test(transcript)) return true;
-
-  // Layer 2: Space-normalized exact match (STT splitting compound names)
-  const nameLower = name.toLowerCase().replace(/\s+/g, "");
-  const words = transcript
-    .split(/\s+/)
-    .map((w) => w.replace(/[.,!?;:'"()]/g, "").toLowerCase())
-    .filter(Boolean);
-
-  for (let i = 0; i < words.length - 1; i++) {
-    if (words[i] + words[i + 1] === nameLower) return true;
-  }
-
-  // Layer 3: Fuzzy Levenshtein match (STT mishearings)
-  const maxEdits = maxEditsForLength(nameLower.length);
-  if (maxEdits === 0) return false;
-
-  for (const word of words) {
-    if (
-      Math.abs(word.length - nameLower.length) <= maxEdits &&
-      levenshteinDistance(word, nameLower) <= maxEdits
-    ) {
-      return true;
-    }
-  }
-
-  for (let i = 0; i < words.length - 1; i++) {
-    const combined = words[i] + words[i + 1];
-    if (
-      Math.abs(combined.length - nameLower.length) <= maxEdits &&
-      levenshteinDistance(combined, nameLower) <= maxEdits
-    ) {
-      return true;
-    }
-  }
-
-  return false;
-}
 
 export function getSystemPrompt(
   agentName: string | null,
@@ -98,43 +16,10 @@ export function getSystemPrompt(
   transcript?: string,
   uiLanguage?: string
 ): string {
+  const opts: ResolvePromptOptions = { agentName, language, customDictionary, uiLanguage };
   const name = agentName?.trim() || "Assistant";
-  const prompts = getPromptBundle(uiLanguage);
-
-  let promptTemplate: string | null = null;
-  if (typeof window !== "undefined" && window.localStorage) {
-    const customPrompt = window.localStorage.getItem("customUnifiedPrompt");
-    if (customPrompt) {
-      try {
-        const parsed = JSON.parse(customPrompt);
-        if (typeof parsed === "string") {
-          promptTemplate = parsed;
-        }
-      } catch {}
-    }
-  }
-
-  let prompt: string;
-  if (promptTemplate) {
-    prompt = promptTemplate.replace(/\{\{agentName\}\}/g, name);
-  } else {
-    const useFullPrompt = transcript ? detectAgentName(transcript, name) : false;
-    prompt = (useFullPrompt ? prompts.fullPrompt : prompts.cleanupPrompt).replace(
-      /\{\{agentName\}\}/g,
-      name
-    );
-  }
-
-  const langInstruction = getLanguageInstruction(language);
-  if (langInstruction) {
-    prompt += "\n\n" + langInstruction;
-  }
-
-  if (customDictionary && customDictionary.length > 0) {
-    prompt += prompts.dictionarySuffix + customDictionary.join(", ");
-  }
-
-  return prompt;
+  const useFullPrompt = transcript ? detectAgentName(transcript, name) : false;
+  return resolvePrompt(useFullPrompt ? "dictationAgent" : "cleanup", opts);
 }
 
 export function getWordBoost(customDictionary?: string[]): string[] {
@@ -142,11 +27,6 @@ export function getWordBoost(customDictionary?: string[]): string[] {
   return customDictionary.filter((w) => w.trim());
 }
 
-const DEFAULT_AGENT_SYSTEM_PROMPT =
-  "You are a helpful voice assistant. Respond concisely and conversationally. " +
-  "Keep answers brief unless the user asks for detail. " +
-  "You may be given a transcription of spoken input, so handle informal phrasing gracefully.";
-
 const TOOL_INSTRUCTIONS: Record<string, string> = {
   search_notes:
     "Use search_notes to find information from the user's past meetings, discussions, or personal notes before answering from memory.",
@@ -167,12 +47,7 @@ const TOOL_INSTRUCTIONS: Record<string, string> = {
 };
 
 export function getAgentSystemPrompt(availableTools?: string[], noteContext?: string): string {
-  if (typeof window !== "undefined" && window.localStorage) {
-    const custom = window.localStorage.getItem("agentSystemPrompt");
-    if (custom) return custom;
-  }
-
-  let prompt = DEFAULT_AGENT_SYSTEM_PROMPT;
+  let prompt = resolvePrompt("chatAgent", { agentName: null });
 
   if (availableTools && availableTools.length > 0) {
     const toolLines = availableTools.map((name) => TOOL_INSTRUCTIONS[name]).filter(Boolean);
diff --git a/src/config/prompts/index.ts b/src/config/prompts/index.ts
new file mode 100644
index 000000000..455a8b54a
--- /dev/null
+++ b/src/config/prompts/index.ts
@@ -0,0 +1,46 @@
+import i18n, { normalizeUiLanguage } from "../../i18n";
+import { useSettingsStore } from "../../stores/settingsStore";
+import { en as enPrompts } from "../../locales/prompts";
+import { getLanguageInstruction } from "../../utils/languageSupport";
+import { PROMPT_KINDS, type PromptKind } from "./registry";
+
+export { PROMPT_KINDS, PROMPT_KIND_LIST, type PromptKind } from "./registry";
+
+export interface ResolvePromptOptions {
+  agentName: string | null;
+  uiLanguage?: string;
+  language?: string;
+  customDictionary?: string[];
+}
+
+export function resolvePrompt(kind: PromptKind, opts: ResolvePromptOptions): string {
+  const custom = useSettingsStore.getState().customPrompts[kind];
+  const template = custom || getDefaultPromptText(kind, opts.uiLanguage);
+  return applySubstitutions(template, opts);
+}
+
+export function getDefaultPromptText(kind: PromptKind, uiLanguage?: string): string {
+  const def = PROMPT_KINDS[kind];
+  if (!def.i18nKey) return def.fallback;
+  const locale = normalizeUiLanguage(uiLanguage || "en");
+  const t = i18n.getFixedT(locale, "prompts");
+  return t(def.i18nKey, { defaultValue: def.fallback });
+}
+
+function applySubstitutions(template: string, opts: ResolvePromptOptions): string {
+  const name = opts.agentName?.trim() || "Assistant";
+  let prompt = template.replace(/\{\{agentName\}\}/g, name);
+
+  const langInstruction = getLanguageInstruction(opts.language);
+  if (langInstruction) prompt += "\n\n" + langInstruction;
+
+  if (opts.customDictionary?.length) {
+    const locale = normalizeUiLanguage(opts.uiLanguage || "en");
+    const suffix = i18n.getFixedT(locale, "prompts")("dictionarySuffix", {
+      defaultValue: enPrompts.dictionarySuffix,
+    });
+    prompt += suffix + opts.customDictionary.join(", ");
+  }
+
+  return prompt;
+}
diff --git a/src/config/prompts/registry.ts b/src/config/prompts/registry.ts
new file mode 100644
index 000000000..68ea5adcf
--- /dev/null
+++ b/src/config/prompts/registry.ts
@@ -0,0 +1,24 @@
+import { en as enPrompts, type PromptBundle } from "../../locales/prompts";
+
+const DEFAULT_CHAT_AGENT_PROMPT =
+  "You are a helpful voice assistant. Respond concisely and conversationally. " +
+  "Keep answers brief unless the user asks for detail. " +
+  "You may be given a transcription of spoken input, so handle informal phrasing gracefully.";
+
+export const PROMPT_KINDS = {
+  cleanup: {
+    i18nKey: "cleanupPrompt" as const,
+    fallback: enPrompts.cleanupPrompt,
+  },
+  dictationAgent: {
+    i18nKey: "fullPrompt" as const,
+    fallback: enPrompts.fullPrompt,
+  },
+  chatAgent: {
+    i18nKey: null,
+    fallback: DEFAULT_CHAT_AGENT_PROMPT,
+  },
+} as const satisfies Record<string, { i18nKey: keyof PromptBundle | null; fallback: string }>;
+
+export type PromptKind = keyof typeof PROMPT_KINDS;
+export const PROMPT_KIND_LIST = Object.keys(PROMPT_KINDS) as readonly PromptKind[];
diff --git a/src/helpers/audioManager.js b/src/helpers/audioManager.js
index b2da10f15..b7999d405 100644
--- a/src/helpers/audioManager.js
+++ b/src/helpers/audioManager.js
@@ -10,11 +10,9 @@ import {
   getLocalSpeechGateDecision,
   recordLocalSpeechWindow,
 } from "./localSpeechGate";
-import {
-  getSettings,
-  getEffectiveReasoningModel,
-  isCloudReasoningMode,
-} from "../stores/settingsStore";
+import { getSettings, getEffectiveCleanupModel, isCloudCleanupMode } from "../stores/settingsStore";
+import { detectAgentName } from "../config/agentDetection";
+import { resolvePrompt } from "../config/prompts";
 import { syncService } from "../services/SyncService.js";
 
 const REASONING_CACHE_TTL = 30000; // 30 seconds
@@ -876,17 +874,18 @@ registerProcessor("pcm-streaming-processor", PCMStreamingProcessor);
     return apiKey;
   }
 
-  async processWithReasoningModel(text, model, agentName) {
+  async processWithReasoningModel(text, model, agentName, config) {
     logger.logReasoning("CALLING_REASONING_SERVICE", {
       model,
       agentName,
       textLength: text.length,
+      hasOverrides: !!config,
     });
 
     const startTime = Date.now();
 
     try {
-      const result = await ReasoningService.processText(text, model, agentName);
+      const result = await ReasoningService.processText(text, model, agentName, config);
 
       const processingTime = Date.now() - startTime;
 
@@ -917,7 +916,7 @@ registerProcessor("pcm-streaming-processor", PCMStreamingProcessor);
       return false;
     }
 
-    const useReasoning = getSettings().useReasoningModel;
+    const useReasoning = getSettings().useCleanupModel;
     const now = Date.now();
     const cacheValid =
       this.reasoningAvailabilityCache &&
@@ -941,7 +940,7 @@ registerProcessor("pcm-streaming-processor", PCMStreamingProcessor);
       return false;
     }
 
-    if (isCloudReasoningMode()) {
+    if (isCloudCleanupMode()) {
       this.reasoningAvailabilityCache = {
         value: true,
         expiresAt: now + REASONING_CACHE_TTL,
@@ -1007,16 +1006,16 @@ registerProcessor("pcm-streaming-processor", PCMStreamingProcessor);
       timestamp: new Date().toISOString(),
     });
 
-    const reasoningModel = getEffectiveReasoningModel();
-    const isCloud = isCloudReasoningMode();
-    const reasoningProvider = getSettings().reasoningProvider || "auto";
+    const cleanupModel = getEffectiveCleanupModel();
+    const isCloud = isCloudCleanupMode();
+    const cleanupProvider = getSettings().cleanupProvider || "auto";
     const agentName =
       typeof window !== "undefined" && window.localStorage
         ? localStorage.getItem("agentName") || null
         : null;
-    if (!reasoningModel && !isCloud) {
+    if (!cleanupModel && !isCloud) {
       logger.logReasoning("REASONING_SKIPPED", {
-        reason: "No reasoning model selected",
+        reason: "No cleanup model selected",
       });
       return normalizedText;
     }
@@ -1025,23 +1024,45 @@ registerProcessor("pcm-streaming-processor", PCMStreamingProcessor);
 
     logger.logReasoning("REASONING_CHECK", {
       useReasoning,
-      reasoningModel,
-      reasoningProvider,
+      cleanupModel,
+      cleanupProvider,
       agentName,
     });
 
     if (useReasoning) {
       try {
+        const settings = getSettings();
+        const isAgentInvocation = !!agentName && detectAgentName(normalizedText, agentName);
+        const dictationAgentModel = settings.dictationAgentModel?.trim() || "";
+        const useDictationAgent = isAgentInvocation && dictationAgentModel.length > 0;
+        const targetModel = useDictationAgent ? dictationAgentModel : cleanupModel;
+        const dictationAgentProvider = settings.dictationAgentProvider?.trim() || "";
+        const targetProvider = useDictationAgent ? dictationAgentProvider || undefined : undefined;
+
         logger.logReasoning("SENDING_TO_REASONING", {
           preparedTextLength: normalizedText.length,
-          model: reasoningModel,
-          provider: reasoningProvider,
+          model: targetModel,
+          provider: targetProvider || cleanupProvider,
+          path: useDictationAgent ? "dictationAgent" : "cleanup",
         });
 
+        const reasoningConfig = useDictationAgent
+          ? {
+              provider: targetProvider,
+              systemPrompt: resolvePrompt("dictationAgent", {
+                agentName,
+                language: settings.preferredLanguage,
+                customDictionary: settings.customDictionary,
+                uiLanguage: settings.uiLanguage,
+              }),
+            }
+          : undefined;
+
         const result = await this.processWithReasoningModel(
           normalizedText,
-          reasoningModel,
-          agentName
+          targetModel,
+          agentName,
+          reasoningConfig
         );
 
         logger.logReasoning("REASONING_SUCCESS", {
@@ -1239,8 +1260,8 @@ registerProcessor("pcm-streaming-processor", PCMStreamingProcessor);
     const audioFormat = audioBlob.type;
     const opts = {};
     if (language) opts.language = language;
-    const reasoningMode = settings.cloudReasoningMode || "openwhispr";
-    if (settings.useReasoningModel && !this.skipReasoning && reasoningMode === "openwhispr") {
+    const cleanupCloudMode = settings.cleanupCloudMode || "openwhispr";
+    if (settings.useCleanupModel && !this.skipReasoning && cleanupCloudMode === "openwhispr") {
       opts.sendLogs = "false";
     }
 
@@ -1263,12 +1284,12 @@ registerProcessor("pcm-streaming-processor", PCMStreamingProcessor);
     // Process with reasoning if enabled
     const rawText = result.text;
     let processedText = result.text;
-    if (settings.useReasoningModel && processedText && !this.skipReasoning) {
+    if (settings.useCleanupModel && processedText && !this.skipReasoning) {
       const reasoningStart = performance.now();
       const agentName = localStorage.getItem("agentName") || null;
-      const cloudReasoningMode = settings.cloudReasoningMode || "openwhispr";
+      const cleanupCloudMode = settings.cleanupCloudMode || "openwhispr";
 
-      if (cloudReasoningMode === "openwhispr") {
+      if (cleanupCloudMode === "openwhispr") {
         const reasonResult = await withSessionRefresh(async () => {
           const res = await window.electronAPI.cloudReason(processedText, {
             agentName,
@@ -1297,7 +1318,7 @@ registerProcessor("pcm-streaming-processor", PCMStreamingProcessor);
           processedText = reasonResult.text;
         }
       } else {
-        const effectiveModel = getEffectiveReasoningModel();
+        const effectiveModel = getEffectiveCleanupModel();
         if (effectiveModel) {
           const result = await this.processWithReasoningModel(
             processedText,
@@ -1329,14 +1350,7 @@ registerProcessor("pcm-streaming-processor", PCMStreamingProcessor);
   }
 
   getCustomPrompt() {
-    try {
-      const raw = localStorage.getItem("customUnifiedPrompt");
-      if (!raw) return undefined;
-      const parsed = JSON.parse(raw);
-      return typeof parsed === "string" ? parsed : undefined;
-    } catch {
-      return undefined;
-    }
+    return getSettings().customPrompts.cleanup || undefined;
   }
 
   getKeyterms() {
@@ -2427,13 +2441,13 @@ registerProcessor("pcm-streaming-processor", PCMStreamingProcessor);
     const streamingSttWordCount = finalText ? finalText.split(/\s+/).filter(Boolean).length : 0;
 
     let usedCloudReasoning = false;
-    if (stSettings.useReasoningModel && finalText && !this.skipReasoning) {
+    if (stSettings.useCleanupModel && finalText && !this.skipReasoning) {
       const reasoningStart = performance.now();
       const agentName = localStorage.getItem("agentName") || null;
-      const cloudReasoningMode = stSettings.cloudReasoningMode || "openwhispr";
+      const cleanupCloudMode = stSettings.cleanupCloudMode || "openwhispr";
 
       try {
-        if (cloudReasoningMode === "openwhispr") {
+        if (cleanupCloudMode === "openwhispr") {
           const reasonResult = await withSessionRefresh(async () => {
             const res = await window.electronAPI.cloudReason(finalText, {
               agentName,
@@ -2472,7 +2486,7 @@ registerProcessor("pcm-streaming-processor", PCMStreamingProcessor);
             "streaming"
           );
         } else {
-          const effectiveModel = getEffectiveReasoningModel();
+          const effectiveModel = getEffectiveCleanupModel();
           if (effectiveModel) {
             const result = await this.processWithReasoningModel(
               finalText,
@@ -2575,7 +2589,7 @@ registerProcessor("pcm-streaming-processor", PCMStreamingProcessor);
         "Streaming total processing",
         {
           totalProcessingMs: Math.round(tBeforePaste - t0),
-          hasReasoning: stSettings.useReasoningModel,
+          hasReasoning: stSettings.useCleanupModel,
         },
         "streaming"
       );
@@ -2598,7 +2612,7 @@ registerProcessor("pcm-streaming-processor", PCMStreamingProcessor);
 
   shouldShowPreviewCleanupState() {
     const settings = getSettings();
-    return !!settings.useReasoningModel && !this.skipReasoning;
+    return !!settings.useCleanupModel && !this.skipReasoning;
   }
 
   cleanupPreview(options = {}) {
diff --git a/src/helpers/environment.js b/src/helpers/environment.js
index 1b78c7220..72bb1abc5 100644
--- a/src/helpers/environment.js
+++ b/src/helpers/environment.js
@@ -13,16 +13,18 @@ const PERSISTED_KEYS = [
   "ASSEMBLYAI_API_KEY",
   "DEEPGRAM_API_KEY",
   "CUSTOM_TRANSCRIPTION_API_KEY",
-  "CUSTOM_REASONING_API_KEY",
+  "CUSTOM_CLEANUP_API_KEY",
   "LOCAL_TRANSCRIPTION_PROVIDER",
   "PARAKEET_MODEL",
   "LOCAL_WHISPER_MODEL",
-  "REASONING_PROVIDER",
-  "LOCAL_REASONING_MODEL",
+  "CLEANUP_PROVIDER",
+  "LOCAL_CLEANUP_MODEL",
+  "DICTATION_AGENT_PROVIDER",
+  "LOCAL_DICTATION_AGENT_MODEL",
   "LLAMA_GPU_BACKEND",
   "LLAMA_VULKAN_ENABLED",
   "DICTATION_KEY",
-  "AGENT_KEY",
+  "CHAT_AGENT_KEY",
   "MEETING_KEY",
   "ACTIVATION_MODE",
   "FLOATING_ICON_AUTO_HIDE",
@@ -151,11 +153,13 @@ class EnvironmentManager {
   }
 
   getCustomReasoningKey() {
-    return this._getKey("CUSTOM_REASONING_API_KEY");
+    // TODO: drop CUSTOM_REASONING_API_KEY fallback after 2 releases.
+    return this._getKey("CUSTOM_CLEANUP_API_KEY") || this._getKey("CUSTOM_REASONING_API_KEY");
   }
 
   saveCustomReasoningKey(key) {
-    return this._saveKey("CUSTOM_REASONING_API_KEY", key);
+    delete process.env.CUSTOM_REASONING_API_KEY;
+    return this._saveKey("CUSTOM_CLEANUP_API_KEY", key);
   }
 
   // Enterprise providers — AWS Bedrock
@@ -247,11 +251,13 @@ class EnvironmentManager {
   }
 
   getAgentKey() {
-    return this._getKey("AGENT_KEY");
+    // TODO: drop AGENT_KEY fallback after 2 releases.
+    return this._getKey("CHAT_AGENT_KEY") || this._getKey("AGENT_KEY");
   }
 
   saveAgentKey(key) {
-    const result = this._saveKey("AGENT_KEY", key);
+    delete process.env.AGENT_KEY;
+    const result = this._saveKey("CHAT_AGENT_KEY", key);
     this.saveAllKeysToEnvFile().catch(() => {});
     return result;
   }
diff --git a/src/helpers/ipcHandlers.js b/src/helpers/ipcHandlers.js
index 16068c5cb..47e63a34a 100644
--- a/src/helpers/ipcHandlers.js
+++ b/src/helpers/ipcHandlers.js
@@ -2748,11 +2748,41 @@ class IPCHandlers {
         });
       }
 
-      if (prefs.reasoningProvider === "local" && prefs.reasoningModel) {
-        setVars.REASONING_PROVIDER = "local";
-        setVars.LOCAL_REASONING_MODEL = prefs.reasoningModel;
-      } else if (prefs.reasoningProvider && prefs.reasoningProvider !== "local") {
+      // TODO: drop legacy REASONING_PROVIDER / LOCAL_REASONING_MODEL clears once
+      // the read fallback is removed (~2 releases after this lands).
+      if (prefs.cleanupProvider === "local" && prefs.cleanupModel) {
+        setVars.CLEANUP_PROVIDER = "local";
+        setVars.LOCAL_CLEANUP_MODEL = prefs.cleanupModel;
         clearVars.push("REASONING_PROVIDER", "LOCAL_REASONING_MODEL");
+      } else if (prefs.cleanupProvider && prefs.cleanupProvider !== "local") {
+        clearVars.push(
+          "CLEANUP_PROVIDER",
+          "LOCAL_CLEANUP_MODEL",
+          "REASONING_PROVIDER",
+          "LOCAL_REASONING_MODEL"
+        );
+      }
+
+      const dictationAgentLocal =
+        prefs.dictationAgentProvider === "local" && prefs.dictationAgentModel;
+      if (dictationAgentLocal) {
+        setVars.DICTATION_AGENT_PROVIDER = "local";
+        setVars.LOCAL_DICTATION_AGENT_MODEL = prefs.dictationAgentModel;
+      } else if (prefs.dictationAgentProvider && prefs.dictationAgentProvider !== "local") {
+        clearVars.push("DICTATION_AGENT_PROVIDER", "LOCAL_DICTATION_AGENT_MODEL");
+      }
+
+      // Stop the local llama-server only when neither cleanup nor dictation-agent
+      // still need a local model. Otherwise the still-active scope would lose
+      // its server on the next provider switch of the other scope.
+      const cleanupNeedsLocal = setVars.CLEANUP_PROVIDER === "local";
+      const dictationAgentNeedsLocal = setVars.DICTATION_AGENT_PROVIDER === "local";
+      if (
+        prefs.cleanupProvider &&
+        prefs.cleanupProvider !== "local" &&
+        !cleanupNeedsLocal &&
+        !dictationAgentNeedsLocal
+      ) {
         const modelManager = require("./modelManagerBridge").default;
         modelManager.stopServer().catch((err) => {
           debugLogger.error("Failed to stop llama-server on provider switch", {
diff --git a/src/hooks/useActionProcessing.ts b/src/hooks/useActionProcessing.ts
index 324f53c35..a20fd7c5f 100644
--- a/src/hooks/useActionProcessing.ts
+++ b/src/hooks/useActionProcessing.ts
@@ -2,7 +2,7 @@ import { useState, useEffect, useRef, useCallback } from "react";
 import { useTranslation } from "react-i18next";
 import reasoningService from "../services/ReasoningService";
 import type { ActionItem } from "../types/electron";
-import { getEffectiveReasoningModel } from "../stores/settingsStore";
+import { getEffectiveCleanupModel } from "../stores/settingsStore";
 import { generateNoteTitle } from "../utils/generateTitle";
 
 export type ActionProcessingState = "idle" | "processing" | "success";
@@ -65,7 +65,7 @@ export function useActionProcessing({ onSuccess, onError }: UseActionProcessingO
     ) => {
       if (processingRef.current) return;
 
-      const modelId = getEffectiveReasoningModel() || options.modelId;
+      const modelId = getEffectiveCleanupModel() || options.modelId;
 
       if (!modelId && !options.isCloudMode) {
         onError(t("notes.actions.errors.noModel"));
diff --git a/src/hooks/useNotesOnboarding.ts b/src/hooks/useNotesOnboarding.ts
index fdf8f4bd3..e845f0e77 100644
--- a/src/hooks/useNotesOnboarding.ts
+++ b/src/hooks/useNotesOnboarding.ts
@@ -1,5 +1,5 @@
 import { useState, useCallback } from "react";
-import { useSettingsStore, selectIsCloudReasoningMode } from "../stores/settingsStore";
+import { useSettingsStore, selectIsCloudCleanupMode } from "../stores/settingsStore";
 import { useUsage } from "./useUsage";
 
 interface UseNotesOnboardingReturn {
@@ -14,15 +14,15 @@ export function useNotesOnboarding(): UseNotesOnboardingReturn {
   const usage = useUsage();
   const isProUser = !!(usage?.isSubscribed || usage?.isTrial);
   const isProLoading = usage !== null && !usage.hasLoaded;
-  const useReasoningModel = useSettingsStore((s) => s.useReasoningModel);
-  const effectiveModel = useSettingsStore((s) => s.reasoningModel);
-  const isCloudReasoning = useSettingsStore(selectIsCloudReasoningMode);
+  const useCleanupModel = useSettingsStore((s) => s.useCleanupModel);
+  const effectiveModel = useSettingsStore((s) => s.cleanupModel);
+  const isCloudCleanup = useSettingsStore(selectIsCloudCleanupMode);
 
   const [isComplete, setIsComplete] = useState(
     () => localStorage.getItem("notesOnboardingComplete") === "true"
   );
 
-  const isLLMConfigured = isCloudReasoning || (useReasoningModel && !!effectiveModel);
+  const isLLMConfigured = isCloudCleanup || (useCleanupModel && !!effectiveModel);
 
   const complete = useCallback(() => {
     localStorage.setItem("notesOnboardingComplete", "true");
diff --git a/src/hooks/useSettings.ts b/src/hooks/useSettings.ts
index 67c435548..e177bdc96 100644
--- a/src/hooks/useSettings.ts
+++ b/src/hooks/useSettings.ts
@@ -26,15 +26,15 @@ export interface TranscriptionSettings {
   showTranscriptionPreview: boolean;
 }
 
-export interface ReasoningSettings {
-  useReasoningModel: boolean;
-  reasoningModel: string;
-  reasoningProvider: string;
-  cloudReasoningBaseUrl?: string;
-  cloudReasoningMode: string;
-  reasoningMode: InferenceMode;
-  remoteReasoningType: SelfHostedType;
-  remoteReasoningUrl: string;
+export interface CleanupSettings {
+  useCleanupModel: boolean;
+  cleanupModel: string;
+  cleanupProvider: string;
+  cleanupCloudBaseUrl?: string;
+  cleanupCloudMode: string;
+  cleanupMode: InferenceMode;
+  cleanupRemoteType: SelfHostedType;
+  cleanupRemoteUrl: string;
 }
 
 export interface HotkeySettings {
@@ -55,7 +55,7 @@ export interface ApiKeySettings {
   groqApiKey: string;
   mistralApiKey: string;
   customTranscriptionApiKey: string;
-  customReasoningApiKey: string;
+  cleanupCustomApiKey: string;
 }
 
 export interface PrivacySettings {
@@ -69,15 +69,16 @@ export interface ThemeSettings {
   theme: "light" | "dark" | "auto";
 }
 
-export interface AgentModeSettings {
-  agentModel: string;
-  agentProvider: string;
-  agentKey: string;
-  agentSystemPrompt: string;
-  agentEnabled: boolean;
-  cloudAgentMode: string;
-  agentInferenceMode: InferenceMode;
-  remoteAgentUrl: string;
+export interface ChatAgentSettings {
+  chatAgentModel: string;
+  chatAgentProvider: string;
+  chatAgentKey: string;
+  chatAgentEnabled: boolean;
+  chatAgentCloudMode: string;
+  chatAgentMode: InferenceMode;
+  chatAgentCloudBaseUrl: string;
+  chatAgentRemoteType: SelfHostedType;
+  chatAgentRemoteUrl: string;
 }
 
 function useSettingsInternal() {
@@ -140,8 +141,10 @@ function useSettingsInternal() {
     localTranscriptionProvider,
     whisperModel,
     parakeetModel,
-    reasoningProvider,
-    reasoningModel,
+    cleanupProvider,
+    cleanupModel,
+    dictationAgentProvider,
+    dictationAgentModel,
   } = store;
 
   useEffect(() => {
@@ -153,8 +156,10 @@ function useSettingsInternal() {
         useLocalWhisper,
         localTranscriptionProvider,
         model: model || undefined,
-        reasoningProvider,
-        reasoningModel: reasoningProvider === "local" ? reasoningModel : undefined,
+        cleanupProvider,
+        cleanupModel: cleanupProvider === "local" ? cleanupModel : undefined,
+        dictationAgentProvider,
+        dictationAgentModel: dictationAgentProvider === "local" ? dictationAgentModel : undefined,
       })
       .catch((err) =>
         logger.warn(
@@ -168,8 +173,10 @@ function useSettingsInternal() {
     localTranscriptionProvider,
     whisperModel,
     parakeetModel,
-    reasoningProvider,
-    reasoningModel,
+    cleanupProvider,
+    cleanupModel,
+    dictationAgentProvider,
+    dictationAgentModel,
   ]);
 
   return {
@@ -185,21 +192,21 @@ function useSettingsInternal() {
     cloudTranscriptionProvider: store.cloudTranscriptionProvider,
     cloudTranscriptionModel: store.cloudTranscriptionModel,
     cloudTranscriptionBaseUrl: store.cloudTranscriptionBaseUrl,
-    cloudReasoningBaseUrl: store.cloudReasoningBaseUrl,
+    cleanupCloudBaseUrl: store.cleanupCloudBaseUrl,
     cloudTranscriptionMode: store.cloudTranscriptionMode,
-    cloudReasoningMode: store.cloudReasoningMode,
+    cleanupCloudMode: store.cleanupCloudMode,
     transcriptionMode: store.transcriptionMode,
     remoteTranscriptionType: store.remoteTranscriptionType,
     remoteTranscriptionUrl: store.remoteTranscriptionUrl,
-    reasoningMode: store.reasoningMode,
-    remoteReasoningType: store.remoteReasoningType,
-    remoteReasoningUrl: store.remoteReasoningUrl,
+    cleanupMode: store.cleanupMode,
+    cleanupRemoteType: store.cleanupRemoteType,
+    cleanupRemoteUrl: store.cleanupRemoteUrl,
     customDictionary: store.customDictionary,
     assemblyAiStreaming: store.assemblyAiStreaming,
     setAssemblyAiStreaming: store.setAssemblyAiStreaming,
-    useReasoningModel: store.useReasoningModel,
-    reasoningModel: store.reasoningModel,
-    reasoningProvider: store.reasoningProvider,
+    useCleanupModel: store.useCleanupModel,
+    cleanupModel: store.cleanupModel,
+    cleanupProvider: store.cleanupProvider,
     openaiApiKey: store.openaiApiKey,
     anthropicApiKey: store.anthropicApiKey,
     geminiApiKey: store.geminiApiKey,
@@ -220,19 +227,19 @@ function useSettingsInternal() {
     setCloudTranscriptionProvider: store.setCloudTranscriptionProvider,
     setCloudTranscriptionModel: store.setCloudTranscriptionModel,
     setCloudTranscriptionBaseUrl: store.setCloudTranscriptionBaseUrl,
-    setCloudReasoningBaseUrl: store.setCloudReasoningBaseUrl,
     setCloudTranscriptionMode: store.setCloudTranscriptionMode,
-    setCloudReasoningMode: store.setCloudReasoningMode,
+    setCleanupCloudBaseUrl: store.setCleanupCloudBaseUrl,
+    setCleanupCloudMode: store.setCleanupCloudMode,
     setTranscriptionMode: store.setTranscriptionMode,
     setRemoteTranscriptionType: store.setRemoteTranscriptionType,
     setRemoteTranscriptionUrl: store.setRemoteTranscriptionUrl,
-    setReasoningMode: store.setReasoningMode,
-    setRemoteReasoningType: store.setRemoteReasoningType,
-    setRemoteReasoningUrl: store.setRemoteReasoningUrl,
+    setCleanupMode: store.setCleanupMode,
+    setCleanupRemoteType: store.setCleanupRemoteType,
+    setCleanupRemoteUrl: store.setCleanupRemoteUrl,
     setCustomDictionary: store.setCustomDictionary,
-    setUseReasoningModel: store.setUseReasoningModel,
-    setReasoningModel: store.setReasoningModel,
-    setReasoningProvider: store.setReasoningProvider,
+    setUseCleanupModel: store.setUseCleanupModel,
+    setCleanupModel: store.setCleanupModel,
+    setCleanupProvider: store.setCleanupProvider,
     setOpenaiApiKey: store.setOpenaiApiKey,
     setAnthropicApiKey: store.setAnthropicApiKey,
     setGeminiApiKey: store.setGeminiApiKey,
@@ -240,8 +247,8 @@ function useSettingsInternal() {
     setMistralApiKey: store.setMistralApiKey,
     customTranscriptionApiKey: store.customTranscriptionApiKey,
     setCustomTranscriptionApiKey: store.setCustomTranscriptionApiKey,
-    customReasoningApiKey: store.customReasoningApiKey,
-    setCustomReasoningApiKey: store.setCustomReasoningApiKey,
+    cleanupCustomApiKey: store.cleanupCustomApiKey,
+    setCleanupCustomApiKey: store.setCleanupCustomApiKey,
     setDictationKey: store.setDictationKey,
     setMeetingKey: store.setMeetingKey,
     setTheme: store.setTheme,
@@ -282,7 +289,7 @@ function useSettingsInternal() {
     dataRetentionEnabled: store.dataRetentionEnabled,
     setDataRetentionEnabled: store.setDataRetentionEnabled,
     updateTranscriptionSettings: store.updateTranscriptionSettings,
-    updateReasoningSettings: store.updateReasoningSettings,
+    updateCleanupSettings: store.updateCleanupSettings,
     updateApiKeys: store.updateApiKeys,
   };
 }
diff --git a/src/locales/de/translation.json b/src/locales/de/translation.json
index 2b8827656..63295c9eb 100644
--- a/src/locales/de/translation.json
+++ b/src/locales/de/translation.json
@@ -1484,8 +1484,9 @@
       "description": "Konfigurieren Sie Modelle für Bereinigung, Notizformatierung und Chat",
       "tabs": {
         "dictationCleanup": "Diktat-Bereinigung",
+        "dictationAgent": "Dictation Agent",
         "noteFormatting": "Notizformatierung",
-        "chatIntelligence": "Chat-Intelligenz"
+        "chatIntelligence": "Chat"
       }
     },
     "transcription": {
@@ -2099,6 +2100,26 @@
       "closeTab": "Du kannst diesen Tab schließen."
     }
   },
+  "dictationAgent": {
+    "title": "Dictation Agent",
+    "description": "Configure a dedicated model and prompt used when you address your agent by name during dictation.",
+    "modes": {
+      "openwhispr": "OpenWhispr Cloud",
+      "openwhisprDesc": "Use the OpenWhispr-managed agent — no API key needed.",
+      "providers": "Bring your own key",
+      "providersDesc": "Connect to OpenAI, Anthropic, Gemini, or Groq with your own API key.",
+      "local": "Local",
+      "localDesc": "Run a local LLM on your device — fully private.",
+      "selfHosted": "Self-hosted",
+      "selfHostedDesc": "Point at a self-hosted OpenAI-compatible endpoint.",
+      "enterprise": "Enterprise",
+      "enterpriseDesc": "Use AWS Bedrock, Azure OpenAI, or Google Vertex."
+    },
+    "prompt": {
+      "title": "Agent prompt",
+      "description": "The system prompt used when the wake word is detected. Falls back to the built-in default."
+    }
+  },
   "agentMode": {
     "settings": {
       "enabled": "Agent-Modus aktivieren",
diff --git a/src/locales/en/translation.json b/src/locales/en/translation.json
index de7078fcb..2e1712c43 100644
--- a/src/locales/en/translation.json
+++ b/src/locales/en/translation.json
@@ -1580,8 +1580,9 @@
       "description": "Configure models for cleanup, note formatting, and chat",
       "tabs": {
         "dictationCleanup": "Dictation Cleanup",
+        "dictationAgent": "Dictation Agent",
         "noteFormatting": "Note Formatting",
-        "chatIntelligence": "Chat Intelligence"
+        "chatIntelligence": "Chat"
       }
     },
     "transcription": {
@@ -2195,6 +2196,26 @@
       "closeTab": "You can close this tab."
     }
   },
+  "dictationAgent": {
+    "title": "Dictation Agent",
+    "description": "Configure a dedicated model and prompt used when you address your agent by name during dictation.",
+    "modes": {
+      "openwhispr": "OpenWhispr Cloud",
+      "openwhisprDesc": "Use the OpenWhispr-managed agent — no API key needed.",
+      "providers": "Bring your own key",
+      "providersDesc": "Connect to OpenAI, Anthropic, Gemini, or Groq with your own API key.",
+      "local": "Local",
+      "localDesc": "Run a local LLM on your device — fully private.",
+      "selfHosted": "Self-hosted",
+      "selfHostedDesc": "Point at a self-hosted OpenAI-compatible endpoint.",
+      "enterprise": "Enterprise",
+      "enterpriseDesc": "Use AWS Bedrock, Azure OpenAI, or Google Vertex."
+    },
+    "prompt": {
+      "title": "Agent prompt",
+      "description": "The system prompt used when the wake word is detected. Falls back to the built-in default."
+    }
+  },
   "agentMode": {
     "settings": {
       "enabled": "Enable Agent Mode",
diff --git a/src/locales/es/translation.json b/src/locales/es/translation.json
index 45a8b6495..46d9c6978 100644
--- a/src/locales/es/translation.json
+++ b/src/locales/es/translation.json
@@ -1532,8 +1532,9 @@
       "description": "Configura modelos para limpieza, formato de notas y chat",
       "tabs": {
         "dictationCleanup": "Limpieza de dictado",
+        "dictationAgent": "Dictation Agent",
         "noteFormatting": "Formato de notas",
-        "chatIntelligence": "Inteligencia de chat"
+        "chatIntelligence": "Chat"
       }
     },
     "transcription": {
@@ -2147,6 +2148,26 @@
       "closeTab": "Puedes cerrar esta pestaña."
     }
   },
+  "dictationAgent": {
+    "title": "Dictation Agent",
+    "description": "Configure a dedicated model and prompt used when you address your agent by name during dictation.",
+    "modes": {
+      "openwhispr": "OpenWhispr Cloud",
+      "openwhisprDesc": "Use the OpenWhispr-managed agent — no API key needed.",
+      "providers": "Bring your own key",
+      "providersDesc": "Connect to OpenAI, Anthropic, Gemini, or Groq with your own API key.",
+      "local": "Local",
+      "localDesc": "Run a local LLM on your device — fully private.",
+      "selfHosted": "Self-hosted",
+      "selfHostedDesc": "Point at a self-hosted OpenAI-compatible endpoint.",
+      "enterprise": "Enterprise",
+      "enterpriseDesc": "Use AWS Bedrock, Azure OpenAI, or Google Vertex."
+    },
+    "prompt": {
+      "title": "Agent prompt",
+      "description": "The system prompt used when the wake word is detected. Falls back to the built-in default."
+    }
+  },
   "agentMode": {
     "settings": {
       "enabled": "Activar Modo Agente",
diff --git a/src/locales/fr/translation.json b/src/locales/fr/translation.json
index e93234ccd..843b7e7ce 100644
--- a/src/locales/fr/translation.json
+++ b/src/locales/fr/translation.json
@@ -1532,8 +1532,9 @@
       "description": "Configurez les modèles pour le nettoyage, la mise en forme des notes et le chat",
       "tabs": {
         "dictationCleanup": "Nettoyage de la dictée",
+        "dictationAgent": "Dictation Agent",
         "noteFormatting": "Mise en forme des notes",
-        "chatIntelligence": "Intelligence du chat"
+        "chatIntelligence": "Chat"
       }
     },
     "transcription": {
@@ -2147,6 +2148,26 @@
       "closeTab": "Vous pouvez fermer cet onglet."
     }
   },
+  "dictationAgent": {
+    "title": "Dictation Agent",
+    "description": "Configure a dedicated model and prompt used when you address your agent by name during dictation.",
+    "modes": {
+      "openwhispr": "OpenWhispr Cloud",
+      "openwhisprDesc": "Use the OpenWhispr-managed agent — no API key needed.",
+      "providers": "Bring your own key",
+      "providersDesc": "Connect to OpenAI, Anthropic, Gemini, or Groq with your own API key.",
+      "local": "Local",
+      "localDesc": "Run a local LLM on your device — fully private.",
+      "selfHosted": "Self-hosted",
+      "selfHostedDesc": "Point at a self-hosted OpenAI-compatible endpoint.",
+      "enterprise": "Enterprise",
+      "enterpriseDesc": "Use AWS Bedrock, Azure OpenAI, or Google Vertex."
+    },
+    "prompt": {
+      "title": "Agent prompt",
+      "description": "The system prompt used when the wake word is detected. Falls back to the built-in default."
+    }
+  },
   "agentMode": {
     "settings": {
       "enabled": "Activer le Mode Agent",
diff --git a/src/locales/it/translation.json b/src/locales/it/translation.json
index fd93a0c00..6c0b02bf8 100644
--- a/src/locales/it/translation.json
+++ b/src/locales/it/translation.json
@@ -1484,8 +1484,9 @@
       "description": "Configura modelli per pulizia, formattazione note e chat",
       "tabs": {
         "dictationCleanup": "Pulizia della dettatura",
+        "dictationAgent": "Dictation Agent",
         "noteFormatting": "Formattazione note",
-        "chatIntelligence": "Intelligenza chat"
+        "chatIntelligence": "Chat"
       }
     },
     "transcription": {
@@ -2099,6 +2100,26 @@
       "closeTab": "Puoi chiudere questa scheda."
     }
   },
+  "dictationAgent": {
+    "title": "Dictation Agent",
+    "description": "Configure a dedicated model and prompt used when you address your agent by name during dictation.",
+    "modes": {
+      "openwhispr": "OpenWhispr Cloud",
+      "openwhisprDesc": "Use the OpenWhispr-managed agent — no API key needed.",
+      "providers": "Bring your own key",
+      "providersDesc": "Connect to OpenAI, Anthropic, Gemini, or Groq with your own API key.",
+      "local": "Local",
+      "localDesc": "Run a local LLM on your device — fully private.",
+      "selfHosted": "Self-hosted",
+      "selfHostedDesc": "Point at a self-hosted OpenAI-compatible endpoint.",
+      "enterprise": "Enterprise",
+      "enterpriseDesc": "Use AWS Bedrock, Azure OpenAI, or Google Vertex."
+    },
+    "prompt": {
+      "title": "Agent prompt",
+      "description": "The system prompt used when the wake word is detected. Falls back to the built-in default."
+    }
+  },
   "agentMode": {
     "settings": {
       "enabled": "Abilita Modalità Agente",
diff --git a/src/locales/ja/translation.json b/src/locales/ja/translation.json
index 03055cfee..418d61463 100644
--- a/src/locales/ja/translation.json
+++ b/src/locales/ja/translation.json
@@ -1484,8 +1484,9 @@
       "description": "クリーンアップ、ノートのフォーマット、チャット用のモデルを設定",
       "tabs": {
         "dictationCleanup": "ディクテーションのクリーンアップ",
+        "dictationAgent": "Dictation Agent",
         "noteFormatting": "ノートのフォーマット",
-        "chatIntelligence": "チャットインテリジェンス"
+        "chatIntelligence": "チャット"
       }
     },
     "transcription": {
@@ -2099,6 +2100,26 @@
       "closeTab": "このタブを閉じてください。"
     }
   },
+  "dictationAgent": {
+    "title": "Dictation Agent",
+    "description": "Configure a dedicated model and prompt used when you address your agent by name during dictation.",
+    "modes": {
+      "openwhispr": "OpenWhispr Cloud",
+      "openwhisprDesc": "Use the OpenWhispr-managed agent — no API key needed.",
+      "providers": "Bring your own key",
+      "providersDesc": "Connect to OpenAI, Anthropic, Gemini, or Groq with your own API key.",
+      "local": "Local",
+      "localDesc": "Run a local LLM on your device — fully private.",
+      "selfHosted": "Self-hosted",
+      "selfHostedDesc": "Point at a self-hosted OpenAI-compatible endpoint.",
+      "enterprise": "Enterprise",
+      "enterpriseDesc": "Use AWS Bedrock, Azure OpenAI, or Google Vertex."
+    },
+    "prompt": {
+      "title": "Agent prompt",
+      "description": "The system prompt used when the wake word is detected. Falls back to the built-in default."
+    }
+  },
   "agentMode": {
     "settings": {
       "enabled": "エージェントモードを有効にする",
@@ -2192,7 +2213,11 @@
       "systemAudioDescription": "会議を文字起こしするには、OpenWhispr に他の参加者の音声を録音するためのシステムオーディオの権限が必要です。画面を録画することはありません。システム設定に移動して有効にします。",
       "openSettings": "システム設定を開く"
     },
-    "sections": { "calendar": "カレンダー", "api": "API", "mcp": "MCP" },
+    "sections": {
+      "calendar": "カレンダー",
+      "api": "API",
+      "mcp": "MCP"
+    },
     "api": {
       "title": "APIキー",
       "description": "プログラムからのアクセス用にAPIキーを管理",
diff --git a/src/locales/pt/translation.json b/src/locales/pt/translation.json
index b15fc6191..e19b716d5 100644
--- a/src/locales/pt/translation.json
+++ b/src/locales/pt/translation.json
@@ -1456,8 +1456,9 @@
       "description": "Configure modelos para limpeza, formatação de notas e chat",
       "tabs": {
         "dictationCleanup": "Limpeza do ditado",
+        "dictationAgent": "Dictation Agent",
         "noteFormatting": "Formatação de notas",
-        "chatIntelligence": "Inteligência de chat"
+        "chatIntelligence": "Chat"
       }
     },
     "transcription": {
@@ -2099,6 +2100,26 @@
       "closeTab": "Você pode fechar esta aba."
     }
   },
+  "dictationAgent": {
+    "title": "Dictation Agent",
+    "description": "Configure a dedicated model and prompt used when you address your agent by name during dictation.",
+    "modes": {
+      "openwhispr": "OpenWhispr Cloud",
+      "openwhisprDesc": "Use the OpenWhispr-managed agent — no API key needed.",
+      "providers": "Bring your own key",
+      "providersDesc": "Connect to OpenAI, Anthropic, Gemini, or Groq with your own API key.",
+      "local": "Local",
+      "localDesc": "Run a local LLM on your device — fully private.",
+      "selfHosted": "Self-hosted",
+      "selfHostedDesc": "Point at a self-hosted OpenAI-compatible endpoint.",
+      "enterprise": "Enterprise",
+      "enterpriseDesc": "Use AWS Bedrock, Azure OpenAI, or Google Vertex."
+    },
+    "prompt": {
+      "title": "Agent prompt",
+      "description": "The system prompt used when the wake word is detected. Falls back to the built-in default."
+    }
+  },
   "agentMode": {
     "settings": {
       "enabled": "Ativar Modo Agente",
diff --git a/src/locales/ru/translation.json b/src/locales/ru/translation.json
index 80bf4f665..9e7b532f2 100644
--- a/src/locales/ru/translation.json
+++ b/src/locales/ru/translation.json
@@ -1484,8 +1484,9 @@
       "description": "Настройка моделей для очистки, форматирования заметок и чата",
       "tabs": {
         "dictationCleanup": "Очистка диктовки",
+        "dictationAgent": "Dictation Agent",
         "noteFormatting": "Форматирование заметок",
-        "chatIntelligence": "Интеллект чата"
+        "chatIntelligence": "Чат"
       }
     },
     "transcription": {
@@ -2101,6 +2102,26 @@
       "closeTab": "Можете закрыть эту вкладку."
     }
   },
+  "dictationAgent": {
+    "title": "Dictation Agent",
+    "description": "Configure a dedicated model and prompt used when you address your agent by name during dictation.",
+    "modes": {
+      "openwhispr": "OpenWhispr Cloud",
+      "openwhisprDesc": "Use the OpenWhispr-managed agent — no API key needed.",
+      "providers": "Bring your own key",
+      "providersDesc": "Connect to OpenAI, Anthropic, Gemini, or Groq with your own API key.",
+      "local": "Local",
+      "localDesc": "Run a local LLM on your device — fully private.",
+      "selfHosted": "Self-hosted",
+      "selfHostedDesc": "Point at a self-hosted OpenAI-compatible endpoint.",
+      "enterprise": "Enterprise",
+      "enterpriseDesc": "Use AWS Bedrock, Azure OpenAI, or Google Vertex."
+    },
+    "prompt": {
+      "title": "Agent prompt",
+      "description": "The system prompt used when the wake word is detected. Falls back to the built-in default."
+    }
+  },
   "agentMode": {
     "settings": {
       "enabled": "Включить режим агента",
diff --git a/src/locales/zh-CN/translation.json b/src/locales/zh-CN/translation.json
index dbd6874e0..60e295653 100644
--- a/src/locales/zh-CN/translation.json
+++ b/src/locales/zh-CN/translation.json
@@ -1479,8 +1479,9 @@
       "description": "配置用于听写清理、笔记格式化和聊天的模型",
       "tabs": {
         "dictationCleanup": "听写清理",
+        "dictationAgent": "Dictation Agent",
         "noteFormatting": "笔记格式化",
-        "chatIntelligence": "聊天智能"
+        "chatIntelligence": "聊天"
       }
     },
     "transcription": {
@@ -2094,6 +2095,26 @@
       "closeTab": "您可以关闭此标签页。"
     }
   },
+  "dictationAgent": {
+    "title": "Dictation Agent",
+    "description": "Configure a dedicated model and prompt used when you address your agent by name during dictation.",
+    "modes": {
+      "openwhispr": "OpenWhispr Cloud",
+      "openwhisprDesc": "Use the OpenWhispr-managed agent — no API key needed.",
+      "providers": "Bring your own key",
+      "providersDesc": "Connect to OpenAI, Anthropic, Gemini, or Groq with your own API key.",
+      "local": "Local",
+      "localDesc": "Run a local LLM on your device — fully private.",
+      "selfHosted": "Self-hosted",
+      "selfHostedDesc": "Point at a self-hosted OpenAI-compatible endpoint.",
+      "enterprise": "Enterprise",
+      "enterpriseDesc": "Use AWS Bedrock, Azure OpenAI, or Google Vertex."
+    },
+    "prompt": {
+      "title": "Agent prompt",
+      "description": "The system prompt used when the wake word is detected. Falls back to the built-in default."
+    }
+  },
   "agentMode": {
     "settings": {
       "enabled": "启用智能助手模式",
diff --git a/src/locales/zh-TW/translation.json b/src/locales/zh-TW/translation.json
index 8b076c4cb..70e0cd54c 100644
--- a/src/locales/zh-TW/translation.json
+++ b/src/locales/zh-TW/translation.json
@@ -1479,8 +1479,9 @@
       "description": "設定用於聽寫清理、筆記格式化和聊天的模型",
       "tabs": {
         "dictationCleanup": "聽寫清理",
+        "dictationAgent": "Dictation Agent",
         "noteFormatting": "筆記格式化",
-        "chatIntelligence": "聊天智能"
+        "chatIntelligence": "聊天"
       }
     },
     "transcription": {
@@ -2094,6 +2095,26 @@
       "closeTab": "您可以關閉此分頁。"
     }
   },
+  "dictationAgent": {
+    "title": "Dictation Agent",
+    "description": "Configure a dedicated model and prompt used when you address your agent by name during dictation.",
+    "modes": {
+      "openwhispr": "OpenWhispr Cloud",
+      "openwhisprDesc": "Use the OpenWhispr-managed agent — no API key needed.",
+      "providers": "Bring your own key",
+      "providersDesc": "Connect to OpenAI, Anthropic, Gemini, or Groq with your own API key.",
+      "local": "Local",
+      "localDesc": "Run a local LLM on your device — fully private.",
+      "selfHosted": "Self-hosted",
+      "selfHostedDesc": "Point at a self-hosted OpenAI-compatible endpoint.",
+      "enterprise": "Enterprise",
+      "enterpriseDesc": "Use AWS Bedrock, Azure OpenAI, or Google Vertex."
+    },
+    "prompt": {
+      "title": "Agent prompt",
+      "description": "The system prompt used when the wake word is detected. Falls back to the built-in default."
+    }
+  },
   "agentMode": {
     "settings": {
       "enabled": "啟用智慧助手模式",
diff --git a/src/models/ModelRegistry.ts b/src/models/ModelRegistry.ts
index 10f4e794f..4a2ca8c4f 100644
--- a/src/models/ModelRegistry.ts
+++ b/src/models/ModelRegistry.ts
@@ -1,5 +1,5 @@
 import modelDataRaw from "./modelRegistryData.json";
-import { isCloudReasoningMode, getSettings } from "../stores/settingsStore";
+import { isCloudCleanupMode, getSettings } from "../stores/settingsStore";
 
 export interface ModelDefinition {
   id: string;
@@ -282,11 +282,11 @@ export function getReasoningModelLabel(modelId: string): string {
 }
 
 export function getModelProvider(modelId: string): string {
-  if (isCloudReasoningMode()) {
+  if (isCloudCleanupMode()) {
     return "openwhispr";
   }
 
-  const storedProvider = getSettings().reasoningProvider;
+  const storedProvider = getSettings().cleanupProvider;
 
   if (storedProvider === "custom") {
     return "custom";
diff --git a/src/services/BaseReasoningService.ts b/src/services/BaseReasoningService.ts
index fafcb0786..7c6022547 100644
--- a/src/services/BaseReasoningService.ts
+++ b/src/services/BaseReasoningService.ts
@@ -7,6 +7,8 @@ export interface ReasoningConfig {
   contextSize?: number;
   systemPrompt?: string;
   lanUrl?: string;
+  /** Overrides the model-id heuristic in `processText` when set. */
+  provider?: string;
 }
 
 export abstract class BaseReasoningService {
diff --git a/src/services/ReasoningService.ts b/src/services/ReasoningService.ts
index 5e56d10a4..0a2bbeb26 100644
--- a/src/services/ReasoningService.ts
+++ b/src/services/ReasoningService.ts
@@ -3,18 +3,17 @@ import {
   getCloudModel,
   getOpenAiApiConfig,
   isEnterpriseProvider,
-  type EnterpriseProvider,
 } from "../models/ModelRegistry";
 import { BaseReasoningService, ReasoningConfig } from "./BaseReasoningService";
 import { SecureCache } from "../utils/SecureCache";
 import { withRetry, createApiRetryStrategy } from "../utils/retry";
 import { API_ENDPOINTS, TOKEN_LIMITS, buildApiUrl, normalizeBaseUrl } from "../config/constants";
 import logger from "../utils/logger";
-import { isSecureEndpoint } from "../utils/urlUtils";
-import { withSessionRefresh } from "../lib/neonAuth";
-import { getSettings, isCloudReasoningMode } from "../stores/settingsStore";
+import { getSettings, isCloudCleanupMode } from "../stores/settingsStore";
 import { streamText, stepCountIs } from "ai";
 import { getAIModel } from "./ai/providers";
+import { PROVIDER_REGISTRY, type ProviderContext } from "./ai/inferenceProviders";
+import { getConfiguredOpenAIBase } from "./ai/openaiBase";
 
 export type AgentStreamChunk =
   | { type: "content"; text: string }
@@ -30,229 +29,42 @@ export type AgentStreamChunk =
 
 class ReasoningService extends BaseReasoningService {
   private apiKeyCache: SecureCache<string>;
-  private openAiEndpointPreference = new Map<string, "responses" | "chat">();
-  private static readonly OPENAI_ENDPOINT_PREF_STORAGE_KEY = "openAiEndpointPreference";
   private static readonly MAX_TOOL_STEPS = 20;
   private cacheCleanupStop: (() => void) | undefined;
   private streamAbortController: AbortController | null = null;
-  private probedBases = new Set<string>();
+
+  private readonly providerContext: ProviderContext;
 
   constructor() {
     super();
     this.apiKeyCache = new SecureCache();
     this.cacheCleanupStop = this.apiKeyCache.startAutoCleanup();
+    this.providerContext = {
+      getApiKey: (provider: string) =>
+        this.getApiKey(provider as Parameters<ReasoningService["getApiKey"]>[0]),
+      getSystemPrompt: this.getSystemPrompt.bind(this),
+      getCustomDictionary: this.getCustomDictionary.bind(this),
+      getPreferredLanguage: this.getPreferredLanguage.bind(this),
+      getUiLanguage: this.getUiLanguage.bind(this),
+      getCustomPrompt: this.getCustomPrompt.bind(this),
+      callChatCompletionsApi: this.callChatCompletionsApi.bind(this),
+      calculateMaxTokens: this.calculateMaxTokens.bind(this),
+    };
 
     if (typeof window !== "undefined") {
       window.addEventListener("beforeunload", () => this.destroy());
     }
   }
 
-  private isLanReasoningMode(): boolean {
+  private isLanCleanupMode(): boolean {
     const settings = getSettings();
     return (
-      settings.reasoningMode === "self-hosted" &&
-      settings.remoteReasoningType === "lan" &&
-      !!settings.remoteReasoningUrl
+      settings.cleanupMode === "self-hosted" &&
+      settings.cleanupRemoteType === "lan" &&
+      !!settings.cleanupRemoteUrl
     );
   }
 
-  private getConfiguredOpenAIBase(): string {
-    if (typeof window === "undefined") {
-      return API_ENDPOINTS.OPENAI_BASE;
-    }
-
-    try {
-      const settings = getSettings();
-      const provider = settings.reasoningProvider || "";
-      const isCustomProvider = provider === "custom";
-
-      if (!isCustomProvider) {
-        logger.logReasoning("CUSTOM_REASONING_ENDPOINT_CHECK", {
-          hasCustomUrl: false,
-          provider,
-          reason: "Provider is not 'custom', using default OpenAI endpoint",
-          defaultEndpoint: API_ENDPOINTS.OPENAI_BASE,
-        });
-        return API_ENDPOINTS.OPENAI_BASE;
-      }
-
-      const stored = settings.cloudReasoningBaseUrl || "";
-      const trimmed = stored.trim();
-
-      if (!trimmed) {
-        logger.logReasoning("CUSTOM_REASONING_ENDPOINT_CHECK", {
-          hasCustomUrl: false,
-          provider,
-          usingDefault: true,
-          defaultEndpoint: API_ENDPOINTS.OPENAI_BASE,
-        });
-        return API_ENDPOINTS.OPENAI_BASE;
-      }
-
-      const normalized = normalizeBaseUrl(trimmed) || API_ENDPOINTS.OPENAI_BASE;
-
-      logger.logReasoning("CUSTOM_REASONING_ENDPOINT_CHECK", {
-        hasCustomUrl: true,
-        provider,
-        rawUrl: trimmed,
-        normalizedUrl: normalized,
-        defaultEndpoint: API_ENDPOINTS.OPENAI_BASE,
-      });
-
-      const knownNonOpenAIUrls = [
-        "api.groq.com",
-        "api.anthropic.com",
-        "generativelanguage.googleapis.com",
-      ];
-
-      const isKnownNonOpenAI = knownNonOpenAIUrls.some((url) => normalized.includes(url));
-      if (isKnownNonOpenAI) {
-        logger.logReasoning("OPENAI_BASE_REJECTED", {
-          reason: "Custom URL is a known non-OpenAI provider, using default OpenAI endpoint",
-          attempted: normalized,
-        });
-        return API_ENDPOINTS.OPENAI_BASE;
-      }
-
-      if (!isSecureEndpoint(normalized)) {
-        logger.logReasoning("OPENAI_BASE_REJECTED", {
-          reason: "HTTPS required (HTTP allowed for local network only)",
-          attempted: normalized,
-        });
-        return API_ENDPOINTS.OPENAI_BASE;
-      }
-
-      logger.logReasoning("CUSTOM_REASONING_ENDPOINT_RESOLVED", {
-        customEndpoint: normalized,
-        isCustom: true,
-        provider,
-      });
-
-      return normalized;
-    } catch (error) {
-      logger.logReasoning("CUSTOM_REASONING_ENDPOINT_ERROR", {
-        error: (error as Error).message,
-        fallbackTo: API_ENDPOINTS.OPENAI_BASE,
-      });
-      return API_ENDPOINTS.OPENAI_BASE;
-    }
-  }
-
-  private getOpenAIEndpointCandidates(
-    base: string
-  ): Array<{ url: string; type: "responses" | "chat" }> {
-    const lower = base.toLowerCase();
-
-    if (lower.endsWith("/responses") || lower.endsWith("/chat/completions")) {
-      const type = lower.endsWith("/responses") ? "responses" : "chat";
-      return [{ url: base, type }];
-    }
-
-    const preference = this.getStoredOpenAiPreference(base);
-    if (preference === "chat") {
-      return [{ url: buildApiUrl(base, "/chat/completions"), type: "chat" }];
-    }
-
-    const candidates: Array<{ url: string; type: "responses" | "chat" }> = [
-      { url: buildApiUrl(base, "/responses"), type: "responses" },
-      { url: buildApiUrl(base, "/chat/completions"), type: "chat" },
-    ];
-
-    return candidates;
-  }
-
-  private getStoredOpenAiPreference(base: string): "responses" | "chat" | undefined {
-    if (this.openAiEndpointPreference.has(base)) {
-      return this.openAiEndpointPreference.get(base);
-    }
-
-    if (typeof window === "undefined" || !window.localStorage) {
-      return undefined;
-    }
-
-    try {
-      const raw = window.localStorage.getItem(ReasoningService.OPENAI_ENDPOINT_PREF_STORAGE_KEY);
-      if (!raw) {
-        return undefined;
-      }
-      const parsed = JSON.parse(raw);
-      if (typeof parsed !== "object" || parsed === null) {
-        return undefined;
-      }
-      const value = parsed[base];
-      if (value === "responses" || value === "chat") {
-        this.openAiEndpointPreference.set(base, value);
-        return value;
-      }
-    } catch {
-      return undefined;
-    }
-
-    return undefined;
-  }
-
-  private rememberOpenAiPreference(base: string, preference: "responses" | "chat"): void {
-    this.openAiEndpointPreference.set(base, preference);
-
-    if (typeof window === "undefined" || !window.localStorage) {
-      return;
-    }
-
-    try {
-      const raw = window.localStorage.getItem(ReasoningService.OPENAI_ENDPOINT_PREF_STORAGE_KEY);
-      const parsed = raw ? JSON.parse(raw) : {};
-      const data = typeof parsed === "object" && parsed !== null ? parsed : {};
-      data[base] = preference;
-      window.localStorage.setItem(
-        ReasoningService.OPENAI_ENDPOINT_PREF_STORAGE_KEY,
-        JSON.stringify(data)
-      );
-    } catch {}
-  }
-
-  /** Probe /v1/models to detect llama.cpp and prefer /chat/completions. */
-  private async detectReasoningServerType(base: string): Promise<void> {
-    if (this.probedBases.has(base) || this.getStoredOpenAiPreference(base) !== undefined) {
-      return;
-    }
-
-    const lower = base.toLowerCase();
-    if (lower.endsWith("/responses") || lower.endsWith("/chat/completions")) {
-      return;
-    }
-
-    try {
-      const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), 2000);
-      const res = await fetch(buildApiUrl(base, "/models"), {
-        method: "GET",
-        signal: controller.signal,
-      });
-      clearTimeout(timeoutId);
-
-      if (!res.ok) {
-        this.probedBases.add(base);
-        return;
-      }
-
-      const body = await res.json();
-      const first = body?.data?.[0];
-
-      if (first?.owned_by === "llamacpp") {
-        this.rememberOpenAiPreference(base, "chat");
-        logger.logReasoning("LLAMACPP_DETECTED_VIA_MODELS", {
-          base,
-          modelId: first?.id,
-          ownedBy: first.owned_by,
-        });
-      }
-
-      this.probedBases.add(base);
-    } catch {
-      this.probedBases.add(base);
-    }
-  }
-
   private async getApiKey(
     provider: "openai" | "anthropic" | "gemini" | "groq" | "custom"
   ): Promise<string> {
@@ -264,7 +76,7 @@ class ReasoningService extends BaseReasoningService {
         logger.logReasoning("CUSTOM_KEY_IPC_FALLBACK", { error: (err as Error)?.message });
       }
       if (!customKey || !customKey.trim()) {
-        customKey = getSettings().customReasoningApiKey || "";
+        customKey = getSettings().cleanupCustomApiKey || "";
       }
       const trimmedKey = customKey.trim();
 
@@ -476,860 +288,57 @@ class ReasoningService extends BaseReasoningService {
     agentName: string | null = null,
     config: ReasoningConfig = {}
   ): Promise<string> {
-    let trimmedModel = model?.trim?.() || "";
-    const provider = getModelProvider(trimmedModel);
+    const trimmedModel = model?.trim?.() || "";
+    const isLanCleanup = !!config.lanUrl || this.isLanCleanupMode();
+    const providerId = isLanCleanup ? "lan" : config.provider || getModelProvider(trimmedModel);
 
-    if (!trimmedModel && provider !== "openwhispr") {
+    if (!trimmedModel && providerId !== "openwhispr" && providerId !== "lan") {
       throw new Error("No reasoning model selected");
     }
 
     logger.logReasoning("PROVIDER_SELECTION", {
+      provider: providerId,
       model: trimmedModel,
-      provider,
       agentName,
-      hasConfig: Object.keys(config).length > 0,
+      isLanCleanup,
       textLength: text.length,
-      timestamp: new Date().toISOString(),
-    });
-
-    try {
-      let result: string;
-      const startTime = Date.now();
-
-      const isLanReasoning = !!config.lanUrl || this.isLanReasoningMode();
-
-      logger.logReasoning("ROUTING_TO_PROVIDER", {
-        provider,
-        model,
-        isLanReasoning,
-      });
-
-      if (isLanReasoning) {
-        result = await this.processWithLan(text, agentName, config);
-      } else {
-        switch (provider) {
-          case "openai":
-            result = await this.processWithOpenAI(text, trimmedModel, agentName, config);
-            break;
-          case "anthropic":
-            result = await this.processWithAnthropic(text, trimmedModel, agentName, config);
-            break;
-          case "local":
-            result = await this.processWithLocal(text, trimmedModel, agentName, config);
-            break;
-          case "gemini":
-            result = await this.processWithGemini(text, trimmedModel, agentName, config);
-            break;
-          case "groq":
-            result = await this.processWithGroq(text, model, agentName, config);
-            break;
-          case "openwhispr":
-            result = await this.processWithOpenWhispr(text, model, agentName, config);
-            break;
-          case "custom":
-            result = await this.processWithOpenAI(text, trimmedModel, agentName, config);
-            break;
-          case "bedrock":
-          case "azure":
-          case "vertex":
-            result = await this.processWithEnterprise(
-              provider as EnterpriseProvider,
-              text,
-              trimmedModel,
-              agentName,
-              config
-            );
-            break;
-          default:
-            throw new Error(`Unsupported reasoning provider: ${provider}`);
-        }
-      }
-
-      const processingTime = Date.now() - startTime;
-
-      logger.logReasoning("PROVIDER_SUCCESS", {
-        provider,
-        model,
-        processingTimeMs: processingTime,
-        resultLength: result.length,
-        resultPreview: result.substring(0, 100) + (result.length > 100 ? "..." : ""),
-      });
-
-      return result;
-    } catch (error) {
-      logger.logReasoning("PROVIDER_ERROR", {
-        provider,
-        model,
-        error: (error as Error).message,
-        stack: (error as Error).stack,
-      });
-
-      throw error;
-    }
-  }
-
-  private async processWithOpenAI(
-    text: string,
-    model: string,
-    agentName: string | null = null,
-    config: ReasoningConfig = {}
-  ): Promise<string> {
-    const reasoningProvider = getSettings().reasoningProvider || "";
-    const isCustomProvider = reasoningProvider === "custom";
-
-    logger.logReasoning("OPENAI_START", {
-      model,
-      agentName,
-      isCustomProvider,
-      hasApiKey: false, // Will update after fetching
     });
 
-    if (this.isProcessing) {
-      throw new Error("Already processing a request");
+    const handler = PROVIDER_REGISTRY[providerId];
+    if (!handler) {
+      throw new Error(`Unsupported reasoning provider: ${providerId}`);
     }
 
-    const apiKey = await this.getApiKey(isCustomProvider ? "custom" : "openai");
-
-    logger.logReasoning("OPENAI_API_KEY", {
-      hasApiKey: !!apiKey,
-      keyLength: apiKey?.length || 0,
-    });
-
-    this.isProcessing = true;
-
+    const startTime = Date.now();
     try {
-      const systemPrompt = config.systemPrompt || this.getSystemPrompt(agentName, text);
-      const userPrompt = text;
-
-      const messages = [
-        { role: "system", content: systemPrompt },
-        { role: "user", content: userPrompt },
-      ];
-
-      const openAiBase = this.getConfiguredOpenAIBase();
-      await this.detectReasoningServerType(openAiBase);
-      const endpointCandidates = this.getOpenAIEndpointCandidates(openAiBase);
-      const isCustomEndpoint = openAiBase !== API_ENDPOINTS.OPENAI_BASE;
-
-      logger.logReasoning("OPENAI_ENDPOINTS", {
-        base: openAiBase,
-        isCustomEndpoint,
-        candidates: endpointCandidates.map((candidate) => candidate.url),
-        preference: this.getStoredOpenAiPreference(openAiBase) || null,
-      });
-
-      if (isCustomEndpoint) {
-        logger.logReasoning("CUSTOM_TEXT_CLEANUP_REQUEST", {
-          customBase: openAiBase,
-          model,
-          textLength: text.length,
-          hasApiKey: !!apiKey,
-          apiKeyPreview: apiKey ? `${apiKey.substring(0, 8)}...` : "(none)",
-        });
-      }
-
-      const response = await withRetry(async () => {
-        let lastError: Error | null = null;
-
-        for (const { url: endpoint, type } of endpointCandidates) {
-          const controller = new AbortController();
-          const timeoutId = setTimeout(() => controller.abort(), 30000);
-          try {
-            const maxTokens =
-              config.maxTokens ||
-              Math.max(
-                4096,
-                this.calculateMaxTokens(
-                  text.length,
-                  TOKEN_LIMITS.MIN_TOKENS,
-                  TOKEN_LIMITS.MAX_TOKENS,
-                  TOKEN_LIMITS.TOKEN_MULTIPLIER
-                )
-              );
-
-            const apiConfig = getOpenAiApiConfig(model);
-            const requestBody: any = { model };
-
-            if (type === "responses") {
-              requestBody.input = messages;
-              requestBody.store = false;
-              requestBody.max_output_tokens = maxTokens;
-            } else {
-              requestBody.messages = messages;
-              requestBody[apiConfig.tokenParam] = maxTokens;
-            }
-
-            if (apiConfig.supportsTemperature) {
-              requestBody.temperature = config.temperature || 0.3;
-            }
-
-            const res = await fetch(endpoint, {
-              method: "POST",
-              headers: {
-                "Content-Type": "application/json",
-                Authorization: `Bearer ${apiKey}`,
-              },
-              body: JSON.stringify(requestBody),
-              signal: controller.signal,
-            });
-
-            if (!res.ok) {
-              const errorData = await res.json().catch(() => ({ error: res.statusText }));
-              const errorMessage =
-                errorData.error?.message || errorData.message || `OpenAI API error: ${res.status}`;
-
-              const isUnsupportedEndpoint =
-                (res.status === 404 || res.status === 405) && type === "responses";
-
-              if (isUnsupportedEndpoint) {
-                lastError = new Error(errorMessage);
-                this.rememberOpenAiPreference(openAiBase, "chat");
-                logger.logReasoning("OPENAI_ENDPOINT_FALLBACK", {
-                  attemptedEndpoint: endpoint,
-                  error: errorMessage,
-                });
-                continue;
-              }
-
-              throw new Error(errorMessage);
-            }
-
-            this.rememberOpenAiPreference(openAiBase, type);
-            return res.json();
-          } catch (error) {
-            if ((error as Error).name === "AbortError") {
-              throw new Error("Request timed out after 30s");
-            }
-            lastError = error as Error;
-            if (type === "responses") {
-              logger.logReasoning("OPENAI_ENDPOINT_FALLBACK", {
-                attemptedEndpoint: endpoint,
-                error: (error as Error).message,
-              });
-              continue;
-            }
-            throw error;
-          } finally {
-            clearTimeout(timeoutId);
-          }
-        }
-
-        throw lastError || new Error("No OpenAI endpoint responded");
-      }, createApiRetryStrategy());
-
-      const isResponsesApi = Array.isArray(response?.output);
-      const isChatCompletions = Array.isArray(response?.choices);
-
-      logger.logReasoning("OPENAI_RAW_RESPONSE", {
-        model,
-        format: isResponsesApi ? "responses" : isChatCompletions ? "chat_completions" : "unknown",
-        hasOutput: isResponsesApi,
-        outputLength: isResponsesApi ? response.output.length : 0,
-        outputTypes: isResponsesApi ? response.output.map((item: any) => item.type) : undefined,
-        hasChoices: isChatCompletions,
-        choicesLength: isChatCompletions ? response.choices.length : 0,
-        usage: response.usage,
-      });
-
-      let responseText = "";
-
-      if (isResponsesApi) {
-        for (const item of response.output) {
-          if (item.type === "message" && item.content) {
-            for (const content of item.content) {
-              if (content.type === "output_text" && content.text) {
-                responseText = content.text.trim();
-                break;
-              }
-            }
-            if (responseText) break;
-          }
-        }
-      }
-
-      if (!responseText && typeof response?.output_text === "string") {
-        responseText = response.output_text.trim();
-      }
-
-      if (!responseText && isChatCompletions) {
-        for (const choice of response.choices) {
-          const message = choice?.message ?? choice?.delta;
-          const content = message?.content;
-
-          if (typeof content === "string" && content.trim()) {
-            responseText = content.trim();
-            break;
-          }
-
-          if (Array.isArray(content)) {
-            for (const part of content) {
-              if (typeof part?.text === "string" && part.text.trim()) {
-                responseText = part.text.trim();
-                break;
-              }
-            }
-          }
-
-          if (responseText) break;
-
-          if (typeof choice?.text === "string" && choice.text.trim()) {
-            responseText = choice.text.trim();
-            break;
-          }
-        }
-      }
-
-      logger.logReasoning("OPENAI_RESPONSE", {
-        model,
-        responseLength: responseText.length,
-        tokensUsed: response.usage?.total_tokens || 0,
-        success: true,
-        isEmpty: responseText.length === 0,
-      });
-
-      if (!responseText) {
-        logger.logReasoning("OPENAI_EMPTY_RESPONSE_FALLBACK", {
-          model,
-          originalTextLength: text.length,
-          reason: "Empty response from API",
-        });
-        return text;
-      }
-
-      return responseText;
-    } catch (error) {
-      logger.logReasoning("OPENAI_ERROR", {
-        model,
-        error: (error as Error).message,
-        errorType: (error as Error).name,
-      });
-      throw error;
-    } finally {
-      this.isProcessing = false;
-    }
-  }
-
-  private async processWithAnthropic(
-    text: string,
-    model: string,
-    agentName: string | null = null,
-    config: ReasoningConfig = {}
-  ): Promise<string> {
-    if (this.isProcessing) {
-      throw new Error("Already processing a request");
-    }
-
-    logger.logReasoning("ANTHROPIC_START", {
-      model,
-      agentName,
-      environment: typeof window !== "undefined" ? "browser" : "node",
-    });
-
-    this.isProcessing = true;
-    try {
-      if (typeof window !== "undefined" && window.electronAPI) {
-        const startTime = Date.now();
-
-        logger.logReasoning("ANTHROPIC_IPC_CALL", {
-          model,
-          textLength: text.length,
-        });
-
-        const systemPrompt = config.systemPrompt || this.getSystemPrompt(agentName, text);
-        const result = await window.electronAPI.processAnthropicReasoning(text, model, agentName, {
-          ...config,
-          systemPrompt,
-        });
-
-        const processingTime = Date.now() - startTime;
-
-        if (result.success) {
-          logger.logReasoning("ANTHROPIC_SUCCESS", {
-            model,
-            processingTimeMs: processingTime,
-            resultLength: result.text.length,
-          });
-          return result.text;
-        } else {
-          logger.logReasoning("ANTHROPIC_ERROR", {
-            model,
-            processingTimeMs: processingTime,
-            error: result.error,
-          });
-          throw new Error(result.error);
-        }
-      } else {
-        logger.logReasoning("ANTHROPIC_UNAVAILABLE", {
-          reason: "Not in Electron environment",
-        });
-        throw new Error("Anthropic reasoning is not available in this environment");
-      }
-    } finally {
-      this.isProcessing = false;
-    }
-  }
-
-  private async processWithEnterprise(
-    provider: EnterpriseProvider,
-    text: string,
-    model: string,
-    agentName: string | null = null,
-    config: ReasoningConfig = {}
-  ): Promise<string> {
-    if (this.isProcessing) {
-      throw new Error("Already processing a request");
-    }
-
-    if (typeof window === "undefined" || !window.electronAPI) {
-      throw new Error("Enterprise reasoning is not available in this environment");
-    }
-
-    logger.logReasoning("ENTERPRISE_START", { provider, model, agentName });
-
-    this.isProcessing = true;
-    try {
-      const systemPrompt = config.systemPrompt || this.getSystemPrompt(agentName, text);
-      const s = getSettings();
-
-      const apiKey =
-        provider === "azure" ? s.azureApiKey : provider === "vertex" ? s.vertexApiKey : "";
-
-      const { supportsTemperature } = getOpenAiApiConfig(model);
-
-      const startTime = Date.now();
-      const result = await window.electronAPI.processEnterpriseReasoning(text, model, agentName, {
-        ...config,
-        systemPrompt,
-        provider,
-        apiKey,
-        supportsTemperature,
-        bedrockRegion: s.bedrockRegion,
-        bedrockProfile: s.bedrockProfile,
-        bedrockAccessKeyId: s.bedrockAccessKeyId,
-        bedrockSecretAccessKey: s.bedrockSecretAccessKey,
-        bedrockSessionToken: s.bedrockSessionToken,
-        azureEndpoint: s.azureEndpoint,
-        azureApiVersion: s.azureApiVersion,
-        vertexProject: s.vertexProject,
-        vertexLocation: s.vertexLocation,
-      });
-
-      const processingTimeMs = Date.now() - startTime;
-
-      if (!result.success) {
-        logger.logReasoning("ENTERPRISE_ERROR", {
-          provider,
-          model,
-          processingTimeMs,
-          error: result.error,
-        });
-        const enhanced = new Error(result.error || `${provider} reasoning failed`) as Error & {
-          retryable?: boolean;
-        };
-        enhanced.retryable = result.retryable ?? false;
-        throw enhanced;
-      }
-
-      logger.logReasoning("ENTERPRISE_SUCCESS", {
-        provider,
-        model,
-        processingTimeMs,
-        resultLength: result.text?.length || 0,
-      });
-      return result.text || "";
-    } finally {
-      this.isProcessing = false;
-    }
-  }
-
-  private async processWithLocal(
-    text: string,
-    model: string,
-    agentName: string | null = null,
-    config: ReasoningConfig = {}
-  ): Promise<string> {
-    if (this.isProcessing) {
-      throw new Error("Already processing a request");
-    }
-
-    logger.logReasoning("LOCAL_START", {
-      model,
-      agentName,
-      environment: typeof window !== "undefined" ? "browser" : "node",
-    });
-
-    this.isProcessing = true;
-    try {
-      if (typeof window !== "undefined" && window.electronAPI) {
-        const startTime = Date.now();
-
-        logger.logReasoning("LOCAL_IPC_CALL", {
-          model,
-          textLength: text.length,
-        });
-
-        const systemPrompt = config.systemPrompt || this.getSystemPrompt(agentName, text);
-        const result = await window.electronAPI.processLocalReasoning(text, model, agentName, {
-          ...config,
-          systemPrompt,
-        });
-
-        const processingTime = Date.now() - startTime;
-
-        if (result.success) {
-          logger.logReasoning("LOCAL_SUCCESS", {
-            model,
-            processingTimeMs: processingTime,
-            resultLength: result.text.length,
-          });
-          return result.text;
-        } else {
-          logger.logReasoning("LOCAL_ERROR", {
-            model,
-            processingTimeMs: processingTime,
-            error: result.error,
-          });
-          throw new Error(result.error);
-        }
-      } else {
-        logger.logReasoning("LOCAL_UNAVAILABLE", {
-          reason: "Not in Electron environment",
-        });
-        throw new Error("Local reasoning is not available in this environment");
-      }
-    } finally {
-      this.isProcessing = false;
-    }
-  }
-
-  private async processWithGemini(
-    text: string,
-    model: string,
-    agentName: string | null = null,
-    config: ReasoningConfig = {}
-  ): Promise<string> {
-    logger.logReasoning("GEMINI_START", {
-      model,
-      agentName,
-      hasApiKey: false,
-    });
-
-    if (this.isProcessing) {
-      throw new Error("Already processing a request");
-    }
-
-    const apiKey = await this.getApiKey("gemini");
-
-    logger.logReasoning("GEMINI_API_KEY", {
-      hasApiKey: !!apiKey,
-      keyLength: apiKey?.length || 0,
-    });
-
-    this.isProcessing = true;
-
-    try {
-      const systemPrompt = config.systemPrompt || this.getSystemPrompt(agentName, text);
-      const userPrompt = text;
-
-      const requestBody = {
-        contents: [
-          {
-            parts: [
-              {
-                text: `${systemPrompt}\n\n${userPrompt}`,
-              },
-            ],
-          },
-        ],
-        generationConfig: {
-          temperature: config.temperature || 0.3,
-          maxOutputTokens:
-            config.maxTokens ||
-            Math.max(
-              2000,
-              this.calculateMaxTokens(
-                text.length,
-                TOKEN_LIMITS.MIN_TOKENS_GEMINI,
-                TOKEN_LIMITS.MAX_TOKENS_GEMINI,
-                TOKEN_LIMITS.TOKEN_MULTIPLIER
-              )
-            ),
-        },
-      };
-
-      let response: any;
-      try {
-        response = await withRetry(async () => {
-          logger.logReasoning("GEMINI_REQUEST", {
-            endpoint: `${API_ENDPOINTS.GEMINI}/models/${model}:generateContent`,
-            model,
-            hasApiKey: !!apiKey,
-            requestBody: JSON.stringify(requestBody).substring(0, 200),
-          });
-
-          const controller = new AbortController();
-          const timeoutId = setTimeout(() => controller.abort(), 30000);
-          try {
-            const res = await fetch(`${API_ENDPOINTS.GEMINI}/models/${model}:generateContent`, {
-              method: "POST",
-              headers: {
-                "Content-Type": "application/json",
-                "x-goog-api-key": apiKey,
-              },
-              body: JSON.stringify(requestBody),
-              signal: controller.signal,
-            });
-
-            if (!res.ok) {
-              const errorText = await res.text();
-              let errorData: any = { error: res.statusText };
-
-              try {
-                errorData = JSON.parse(errorText);
-              } catch {
-                errorData = { error: errorText || res.statusText };
-              }
-
-              logger.logReasoning("GEMINI_API_ERROR_DETAIL", {
-                status: res.status,
-                statusText: res.statusText,
-                error: errorData,
-                errorMessage: errorData.error?.message || errorData.message || errorData.error,
-                fullResponse: errorText.substring(0, 500),
-              });
-
-              const errorMessage =
-                errorData.error?.message ||
-                errorData.message ||
-                errorData.error ||
-                `Gemini API error: ${res.status}`;
-              throw new Error(errorMessage);
-            }
-
-            const jsonResponse = await res.json();
-
-            logger.logReasoning("GEMINI_RAW_RESPONSE", {
-              hasResponse: !!jsonResponse,
-              responseKeys: jsonResponse ? Object.keys(jsonResponse) : [],
-              hasCandidates: !!jsonResponse?.candidates,
-              candidatesLength: jsonResponse?.candidates?.length || 0,
-              fullResponse: JSON.stringify(jsonResponse).substring(0, 500),
-            });
-
-            return jsonResponse;
-          } catch (error) {
-            if ((error as Error).name === "AbortError") {
-              throw new Error("Request timed out after 30s");
-            }
-            throw error;
-          } finally {
-            clearTimeout(timeoutId);
-          }
-        }, createApiRetryStrategy());
-      } catch (fetchError) {
-        logger.logReasoning("GEMINI_FETCH_ERROR", {
-          error: (fetchError as Error).message,
-          stack: (fetchError as Error).stack,
-        });
-        throw fetchError;
-      }
-
-      if (!response.candidates || !response.candidates[0]) {
-        logger.logReasoning("GEMINI_RESPONSE_ERROR", {
-          model,
-          response: JSON.stringify(response).substring(0, 500),
-          hasCandidate: !!response.candidates,
-          candidateCount: response.candidates?.length || 0,
-        });
-        throw new Error("Invalid response structure from Gemini API");
-      }
-
-      const candidate = response.candidates[0];
-      if (!candidate.content?.parts?.[0]?.text) {
-        logger.logReasoning("GEMINI_EMPTY_RESPONSE", {
-          model,
-          finishReason: candidate.finishReason,
-          hasContent: !!candidate.content,
-          hasParts: !!candidate.content?.parts,
-          response: JSON.stringify(candidate).substring(0, 500),
-        });
-
-        if (candidate.finishReason === "MAX_TOKENS") {
-          throw new Error(
-            "Gemini reached token limit before generating response. Try a shorter input or increase max tokens."
-          );
-        }
-        throw new Error("Gemini returned empty response");
-      }
-
-      const responseText = candidate.content.parts[0].text.trim();
-
-      logger.logReasoning("GEMINI_RESPONSE", {
-        model,
-        responseLength: responseText.length,
-        tokensUsed: response.usageMetadata?.totalTokenCount || 0,
-        success: true,
-      });
-
-      return responseText;
-    } catch (error) {
-      logger.logReasoning("GEMINI_ERROR", {
-        model,
-        error: (error as Error).message,
-        errorType: (error as Error).name,
-      });
-      throw error;
-    } finally {
-      this.isProcessing = false;
-    }
-  }
-
-  private async processWithGroq(
-    text: string,
-    model: string,
-    agentName: string | null = null,
-    config: ReasoningConfig = {}
-  ): Promise<string> {
-    logger.logReasoning("GROQ_START", { model, agentName });
-
-    if (this.isProcessing) {
-      throw new Error("Already processing a request");
-    }
-
-    const apiKey = await this.getApiKey("groq");
-    this.isProcessing = true;
-
-    try {
-      const endpoint = buildApiUrl(API_ENDPOINTS.GROQ_BASE, "/chat/completions");
-      return await this.callChatCompletionsApi(
-        endpoint,
-        apiKey,
-        model,
-        text,
-        agentName,
-        config,
-        "Groq"
-      );
-    } catch (error) {
-      logger.logReasoning("GROQ_ERROR", {
-        model,
-        error: (error as Error).message,
-        errorType: (error as Error).name,
-      });
-      throw error;
-    } finally {
-      this.isProcessing = false;
-    }
-  }
-
-  private async processWithLan(
-    text: string,
-    agentName: string | null = null,
-    config: ReasoningConfig = {}
-  ): Promise<string> {
-    const settings = getSettings();
-    const lanUrl = (config.lanUrl || settings.remoteReasoningUrl).trim();
-
-    logger.logReasoning("LAN_START", { url: lanUrl, agentName });
-
-    if (this.isProcessing) {
-      throw new Error("Already processing a request");
-    }
-
-    this.isProcessing = true;
-
-    try {
-      const baseUrl = normalizeBaseUrl(lanUrl) || lanUrl;
-      const endpoint = buildApiUrl(baseUrl, "/v1/chat/completions");
-
-      return await this.callChatCompletionsApi(
-        endpoint,
-        "",
-        "default",
+      const result = await handler.call({
         text,
+        model: trimmedModel,
         agentName,
         config,
-        "LAN"
-      );
-    } catch (error) {
-      logger.logReasoning("LAN_ERROR", {
-        url: lanUrl,
-        error: (error as Error).message,
-        errorType: (error as Error).name,
+        ctx: this.providerContext,
       });
-      throw error;
-    } finally {
-      this.isProcessing = false;
-    }
-  }
-
-  private async processWithOpenWhispr(
-    text: string,
-    model: string,
-    agentName: string | null = null,
-    config: ReasoningConfig = {}
-  ): Promise<string> {
-    logger.logReasoning("OPENWHISPR_START", { model, agentName });
-
-    if (this.isProcessing) {
-      throw new Error("Already processing a request");
-    }
-
-    this.isProcessing = true;
-
-    try {
-      const customDictionary = this.getCustomDictionary();
-      const language = this.getPreferredLanguage();
-      const locale = this.getUiLanguage();
-
-      const result = await withSessionRefresh(async () => {
-        const res = await window.electronAPI?.cloudReason?.(text, {
-          agentName,
-          customDictionary,
-          customPrompt: this.getCustomPrompt(),
-          systemPrompt: config.systemPrompt,
-          language,
-          locale,
-        });
 
-        if (!res?.success) {
-          const err: any = new Error(res?.error || "OpenWhispr cloud reasoning failed");
-          err.code = res?.code;
-          throw err;
-        }
-
-        return res;
-      });
-
-      logger.logReasoning("OPENWHISPR_SUCCESS", {
-        model: result.model,
-        provider: result.provider,
-        resultLength: result.text.length,
-        promptMode: result.promptMode,
-        matchType: result.matchType,
+      logger.logReasoning("PROVIDER_SUCCESS", {
+        provider: providerId,
+        model: trimmedModel,
+        processingTimeMs: Date.now() - startTime,
+        resultLength: result.length,
       });
 
-      return result.text;
+      return result;
     } catch (error) {
-      logger.logReasoning("OPENWHISPR_ERROR", {
-        model,
+      logger.logReasoning("PROVIDER_ERROR", {
+        provider: providerId,
+        model: trimmedModel,
         error: (error as Error).message,
       });
       throw error;
-    } finally {
-      this.isProcessing = false;
     }
   }
 
   private getCustomPrompt(): string | undefined {
-    try {
-      const raw = localStorage.getItem("customUnifiedPrompt");
-      if (!raw) return undefined;
-      const parsed = JSON.parse(raw);
-      return typeof parsed === "string" ? parsed : undefined;
-    } catch {
-      return undefined;
-    }
+    return getSettings().customPrompts.cleanup || undefined;
   }
 
   async *processTextStreaming(
@@ -1343,13 +352,13 @@ class ReasoningService extends BaseReasoningService {
 
     const settings = getSettings();
     const lanOverride = config.lanUrl?.trim();
-    const isLanReasoning = !!lanOverride || this.isLanReasoningMode();
+    const isLanCleanup = !!lanOverride || this.isLanCleanupMode();
 
     let endpoint: string;
     let apiKey = "";
 
-    if (isLanReasoning) {
-      const rawUrl = lanOverride || settings.remoteReasoningUrl.trim();
+    if (isLanCleanup) {
+      const rawUrl = lanOverride || settings.cleanupRemoteUrl.trim();
       const baseUrl = normalizeBaseUrl(rawUrl) || rawUrl;
       endpoint = buildApiUrl(baseUrl, "/v1/chat/completions");
     } else if (isLocalProvider) {
@@ -1371,7 +380,7 @@ class ReasoningService extends BaseReasoningService {
           break;
         case "openai":
         case "custom":
-          endpoint = buildApiUrl(this.getConfiguredOpenAIBase(), "/chat/completions");
+          endpoint = buildApiUrl(getConfiguredOpenAIBase(), "/chat/completions");
           break;
         default:
           endpoint = buildApiUrl(API_ENDPOINTS.OPENAI_BASE, "/chat/completions");
@@ -1380,7 +389,7 @@ class ReasoningService extends BaseReasoningService {
     }
 
     const apiConfig = getOpenAiApiConfig(model);
-    const useOldTokenParam = isLocalProvider || isLanReasoning || provider === "groq";
+    const useOldTokenParam = isLocalProvider || isLanCleanup || provider === "groq";
 
     const requestBody: Record<string, unknown> = {
       model,
@@ -1405,7 +414,7 @@ class ReasoningService extends BaseReasoningService {
       model,
       provider,
       isLocal: isLocalProvider,
-      isLan: !!isLanReasoning,
+      isLan: !!isLanCleanup,
       messageCount: messages.length,
     });
 
@@ -1482,7 +491,7 @@ class ReasoningService extends BaseReasoningService {
             if (!content) continue;
 
             // Strip Qwen3 <think> blocks from streamed output
-            if (isLocalProvider || isLanReasoning) {
+            if (isLocalProvider || isLanCleanup) {
               if (insideThinkBlock) {
                 const endIdx = content.indexOf("</think>");
                 if (endIdx !== -1) {
@@ -1539,9 +548,9 @@ class ReasoningService extends BaseReasoningService {
 
     const settings = getSettings();
     const lanOverride = config.lanUrl?.trim();
-    const isLanReasoning = !!lanOverride || this.isLanReasoningMode();
+    const isLanCleanup = !!lanOverride || this.isLanCleanupMode();
 
-    if ((isLocalProvider || isLanReasoning) && !tools) {
+    if ((isLocalProvider || isLanCleanup) && !tools) {
       const contentGen = this.processTextStreaming(messages, model, provider, config);
       for await (const text of contentGen) {
         yield { type: "content", text };
@@ -1553,8 +562,8 @@ class ReasoningService extends BaseReasoningService {
     let apiKey = "";
     let baseURL: string | undefined;
 
-    if (isLanReasoning) {
-      const rawUrl = lanOverride || settings.remoteReasoningUrl.trim();
+    if (isLanCleanup) {
+      const rawUrl = lanOverride || settings.cleanupRemoteUrl.trim();
       baseURL = normalizeBaseUrl(rawUrl) || rawUrl;
       if (!baseURL.endsWith("/v1")) {
         baseURL = buildApiUrl(baseURL, "/v1");
@@ -1568,11 +577,11 @@ class ReasoningService extends BaseReasoningService {
     } else {
       const providerKey = provider as "openai" | "groq" | "gemini" | "anthropic" | "custom";
       apiKey = await this.getApiKey(providerKey);
-      baseURL = provider === "custom" ? this.getConfiguredOpenAIBase() : undefined;
+      baseURL = provider === "custom" ? getConfiguredOpenAIBase() : undefined;
     }
     const apiConfig = getOpenAiApiConfig(model);
 
-    const aiProvider = isLocalProvider || isLanReasoning ? "local" : provider;
+    const aiProvider = isLocalProvider || isLanCleanup ? "local" : provider;
     const aiModel = getAIModel(aiProvider, model, apiKey, baseURL);
 
     const modelDef = getCloudModel(model);
@@ -1586,7 +595,7 @@ class ReasoningService extends BaseReasoningService {
       messageCount: messages.length,
     });
 
-    const useTemperature = isLocalProvider || isLanReasoning || apiConfig.supportsTemperature;
+    const useTemperature = isLocalProvider || isLanCleanup || apiConfig.supportsTemperature;
 
     const result = streamText({
       model: aiModel,
@@ -1801,18 +810,18 @@ class ReasoningService extends BaseReasoningService {
 
   async isAvailable(): Promise<boolean> {
     try {
-      if (isCloudReasoningMode()) {
-        logger.logReasoning("API_KEY_CHECK", { cloudReasoningMode: true });
+      if (isCloudCleanupMode()) {
+        logger.logReasoning("API_KEY_CHECK", { cloudCleanupMode: true });
         return true;
       }
 
-      if (this.isLanReasoningMode()) {
-        logger.logReasoning("API_KEY_CHECK", { lanReasoning: true });
+      if (this.isLanCleanupMode()) {
+        logger.logReasoning("API_KEY_CHECK", { lanCleanup: true });
         return true;
       }
 
       const settings = getSettings();
-      if (settings.reasoningProvider === "custom" && settings.cloudReasoningBaseUrl?.trim()) {
+      if (settings.cleanupProvider === "custom" && settings.cleanupCloudBaseUrl?.trim()) {
         logger.logReasoning("API_KEY_CHECK", {
           customProvider: true,
           hasCustomEndpoint: true,
@@ -1823,19 +832,19 @@ class ReasoningService extends BaseReasoningService {
       // Enterprise providers: detect credentials by provider, short-circuit.
       // Runtime auth errors (expired SSO, missing ADC) surface via
       // mapEnterpriseError with actionable remediation copy.
-      if (settings.reasoningProvider === "bedrock") {
+      if (settings.cleanupProvider === "bedrock") {
         const hasBedrockCreds =
           !!settings.bedrockProfile?.trim() ||
           (!!settings.bedrockAccessKeyId?.trim() && !!settings.bedrockSecretAccessKey?.trim());
         logger.logReasoning("API_KEY_CHECK", { bedrock: true, hasBedrockCreds });
         if (hasBedrockCreds) return true;
       }
-      if (settings.reasoningProvider === "azure") {
+      if (settings.cleanupProvider === "azure") {
         const hasAzureCreds = !!settings.azureApiKey?.trim() && !!settings.azureEndpoint?.trim();
         logger.logReasoning("API_KEY_CHECK", { azure: true, hasAzureCreds });
         if (hasAzureCreds) return true;
       }
-      if (settings.reasoningProvider === "vertex") {
+      if (settings.cleanupProvider === "vertex") {
         const hasVertexCreds = !!settings.vertexApiKey?.trim() || !!settings.vertexProject?.trim();
         logger.logReasoning("API_KEY_CHECK", { vertex: true, hasVertexCreds });
         if (hasVertexCreds) return true;
diff --git a/src/services/ai/inferenceProviders/anthropic.ts b/src/services/ai/inferenceProviders/anthropic.ts
new file mode 100644
index 000000000..0eeec0741
--- /dev/null
+++ b/src/services/ai/inferenceProviders/anthropic.ts
@@ -0,0 +1,36 @@
+import type { InferenceProvider } from "./types";
+import logger from "../../../utils/logger";
+
+export const anthropicProvider: InferenceProvider = {
+  id: "anthropic",
+  async call({ text, model, agentName, config, ctx }) {
+    if (typeof window === "undefined" || !window.electronAPI) {
+      throw new Error("Anthropic reasoning is not available in this environment");
+    }
+
+    logger.logReasoning("ANTHROPIC_START", { model, agentName, environment: "browser" });
+    const startTime = Date.now();
+
+    logger.logReasoning("ANTHROPIC_IPC_CALL", { model, textLength: text.length });
+
+    const systemPrompt = config.systemPrompt || ctx.getSystemPrompt(agentName, text);
+    const result = await window.electronAPI.processAnthropicReasoning(text, model, agentName, {
+      ...config,
+      systemPrompt,
+    });
+
+    const processingTimeMs = Date.now() - startTime;
+
+    if (!result.success) {
+      logger.logReasoning("ANTHROPIC_ERROR", { model, processingTimeMs, error: result.error });
+      throw new Error(result.error);
+    }
+
+    logger.logReasoning("ANTHROPIC_SUCCESS", {
+      model,
+      processingTimeMs,
+      resultLength: result.text.length,
+    });
+    return result.text;
+  },
+};
diff --git a/src/services/ai/inferenceProviders/enterprise.ts b/src/services/ai/inferenceProviders/enterprise.ts
new file mode 100644
index 000000000..dbd905732
--- /dev/null
+++ b/src/services/ai/inferenceProviders/enterprise.ts
@@ -0,0 +1,73 @@
+import type { InferenceProvider } from "./types";
+import {
+  getOpenAiApiConfig,
+  isEnterpriseProvider,
+  type EnterpriseProvider as EnterpriseProviderId,
+} from "../../../models/ModelRegistry";
+import { getSettings } from "../../../stores/settingsStore";
+import logger from "../../../utils/logger";
+
+export const enterpriseProvider: InferenceProvider = {
+  id: "enterprise",
+  async call({ text, model, agentName, config, ctx }) {
+    if (typeof window === "undefined" || !window.electronAPI) {
+      throw new Error("Enterprise reasoning is not available in this environment");
+    }
+
+    const provider = getSettings().cleanupProvider;
+    if (!isEnterpriseProvider(provider)) {
+      throw new Error(`Unsupported enterprise provider: ${provider}`);
+    }
+    const enterpriseId = provider as EnterpriseProviderId;
+
+    logger.logReasoning("ENTERPRISE_START", { provider: enterpriseId, model, agentName });
+
+    const systemPrompt = config.systemPrompt || ctx.getSystemPrompt(agentName, text);
+    const s = getSettings();
+    const apiKey =
+      enterpriseId === "azure" ? s.azureApiKey : enterpriseId === "vertex" ? s.vertexApiKey : "";
+    const { supportsTemperature } = getOpenAiApiConfig(model);
+
+    const startTime = Date.now();
+    const result = await window.electronAPI.processEnterpriseReasoning(text, model, agentName, {
+      ...config,
+      systemPrompt,
+      provider: enterpriseId,
+      apiKey,
+      supportsTemperature,
+      bedrockRegion: s.bedrockRegion,
+      bedrockProfile: s.bedrockProfile,
+      bedrockAccessKeyId: s.bedrockAccessKeyId,
+      bedrockSecretAccessKey: s.bedrockSecretAccessKey,
+      bedrockSessionToken: s.bedrockSessionToken,
+      azureEndpoint: s.azureEndpoint,
+      azureApiVersion: s.azureApiVersion,
+      vertexProject: s.vertexProject,
+      vertexLocation: s.vertexLocation,
+    });
+
+    const processingTimeMs = Date.now() - startTime;
+
+    if (!result.success) {
+      logger.logReasoning("ENTERPRISE_ERROR", {
+        provider: enterpriseId,
+        model,
+        processingTimeMs,
+        error: result.error,
+      });
+      const enhanced = new Error(result.error || `${enterpriseId} reasoning failed`) as Error & {
+        retryable?: boolean;
+      };
+      enhanced.retryable = result.retryable ?? false;
+      throw enhanced;
+    }
+
+    logger.logReasoning("ENTERPRISE_SUCCESS", {
+      provider: enterpriseId,
+      model,
+      processingTimeMs,
+      resultLength: result.text?.length || 0,
+    });
+    return result.text || "";
+  },
+};
diff --git a/src/services/ai/inferenceProviders/gemini.ts b/src/services/ai/inferenceProviders/gemini.ts
new file mode 100644
index 000000000..951d794e1
--- /dev/null
+++ b/src/services/ai/inferenceProviders/gemini.ts
@@ -0,0 +1,125 @@
+import type { InferenceProvider } from "./types";
+import { withRetry, createApiRetryStrategy } from "../../../utils/retry";
+import { API_ENDPOINTS, TOKEN_LIMITS } from "../../../config/constants";
+import logger from "../../../utils/logger";
+
+interface GeminiResponse {
+  candidates?: Array<{
+    content?: { parts?: Array<{ text?: string }> };
+    finishReason?: string;
+  }>;
+  usageMetadata?: { totalTokenCount?: number };
+}
+
+export const geminiProvider: InferenceProvider = {
+  id: "gemini",
+  async call({ text, model, agentName, config, ctx }) {
+    logger.logReasoning("GEMINI_START", { model, agentName, hasApiKey: false });
+    const apiKey = await ctx.getApiKey("gemini");
+    logger.logReasoning("GEMINI_API_KEY", { hasApiKey: !!apiKey, keyLength: apiKey?.length || 0 });
+
+    const systemPrompt = config.systemPrompt || ctx.getSystemPrompt(agentName, text);
+
+    const requestBody = {
+      contents: [{ parts: [{ text: `${systemPrompt}\n\n${text}` }] }],
+      generationConfig: {
+        temperature: config.temperature || 0.3,
+        maxOutputTokens:
+          config.maxTokens ||
+          Math.max(
+            2000,
+            ctx.calculateMaxTokens(
+              text.length,
+              TOKEN_LIMITS.MIN_TOKENS_GEMINI,
+              TOKEN_LIMITS.MAX_TOKENS_GEMINI,
+              TOKEN_LIMITS.TOKEN_MULTIPLIER
+            )
+          ),
+      },
+    };
+
+    const response = await withRetry(async () => {
+      logger.logReasoning("GEMINI_REQUEST", {
+        endpoint: `${API_ENDPOINTS.GEMINI}/models/${model}:generateContent`,
+        model,
+        hasApiKey: !!apiKey,
+        requestBody: JSON.stringify(requestBody).substring(0, 200),
+      });
+
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 30000);
+      try {
+        const res = await fetch(`${API_ENDPOINTS.GEMINI}/models/${model}:generateContent`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", "x-goog-api-key": apiKey },
+          body: JSON.stringify(requestBody),
+          signal: controller.signal,
+        });
+
+        if (!res.ok) {
+          const errorText = await res.text();
+          let errorData: { error?: { message?: string } | string; message?: string } = {
+            error: res.statusText,
+          };
+          try {
+            errorData = JSON.parse(errorText);
+          } catch {
+            errorData = { error: errorText || res.statusText };
+          }
+
+          logger.logReasoning("GEMINI_API_ERROR_DETAIL", {
+            status: res.status,
+            statusText: res.statusText,
+            error: errorData,
+            fullResponse: errorText.substring(0, 500),
+          });
+
+          const errMsg =
+            (typeof errorData.error === "object" && errorData.error?.message) ||
+            errorData.message ||
+            (typeof errorData.error === "string" ? errorData.error : null) ||
+            `Gemini API error: ${res.status}`;
+          throw new Error(errMsg);
+        }
+
+        const jsonResponse = (await res.json()) as GeminiResponse;
+        logger.logReasoning("GEMINI_RAW_RESPONSE", {
+          hasResponse: !!jsonResponse,
+          hasCandidates: !!jsonResponse?.candidates,
+          candidatesLength: jsonResponse?.candidates?.length || 0,
+        });
+        return jsonResponse;
+      } catch (error) {
+        if ((error as Error).name === "AbortError") {
+          throw new Error("Request timed out after 30s");
+        }
+        throw error;
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    }, createApiRetryStrategy());
+
+    const candidate = response.candidates?.[0];
+    if (!candidate?.content?.parts?.[0]?.text) {
+      logger.logReasoning("GEMINI_EMPTY_RESPONSE", {
+        model,
+        finishReason: candidate?.finishReason,
+      });
+      if (candidate?.finishReason === "MAX_TOKENS") {
+        throw new Error(
+          "Gemini reached token limit before generating response. Try a shorter input or increase max tokens."
+        );
+      }
+      throw new Error("Gemini returned empty response");
+    }
+
+    const responseText = candidate.content.parts[0].text!.trim();
+    logger.logReasoning("GEMINI_RESPONSE", {
+      model,
+      responseLength: responseText.length,
+      tokensUsed: response.usageMetadata?.totalTokenCount || 0,
+      success: true,
+    });
+    return responseText;
+  },
+};
diff --git a/src/services/ai/inferenceProviders/groq.ts b/src/services/ai/inferenceProviders/groq.ts
new file mode 100644
index 000000000..88824d320
--- /dev/null
+++ b/src/services/ai/inferenceProviders/groq.ts
@@ -0,0 +1,13 @@
+import type { InferenceProvider } from "./types";
+import { API_ENDPOINTS, buildApiUrl } from "../../../config/constants";
+import logger from "../../../utils/logger";
+
+export const groqProvider: InferenceProvider = {
+  id: "groq",
+  async call({ text, model, agentName, config, ctx }) {
+    logger.logReasoning("GROQ_START", { model, agentName });
+    const apiKey = await ctx.getApiKey("groq");
+    const endpoint = buildApiUrl(API_ENDPOINTS.GROQ_BASE, "/chat/completions");
+    return ctx.callChatCompletionsApi(endpoint, apiKey, model, text, agentName, config, "Groq");
+  },
+};
diff --git a/src/services/ai/inferenceProviders/index.ts b/src/services/ai/inferenceProviders/index.ts
new file mode 100644
index 000000000..58bfe5c46
--- /dev/null
+++ b/src/services/ai/inferenceProviders/index.ts
@@ -0,0 +1,25 @@
+import type { InferenceProvider } from "./types";
+import { anthropicProvider } from "./anthropic";
+import { geminiProvider } from "./gemini";
+import { groqProvider } from "./groq";
+import { localProvider } from "./local";
+import { enterpriseProvider } from "./enterprise";
+import { openwhisprProvider } from "./openwhispr";
+import { lanProvider } from "./lan";
+import { openaiProvider } from "./openai";
+
+export const PROVIDER_REGISTRY: Readonly<Record<string, InferenceProvider>> = Object.freeze({
+  openai: openaiProvider,
+  custom: openaiProvider,
+  anthropic: anthropicProvider,
+  gemini: geminiProvider,
+  groq: groqProvider,
+  local: localProvider,
+  bedrock: enterpriseProvider,
+  azure: enterpriseProvider,
+  vertex: enterpriseProvider,
+  openwhispr: openwhisprProvider,
+  lan: lanProvider,
+});
+
+export type { InferenceProvider, ProviderContext, ProviderCallParams } from "./types";
diff --git a/src/services/ai/inferenceProviders/lan.ts b/src/services/ai/inferenceProviders/lan.ts
new file mode 100644
index 000000000..d5a40b2a0
--- /dev/null
+++ b/src/services/ai/inferenceProviders/lan.ts
@@ -0,0 +1,33 @@
+import type { InferenceProvider } from "./types";
+import { buildApiUrl, normalizeBaseUrl } from "../../../config/constants";
+import { getSettings } from "../../../stores/settingsStore";
+import logger from "../../../utils/logger";
+
+export const lanProvider: InferenceProvider = {
+  id: "lan",
+  async call({ text, agentName, config, ctx }) {
+    const lanUrl = (config.lanUrl || getSettings().cleanupRemoteUrl).trim();
+    logger.logReasoning("LAN_START", { url: lanUrl, agentName });
+
+    try {
+      const baseUrl = normalizeBaseUrl(lanUrl) || lanUrl;
+      const endpoint = buildApiUrl(baseUrl, "/v1/chat/completions");
+      return await ctx.callChatCompletionsApi(
+        endpoint,
+        "",
+        "default",
+        text,
+        agentName,
+        config,
+        "LAN"
+      );
+    } catch (error) {
+      logger.logReasoning("LAN_ERROR", {
+        url: lanUrl,
+        error: (error as Error).message,
+        errorType: (error as Error).name,
+      });
+      throw error;
+    }
+  },
+};
diff --git a/src/services/ai/inferenceProviders/local.ts b/src/services/ai/inferenceProviders/local.ts
new file mode 100644
index 000000000..b9e40715b
--- /dev/null
+++ b/src/services/ai/inferenceProviders/local.ts
@@ -0,0 +1,36 @@
+import type { InferenceProvider } from "./types";
+import logger from "../../../utils/logger";
+
+export const localProvider: InferenceProvider = {
+  id: "local",
+  async call({ text, model, agentName, config, ctx }) {
+    if (typeof window === "undefined" || !window.electronAPI) {
+      throw new Error("Local reasoning is not available in this environment");
+    }
+
+    logger.logReasoning("LOCAL_START", { model, agentName, environment: "browser" });
+    const startTime = Date.now();
+
+    logger.logReasoning("LOCAL_IPC_CALL", { model, textLength: text.length });
+
+    const systemPrompt = config.systemPrompt || ctx.getSystemPrompt(agentName, text);
+    const result = await window.electronAPI.processLocalReasoning(text, model, agentName, {
+      ...config,
+      systemPrompt,
+    });
+
+    const processingTimeMs = Date.now() - startTime;
+
+    if (!result.success) {
+      logger.logReasoning("LOCAL_ERROR", { model, processingTimeMs, error: result.error });
+      throw new Error(result.error);
+    }
+
+    logger.logReasoning("LOCAL_SUCCESS", {
+      model,
+      processingTimeMs,
+      resultLength: result.text.length,
+    });
+    return result.text;
+  },
+};
diff --git a/src/services/ai/inferenceProviders/openai.ts b/src/services/ai/inferenceProviders/openai.ts
new file mode 100644
index 000000000..d88502638
--- /dev/null
+++ b/src/services/ai/inferenceProviders/openai.ts
@@ -0,0 +1,339 @@
+import type { InferenceProvider } from "./types";
+import { API_ENDPOINTS, TOKEN_LIMITS, buildApiUrl } from "../../../config/constants";
+import { getOpenAiApiConfig } from "../../../models/ModelRegistry";
+import { getSettings } from "../../../stores/settingsStore";
+import { withRetry, createApiRetryStrategy } from "../../../utils/retry";
+import logger from "../../../utils/logger";
+import { getConfiguredOpenAIBase } from "../openaiBase";
+
+const OPENAI_ENDPOINT_PREF_STORAGE_KEY = "openAiEndpointPreference";
+const REQUEST_TIMEOUT_MS = 30_000;
+const PROBE_TIMEOUT_MS = 2_000;
+
+const endpointPreferenceCache = new Map<string, "responses" | "chat">();
+const probedBases = new Set<string>();
+
+function readStoredPreference(base: string): "responses" | "chat" | undefined {
+  if (endpointPreferenceCache.has(base)) {
+    return endpointPreferenceCache.get(base);
+  }
+
+  if (typeof window === "undefined" || !window.localStorage) {
+    return undefined;
+  }
+
+  try {
+    const raw = window.localStorage.getItem(OPENAI_ENDPOINT_PREF_STORAGE_KEY);
+    if (!raw) return undefined;
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null) return undefined;
+    const value = parsed[base];
+    if (value === "responses" || value === "chat") {
+      endpointPreferenceCache.set(base, value);
+      return value;
+    }
+  } catch {
+    return undefined;
+  }
+
+  return undefined;
+}
+
+function rememberPreference(base: string, preference: "responses" | "chat"): void {
+  endpointPreferenceCache.set(base, preference);
+
+  if (typeof window === "undefined" || !window.localStorage) {
+    return;
+  }
+
+  try {
+    const raw = window.localStorage.getItem(OPENAI_ENDPOINT_PREF_STORAGE_KEY);
+    const parsed = raw ? JSON.parse(raw) : {};
+    const data = typeof parsed === "object" && parsed !== null ? parsed : {};
+    data[base] = preference;
+    window.localStorage.setItem(OPENAI_ENDPOINT_PREF_STORAGE_KEY, JSON.stringify(data));
+  } catch {}
+}
+
+function getEndpointCandidates(base: string): Array<{ url: string; type: "responses" | "chat" }> {
+  const lower = base.toLowerCase();
+
+  if (lower.endsWith("/responses") || lower.endsWith("/chat/completions")) {
+    const type: "responses" | "chat" = lower.endsWith("/responses") ? "responses" : "chat";
+    return [{ url: base, type }];
+  }
+
+  const preference = readStoredPreference(base);
+  if (preference === "chat") {
+    return [{ url: buildApiUrl(base, "/chat/completions"), type: "chat" }];
+  }
+
+  return [
+    { url: buildApiUrl(base, "/responses"), type: "responses" },
+    { url: buildApiUrl(base, "/chat/completions"), type: "chat" },
+  ];
+}
+
+/** Probe `/v1/models` to detect llama.cpp and prefer `/chat/completions`. */
+async function detectServerType(base: string): Promise<void> {
+  if (probedBases.has(base) || readStoredPreference(base) !== undefined) {
+    return;
+  }
+
+  const lower = base.toLowerCase();
+  if (lower.endsWith("/responses") || lower.endsWith("/chat/completions")) {
+    return;
+  }
+
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), PROBE_TIMEOUT_MS);
+    const res = await fetch(buildApiUrl(base, "/models"), {
+      method: "GET",
+      signal: controller.signal,
+    });
+    clearTimeout(timeoutId);
+
+    if (!res.ok) {
+      probedBases.add(base);
+      return;
+    }
+
+    const body = await res.json();
+    const first = body?.data?.[0];
+
+    if (first?.owned_by === "llamacpp") {
+      rememberPreference(base, "chat");
+      logger.logReasoning("LLAMACPP_DETECTED_VIA_MODELS", {
+        base,
+        modelId: first?.id,
+        ownedBy: first.owned_by,
+      });
+    }
+
+    probedBases.add(base);
+  } catch {
+    probedBases.add(base);
+  }
+}
+
+export const openaiProvider: InferenceProvider = {
+  id: "openai",
+  async call({ text, model, agentName, config, ctx }) {
+    const resolvedProvider = config.provider || getSettings().cleanupProvider || "";
+    const isCustomProvider = resolvedProvider === "custom";
+
+    logger.logReasoning("OPENAI_START", {
+      model,
+      agentName,
+      isCustomProvider,
+    });
+
+    const apiKey = await ctx.getApiKey(isCustomProvider ? "custom" : "openai");
+
+    logger.logReasoning("OPENAI_API_KEY", {
+      hasApiKey: !!apiKey,
+      keyLength: apiKey?.length || 0,
+    });
+
+    const systemPrompt = config.systemPrompt || ctx.getSystemPrompt(agentName, text);
+    const messages = [
+      { role: "system", content: systemPrompt },
+      { role: "user", content: text },
+    ];
+
+    const openAiBase = getConfiguredOpenAIBase();
+    await detectServerType(openAiBase);
+    const endpointCandidates = getEndpointCandidates(openAiBase);
+    const isCustomEndpoint = openAiBase !== API_ENDPOINTS.OPENAI_BASE;
+
+    logger.logReasoning("OPENAI_ENDPOINTS", {
+      base: openAiBase,
+      isCustomEndpoint,
+      candidates: endpointCandidates.map((candidate) => candidate.url),
+      preference: readStoredPreference(openAiBase) || null,
+    });
+
+    if (isCustomEndpoint) {
+      logger.logReasoning("CUSTOM_TEXT_CLEANUP_REQUEST", {
+        customBase: openAiBase,
+        model,
+        textLength: text.length,
+        hasApiKey: !!apiKey,
+        apiKeyPreview: apiKey ? `${apiKey.substring(0, 8)}...` : "(none)",
+      });
+    }
+
+    const response = await withRetry(async () => {
+      let lastError: Error | null = null;
+
+      for (const { url: endpoint, type } of endpointCandidates) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+        try {
+          const maxTokens =
+            config.maxTokens ||
+            Math.max(
+              4096,
+              ctx.calculateMaxTokens(
+                text.length,
+                TOKEN_LIMITS.MIN_TOKENS,
+                TOKEN_LIMITS.MAX_TOKENS,
+                TOKEN_LIMITS.TOKEN_MULTIPLIER
+              )
+            );
+
+          const apiConfig = getOpenAiApiConfig(model);
+          const requestBody: Record<string, unknown> = { model };
+
+          if (type === "responses") {
+            requestBody.input = messages;
+            requestBody.store = false;
+            requestBody.max_output_tokens = maxTokens;
+          } else {
+            requestBody.messages = messages;
+            requestBody[apiConfig.tokenParam] = maxTokens;
+          }
+
+          if (apiConfig.supportsTemperature) {
+            requestBody.temperature = config.temperature || 0.3;
+          }
+
+          const res = await fetch(endpoint, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: `Bearer ${apiKey}`,
+            },
+            body: JSON.stringify(requestBody),
+            signal: controller.signal,
+          });
+
+          if (!res.ok) {
+            const errorData = await res.json().catch(() => ({ error: res.statusText }));
+            const errorMessage =
+              errorData.error?.message || errorData.message || `OpenAI API error: ${res.status}`;
+
+            const isUnsupportedEndpoint =
+              (res.status === 404 || res.status === 405) && type === "responses";
+
+            if (isUnsupportedEndpoint) {
+              lastError = new Error(errorMessage);
+              rememberPreference(openAiBase, "chat");
+              logger.logReasoning("OPENAI_ENDPOINT_FALLBACK", {
+                attemptedEndpoint: endpoint,
+                error: errorMessage,
+              });
+              continue;
+            }
+
+            throw new Error(errorMessage);
+          }
+
+          rememberPreference(openAiBase, type);
+          return res.json();
+        } catch (error) {
+          if ((error as Error).name === "AbortError") {
+            throw new Error("Request timed out after 30s");
+          }
+          lastError = error as Error;
+          if (type === "responses") {
+            logger.logReasoning("OPENAI_ENDPOINT_FALLBACK", {
+              attemptedEndpoint: endpoint,
+              error: (error as Error).message,
+            });
+            continue;
+          }
+          throw error;
+        } finally {
+          clearTimeout(timeoutId);
+        }
+      }
+
+      throw lastError || new Error("No OpenAI endpoint responded");
+    }, createApiRetryStrategy());
+
+    const isResponsesApi = Array.isArray(response?.output);
+    const isChatCompletions = Array.isArray(response?.choices);
+
+    logger.logReasoning("OPENAI_RAW_RESPONSE", {
+      model,
+      format: isResponsesApi ? "responses" : isChatCompletions ? "chat_completions" : "unknown",
+      hasOutput: isResponsesApi,
+      outputLength: isResponsesApi ? response.output.length : 0,
+      outputTypes: isResponsesApi
+        ? response.output.map((item: { type: string }) => item.type)
+        : undefined,
+      hasChoices: isChatCompletions,
+      choicesLength: isChatCompletions ? response.choices.length : 0,
+      usage: response.usage,
+    });
+
+    let responseText = "";
+
+    if (isResponsesApi) {
+      for (const item of response.output) {
+        if (item.type === "message" && item.content) {
+          for (const content of item.content) {
+            if (content.type === "output_text" && content.text) {
+              responseText = content.text.trim();
+              break;
+            }
+          }
+          if (responseText) break;
+        }
+      }
+    }
+
+    if (!responseText && typeof response?.output_text === "string") {
+      responseText = response.output_text.trim();
+    }
+
+    if (!responseText && isChatCompletions) {
+      for (const choice of response.choices) {
+        const message = choice?.message ?? choice?.delta;
+        const content = message?.content;
+
+        if (typeof content === "string" && content.trim()) {
+          responseText = content.trim();
+          break;
+        }
+
+        if (Array.isArray(content)) {
+          for (const part of content) {
+            if (typeof part?.text === "string" && part.text.trim()) {
+              responseText = part.text.trim();
+              break;
+            }
+          }
+        }
+
+        if (responseText) break;
+
+        if (typeof choice?.text === "string" && choice.text.trim()) {
+          responseText = choice.text.trim();
+          break;
+        }
+      }
+    }
+
+    logger.logReasoning("OPENAI_RESPONSE", {
+      model,
+      responseLength: responseText.length,
+      tokensUsed: response.usage?.total_tokens || 0,
+      success: true,
+      isEmpty: responseText.length === 0,
+    });
+
+    if (!responseText) {
+      logger.logReasoning("OPENAI_EMPTY_RESPONSE_FALLBACK", {
+        model,
+        originalTextLength: text.length,
+        reason: "Empty response from API",
+      });
+      return text;
+    }
+
+    return responseText;
+  },
+};
diff --git a/src/services/ai/inferenceProviders/openwhispr.ts b/src/services/ai/inferenceProviders/openwhispr.ts
new file mode 100644
index 000000000..d699466fb
--- /dev/null
+++ b/src/services/ai/inferenceProviders/openwhispr.ts
@@ -0,0 +1,41 @@
+import type { InferenceProvider } from "./types";
+import { withSessionRefresh } from "../../../lib/neonAuth";
+import logger from "../../../utils/logger";
+
+export const openwhisprProvider: InferenceProvider = {
+  id: "openwhispr",
+  async call({ text, model, agentName, config, ctx }) {
+    logger.logReasoning("OPENWHISPR_START", { model, agentName });
+
+    const result = await withSessionRefresh(async () => {
+      const res = await window.electronAPI?.cloudReason?.(text, {
+        agentName,
+        customDictionary: ctx.getCustomDictionary(),
+        customPrompt: ctx.getCustomPrompt(),
+        systemPrompt: config.systemPrompt,
+        language: ctx.getPreferredLanguage(),
+        locale: ctx.getUiLanguage(),
+      });
+
+      if (!res?.success) {
+        const err: Error & { code?: string } = new Error(
+          res?.error || "OpenWhispr cloud reasoning failed"
+        );
+        err.code = res?.code;
+        throw err;
+      }
+
+      return res;
+    });
+
+    logger.logReasoning("OPENWHISPR_SUCCESS", {
+      model: result.model,
+      provider: result.provider,
+      resultLength: result.text.length,
+      promptMode: result.promptMode,
+      matchType: result.matchType,
+    });
+
+    return result.text;
+  },
+};
diff --git a/src/services/ai/inferenceProviders/types.ts b/src/services/ai/inferenceProviders/types.ts
new file mode 100644
index 000000000..f75ff5481
--- /dev/null
+++ b/src/services/ai/inferenceProviders/types.ts
@@ -0,0 +1,38 @@
+import type { ReasoningConfig } from "../../BaseReasoningService";
+
+export interface ProviderContext {
+  getApiKey(provider: string): Promise<string>;
+  getSystemPrompt(agentName: string | null, transcript?: string): string;
+  getCustomDictionary(): string[];
+  getPreferredLanguage(): string;
+  getUiLanguage(): string;
+  getCustomPrompt(): string | undefined;
+  callChatCompletionsApi(
+    endpoint: string,
+    apiKey: string,
+    model: string,
+    text: string,
+    agentName: string | null,
+    config: ReasoningConfig,
+    providerName: string
+  ): Promise<string>;
+  calculateMaxTokens(
+    textLength: number,
+    minTokens?: number,
+    maxTokens?: number,
+    multiplier?: number
+  ): number;
+}
+
+export interface ProviderCallParams {
+  text: string;
+  model: string;
+  agentName: string | null;
+  config: ReasoningConfig;
+  ctx: ProviderContext;
+}
+
+export interface InferenceProvider {
+  readonly id: string;
+  call(params: ProviderCallParams): Promise<string>;
+}
diff --git a/src/services/ai/openaiBase.ts b/src/services/ai/openaiBase.ts
new file mode 100644
index 000000000..3bb8e6ec2
--- /dev/null
+++ b/src/services/ai/openaiBase.ts
@@ -0,0 +1,86 @@
+import { API_ENDPOINTS, normalizeBaseUrl } from "../../config/constants";
+import { getSettings } from "../../stores/settingsStore";
+import { isSecureEndpoint } from "../../utils/urlUtils";
+import logger from "../../utils/logger";
+
+export function getConfiguredOpenAIBase(): string {
+  if (typeof window === "undefined") {
+    return API_ENDPOINTS.OPENAI_BASE;
+  }
+
+  try {
+    const settings = getSettings();
+    const provider = settings.cleanupProvider || "";
+    const isCustomProvider = provider === "custom";
+
+    if (!isCustomProvider) {
+      logger.logReasoning("CUSTOM_CLEANUP_ENDPOINT_CHECK", {
+        hasCustomUrl: false,
+        provider,
+        reason: "Provider is not 'custom', using default OpenAI endpoint",
+        defaultEndpoint: API_ENDPOINTS.OPENAI_BASE,
+      });
+      return API_ENDPOINTS.OPENAI_BASE;
+    }
+
+    const stored = settings.cleanupCloudBaseUrl || "";
+    const trimmed = stored.trim();
+
+    if (!trimmed) {
+      logger.logReasoning("CUSTOM_CLEANUP_ENDPOINT_CHECK", {
+        hasCustomUrl: false,
+        provider,
+        usingDefault: true,
+        defaultEndpoint: API_ENDPOINTS.OPENAI_BASE,
+      });
+      return API_ENDPOINTS.OPENAI_BASE;
+    }
+
+    const normalized = normalizeBaseUrl(trimmed) || API_ENDPOINTS.OPENAI_BASE;
+
+    logger.logReasoning("CUSTOM_CLEANUP_ENDPOINT_CHECK", {
+      hasCustomUrl: true,
+      provider,
+      rawUrl: trimmed,
+      normalizedUrl: normalized,
+      defaultEndpoint: API_ENDPOINTS.OPENAI_BASE,
+    });
+
+    const knownNonOpenAIUrls = [
+      "api.groq.com",
+      "api.anthropic.com",
+      "generativelanguage.googleapis.com",
+    ];
+
+    const isKnownNonOpenAI = knownNonOpenAIUrls.some((url) => normalized.includes(url));
+    if (isKnownNonOpenAI) {
+      logger.logReasoning("OPENAI_BASE_REJECTED", {
+        reason: "Custom URL is a known non-OpenAI provider, using default OpenAI endpoint",
+        attempted: normalized,
+      });
+      return API_ENDPOINTS.OPENAI_BASE;
+    }
+
+    if (!isSecureEndpoint(normalized)) {
+      logger.logReasoning("OPENAI_BASE_REJECTED", {
+        reason: "HTTPS required (HTTP allowed for local network only)",
+        attempted: normalized,
+      });
+      return API_ENDPOINTS.OPENAI_BASE;
+    }
+
+    logger.logReasoning("CUSTOM_CLEANUP_ENDPOINT_RESOLVED", {
+      customEndpoint: normalized,
+      isCustom: true,
+      provider,
+    });
+
+    return normalized;
+  } catch (error) {
+    logger.logReasoning("CUSTOM_CLEANUP_ENDPOINT_ERROR", {
+      error: (error as Error).message,
+      fallbackTo: API_ENDPOINTS.OPENAI_BASE,
+    });
+    return API_ENDPOINTS.OPENAI_BASE;
+  }
+}
diff --git a/src/stores/settingsStore.ts b/src/stores/settingsStore.ts
index d7e14a094..52c5c3f08 100644
--- a/src/stores/settingsStore.ts
+++ b/src/stores/settingsStore.ts
@@ -7,15 +7,22 @@ import { useStreamingProvidersStore } from "./streamingProvidersStore";
 import logger from "../utils/logger";
 import type { LocalTranscriptionProvider, InferenceMode, SelfHostedType } from "../types/electron";
 import type { GoogleCalendarAccount } from "../types/calendar";
+import { PROMPT_KIND_LIST, type PromptKind } from "../config/prompts/registry";
+import {
+  INFERENCE_SCOPES,
+  type InferenceScope,
+  type InferenceScopeDefinition,
+  type InferenceScopeStoreKeys,
+} from "../config/inferenceScopes";
 import type {
   TranscriptionSettings,
-  ReasoningSettings,
+  CleanupSettings,
   HotkeySettings,
   MicrophoneSettings,
   ApiKeySettings,
   PrivacySettings,
   ThemeSettings,
-  AgentModeSettings,
+  ChatAgentSettings,
 } from "../hooks/useSettings";
 
 let _ReasoningService: typeof import("../services/ReasoningService").default | null = null;
@@ -99,7 +106,7 @@ const BOOLEAN_SETTINGS = new Set([
   "allowOpenAIFallback",
   "allowLocalFallback",
   "assemblyAiStreaming",
-  "useReasoningModel",
+  "useCleanupModel",
   "preferBuiltInMic",
   "cloudBackupEnabled",
   "telemetryEnabled",
@@ -111,7 +118,7 @@ const BOOLEAN_SETTINGS = new Set([
   "meetingAudioDetection",
   "speakerDiarizationEnabled",
   "isSignedIn",
-  "agentEnabled",
+  "chatAgentEnabled",
   "autoPasteEnabled",
   "keepTranscriptionInClipboard",
   "dataRetentionEnabled",
@@ -221,16 +228,93 @@ function migrateAgentMode() {
 
 migrateAgentMode();
 
+function migrateCustomPrompts() {
+  if (!isBrowser) return;
+  if (localStorage.getItem("_promptsMigrated") === "1") return;
+
+  const legacyUnified = localStorage.getItem("customUnifiedPrompt");
+  if (legacyUnified) {
+    try {
+      const parsed = JSON.parse(legacyUnified);
+      if (typeof parsed === "string" && parsed.length > 0) {
+        if (!localStorage.getItem("customPrompt.cleanup")) {
+          localStorage.setItem("customPrompt.cleanup", parsed);
+        }
+        if (!localStorage.getItem("customPrompt.dictationAgent")) {
+          localStorage.setItem("customPrompt.dictationAgent", parsed);
+        }
+      }
+    } catch {}
+    localStorage.removeItem("customUnifiedPrompt");
+  }
+
+  const legacyChat = localStorage.getItem("agentSystemPrompt");
+  if (legacyChat && legacyChat.length > 0 && !localStorage.getItem("customPrompt.chatAgent")) {
+    localStorage.setItem("customPrompt.chatAgent", legacyChat);
+  }
+  if (legacyChat !== null) localStorage.removeItem("agentSystemPrompt");
+
+  localStorage.setItem("_promptsMigrated", "1");
+}
+
+migrateCustomPrompts();
+
+// One-time migration of legacy LLM-scope localStorage keys. Safe to delete
+// after a few releases.
+const LLM_SCOPE_KEY_PAIRS: ReadonlyArray<[string, string]> = [
+  ["reasoningModel", "cleanupModel"],
+  ["reasoningProvider", "cleanupProvider"],
+  ["reasoningMode", "cleanupMode"],
+  ["useReasoningModel", "useCleanupModel"],
+  ["cloudReasoningMode", "cleanupCloudMode"],
+  ["cloudReasoningBaseUrl", "cleanupCloudBaseUrl"],
+  ["customReasoningApiKey", "cleanupCustomApiKey"],
+  ["remoteReasoningType", "cleanupRemoteType"],
+  ["remoteReasoningUrl", "cleanupRemoteUrl"],
+  ["meetingReasoningMode", "noteFormattingMode"],
+  ["meetingReasoningProvider", "noteFormattingProvider"],
+  ["meetingReasoningModel", "noteFormattingModel"],
+  ["meetingCloudReasoningMode", "noteFormattingCloudMode"],
+  ["meetingCloudReasoningBaseUrl", "noteFormattingCloudBaseUrl"],
+  ["meetingRemoteReasoningType", "noteFormattingRemoteType"],
+  ["meetingRemoteReasoningUrl", "noteFormattingRemoteUrl"],
+  ["agentInferenceMode", "chatAgentMode"],
+  ["agentProvider", "chatAgentProvider"],
+  ["agentModel", "chatAgentModel"],
+  ["cloudAgentMode", "chatAgentCloudMode"],
+  ["remoteAgentUrl", "chatAgentRemoteUrl"],
+  ["agentEnabled", "chatAgentEnabled"],
+  ["agentKey", "chatAgentKey"],
+];
+
+function migrateLLMScopeKeys() {
+  if (!isBrowser) return;
+  if (localStorage.getItem("_llmScopeKeysMigrated") === "1") return;
+
+  for (const [oldKey, newKey] of LLM_SCOPE_KEY_PAIRS) {
+    const value = localStorage.getItem(oldKey);
+    if (value === null) continue;
+    if (localStorage.getItem(newKey) === null) {
+      localStorage.setItem(newKey, value);
+    }
+    localStorage.removeItem(oldKey);
+  }
+
+  localStorage.setItem("_llmScopeKeysMigrated", "1");
+}
+
+migrateLLMScopeKeys();
+
 export interface SettingsState
   extends
     TranscriptionSettings,
-    ReasoningSettings,
+    CleanupSettings,
     HotkeySettings,
     MicrophoneSettings,
     ApiKeySettings,
     PrivacySettings,
     ThemeSettings,
-    AgentModeSettings {
+    ChatAgentSettings {
   isSignedIn: boolean;
   audioCuesEnabled: boolean;
   pauseMediaOnDictation: boolean;
@@ -252,9 +336,9 @@ export interface SettingsState
   transcriptionMode: InferenceMode;
   remoteTranscriptionType: SelfHostedType;
   remoteTranscriptionUrl: string;
-  reasoningMode: InferenceMode;
-  remoteReasoningType: SelfHostedType;
-  remoteReasoningUrl: string;
+  cleanupMode: InferenceMode;
+  cleanupRemoteType: SelfHostedType;
+  cleanupRemoteUrl: string;
 
   meetingTranscriptionMode: InferenceMode;
   meetingUseLocalWhisper: boolean;
@@ -268,20 +352,42 @@ export interface SettingsState
   meetingRemoteTranscriptionType: SelfHostedType;
   meetingRemoteTranscriptionUrl: string;
 
-  meetingReasoningMode: InferenceMode;
-  meetingReasoningProvider: string;
-  meetingReasoningModel: string;
-  meetingCloudReasoningMode: string;
-  meetingCloudReasoningBaseUrl: string;
-  meetingRemoteReasoningType: SelfHostedType;
-  meetingRemoteReasoningUrl: string;
+  noteFormattingMode: InferenceMode;
+  noteFormattingProvider: string;
+  noteFormattingModel: string;
+  noteFormattingCloudMode: string;
+  noteFormattingCloudBaseUrl: string;
+  noteFormattingRemoteType: SelfHostedType;
+  noteFormattingRemoteUrl: string;
+  noteFormattingCustomApiKey: string;
+
+  dictationAgentMode: InferenceMode;
+  dictationAgentProvider: string;
+  dictationAgentModel: string;
+  dictationAgentCloudMode: string;
+  dictationAgentCloudBaseUrl: string;
+  dictationAgentRemoteType: SelfHostedType;
+  dictationAgentRemoteUrl: string;
+  dictationAgentCustomApiKey: string;
+
+  customPrompts: Record<PromptKind, string>;
+  setCustomPrompt: (kind: PromptKind, value: string) => void;
+
+  setDictationAgentMode: (mode: InferenceMode) => void;
+  setDictationAgentProvider: (value: string) => void;
+  setDictationAgentModel: (value: string) => void;
+  setDictationAgentCloudMode: (value: string) => void;
+  setDictationAgentCloudBaseUrl: (value: string) => void;
+  setDictationAgentRemoteType: (type: SelfHostedType) => void;
+  setDictationAgentRemoteUrl: (url: string) => void;
+  setDictationAgentCustomApiKey: (key: string) => void;
 
   setTranscriptionMode: (mode: InferenceMode) => void;
   setRemoteTranscriptionType: (type: SelfHostedType) => void;
   setRemoteTranscriptionUrl: (url: string) => void;
-  setReasoningMode: (mode: InferenceMode) => void;
-  setRemoteReasoningType: (type: SelfHostedType) => void;
-  setRemoteReasoningUrl: (url: string) => void;
+  setCleanupMode: (mode: InferenceMode) => void;
+  setCleanupRemoteType: (type: SelfHostedType) => void;
+  setCleanupRemoteUrl: (url: string) => void;
 
   setMeetingTranscriptionMode: (mode: InferenceMode) => void;
   setMeetingUseLocalWhisper: (value: boolean) => void;
@@ -295,13 +401,14 @@ export interface SettingsState
   setMeetingRemoteTranscriptionType: (type: SelfHostedType) => void;
   setMeetingRemoteTranscriptionUrl: (url: string) => void;
 
-  setMeetingReasoningMode: (mode: InferenceMode) => void;
-  setMeetingReasoningProvider: (value: string) => void;
-  setMeetingReasoningModel: (value: string) => void;
-  setMeetingCloudReasoningMode: (value: string) => void;
-  setMeetingCloudReasoningBaseUrl: (value: string) => void;
-  setMeetingRemoteReasoningType: (type: SelfHostedType) => void;
-  setMeetingRemoteReasoningUrl: (url: string) => void;
+  setNoteFormattingMode: (mode: InferenceMode) => void;
+  setNoteFormattingProvider: (value: string) => void;
+  setNoteFormattingModel: (value: string) => void;
+  setNoteFormattingCloudMode: (value: string) => void;
+  setNoteFormattingCloudBaseUrl: (value: string) => void;
+  setNoteFormattingRemoteType: (type: SelfHostedType) => void;
+  setNoteFormattingRemoteUrl: (url: string) => void;
+  setNoteFormattingCustomApiKey: (key: string) => void;
 
   setUseLocalWhisper: (value: boolean) => void;
   setWhisperModel: (value: string) => void;
@@ -315,13 +422,13 @@ export interface SettingsState
   setCloudTranscriptionModel: (value: string) => void;
   setCloudTranscriptionBaseUrl: (value: string) => void;
   setCloudTranscriptionMode: (value: string) => void;
-  setCloudReasoningMode: (value: string) => void;
-  setCloudReasoningBaseUrl: (value: string) => void;
+  setCleanupCloudMode: (value: string) => void;
+  setCleanupCloudBaseUrl: (value: string) => void;
   setCustomDictionary: (words: string[]) => void;
   setAssemblyAiStreaming: (value: boolean) => void;
-  setUseReasoningModel: (value: boolean) => void;
-  setReasoningModel: (value: string) => void;
-  setReasoningProvider: (value: string) => void;
+  setUseCleanupModel: (value: boolean) => void;
+  setCleanupModel: (value: string) => void;
+  setCleanupProvider: (value: string) => void;
   setUiLanguage: (language: string) => void;
 
   setOpenaiApiKey: (key: string) => void;
@@ -330,7 +437,7 @@ export interface SettingsState
   setGroqApiKey: (key: string) => void;
   setMistralApiKey: (key: string) => void;
   setCustomTranscriptionApiKey: (key: string) => void;
-  setCustomReasoningApiKey: (key: string) => void;
+  setCleanupCustomApiKey: (key: string) => void;
 
   // Enterprise providers
   bedrockAuthMode: string;
@@ -390,19 +497,20 @@ export interface SettingsState
   setNoteFilesPath: (value: string) => void;
   setIsSignedIn: (value: boolean) => void;
 
-  setAgentModel: (value: string) => void;
-  setAgentProvider: (value: string) => void;
-  setAgentKey: (key: string) => void;
-  setAgentSystemPrompt: (value: string) => void;
-  setAgentEnabled: (value: boolean) => void;
-  setCloudAgentMode: (value: string) => void;
-  setAgentInferenceMode: (mode: InferenceMode) => void;
-  setRemoteAgentUrl: (url: string) => void;
+  setChatAgentModel: (value: string) => void;
+  setChatAgentProvider: (value: string) => void;
+  setChatAgentKey: (key: string) => void;
+  setChatAgentEnabled: (value: boolean) => void;
+  setChatAgentCloudMode: (value: string) => void;
+  setChatAgentMode: (mode: InferenceMode) => void;
+  setChatAgentCloudBaseUrl: (value: string) => void;
+  setChatAgentRemoteType: (type: SelfHostedType) => void;
+  setChatAgentRemoteUrl: (url: string) => void;
 
   updateTranscriptionSettings: (settings: Partial<TranscriptionSettings>) => void;
-  updateReasoningSettings: (settings: Partial<ReasoningSettings>) => void;
+  updateCleanupSettings: (settings: Partial<CleanupSettings>) => void;
   updateApiKeys: (keys: Partial<ApiKeySettings>) => void;
-  updateAgentModeSettings: (settings: Partial<AgentModeSettings>) => void;
+  updateChatAgentSettings: (settings: Partial<ChatAgentSettings>) => void;
 }
 
 function createStringSetter(key: string) {
@@ -475,14 +583,14 @@ export const useSettingsStore = create<SettingsState>()((set, get) => ({
     "cloudTranscriptionMode",
     hasStoredByokKey() ? "byok" : "openwhispr"
   ),
-  cloudReasoningMode: readString("cloudReasoningMode", "openwhispr"),
-  cloudReasoningBaseUrl: readString("cloudReasoningBaseUrl", API_ENDPOINTS.OPENAI_BASE),
+  cleanupCloudMode: readString("cleanupCloudMode", "openwhispr"),
+  cleanupCloudBaseUrl: readString("cleanupCloudBaseUrl", API_ENDPOINTS.OPENAI_BASE),
   customDictionary: readStringArray("customDictionary", []),
   assemblyAiStreaming: readBoolean("assemblyAiStreaming", true),
 
-  useReasoningModel: readBoolean("useReasoningModel", true),
-  reasoningModel: readString("reasoningModel", ""),
-  reasoningProvider: readString("reasoningProvider", "openai"),
+  useCleanupModel: readBoolean("useCleanupModel", true),
+  cleanupModel: readString("cleanupModel", ""),
+  cleanupProvider: readString("cleanupProvider", "openai"),
 
   openaiApiKey: readString("openaiApiKey", ""),
   anthropicApiKey: readString("anthropicApiKey", ""),
@@ -490,7 +598,7 @@ export const useSettingsStore = create<SettingsState>()((set, get) => ({
   groqApiKey: readString("groqApiKey", ""),
   mistralApiKey: readString("mistralApiKey", ""),
   customTranscriptionApiKey: readString("customTranscriptionApiKey", ""),
-  customReasoningApiKey: readString("customReasoningApiKey", ""),
+  cleanupCustomApiKey: readString("cleanupCustomApiKey", ""),
 
   // Enterprise providers
   bedrockAuthMode: readString("bedrockAuthMode", "sso"),
@@ -575,8 +683,8 @@ export const useSettingsStore = create<SettingsState>()((set, get) => ({
     return v === "openai-compatible" ? "openai-compatible" : ("lan" as SelfHostedType);
   })(),
   remoteTranscriptionUrl: readString("remoteTranscriptionUrl", ""),
-  reasoningMode: (() => {
-    const v = readString("reasoningMode", "openwhispr");
+  cleanupMode: (() => {
+    const v = readString("cleanupMode", "openwhispr");
     if (
       v === "openwhispr" ||
       v === "providers" ||
@@ -587,11 +695,11 @@ export const useSettingsStore = create<SettingsState>()((set, get) => ({
       return v;
     return "openwhispr" as InferenceMode;
   })(),
-  remoteReasoningType: (() => {
-    const v = readString("remoteReasoningType", "lan");
+  cleanupRemoteType: (() => {
+    const v = readString("cleanupRemoteType", "lan");
     return v === "openai-compatible" ? "openai-compatible" : ("lan" as SelfHostedType);
   })(),
-  remoteReasoningUrl: readString("remoteReasoningUrl", ""),
+  cleanupRemoteUrl: readString("cleanupRemoteUrl", ""),
 
   meetingTranscriptionMode: (() => {
     const v = readString("meetingTranscriptionMode", "openwhispr");
@@ -615,8 +723,8 @@ export const useSettingsStore = create<SettingsState>()((set, get) => ({
   })(),
   meetingRemoteTranscriptionUrl: readString("meetingRemoteTranscriptionUrl", ""),
 
-  meetingReasoningMode: (() => {
-    const v = readString("meetingReasoningMode", "openwhispr");
+  noteFormattingMode: (() => {
+    const v = readString("noteFormattingMode", "openwhispr");
     if (
       v === "openwhispr" ||
       v === "providers" ||
@@ -627,26 +735,25 @@ export const useSettingsStore = create<SettingsState>()((set, get) => ({
       return v;
     return "openwhispr" as InferenceMode;
   })(),
-  meetingReasoningProvider: readString("meetingReasoningProvider", ""),
-  meetingReasoningModel: readString("meetingReasoningModel", ""),
-  meetingCloudReasoningMode: readString("meetingCloudReasoningMode", ""),
-  meetingCloudReasoningBaseUrl: readString("meetingCloudReasoningBaseUrl", ""),
-  meetingRemoteReasoningType: (() => {
-    const v = readString("meetingRemoteReasoningType", "lan");
+  noteFormattingProvider: readString("noteFormattingProvider", ""),
+  noteFormattingModel: readString("noteFormattingModel", ""),
+  noteFormattingCloudMode: readString("noteFormattingCloudMode", ""),
+  noteFormattingCloudBaseUrl: readString("noteFormattingCloudBaseUrl", ""),
+  noteFormattingRemoteType: (() => {
+    const v = readString("noteFormattingRemoteType", "lan");
     return v === "openai-compatible" ? "openai-compatible" : ("lan" as SelfHostedType);
   })(),
-  meetingRemoteReasoningUrl: readString("meetingRemoteReasoningUrl", ""),
+  noteFormattingRemoteUrl: readString("noteFormattingRemoteUrl", ""),
+  noteFormattingCustomApiKey: readString("noteFormattingCustomApiKey", ""),
 
   setTranscriptionMode: createStringSetter("transcriptionMode") as (mode: InferenceMode) => void,
   setRemoteTranscriptionType: createStringSetter("remoteTranscriptionType") as (
     type: SelfHostedType
   ) => void,
   setRemoteTranscriptionUrl: createStringSetter("remoteTranscriptionUrl"),
-  setReasoningMode: createStringSetter("reasoningMode") as (mode: InferenceMode) => void,
-  setRemoteReasoningType: createStringSetter("remoteReasoningType") as (
-    type: SelfHostedType
-  ) => void,
-  setRemoteReasoningUrl: createStringSetter("remoteReasoningUrl"),
+  setCleanupMode: createStringSetter("cleanupMode") as (mode: InferenceMode) => void,
+  setCleanupRemoteType: createStringSetter("cleanupRemoteType") as (type: SelfHostedType) => void,
+  setCleanupRemoteUrl: createStringSetter("cleanupRemoteUrl"),
 
   setMeetingTranscriptionMode: createStringSetter("meetingTranscriptionMode") as (
     mode: InferenceMode
@@ -667,26 +774,24 @@ export const useSettingsStore = create<SettingsState>()((set, get) => ({
   ) => void,
   setMeetingRemoteTranscriptionUrl: createStringSetter("meetingRemoteTranscriptionUrl"),
 
-  setMeetingReasoningMode: createStringSetter("meetingReasoningMode") as (
-    mode: InferenceMode
-  ) => void,
-  setMeetingReasoningProvider: createStringSetter("meetingReasoningProvider"),
-  setMeetingReasoningModel: createStringSetter("meetingReasoningModel"),
-  setMeetingCloudReasoningMode: createStringSetter("meetingCloudReasoningMode"),
-  setMeetingCloudReasoningBaseUrl: createStringSetter("meetingCloudReasoningBaseUrl"),
-  setMeetingRemoteReasoningType: createStringSetter("meetingRemoteReasoningType") as (
+  setNoteFormattingMode: createStringSetter("noteFormattingMode") as (mode: InferenceMode) => void,
+  setNoteFormattingProvider: createStringSetter("noteFormattingProvider"),
+  setNoteFormattingModel: createStringSetter("noteFormattingModel"),
+  setNoteFormattingCloudMode: createStringSetter("noteFormattingCloudMode"),
+  setNoteFormattingCloudBaseUrl: createStringSetter("noteFormattingCloudBaseUrl"),
+  setNoteFormattingRemoteType: createStringSetter("noteFormattingRemoteType") as (
     type: SelfHostedType
   ) => void,
-  setMeetingRemoteReasoningUrl: createStringSetter("meetingRemoteReasoningUrl"),
-
-  agentModel: readString("agentModel", "openai/gpt-oss-120b"),
-  agentProvider: readString("agentProvider", "groq"),
-  agentKey: readString("agentKey", ""),
-  agentSystemPrompt: readString("agentSystemPrompt", ""),
-  agentEnabled: readBoolean("agentEnabled", true),
-  cloudAgentMode: readString("cloudAgentMode", "openwhispr"),
-  agentInferenceMode: (() => {
-    const v = readString("agentInferenceMode", "openwhispr");
+  setNoteFormattingRemoteUrl: createStringSetter("noteFormattingRemoteUrl"),
+  setNoteFormattingCustomApiKey: createStringSetter("noteFormattingCustomApiKey"),
+
+  chatAgentModel: readString("chatAgentModel", "openai/gpt-oss-120b"),
+  chatAgentProvider: readString("chatAgentProvider", "groq"),
+  chatAgentKey: readString("chatAgentKey", ""),
+  chatAgentEnabled: readBoolean("chatAgentEnabled", true),
+  chatAgentCloudMode: readString("chatAgentCloudMode", "openwhispr"),
+  chatAgentMode: (() => {
+    const v = readString("chatAgentMode", "openwhispr");
     if (
       v === "openwhispr" ||
       v === "providers" ||
@@ -697,7 +802,57 @@ export const useSettingsStore = create<SettingsState>()((set, get) => ({
       return v;
     return "openwhispr" as InferenceMode;
   })(),
-  remoteAgentUrl: readString("remoteAgentUrl", ""),
+  chatAgentRemoteUrl: readString("chatAgentRemoteUrl", ""),
+  chatAgentCloudBaseUrl: readString("chatAgentCloudBaseUrl", ""),
+  chatAgentRemoteType: (() => {
+    const v = readString("chatAgentRemoteType", "lan");
+    return v === "openai-compatible" ? "openai-compatible" : ("lan" as SelfHostedType);
+  })(),
+
+  dictationAgentMode: (() => {
+    const v = readString("dictationAgentMode", "");
+    if (
+      v === "openwhispr" ||
+      v === "providers" ||
+      v === "local" ||
+      v === "self-hosted" ||
+      v === "enterprise"
+    )
+      return v;
+    return "providers" as InferenceMode;
+  })(),
+  dictationAgentProvider: readString("dictationAgentProvider", ""),
+  dictationAgentModel: readString("dictationAgentModel", ""),
+  dictationAgentCloudMode: readString("dictationAgentCloudMode", ""),
+  dictationAgentCloudBaseUrl: readString("dictationAgentCloudBaseUrl", ""),
+  dictationAgentRemoteType: (() => {
+    const v = readString("dictationAgentRemoteType", "lan");
+    return v === "openai-compatible" ? "openai-compatible" : ("lan" as SelfHostedType);
+  })(),
+  dictationAgentRemoteUrl: readString("dictationAgentRemoteUrl", ""),
+  dictationAgentCustomApiKey: readString("dictationAgentCustomApiKey", ""),
+
+  customPrompts: PROMPT_KIND_LIST.reduce(
+    (acc, kind) => ({ ...acc, [kind]: readString(`customPrompt.${kind}`, "") }),
+    {} as Record<PromptKind, string>
+  ),
+  setCustomPrompt: (kind, value) => {
+    if (isBrowser) localStorage.setItem(`customPrompt.${kind}`, value);
+    useSettingsStore.setState((s) => ({
+      customPrompts: { ...s.customPrompts, [kind]: value },
+    }));
+  },
+
+  setDictationAgentMode: createStringSetter("dictationAgentMode") as (mode: InferenceMode) => void,
+  setDictationAgentProvider: createStringSetter("dictationAgentProvider"),
+  setDictationAgentModel: createStringSetter("dictationAgentModel"),
+  setDictationAgentCloudMode: createStringSetter("dictationAgentCloudMode"),
+  setDictationAgentCloudBaseUrl: createStringSetter("dictationAgentCloudBaseUrl"),
+  setDictationAgentRemoteType: createStringSetter("dictationAgentRemoteType") as (
+    type: SelfHostedType
+  ) => void,
+  setDictationAgentRemoteUrl: createStringSetter("dictationAgentRemoteUrl"),
+  setDictationAgentCustomApiKey: createStringSetter("dictationAgentCustomApiKey"),
 
   setUseLocalWhisper: createBooleanSetter("useLocalWhisper"),
   setWhisperModel: createStringSetter("whisperModel"),
@@ -714,18 +869,12 @@ export const useSettingsStore = create<SettingsState>()((set, get) => ({
   setCloudTranscriptionModel: createStringSetter("cloudTranscriptionModel"),
   setCloudTranscriptionBaseUrl: createStringSetter("cloudTranscriptionBaseUrl"),
   setCloudTranscriptionMode: createStringSetter("cloudTranscriptionMode"),
-  setCloudReasoningMode: createStringSetter("cloudReasoningMode"),
-  setCloudReasoningBaseUrl: createStringSetter("cloudReasoningBaseUrl"),
+  setCleanupCloudMode: createStringSetter("cleanupCloudMode"),
+  setCleanupCloudBaseUrl: createStringSetter("cleanupCloudBaseUrl"),
   setAssemblyAiStreaming: createBooleanSetter("assemblyAiStreaming"),
-  setUseReasoningModel: createBooleanSetter("useReasoningModel"),
-  setReasoningProvider: (value: string) => {
-    if (isBrowser) localStorage.setItem("reasoningProvider", value);
-    useSettingsStore.setState({ reasoningProvider: value });
-  },
-  setReasoningModel: (value: string) => {
-    if (isBrowser) localStorage.setItem("reasoningModel", value);
-    useSettingsStore.setState({ reasoningModel: value });
-  },
+  setUseCleanupModel: createBooleanSetter("useCleanupModel"),
+  setCleanupProvider: createStringSetter("cleanupProvider"),
+  setCleanupModel: createStringSetter("cleanupModel"),
 
   setCustomDictionary: (words: string[]) => {
     if (isBrowser) localStorage.setItem("customDictionary", JSON.stringify(words));
@@ -791,9 +940,9 @@ export const useSettingsStore = create<SettingsState>()((set, get) => ({
     window.electronAPI?.saveCustomTranscriptionKey?.(key);
     invalidateApiKeyCaches("custom");
   },
-  setCustomReasoningApiKey: (key: string) => {
-    if (isBrowser) localStorage.setItem("customReasoningApiKey", key);
-    set({ customReasoningApiKey: key });
+  setCleanupCustomApiKey: (key: string) => {
+    if (isBrowser) localStorage.setItem("cleanupCustomApiKey", key);
+    set({ cleanupCustomApiKey: key });
     window.electronAPI?.saveCustomReasoningKey?.(key);
     invalidateApiKeyCaches("custom");
   },
@@ -984,59 +1133,56 @@ export const useSettingsStore = create<SettingsState>()((set, get) => ({
     set({ isSignedIn: value });
   },
 
-  setAgentModel: (value: string) => {
-    if (isBrowser) localStorage.setItem("agentModel", value);
-    useSettingsStore.setState({ agentModel: value });
-  },
-  setAgentProvider: (value: string) => {
-    if (isBrowser) localStorage.setItem("agentProvider", value);
-    useSettingsStore.setState({ agentProvider: value });
-  },
-  setAgentKey: (key: string) => {
+  setChatAgentModel: createStringSetter("chatAgentModel"),
+  setChatAgentProvider: createStringSetter("chatAgentProvider"),
+  setChatAgentKey: (key: string) => {
     if (!isBrowser) {
-      useSettingsStore.setState({ agentKey: key });
+      useSettingsStore.setState({ chatAgentKey: key });
       return;
     }
 
     const updateAgentHotkey = window.electronAPI?.updateAgentHotkey;
     if (!updateAgentHotkey) {
-      localStorage.setItem("agentKey", key);
-      useSettingsStore.setState({ agentKey: key });
+      localStorage.setItem("chatAgentKey", key);
+      useSettingsStore.setState({ chatAgentKey: key });
       window.electronAPI?.saveAgentKey?.(key);
       return;
     }
 
-    const previousKey = get().agentKey;
+    const previousKey = get().chatAgentKey;
 
     void updateAgentHotkey(key)
       .then((result) => {
         if (!result?.success) {
-          localStorage.setItem("agentKey", previousKey);
-          useSettingsStore.setState({ agentKey: previousKey });
+          localStorage.setItem("chatAgentKey", previousKey);
+          useSettingsStore.setState({ chatAgentKey: previousKey });
           logger.warn(
-            "Failed to update agent hotkey",
+            "Failed to update chat agent hotkey",
             { hotkey: key, message: result?.message },
             "settings"
           );
           return;
         }
 
-        localStorage.setItem("agentKey", key);
-        useSettingsStore.setState({ agentKey: key });
+        localStorage.setItem("chatAgentKey", key);
+        useSettingsStore.setState({ chatAgentKey: key });
       })
       .catch((error) => {
         logger.warn(
-          "Failed to update agent hotkey",
+          "Failed to update chat agent hotkey",
           { hotkey: key, error: error instanceof Error ? error.message : String(error) },
           "settings"
         );
       });
   },
-  setAgentSystemPrompt: createStringSetter("agentSystemPrompt"),
-  setAgentEnabled: createBooleanSetter("agentEnabled"),
-  setCloudAgentMode: createStringSetter("cloudAgentMode"),
-  setAgentInferenceMode: createStringSetter("agentInferenceMode") as (mode: InferenceMode) => void,
-  setRemoteAgentUrl: createStringSetter("remoteAgentUrl"),
+  setChatAgentEnabled: createBooleanSetter("chatAgentEnabled"),
+  setChatAgentCloudMode: createStringSetter("chatAgentCloudMode"),
+  setChatAgentMode: createStringSetter("chatAgentMode") as (mode: InferenceMode) => void,
+  setChatAgentCloudBaseUrl: createStringSetter("chatAgentCloudBaseUrl"),
+  setChatAgentRemoteType: createStringSetter("chatAgentRemoteType") as (
+    type: SelfHostedType
+  ) => void,
+  setChatAgentRemoteUrl: createStringSetter("chatAgentRemoteUrl"),
 
   updateTranscriptionSettings: (settings: Partial<TranscriptionSettings>) => {
     const s = useSettingsStore.getState();
@@ -1069,17 +1215,14 @@ export const useSettingsStore = create<SettingsState>()((set, get) => ({
       s.setShowTranscriptionPreview(settings.showTranscriptionPreview);
   },
 
-  updateReasoningSettings: (settings: Partial<ReasoningSettings>) => {
+  updateCleanupSettings: (settings: Partial<CleanupSettings>) => {
     const s = useSettingsStore.getState();
-    if (settings.useReasoningModel !== undefined)
-      s.setUseReasoningModel(settings.useReasoningModel);
-    if (settings.reasoningModel !== undefined) s.setReasoningModel(settings.reasoningModel);
-    if (settings.reasoningProvider !== undefined)
-      s.setReasoningProvider(settings.reasoningProvider);
-    if (settings.cloudReasoningBaseUrl !== undefined)
-      s.setCloudReasoningBaseUrl(settings.cloudReasoningBaseUrl);
-    if (settings.cloudReasoningMode !== undefined)
-      s.setCloudReasoningMode(settings.cloudReasoningMode);
+    if (settings.useCleanupModel !== undefined) s.setUseCleanupModel(settings.useCleanupModel);
+    if (settings.cleanupModel !== undefined) s.setCleanupModel(settings.cleanupModel);
+    if (settings.cleanupProvider !== undefined) s.setCleanupProvider(settings.cleanupProvider);
+    if (settings.cleanupCloudBaseUrl !== undefined)
+      s.setCleanupCloudBaseUrl(settings.cleanupCloudBaseUrl);
+    if (settings.cleanupCloudMode !== undefined) s.setCleanupCloudMode(settings.cleanupCloudMode);
   },
 
   updateApiKeys: (keys: Partial<ApiKeySettings>) => {
@@ -1091,32 +1234,31 @@ export const useSettingsStore = create<SettingsState>()((set, get) => ({
     if (keys.mistralApiKey !== undefined) s.setMistralApiKey(keys.mistralApiKey);
     if (keys.customTranscriptionApiKey !== undefined)
       s.setCustomTranscriptionApiKey(keys.customTranscriptionApiKey);
-    if (keys.customReasoningApiKey !== undefined)
-      s.setCustomReasoningApiKey(keys.customReasoningApiKey);
+    if (keys.cleanupCustomApiKey !== undefined) s.setCleanupCustomApiKey(keys.cleanupCustomApiKey);
   },
 
-  updateAgentModeSettings: (settings: Partial<AgentModeSettings>) => {
+  updateChatAgentSettings: (settings: Partial<ChatAgentSettings>) => {
     const s = useSettingsStore.getState();
-    if (settings.agentModel !== undefined) s.setAgentModel(settings.agentModel);
-    if (settings.agentProvider !== undefined) s.setAgentProvider(settings.agentProvider);
-    if (settings.agentKey !== undefined) s.setAgentKey(settings.agentKey);
-    if (settings.agentSystemPrompt !== undefined)
-      s.setAgentSystemPrompt(settings.agentSystemPrompt);
-    if (settings.agentEnabled !== undefined) s.setAgentEnabled(settings.agentEnabled);
-    if (settings.cloudAgentMode !== undefined) s.setCloudAgentMode(settings.cloudAgentMode);
+    if (settings.chatAgentModel !== undefined) s.setChatAgentModel(settings.chatAgentModel);
+    if (settings.chatAgentProvider !== undefined)
+      s.setChatAgentProvider(settings.chatAgentProvider);
+    if (settings.chatAgentKey !== undefined) s.setChatAgentKey(settings.chatAgentKey);
+    if (settings.chatAgentEnabled !== undefined) s.setChatAgentEnabled(settings.chatAgentEnabled);
+    if (settings.chatAgentCloudMode !== undefined)
+      s.setChatAgentCloudMode(settings.chatAgentCloudMode);
   },
 }));
 
 // --- Selectors (derived state, not stored) ---
 
-export const selectIsCloudReasoningMode = (state: SettingsState) =>
-  state.isSignedIn && state.cloudReasoningMode === "openwhispr";
+export const selectIsCloudCleanupMode = (state: SettingsState) =>
+  state.isSignedIn && state.cleanupCloudMode === "openwhispr";
 
-export const selectEffectiveReasoningProvider = (state: SettingsState) =>
-  selectIsCloudReasoningMode(state) ? "openwhispr" : state.reasoningProvider;
+export const selectEffectiveCleanupProvider = (state: SettingsState) =>
+  selectIsCloudCleanupMode(state) ? "openwhispr" : state.cleanupProvider;
 
-export const selectIsCloudAgentMode = (state: SettingsState) =>
-  state.isSignedIn && state.cloudAgentMode === "openwhispr";
+export const selectIsCloudChatAgentMode = (state: SettingsState) =>
+  state.isSignedIn && state.chatAgentCloudMode === "openwhispr";
 
 export interface ResolvedMeetingTranscription {
   useLocalWhisper: boolean;
@@ -1154,28 +1296,89 @@ export const selectResolvedMeetingTranscription = (
   };
 };
 
-export interface ResolvedMeetingReasoning {
-  reasoningProvider: string;
-  reasoningModel: string;
-  reasoningMode: InferenceMode;
-  cloudReasoningMode: string;
-  cloudReasoningBaseUrl: string;
-  remoteReasoningType: SelfHostedType;
-  remoteReasoningUrl: string;
+export interface ResolvedNoteFormatting {
+  provider: string;
+  model: string;
+  mode: InferenceMode;
+  cloudMode: string;
+  cloudBaseUrl: string;
+  remoteType: SelfHostedType;
+  remoteUrl: string;
+}
+
+export const selectResolvedNoteFormatting = (state: SettingsState): ResolvedNoteFormatting => {
+  const cfg = selectResolvedLLMConfig(state, "noteFormatting");
+  return {
+    provider: cfg.provider,
+    model: cfg.model,
+    mode: cfg.mode,
+    cloudMode: cfg.cloudMode || "",
+    cloudBaseUrl: cfg.cloudBaseUrl || "",
+    remoteType: cfg.remoteType ?? "lan",
+    remoteUrl: cfg.remoteUrl || "",
+  };
+};
+
+export interface ResolvedLLMConfig {
+  scope: InferenceScope;
+  mode: InferenceMode;
+  provider: string;
+  model: string;
+  cloudMode?: string;
+  cloudBaseUrl?: string;
+  remoteType?: SelfHostedType;
+  remoteUrl?: string;
+  customApiKey?: string;
+}
+
+export const selectResolvedLLMConfig = (
+  state: SettingsState,
+  scope: InferenceScope
+): ResolvedLLMConfig => {
+  const def: InferenceScopeDefinition = INFERENCE_SCOPES[scope];
+  const fallback = def.fallbackScope
+    ? selectResolvedLLMConfig(state, def.fallbackScope as InferenceScope)
+    : undefined;
+
+  const read = (field: keyof InferenceScopeStoreKeys): string | undefined => {
+    const key = def.storeKeys[field];
+    if (!key) return undefined;
+    return (state[key] as string | undefined) || undefined;
+  };
+
+  return {
+    scope,
+    mode: state[def.storeKeys.mode] as InferenceMode,
+    provider: read("provider") || fallback?.provider || "",
+    model: read("model") || fallback?.model || "",
+    cloudMode: read("cloudMode") || fallback?.cloudMode,
+    cloudBaseUrl: read("cloudBaseUrl") || fallback?.cloudBaseUrl,
+    remoteType: (read("remoteType") as SelfHostedType | undefined) ?? fallback?.remoteType,
+    remoteUrl: read("remoteUrl") || fallback?.remoteUrl,
+    // No fallback inheritance: each scope owns its custom API key explicitly.
+    // Inheriting cleanup's key into other scopes silently was a footgun.
+    customApiKey: read("customApiKey"),
+  };
+};
+
+export function setResolvedLLMConfig(
+  scope: InferenceScope,
+  patch: Partial<Omit<ResolvedLLMConfig, "scope">>
+): void {
+  const def: InferenceScopeDefinition = INFERENCE_SCOPES[scope];
+  const updates: Partial<SettingsState> = {};
+  for (const [field, value] of Object.entries(patch)) {
+    if (value === undefined) continue;
+    const storeKey = def.storeKeys[field as keyof InferenceScopeStoreKeys];
+    if (!storeKey) continue;
+    if (isBrowser) localStorage.setItem(storeKey as string, value as string);
+    (updates as Record<string, unknown>)[storeKey as string] = value;
+  }
+  if (Object.keys(updates).length > 0) useSettingsStore.setState(updates);
 }
 
-export const selectResolvedMeetingReasoning = (state: SettingsState): ResolvedMeetingReasoning => ({
-  reasoningProvider: state.meetingReasoningProvider || state.reasoningProvider,
-  reasoningModel: state.meetingReasoningModel || state.reasoningModel,
-  reasoningMode: state.meetingReasoningMode,
-  cloudReasoningMode: state.meetingCloudReasoningMode || state.cloudReasoningMode,
-  cloudReasoningBaseUrl: state.meetingCloudReasoningBaseUrl || state.cloudReasoningBaseUrl || "",
-  remoteReasoningType: state.meetingRemoteReasoningType,
-  remoteReasoningUrl: state.meetingRemoteReasoningUrl || state.remoteReasoningUrl,
-});
-
-export function isCloudAgentMode() {
-  return selectIsCloudAgentMode(useSettingsStore.getState());
+export function isCloudChatAgentMode() {
+  return selectIsCloudChatAgentMode(useSettingsStore.getState());
 }
 
 // --- Convenience getters for non-React code ---
@@ -1184,16 +1387,16 @@ export function getSettings() {
   return useSettingsStore.getState();
 }
 
-export function getEffectiveReasoningModel() {
+export function getEffectiveCleanupModel() {
   const state = useSettingsStore.getState();
-  if (selectIsCloudReasoningMode(state)) {
+  if (selectIsCloudCleanupMode(state)) {
     return "";
   }
-  return state.reasoningModel;
+  return state.cleanupModel;
 }
 
-export function isCloudReasoningMode() {
-  return selectIsCloudReasoningMode(useSettingsStore.getState());
+export function isCloudCleanupMode() {
+  return selectIsCloudCleanupMode(useSettingsStore.getState());
 }
 
 // --- Initialization ---
@@ -1235,9 +1438,9 @@ export async function initializeSettings(): Promise<void> {
         const envKey = await window.electronAPI.getCustomTranscriptionKey?.();
         if (envKey) createStringSetter("customTranscriptionApiKey")(envKey);
       }
-      if (!state.customReasoningApiKey) {
+      if (!state.cleanupCustomApiKey) {
         const envKey = await window.electronAPI.getCustomReasoningKey?.();
-        if (envKey) createStringSetter("customReasoningApiKey")(envKey);
+        if (envKey) createStringSetter("cleanupCustomApiKey")(envKey);
       }
     } catch (err) {
       logger.warn(
@@ -1280,15 +1483,15 @@ export async function initializeSettings(): Promise<void> {
       );
     }
 
-    // Sync agent key from main process
+    // Sync chat agent hotkey from main process
     try {
       const envKey = await window.electronAPI.getAgentKey?.();
-      if (envKey && envKey !== state.agentKey) {
-        createStringSetter("agentKey")(envKey);
+      if (envKey && envKey !== state.chatAgentKey) {
+        createStringSetter("chatAgentKey")(envKey);
       }
     } catch (err) {
       logger.warn(
-        "Failed to sync agent key on startup",
+        "Failed to sync chat agent hotkey on startup",
         { error: (err as Error).message },
         "settings"
       );
diff --git a/src/types/electron.ts b/src/types/electron.ts
index a4796c59c..0358bb4fc 100644
--- a/src/types/electron.ts
+++ b/src/types/electron.ts
@@ -576,8 +576,10 @@ declare global {
         useLocalWhisper: boolean;
         localTranscriptionProvider: LocalTranscriptionProvider;
         model?: string;
-        reasoningProvider: string;
-        reasoningModel?: string;
+        cleanupProvider: string;
+        cleanupModel?: string;
+        dictationAgentProvider: string;
+        dictationAgentModel?: string;
       }) => Promise<void>;
 
       // Clipboard operations