diff --git a/app/src-tauri/Cargo.lock b/app/src-tauri/Cargo.lock
index 662d42c4f1c..8ca6d1ce62e 100644
--- a/app/src-tauri/Cargo.lock
+++ b/app/src-tauri/Cargo.lock
@@ -220,7 +220,7 @@ dependencies = [
  "objc2-foundation 0.3.2",
  "parking_lot",
  "percent-encoding",
- "windows-sys 0.59.0",
+ "windows-sys 0.60.2",
  "x11rb",
 ]
 
@@ -1678,7 +1678,7 @@ dependencies = [
  "libc",
  "option-ext",
  "redox_users 0.5.2",
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -1989,7 +1989,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
  "libc",
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -3974,7 +3974,7 @@ version = "0.50.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
 dependencies = [
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -4108,6 +4108,17 @@ dependencies = [
  "objc2-foundation 0.3.2",
 ]
 
+[[package]]
+name = "objc2-contacts"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b034b578389f89a85c055eacc8d8b368be5f04a6c1b07f672bf3aec21d0ef621"
+dependencies = [
+ "block2 0.6.2",
+ "objc2 0.6.4",
+ "objc2-foundation 0.3.2",
+]
+
 [[package]]
 name = "objc2-core-data"
 version = "0.2.2"
@@ -4466,6 +4477,7 @@ dependencies = [
  "async-trait",
  "axum",
  "base64 0.22.1",
+ "block2 0.6.2",
  "chacha20poly1305",
  "chrono",
  "chrono-tz",
@@ -4483,6 +4495,7 @@ dependencies = [
  "fs2",
  "futures",
  "futures-util",
+ "glob",
  "hex",
  "hmac 0.12.1",
  "hostname",
@@ -4493,6 +4506,9 @@ dependencies = [
  "log",
  "mail-parser",
  "nu-ansi-term 0.46.0",
+ "objc2 0.6.4",
+ "objc2-contacts",
+ "objc2-foundation 0.3.2",
  "once_cell",
  "opentelemetry",
  "opentelemetry-otlp",
@@ -4538,6 +4554,7 @@ dependencies = [
  "urlencoding",
  "uuid",
  "wait-timeout",
+ "walkdir",
  "webpki-roots 1.0.6",
  "whisper-rs",
  "xz2",
@@ -5420,7 +5437,7 @@ dependencies = [
  "once_cell",
  "socket2",
  "tracing",
- "windows-sys 0.59.0",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -5846,7 +5863,7 @@ dependencies = [
  "errno",
  "libc",
  "linux-raw-sys",
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -5905,7 +5922,7 @@ dependencies = [
  "security-framework",
  "security-framework-sys",
  "webpki-root-certs",
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -7236,7 +7253,7 @@ dependencies = [
  "getrandom 0.4.2",
  "once_cell",
  "rustix",
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -8534,7 +8551,7 @@ version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "windows-sys 0.48.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
diff --git a/app/src/components/settings/panels/LocalModelPanel.tsx b/app/src/components/settings/panels/LocalModelPanel.tsx
index 2d47e52e487..3a0b7b6d0cf 100644
--- a/app/src/components/settings/panels/LocalModelPanel.tsx
+++ b/app/src/components/settings/panels/LocalModelPanel.tsx
@@ -10,11 +10,13 @@ import {
   type ApplyPresetResult,
   type LocalAiDownloadsProgress,
   type LocalAiStatus,
+  openhumanGetConfig,
   openhumanLocalAiDownload,
   openhumanLocalAiDownloadAllAssets,
   openhumanLocalAiDownloadsProgress,
   openhumanLocalAiPresets,
   openhumanLocalAiStatus,
+  openhumanUpdateLocalAiSettings,
   type PresetsResponse,
 } from '../../../utils/tauriCommands';
 import SettingsHeader from '../components/SettingsHeader';
@@ -39,6 +41,22 @@ const LocalModelPanel = () => {
   const [presetError, setPresetError] = useState('');
   const [presetSuccess, setPresetSuccess] = useState<ApplyPresetResult | null>(null);
 
+  const [usageFlags, setUsageFlags] = useState<{
+    runtime_enabled: boolean;
+    usage_embeddings: boolean;
+    usage_heartbeat: boolean;
+    usage_learning_reflection: boolean;
+    usage_subconscious: boolean;
+  }>({
+    runtime_enabled: false,
+    usage_embeddings: false,
+    usage_heartbeat: false,
+    usage_learning_reflection: false,
+    usage_subconscious: false,
+  });
+  const [usageError, setUsageError] = useState('');
+  const [usageSaving, setUsageSaving] = useState(false);
+
   const progress = useMemo(() => {
     const downloadProgress = progressFromDownloads(downloads);
     if (downloadProgress != null) return downloadProgress;
@@ -87,9 +105,45 @@ const LocalModelPanel = () => {
     }
   };
 
+  const loadUsage = async () => {
+    try {
+      const snap = await openhumanGetConfig();
+      const localAi = (snap.result?.config?.local_ai ?? {}) as Record<string, unknown>;
+      const usage = (localAi.usage ?? {}) as Record<string, unknown>;
+      setUsageFlags({
+        runtime_enabled: Boolean(localAi.runtime_enabled),
+        usage_embeddings: Boolean(usage.embeddings),
+        usage_heartbeat: Boolean(usage.heartbeat),
+        usage_learning_reflection: Boolean(usage.learning_reflection),
+        usage_subconscious: Boolean(usage.subconscious),
+      });
+      setUsageError('');
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : 'Failed to load local AI flags';
+      setUsageError(msg);
+    }
+  };
+
+  const updateUsage = async (patch: Partial<typeof usageFlags>) => {
+    const next = { ...usageFlags, ...patch };
+    setUsageFlags(next);
+    setUsageSaving(true);
+    setUsageError('');
+    try {
+      await openhumanUpdateLocalAiSettings(patch);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : 'Failed to save local AI flags';
+      setUsageError(msg);
+      void loadUsage();
+    } finally {
+      setUsageSaving(false);
+    }
+  };
+
   useEffect(() => {
     void loadStatus();
     void loadPresets();
+    void loadUsage();
     const timer = setInterval(() => {
       void loadStatus();
     }, 1500);
@@ -212,6 +266,79 @@ const LocalModelPanel = () => {
           )}
         </section>
 
+        <section className="bg-stone-50 rounded-lg border border-stone-200 p-4 space-y-3">
+          <div>
+            <h3 className="text-sm font-semibold text-stone-900">Usage</h3>
+            <p className="text-xs text-stone-500 mt-0.5">
+              Choose which subsystems run on the local model. Anything off uses the cloud.
+            </p>
+          </div>
+
+          <label className="flex items-start gap-3 cursor-pointer">
+            <input
+              type="checkbox"
+              className="mt-0.5"
+              checked={usageFlags.runtime_enabled}
+              disabled={usageSaving}
+              onChange={e => void updateUsage({ runtime_enabled: e.target.checked })}
+            />
+            <div>
+              <div className="text-sm text-stone-900">Enable local AI runtime</div>
+              <div className="text-xs text-stone-500">
+                Master switch. Off by default — Ollama stays idle. When on, the tree summarizer,
+                screen intelligence, and autocomplete always use the local model.
+              </div>
+            </div>
+          </label>
+
+          <div className={`space-y-2 pl-6 ${usageFlags.runtime_enabled ? '' : 'opacity-50'}`}>
+            {(
+              [
+                {
+                  key: 'usage_embeddings' as const,
+                  label: 'Embeddings',
+                  hint: 'Generate memory embeddings locally instead of in the cloud.',
+                },
+                {
+                  key: 'usage_heartbeat' as const,
+                  label: 'Heartbeat',
+                  hint: 'Run heartbeat reasoning locally.',
+                },
+                {
+                  key: 'usage_learning_reflection' as const,
+                  label: 'Learning / reflection',
+                  hint: 'Run learning and reflection passes locally.',
+                },
+                {
+                  key: 'usage_subconscious' as const,
+                  label: 'Subconscious',
+                  hint: 'Run subconscious evaluation locally.',
+                },
+              ] as const
+            ).map(({ key, label, hint }) => (
+              <label key={key} className="flex items-start gap-3 cursor-pointer">
+                <input
+                  type="checkbox"
+                  className="mt-0.5"
+                  checked={usageFlags[key]}
+                  disabled={!usageFlags.runtime_enabled || usageSaving}
+                  onChange={e => void updateUsage({ [key]: e.target.checked })}
+                />
+                <div>
+                  <div className="text-sm text-stone-900">{label}</div>
+                  <div className="text-xs text-stone-500">{hint}</div>
+                </div>
+              </label>
+            ))}
+          </div>
+
+          {usageError && (
+            <div className="rounded-md border border-red-200 bg-red-50 p-3 text-xs text-red-600">
+              {usageError}
+            </div>
+          )}
+        </section>
+
         <button
           type="button"
           onClick={() => navigateToSettings('local-model-debug')}
diff --git a/app/src/components/settings/panels/__tests__/LocalModelPanel.test.tsx b/app/src/components/settings/panels/__tests__/LocalModelPanel.test.tsx
new file mode 100644
index 00000000000..d4c5249b8a3
--- /dev/null
+++ b/app/src/components/settings/panels/__tests__/LocalModelPanel.test.tsx
@@ -0,0 +1,203 @@
+import { fireEvent, screen, waitFor } from '@testing-library/react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { renderWithProviders } from '../../../../test/test-utils';
+import {
+  type CommandResponse,
+  type ConfigSnapshot,
+  isTauri,
+  type LocalAiDownloadsProgress,
+  type LocalAiStatus,
+  openhumanGetConfig,
+  openhumanLocalAiDownload,
+  openhumanLocalAiDownloadAllAssets,
+  openhumanLocalAiDownloadsProgress,
+  openhumanLocalAiPresets,
+  openhumanLocalAiStatus,
+  openhumanUpdateLocalAiSettings,
+  type PresetsResponse,
+} from '../../../../utils/tauriCommands';
+import LocalModelPanel from '../LocalModelPanel';
+
+vi.mock('../../../../utils/tauriCommands', () => ({
+  isTauri: vi.fn(() => true),
+  openhumanGetConfig: vi.fn(),
+  openhumanLocalAiDownload: vi.fn(),
+  openhumanLocalAiDownloadAllAssets: vi.fn(),
+  openhumanLocalAiDownloadsProgress: vi.fn(),
+  openhumanLocalAiPresets: vi.fn(),
+  openhumanLocalAiStatus: vi.fn(),
+  openhumanUpdateLocalAiSettings: vi.fn(),
+}));
+
+interface UsageFlags {
+  runtime_enabled: boolean;
+  embeddings: boolean;
+  heartbeat: boolean;
+  learning_reflection: boolean;
+  subconscious: boolean;
+}
+
+const defaultUsage: UsageFlags = {
+  runtime_enabled: false,
+  embeddings: false,
+  heartbeat: false,
+  learning_reflection: false,
+  subconscious: false,
+};
+
+const makeSnapshot = (flags: UsageFlags): CommandResponse<ConfigSnapshot> => ({
+  result: {
+    config: {
+      local_ai: {
+        runtime_enabled: flags.runtime_enabled,
+        usage: {
+          embeddings: flags.embeddings,
+          heartbeat: flags.heartbeat,
+          learning_reflection: flags.learning_reflection,
+          subconscious: flags.subconscious,
+        },
+      },
+    },
+    workspace_dir: '/tmp/openhuman-test',
+    config_path: '/tmp/openhuman-test/config.toml',
+  },
+  logs: [],
+});
+
+const idleStatus: LocalAiStatus = {
+  state: 'idle',
+  installed: false,
+  download_progress: null,
+  downloaded_bytes: null,
+  total_bytes: null,
+  download_speed_bps: null,
+  eta_seconds: null,
+  message: null,
+  selected_tier: null,
+} as unknown as LocalAiStatus;
+
+const idleDownloads: LocalAiDownloadsProgress = {
+  state: 'idle',
+  progress: null,
+  downloaded_bytes: null,
+  total_bytes: null,
+  speed_bps: null,
+  eta_seconds: null,
+} as unknown as LocalAiDownloadsProgress;
+
+const presets: PresetsResponse = {
+  presets: [],
+  selected_tier: null,
+  detected_ram_bytes: 16 * 1024 * 1024 * 1024,
+  local_ai_enabled: false,
+} as unknown as PresetsResponse;
+
+describe('LocalModelPanel — usage flags', () => {
+  let runtime: UsageFlags;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(isTauri).mockReturnValue(true);
+    runtime = { ...defaultUsage };
+
+    vi.mocked(openhumanLocalAiStatus).mockResolvedValue({ result: idleStatus, logs: [] });
+    vi.mocked(openhumanLocalAiDownloadsProgress).mockResolvedValue({
+      result: idleDownloads,
+      logs: [],
+    });
+    vi.mocked(openhumanLocalAiPresets).mockResolvedValue(presets);
+    vi.mocked(openhumanLocalAiDownload).mockResolvedValue({ result: idleStatus, logs: [] });
+    vi.mocked(openhumanLocalAiDownloadAllAssets).mockResolvedValue({
+      result: idleDownloads,
+      logs: [],
+    });
+
+    vi.mocked(openhumanGetConfig).mockImplementation(async () => makeSnapshot(runtime));
+    vi.mocked(openhumanUpdateLocalAiSettings).mockImplementation(async patch => {
+      runtime = {
+        runtime_enabled: patch.runtime_enabled ?? runtime.runtime_enabled,
+        embeddings: patch.usage_embeddings ?? runtime.embeddings,
+        heartbeat: patch.usage_heartbeat ?? runtime.heartbeat,
+        learning_reflection: patch.usage_learning_reflection ?? runtime.learning_reflection,
+        subconscious: patch.usage_subconscious ?? runtime.subconscious,
+      };
+      return makeSnapshot(runtime);
+    });
+  });
+
+  it('renders all five usage toggles with sub-flags disabled when runtime is off', async () => {
+    renderWithProviders(<LocalModelPanel />, { initialEntries: ['/settings/local-model'] });
+
+    await screen.findByText('Enable local AI runtime');
+    expect(screen.getByText('Embeddings')).toBeInTheDocument();
+    expect(screen.getByText('Heartbeat')).toBeInTheDocument();
+    expect(screen.getByText('Learning / reflection')).toBeInTheDocument();
+    expect(screen.getByText('Subconscious')).toBeInTheDocument();
+
+    // The four sub-flag inputs should be disabled while runtime is off
+    const checkboxes = screen.getAllByRole('checkbox');
+    const masterIdx = checkboxes.findIndex(cb =>
+      cb.closest('label')?.textContent?.includes('Enable local AI runtime')
+    );
+    expect(masterIdx).toBeGreaterThanOrEqual(0);
+    const subFlags = checkboxes.filter((_, i) => i !== masterIdx);
+    for (const cb of subFlags) {
+      expect(cb).toBeDisabled();
+    }
+  });
+
+  it('persists master toggle change via openhumanUpdateLocalAiSettings', async () => {
+    renderWithProviders(<LocalModelPanel />, { initialEntries: ['/settings/local-model'] });
+
+    const masterLabel = await screen.findByText('Enable local AI runtime');
+    const master = masterLabel.closest('label')?.querySelector('input[type="checkbox"]');
+    expect(master).toBeTruthy();
+    fireEvent.click(master as HTMLInputElement);
+
+    await waitFor(() => {
+      expect(openhumanUpdateLocalAiSettings).toHaveBeenCalledWith({ runtime_enabled: true });
+    });
+  });
+
+  it('surfaces an error when the initial config load fails', async () => {
+    vi.mocked(openhumanGetConfig).mockRejectedValueOnce(new Error('boom: get_config'));
+    renderWithProviders(<LocalModelPanel />, { initialEntries: ['/settings/local-model'] });
+    await screen.findByText('boom: get_config');
+  });
+
+  it('rolls state back and shows error when save fails', async () => {
+    runtime.runtime_enabled = true;
+    vi.mocked(openhumanUpdateLocalAiSettings).mockRejectedValueOnce(new Error('save: forbidden'));
+    // Initial load succeeds; the reload triggered after a save error fails
+    // too, so the error message is not immediately cleared by a successful
+    // refetch. This exercises the catch arm in `updateUsage`.
+    vi.mocked(openhumanGetConfig).mockImplementationOnce(async () => makeSnapshot(runtime));
+    vi.mocked(openhumanGetConfig).mockRejectedValueOnce(new Error('save: forbidden'));
+    renderWithProviders(<LocalModelPanel />, { initialEntries: ['/settings/local-model'] });
+
+    const heartbeatLabel = await screen.findByText('Heartbeat');
+    const cb = heartbeatLabel.closest('label')?.querySelector('input[type="checkbox"]');
+    fireEvent.click(cb as HTMLInputElement);
+
+    await waitFor(() => {
+      expect(openhumanUpdateLocalAiSettings).toHaveBeenCalledWith({ usage_heartbeat: true });
+    });
+    await screen.findByText('save: forbidden');
+  });
+
+  it('persists a sub-flag toggle once master is enabled', async () => {
+    runtime.runtime_enabled = true;
+    renderWithProviders(<LocalModelPanel />, { initialEntries: ['/settings/local-model'] });
+
+    const embeddingsLabel = await screen.findByText('Embeddings');
+    const checkbox = embeddingsLabel.closest('label')?.querySelector('input[type="checkbox"]');
+    expect(checkbox).toBeTruthy();
+    expect(checkbox as HTMLInputElement).not.toBeDisabled();
+    fireEvent.click(checkbox as HTMLInputElement);
+
+    await waitFor(() => {
+      expect(openhumanUpdateLocalAiSettings).toHaveBeenCalledWith({ usage_embeddings: true });
+    });
+  });
+});
diff --git a/app/src/hooks/useAppUpdate.ts b/app/src/hooks/useAppUpdate.ts
index 8e78305373b..1bd20c164ee 100644
--- a/app/src/hooks/useAppUpdate.ts
+++ b/app/src/hooks/useAppUpdate.ts
@@ -53,10 +53,10 @@ export interface UseAppUpdateOptions {
    * Default: true. Skipped when `isTauri()` is false.
    */
   autoCheck?: boolean;
-  /** Delay before the first auto-check fires, in ms. Default: 30_000. */
+  /** Delay before the first auto-check fires, in ms. Default: 5_000. */
   initialCheckDelayMs?: number;
   /**
-   * Repeat interval between background checks, in ms. Default: 4 * 60 * 60 * 1000.
+   * Repeat interval between background checks, in ms. Default: 15 * 60 * 1000.
    * Set to 0 (or a negative number) to disable repeating.
    */
   recheckIntervalMs?: number;
@@ -101,8 +101,8 @@ export interface UseAppUpdateResult {
   reset: () => void;
 }
 
-const DEFAULT_INITIAL_DELAY_MS = 30_000;
-const DEFAULT_RECHECK_INTERVAL_MS = 4 * 60 * 60 * 1000; // 4h
+const DEFAULT_INITIAL_DELAY_MS = 5_000;
+const DEFAULT_RECHECK_INTERVAL_MS = 15 * 60 * 1000; // 15m
 
 /** A short grace before the auto-download fires, so the UI can show the
  *  fact that an update was *detected* (briefly) before going into "downloading"
diff --git a/app/src/utils/tauriCommands/config.test.ts b/app/src/utils/tauriCommands/config.test.ts
new file mode 100644
index 00000000000..bea663a4c40
--- /dev/null
+++ b/app/src/utils/tauriCommands/config.test.ts
@@ -0,0 +1,47 @@
+import { isTauri } from '@tauri-apps/api/core';
+import { afterEach, beforeEach, describe, expect, type Mock, test, vi } from 'vitest';
+
+import { callCoreRpc } from '../../services/coreRpcClient';
+
+vi.mock('@tauri-apps/api/core', () => ({ invoke: vi.fn(), isTauri: vi.fn() }));
+vi.mock('../../services/coreRpcClient', () => ({ callCoreRpc: vi.fn() }));
+
+describe('tauriCommands/config', () => {
+  const mockIsTauri = isTauri as Mock;
+  const mockCallCoreRpc = callCoreRpc as Mock;
+  let openhumanUpdateLocalAiSettings: typeof import('./config').openhumanUpdateLocalAiSettings;
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    mockIsTauri.mockReturnValue(true);
+    const actual = await vi.importActual<typeof import('./config')>('./config');
+    openhumanUpdateLocalAiSettings = actual.openhumanUpdateLocalAiSettings;
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('openhumanUpdateLocalAiSettings', () => {
+    test('throws when not running in Tauri', async () => {
+      mockIsTauri.mockReturnValue(false);
+      await expect(openhumanUpdateLocalAiSettings({ runtime_enabled: true })).rejects.toThrow(
+        'Not running in Tauri'
+      );
+      expect(mockCallCoreRpc).not.toHaveBeenCalled();
+    });
+
+    test('forwards the patch to openhuman.update_local_ai_settings', async () => {
+      mockCallCoreRpc.mockResolvedValue({
+        result: { config: {}, workspace_dir: '/tmp', config_path: '/tmp/cfg.toml' },
+        logs: [],
+      });
+      const patch = { runtime_enabled: true, usage_embeddings: true, usage_subconscious: false };
+      await openhumanUpdateLocalAiSettings(patch);
+      expect(mockCallCoreRpc).toHaveBeenCalledWith({
+        method: 'openhuman.update_local_ai_settings',
+        params: patch,
+      });
+    });
+  });
+});
diff --git a/app/src/utils/tauriCommands/config.ts b/app/src/utils/tauriCommands/config.ts
index a1bb3be7662..84576c1fa36 100644
--- a/app/src/utils/tauriCommands/config.ts
+++ b/app/src/utils/tauriCommands/config.ts
@@ -64,6 +64,14 @@ export interface ScreenIntelligenceSettingsUpdate {
   denylist?: string[] | null;
 }
 
+export interface LocalAiSettingsUpdate {
+  runtime_enabled?: boolean | null;
+  usage_embeddings?: boolean | null;
+  usage_heartbeat?: boolean | null;
+  usage_learning_reflection?: boolean | null;
+  usage_subconscious?: boolean | null;
+}
+
 export interface RuntimeFlags {
   browser_allow_all: boolean;
   log_prompts: boolean;
@@ -161,6 +169,18 @@ export async function openhumanUpdateScreenIntelligenceSettings(
   });
 }
 
+export async function openhumanUpdateLocalAiSettings(
+  update: LocalAiSettingsUpdate
+): Promise<CommandResponse<ConfigSnapshot>> {
+  if (!isTauri()) {
+    throw new Error('Not running in Tauri');
+  }
+  return await callCoreRpc<CommandResponse<ConfigSnapshot>>({
+    method: 'openhuman.update_local_ai_settings',
+    params: update,
+  });
+}
+
 export async function openhumanUpdateAnalyticsSettings(update: {
   enabled?: boolean;
 }): Promise<CommandResponse<ConfigSnapshot>> {
diff --git a/app/src/utils/tauriCommands/localAi.ts b/app/src/utils/tauriCommands/localAi.ts
index cd5b61d55e7..c8427980d1a 100644
--- a/app/src/utils/tauriCommands/localAi.ts
+++ b/app/src/utils/tauriCommands/localAi.ts
@@ -181,7 +181,7 @@ export interface PresetsResponse {
   device: DeviceProfileResult;
   /** When true the device is below the RAM floor and cloud fallback is the recommended default. */
   recommend_disabled?: boolean;
-  /** Current value of `config.local_ai.enabled`. When false, cloud fallback is in use. */
+  /** Current value of `config.local_ai.runtime_enabled`. When false, cloud fallback is in use. */
   local_ai_enabled?: boolean;
 }
 
diff --git a/docs/AUTO_UPDATE.md b/docs/AUTO_UPDATE.md
index 89eed2156db..5845a382f3f 100644
--- a/docs/AUTO_UPDATE.md
+++ b/docs/AUTO_UPDATE.md
@@ -33,8 +33,8 @@ restarting | up_to_date | error`).
 
 ## User flow (Option 2: auto-download, prompt to restart)
 
-1. ~30 seconds after launch, the hook runs a silent `check_app_update`. It
-   re-checks every 4 hours.
+1. ~5 seconds after launch, the hook runs a silent `check_app_update`. It
+   re-checks every 15 minutes.
 2. If the manifest reports a newer version, the hook **automatically calls
    `download_app_update`** in the background — the user sees nothing.
 3. Once the bytes are staged, the Rust side emits `ready_to_install` and the
@@ -112,11 +112,11 @@ artifacts. Use this recipe.
    ./app/src-tauri/target/release/bundle/macos/OpenHuman.app/Contents/MacOS/OpenHuman
    ```
 
-   You should see `[app-update]` lines start to flow ~30 seconds after
+   You should see `[app-update]` lines start to flow ~5 seconds after
    launch (auto-check), or immediately after clicking
    **Settings → About → Check for updates**.
 
-4. **Trigger the check** — either wait ~30s for the auto-check, or open
+4. **Trigger the check** — either wait ~5s for the auto-check, or open
    **Settings → About** → **Check for updates**. The check is silent;
    the prompt appears only once the download has staged.
 
@@ -162,7 +162,7 @@ artifacts. Use this recipe.
   so the dev profile never produces a bundle the updater can swap in. Use
   `pnpm tauri build`.
 - **The banner never shows on first launch** — that's expected; the
-  initial probe is delayed 30s. To force it, click "Check for updates" in
+  initial probe is delayed 5s. To force it, click "Check for updates" in
   the About panel.
 
 ## Logs
diff --git a/src/openhuman/agent/triage/evaluator.rs b/src/openhuman/agent/triage/evaluator.rs
index 23eefe9987e..f08b15b9db8 100644
--- a/src/openhuman/agent/triage/evaluator.rs
+++ b/src/openhuman/agent/triage/evaluator.rs
@@ -43,7 +43,7 @@ use crate::openhuman::config::Config;
 use super::decision::{parse_triage_decision, ParseError, TriageDecision};
 use super::envelope::TriggerEnvelope;
 use super::events;
-use super::routing::{self, resolve_provider_with_config, ResolvedProvider};
+use super::routing::{resolve_provider_with_config, ResolvedProvider};
 
 /// Agent definition id for the built-in triage classifier. Hard-coded
 /// so a rogue workspace TOML can't override it to point at a different
@@ -88,46 +88,12 @@ pub async fn run_triage(envelope: &TriggerEnvelope) -> anyhow::Result<TriageRun>
         .await
         .context("resolving provider for triage turn")?;
 
-    // First attempt. On success, publish latency + return.
+    // Single attempt — triage always uses the remote provider.
+    // The local-AI retry path has been removed: used_local is always false
+    // so that branch could never fire, and mark_degraded no longer exists.
     match run_triage_with_resolved(resolved, envelope).await {
         Ok(run) => Ok(run),
-        Err(first_err)
-            if first_err
-                .downcast_ref::<TurnOutcomeFailure>()
-                .is_some_and(|f| f.used_local) =>
-        {
-            // Local turn failed — mark cache degraded, rebuild a remote
-            // provider from the SAME config, and retry once. If that
-            // also fails, publish `TriggerEscalationFailed` and return.
-            tracing::warn!(
-                error = %first_err,
-                "[triage::evaluator] local attempt failed — retrying on remote"
-            );
-            routing::mark_degraded().await;
-            let remote = resolve_provider_with_config(&config)
-                .await
-                .context("rebuilding remote provider for triage retry")?;
-            debug_assert!(!remote.used_local, "mark_degraded must force remote");
-            match run_triage_with_resolved(remote, envelope).await {
-                Ok(run) => {
-                    tracing::info!(
-                        label = %envelope.display_label,
-                        "[triage::evaluator] remote retry succeeded after local failure"
-                    );
-                    Ok(run)
-                }
-                Err(second_err) => {
-                    let reason =
-                        format!("local then remote both failed: {first_err} / {second_err}");
-                    events::publish_failed(envelope, &reason);
-                    Err(anyhow!(reason))
-                }
-            }
-        }
         Err(err) => {
-            // Remote attempt failed, or local attempt failed in a way
-            // that isn't eligible for retry (e.g. registry missing
-            // built-in — rebuilding won't help). Publish failure.
             let reason = format!("{err}");
             events::publish_failed(envelope, &reason);
             Err(err)
diff --git a/src/openhuman/agent/triage/routing.rs b/src/openhuman/agent/triage/routing.rs
index 87dfa33b491..a4d4b545c53 100644
--- a/src/openhuman/agent/triage/routing.rs
+++ b/src/openhuman/agent/triage/routing.rs
@@ -2,56 +2,18 @@
 //!
 //! ## What this does
 //!
-//! [`resolve_provider`] picks one of two paths for the next triage turn:
+//! [`resolve_provider`] always builds the remote provider. Local AI is never
+//! used for chat triage — the local path has been removed to guarantee that
+//! a triage turn never errors due to Ollama unavailability.
 //!
-//! - **Local** — wrap the bundled `LocalAiService` (Ollama) in a tiny
-//!   [`Provider`]-trait adapter so the existing `agent.run_turn` bus
-//!   dispatch flows through unchanged. Used when all of the following
-//!   hold:
-//!     1. `config.local_ai.enabled == true`
-//!     2. Current [`ModelTier`] from config is at or above
-//!        `Ram4To8Gb` — the decision locked in during planning (see
-//!        `linear-bouncing-lovelace.md`). Tiny 1B models are permitted
-//!        because the tolerant parser in `decision.rs` handles their
-//!        malformed JSON and the evaluator retries on remote if the
-//!        reply can't be parsed.
-//!     3. `LocalAiService::status().state == "ready"` — the service
-//!        singleton has finished bootstrap and is not installing /
-//!        downloading / degraded.
-//! - **Remote** — the existing `OpenHumanBackendProvider` via
-//!   `create_routed_provider_with_options`, same as commit 1.
-//!
-//! ## Caching
-//!
-//! The decision is cached in a process-wide `tokio::sync::Mutex<
-//! Option<CachedDecision>>` with a 60 s TTL. The first call in a window
-//! pays the config-load cost; subsequent calls reuse. A `Degraded` state
-//! (set by [`mark_degraded`]) forces remote for the rest of the window
-//! so a flaky local adapter can't thrash.
-//!
-//! ## No live network probe
-//!
-//! The plan floated a ~500 ms Ollama `/api/generate` probe inside the
-//! availability check. We deliberately skip that here because
-//! (a) the `LocalAiService` bootstrap state is already a coarse
-//! liveness signal, and (b) if the actual inference fails mid-turn the
-//! evaluator's retry-on-remote path covers the gap. That keeps
-//! `resolve_provider` free of hidden I/O and unit tests of the state
-//! machine don't need to stub a network transport.
+//! `ResolvedProvider.used_local` is preserved for telemetry compatibility but
+//! is always `false`.
 
 use std::sync::Arc;
-use std::time::{Duration, Instant};
 
 use anyhow::Context;
-use async_trait::async_trait;
-use tokio::sync::Mutex;
 
 use crate::openhuman::config::Config;
-use crate::openhuman::local_ai::{
-    self,
-    presets::{current_tier_from_config, ModelTier},
-    LocalAiService,
-};
 use crate::openhuman::providers::{self, Provider, ProviderRuntimeOptions, INFERENCE_BACKEND_ID};
 
 /// The concrete provider + metadata that [`crate::openhuman::agent::triage::evaluator::run_triage`]
@@ -59,49 +21,22 @@ use crate::openhuman::providers::{self, Provider, ProviderRuntimeOptions, INFERE
 pub struct ResolvedProvider {
     /// Ready-to-use provider, already constructed.
     pub provider: Arc<dyn Provider>,
-    /// Provider name token — `"openhuman"` for the remote backend and
-    /// `"local-ollama"` for the local path. Passed through unchanged
-    /// into `AgentTurnRequest::provider_name`.
+    /// Provider name token — always `"openhuman"` (remote backend).
+    /// Kept for telemetry / observability compat with the previous two-path design.
     pub provider_name: String,
     /// Model identifier — the concrete string `run_tool_call_loop`
     /// will hand to the provider.
     pub model: String,
-    /// `true` if this turn is running on the local LLM. Published in
-    /// `DomainEvent::TriggerEvaluated.used_local` for observability.
+    /// Always `false` — local AI is never used for triage.
+    /// Preserved so existing telemetry subscribers that read this field do not
+    /// need code changes.
     pub used_local: bool,
 }
 
-// ── Cache state machine ─────────────────────────────────────────────────
-
-/// Decision stored in the 60 s cache.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-enum CacheState {
-    /// Next turn runs on the local adapter.
-    Local,
-    /// Next turn runs on the remote backend.
-    Remote,
-    /// A previous local turn failed — force remote for the rest of the
-    /// TTL so we don't thrash when Ollama is flaky.
-    Degraded,
-}
-
-#[derive(Clone, Copy, Debug)]
-struct CachedDecision {
-    at: Instant,
-    state: CacheState,
-}
-
-const CACHE_TTL: Duration = Duration::from_secs(60);
-
-/// Process-wide decision cache. `tokio::sync::Mutex::const_new` allows a
-/// `static` without a `Lazy`/`OnceLock` wrapper.
-static DECISION_CACHE: Mutex<Option<CachedDecision>> = Mutex::const_new(None);
-
 // ── Public API ──────────────────────────────────────────────────────────
 
-/// Resolve a provider for a single triage turn. Consults the cache,
-/// constructs the chosen provider, and returns a fully-formed
-/// [`ResolvedProvider`].
+/// Resolve a provider for a single triage turn. Always returns the remote
+/// backend — local AI is hard-disabled for the chat/triage path.
 pub async fn resolve_provider() -> anyhow::Result<ResolvedProvider> {
     let config = Config::load_or_init()
         .await
@@ -110,125 +45,16 @@ pub async fn resolve_provider() -> anyhow::Result<ResolvedProvider> {
 }
 
 /// Inner half of [`resolve_provider`] that takes an already-loaded
-/// [`Config`]. Exposed so the evaluator's "retry on remote after local
-/// failure" path can reuse the same config it already loaded for the
-/// first attempt.
+/// [`Config`]. Exposed for tests and for the evaluator's retry path.
 pub async fn resolve_provider_with_config(config: &Config) -> anyhow::Result<ResolvedProvider> {
-    let state = decide_with_cache(config).await;
     tracing::debug!(
-        ?state,
-        local_enabled = config.local_ai.enabled,
-        "[triage::routing] resolving provider"
+        runtime_enabled = config.local_ai.runtime_enabled,
+        "[triage::routing] resolving provider (always remote)"
     );
-    match state {
-        CacheState::Local => match build_local_provider(config) {
-            Ok(resolved) => Ok(resolved),
-            Err(err) => {
-                tracing::warn!(
-                    error = %err,
-                    "[triage::routing] local provider build failed — falling back to remote"
-                );
-                mark_degraded_internal().await;
-                build_remote_provider(config)
-            }
-        },
-        CacheState::Remote | CacheState::Degraded => build_remote_provider(config),
-    }
-}
-
-/// Force the next turn onto remote regardless of the cached decision.
-/// Called by the evaluator after a local turn fails so subsequent
-/// triggers in the same TTL window don't re-hit the broken local path.
-pub async fn mark_degraded() {
-    mark_degraded_internal().await;
-}
-
-/// Snapshot of the cache for ops debugging / tests. Returns the raw
-/// decision + how much of the TTL is left in milliseconds.
-#[derive(Debug, Clone, Copy)]
-pub struct CacheSnapshot {
-    pub state: &'static str,
-    pub ttl_remaining_ms: u128,
-}
-
-pub async fn cache_snapshot() -> Option<CacheSnapshot> {
-    let cache = DECISION_CACHE.lock().await;
-    cache.map(|c| CacheSnapshot {
-        state: match c.state {
-            CacheState::Local => "local",
-            CacheState::Remote => "remote",
-            CacheState::Degraded => "degraded",
-        },
-        ttl_remaining_ms: CACHE_TTL.saturating_sub(c.at.elapsed()).as_millis(),
-    })
-}
-
-// ── Cache helpers ───────────────────────────────────────────────────────
-
-async fn mark_degraded_internal() {
-    let mut cache = DECISION_CACHE.lock().await;
-    *cache = Some(CachedDecision {
-        at: Instant::now(),
-        state: CacheState::Degraded,
-    });
-}
-
-async fn decide_with_cache(config: &Config) -> CacheState {
-    {
-        let cache = DECISION_CACHE.lock().await;
-        if let Some(cached) = *cache {
-            if cached.at.elapsed() < CACHE_TTL {
-                return cached.state;
-            }
-        }
-    }
-    let state = decide_fresh(config);
-    let mut cache = DECISION_CACHE.lock().await;
-    *cache = Some(CachedDecision {
-        at: Instant::now(),
-        state,
-    });
-    state
-}
-
-/// Pure decision function — no I/O beyond `LocalAiService::status()`
-/// (which is a `parking_lot::Mutex::lock().clone()` on a cached struct,
-/// so effectively free). Cheap enough to call on every cache refresh.
-fn decide_fresh(config: &Config) -> CacheState {
-    if !config.local_ai.enabled {
-        return CacheState::Remote;
-    }
-    let tier = current_tier_from_config(&config.local_ai);
-    if tier_score(tier) < tier_score(ModelTier::Ram4To8Gb) {
-        tracing::debug!(?tier, "[triage::routing] tier below floor — forcing remote");
-        return CacheState::Remote;
-    }
-    let service = local_ai::global(config);
-    let state = service.status().state;
-    if state != "ready" {
-        tracing::debug!(
-            service_state = %state,
-            "[triage::routing] LocalAiService not ready — forcing remote"
-        );
-        return CacheState::Remote;
-    }
-    CacheState::Local
-}
-
-fn tier_score(tier: ModelTier) -> u8 {
-    match tier {
-        ModelTier::Ram1Gb => 1,
-        ModelTier::Ram2To4Gb => 2,
-        ModelTier::Ram4To8Gb => 3,
-        ModelTier::Ram8To16Gb => 4,
-        ModelTier::Ram16PlusGb => 5,
-        // Custom means the user wired their own model IDs explicitly
-        // and should be trusted — same priority as the highest preset.
-        ModelTier::Custom => 5,
-    }
+    build_remote_provider(config)
 }
 
-// ── Provider builders ───────────────────────────────────────────────────
+// ── Provider builder ────────────────────────────────────────────────────
 
 /// Build the default remote routed backend provider. Same wiring as
 /// `local_ai::ops::agent_chat_simple` uses so we stay consistent with
@@ -269,76 +95,6 @@ fn build_remote_provider(config: &Config) -> anyhow::Result<ResolvedProvider> {
     })
 }
 
-/// Build a [`Provider`]-trait adapter over the bundled
-/// [`LocalAiService`] so local triage turns can flow through the same
-/// `agent.run_turn` bus dispatch the remote path uses. Constructed
-/// fresh per turn — the underlying `LocalAiService` is an `Arc`
-/// singleton so the wrapper itself is essentially free.
-fn build_local_provider(config: &Config) -> anyhow::Result<ResolvedProvider> {
-    let service = local_ai::global(config);
-    let model = crate::openhuman::local_ai::model_ids::effective_chat_model_id(config);
-    let adapter = LocalAiAdapter {
-        service,
-        config: config.clone(),
-    };
-    tracing::debug!(
-        model = %model,
-        "[triage::routing] resolved local provider"
-    );
-    Ok(ResolvedProvider {
-        provider: Arc::new(adapter),
-        provider_name: "local-ollama".to_string(),
-        model,
-        used_local: true,
-    })
-}
-
-/// Minimal [`Provider`] implementation over [`LocalAiService`].
-///
-/// We only implement the single required method — `chat_with_system` —
-/// and let the trait's default impls handle `chat_with_history`,
-/// `chat`, `simple_chat`, etc. For triage the path reduces to:
-///
-/// ```text
-/// agent.run_turn → run_tool_call_loop → (no tools) → chat_with_history
-///                → (default) → chat_with_system → LocalAiService::inference_with_temperature
-/// ```
-///
-/// The triage agent has `named = []`, so the tool path is never taken.
-struct LocalAiAdapter {
-    service: Arc<LocalAiService>,
-    /// Owned snapshot — we need it for every `inference_with_temperature`
-    /// call because that API takes `&Config` for model-id resolution.
-    config: Config,
-}
-
-#[async_trait]
-impl Provider for LocalAiAdapter {
-    async fn chat_with_system(
-        &self,
-        system_prompt: Option<&str>,
-        message: &str,
-        _model: &str,
-        temperature: f64,
-    ) -> anyhow::Result<String> {
-        // `_model` is ignored — `LocalAiService` resolves its own chat
-        // model via `effective_chat_model_id(config)`. If we ever want
-        // per-call model override we'll thread it through a tweaked
-        // config clone, but the triage path only cares about the
-        // configured default anyway.
-        let system = system_prompt.unwrap_or("You are a helpful assistant.");
-        // Clamp temperature to f32 — LocalAiService API uses f32 whereas
-        // the Provider trait uses f64.
-        let temp = temperature as f32;
-        // Small max_tokens is fine: triage replies are a few dozen
-        // tokens at most (short JSON decision block).
-        self.service
-            .inference_with_temperature(&self.config, system, message, Some(512), true, temp)
-            .await
-            .map_err(|e| anyhow::anyhow!("local AI inference failed: {e}"))
-    }
-}
-
 // ── Tests ───────────────────────────────────────────────────────────────
 
 #[cfg(test)]
diff --git a/src/openhuman/agent/triage/routing_tests.rs b/src/openhuman/agent/triage/routing_tests.rs
index a6b71815a34..c128f218322 100644
--- a/src/openhuman/agent/triage/routing_tests.rs
+++ b/src/openhuman/agent/triage/routing_tests.rs
@@ -1,106 +1,9 @@
 use super::*;
-use crate::openhuman::local_ai::presets::apply_preset_to_config;
-
-/// Reset the cache between tests so they don't observe each
-/// other's state. Called at the top of every cache-state test.
-async fn clear_cache() {
-    let mut cache = DECISION_CACHE.lock().await;
-    *cache = None;
-}
-
-#[test]
-fn tier_score_orders_ascending_by_capability() {
-    assert!(tier_score(ModelTier::Ram1Gb) < tier_score(ModelTier::Ram2To4Gb));
-    assert!(tier_score(ModelTier::Ram2To4Gb) < tier_score(ModelTier::Ram4To8Gb));
-    assert!(tier_score(ModelTier::Ram4To8Gb) < tier_score(ModelTier::Ram8To16Gb));
-    assert!(tier_score(ModelTier::Ram8To16Gb) < tier_score(ModelTier::Ram16PlusGb));
-    assert_eq!(
-        tier_score(ModelTier::Custom),
-        tier_score(ModelTier::Ram16PlusGb)
-    );
-}
-
-#[test]
-fn tier_score_floor_is_ram_4_to_8_gb() {
-    // Anything below the floor must be rejected.
-    let floor = tier_score(ModelTier::Ram4To8Gb);
-    assert!(tier_score(ModelTier::Ram1Gb) < floor);
-    assert!(tier_score(ModelTier::Ram2To4Gb) < floor);
-    // And anything at or above must pass.
-    assert!(tier_score(ModelTier::Ram4To8Gb) >= floor);
-    assert!(tier_score(ModelTier::Ram8To16Gb) >= floor);
-    assert!(tier_score(ModelTier::Ram16PlusGb) >= floor);
-    assert!(tier_score(ModelTier::Custom) >= floor);
-}
 
 fn test_config() -> Config {
     Config::default()
 }
 
-#[test]
-fn decide_fresh_returns_remote_when_local_disabled() {
-    let mut config = test_config();
-    config.local_ai.enabled = false;
-    assert_eq!(decide_fresh(&config), CacheState::Remote);
-}
-
-#[tokio::test]
-async fn mark_degraded_forces_remote_on_next_resolve() {
-    // Note: no assertion on cache-starts-empty — parallel tests
-    // share the global static and can race with clear_cache. The
-    // important invariant is: after mark_degraded, snapshot is
-    // Degraded with a positive TTL.
-    clear_cache().await;
-    mark_degraded().await;
-    let snap = cache_snapshot()
-        .await
-        .expect("cache seeded by mark_degraded");
-    assert_eq!(snap.state, "degraded");
-    assert!(snap.ttl_remaining_ms <= CACHE_TTL.as_millis());
-}
-
-#[tokio::test]
-async fn decide_with_cache_respects_ttl_window() {
-    clear_cache().await;
-    // Prime the cache manually so we don't need to stub config IO.
-    {
-        let mut guard = DECISION_CACHE.lock().await;
-        *guard = Some(CachedDecision {
-            at: Instant::now(),
-            state: CacheState::Degraded,
-        });
-    }
-    // Within TTL, decide_with_cache should return the cached state
-    // without recomputing. Since the cached state is `Degraded` and
-    // default config would normally pick `Remote`, the fact that we
-    // observe `Degraded` proves the cache was hit.
-    let state = decide_with_cache(&test_config()).await;
-    assert!(matches!(state, CacheState::Degraded | CacheState::Remote));
-}
-
-#[tokio::test]
-async fn cache_snapshot_returns_none_when_empty_and_refreshes_expired_entries() {
-    clear_cache().await;
-    assert!(cache_snapshot().await.is_none());
-
-    {
-        let mut guard = DECISION_CACHE.lock().await;
-        *guard = Some(CachedDecision {
-            at: Instant::now() - CACHE_TTL - Duration::from_secs(1),
-            state: CacheState::Degraded,
-        });
-    }
-
-    let mut config = test_config();
-    config.local_ai.enabled = false;
-    let refreshed = decide_with_cache(&config).await;
-    assert_eq!(refreshed, CacheState::Remote);
-
-    let snap = cache_snapshot().await.expect("cache should be repopulated");
-    assert_eq!(snap.state, "remote");
-    assert!(snap.ttl_remaining_ms > 0);
-}
-
 #[test]
 fn build_remote_provider_uses_backend_id_and_default_model() {
     let config = test_config();
@@ -110,65 +13,37 @@ fn build_remote_provider_uses_backend_id_and_default_model() {
         resolved.model,
         crate::openhuman::config::DEFAULT_MODEL.to_string()
     );
-    assert!(!resolved.used_local);
+    assert!(!resolved.used_local, "used_local is always false");
 }
 
 #[test]
-fn decide_fresh_returns_local_when_service_ready_and_tier_is_high_enough() {
-    let _guard = crate::openhuman::local_ai::LOCAL_AI_TEST_MUTEX
-        .lock()
-        .expect("local ai test mutex poisoned");
+fn build_remote_provider_uses_configured_default_model() {
     let mut config = test_config();
-    config.local_ai.enabled = true;
-    apply_preset_to_config(&mut config.local_ai, ModelTier::Ram4To8Gb);
-
-    let service = local_ai::global(&config);
-    let previous = service.status.lock().state.clone();
-    service.status.lock().state = "ready".into();
-
-    let decision = decide_fresh(&config);
-    service.status.lock().state = previous;
-
-    assert_eq!(decision, CacheState::Local);
+    config.default_model = Some("custom-model-v1".to_string());
+    let resolved = build_remote_provider(&config).expect("remote provider should build");
+    assert_eq!(resolved.model, "custom-model-v1");
+    assert!(!resolved.used_local);
 }
 
-#[test]
-fn build_local_provider_uses_local_metadata() {
+#[tokio::test]
+async fn resolve_provider_with_config_always_returns_remote() {
+    // Even when runtime_enabled is true, triage must always use remote.
     let mut config = test_config();
-    config.local_ai.enabled = true;
-    apply_preset_to_config(&mut config.local_ai, ModelTier::Ram4To8Gb);
-
-    let resolved = build_local_provider(&config).expect("local provider should build");
-    assert_eq!(resolved.provider_name, "local-ollama");
-    assert!(!resolved.model.is_empty());
-    assert!(resolved.used_local);
+    config.local_ai.runtime_enabled = true;
+    let resolved = resolve_provider_with_config(&config)
+        .await
+        .expect("resolve should succeed");
+    assert!(!resolved.used_local, "triage must never use local AI");
+    assert_eq!(resolved.provider_name, INFERENCE_BACKEND_ID);
 }
 
 #[tokio::test]
-async fn resolve_provider_with_config_uses_local_and_remote_paths() {
-    let _guard = crate::openhuman::local_ai::LOCAL_AI_TEST_MUTEX
-        .lock()
-        .expect("local ai test mutex poisoned");
-    clear_cache().await;
-
+async fn resolve_provider_with_config_returns_remote_when_local_disabled() {
     let mut config = test_config();
-    config.local_ai.enabled = true;
-    apply_preset_to_config(&mut config.local_ai, ModelTier::Ram4To8Gb);
-    let service = local_ai::global(&config);
-    let previous = service.status.lock().state.clone();
-    service.status.lock().state = "ready".into();
-
-    let local = resolve_provider_with_config(&config)
-        .await
-        .expect("local provider should resolve");
-    assert!(local.used_local);
-    assert_eq!(local.provider_name, "local-ollama");
-
-    mark_degraded().await;
-    let remote = resolve_provider_with_config(&config)
+    config.local_ai.runtime_enabled = false;
+    let resolved = resolve_provider_with_config(&config)
         .await
-        .expect("degraded cache should force remote");
-    service.status.lock().state = previous;
-    assert!(!remote.used_local);
-    assert_eq!(remote.provider_name, INFERENCE_BACKEND_ID);
+        .expect("resolve should succeed");
+    assert!(!resolved.used_local);
+    assert_eq!(resolved.provider_name, INFERENCE_BACKEND_ID);
 }
diff --git a/src/openhuman/channels/providers/presentation.rs b/src/openhuman/channels/providers/presentation.rs
index 7833d72f3fc..bd2cd7136e9 100644
--- a/src/openhuman/channels/providers/presentation.rs
+++ b/src/openhuman/channels/providers/presentation.rs
@@ -377,7 +377,7 @@ async fn try_reaction(user_message: &str) -> Option<String> {
         Err(_) => return None,
     };
 
-    if !config.local_ai.enabled {
+    if !config.local_ai.runtime_enabled {
         return None;
     }
 
diff --git a/src/openhuman/config/ops.rs b/src/openhuman/config/ops.rs
index 839741c7e91..b28e19e4194 100644
--- a/src/openhuman/config/ops.rs
+++ b/src/openhuman/config/ops.rs
@@ -219,6 +219,15 @@ pub struct AnalyticsSettingsPatch {
     pub enabled: Option<bool>,
 }
 
+#[derive(Debug, Clone, Default)]
+pub struct LocalAiSettingsPatch {
+    pub runtime_enabled: Option<bool>,
+    pub usage_embeddings: Option<bool>,
+    pub usage_heartbeat: Option<bool>,
+    pub usage_learning_reflection: Option<bool>,
+    pub usage_subconscious: Option<bool>,
+}
+
 #[derive(Debug, Clone, Serialize)]
 pub struct RuntimeFlagsOut {
     pub browser_allow_all: bool,
@@ -486,6 +495,45 @@ pub async fn load_and_apply_browser_settings(
     apply_browser_settings(&mut config, update).await
 }
 
+/// Updates the local-AI runtime + per-feature usage flags in the configuration.
+pub async fn apply_local_ai_settings(
+    config: &mut Config,
+    update: LocalAiSettingsPatch,
+) -> Result<RpcOutcome<serde_json::Value>, String> {
+    if let Some(v) = update.runtime_enabled {
+        config.local_ai.runtime_enabled = v;
+    }
+    if let Some(v) = update.usage_embeddings {
+        config.local_ai.usage.embeddings = v;
+    }
+    if let Some(v) = update.usage_heartbeat {
+        config.local_ai.usage.heartbeat = v;
+    }
+    if let Some(v) = update.usage_learning_reflection {
+        config.local_ai.usage.learning_reflection = v;
+    }
+    if let Some(v) = update.usage_subconscious {
+        config.local_ai.usage.subconscious = v;
+    }
+    config.save().await.map_err(|e| e.to_string())?;
+    let snapshot = snapshot_config_json(config)?;
+    Ok(RpcOutcome::new(
+        snapshot,
+        vec![format!(
+            "local AI settings saved to {}",
+            config.config_path.display()
+        )],
+    ))
+}
+
+/// Loads the configuration, applies local-AI settings updates, and saves it.
+pub async fn load_and_apply_local_ai_settings(
+    update: LocalAiSettingsPatch,
+) -> Result<RpcOutcome<serde_json::Value>, String> {
+    let mut config = load_config_with_timeout().await?;
+    apply_local_ai_settings(&mut config, update).await
+}
+
 /// Resolves the effective API URL from configuration or defaults.
 pub async fn load_and_resolve_api_url() -> Result<RpcOutcome<serde_json::Value>, String> {
     let config = load_config_with_timeout().await?;
diff --git a/src/openhuman/config/schema/local_ai.rs b/src/openhuman/config/schema/local_ai.rs
index 2eec92e1a13..3315cd3da4e 100644
--- a/src/openhuman/config/schema/local_ai.rs
+++ b/src/openhuman/config/schema/local_ai.rs
@@ -3,10 +3,48 @@
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
+/// Per-feature flags controlling which subsystems route through the local
+/// Ollama runtime. All default to `false` (use cloud instead). Guarded by
+/// `LocalAiConfig::runtime_enabled` — when that is `false` every helper
+/// method below returns `false` regardless of these values.
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+pub struct LocalAiUsage {
+    /// When true (and `runtime_enabled`), use the local model for embedding
+    /// generation instead of the cloud backend.
+    #[serde(default)]
+    pub embeddings: bool,
+    /// When true (and `runtime_enabled`), use the local model inside the
+    /// heartbeat loop.
+    #[serde(default)]
+    pub heartbeat: bool,
+    /// When true (and `runtime_enabled`), use the local model for
+    /// learning/reflection passes.
+    #[serde(default)]
+    pub learning_reflection: bool,
+    /// When true (and `runtime_enabled`), use the local model for
+    /// subconscious evaluation and execution.
+    #[serde(default)]
+    pub subconscious: bool,
+}
+
+impl Default for LocalAiUsage {
+    fn default() -> Self {
+        Self {
+            embeddings: false,
+            heartbeat: false,
+            learning_reflection: false,
+            subconscious: false,
+        }
+    }
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
 pub struct LocalAiConfig {
-    #[serde(default = "default_enabled")]
-    pub enabled: bool,
+    /// Master runtime switch. Defaults to `false` — Ollama is OFF by default.
+    /// Note: the old on-disk field was `enabled`; that key is now unknown to
+    /// serde and will be silently ignored on load (intentional forced reset).
+    #[serde(default = "default_runtime_enabled")]
+    pub runtime_enabled: bool,
     #[serde(default = "default_provider")]
     pub provider: String,
     #[serde(default)]
@@ -64,10 +102,14 @@ pub struct LocalAiConfig {
     /// local LLM to fix grammar/punctuation using conversation context.
     #[serde(default = "default_voice_llm_cleanup_enabled")]
     pub voice_llm_cleanup_enabled: bool,
+    /// Per-feature flags. Each gate is AND-ed with `runtime_enabled`.
+    /// All default to `false` (cloud path).
+    #[serde(default)]
+    pub usage: LocalAiUsage,
 }
 
-fn default_enabled() -> bool {
-    true
+fn default_runtime_enabled() -> bool {
+    false
 }
 
 fn default_provider() -> String {
@@ -155,10 +197,38 @@ fn default_voice_llm_cleanup_enabled() -> bool {
     true
 }
 
+impl LocalAiConfig {
+    /// Returns `true` when the local Ollama runtime is active.
+    /// This is the primary gate; all per-feature helpers below AND with this.
+    pub fn is_active(&self) -> bool {
+        self.runtime_enabled
+    }
+
+    /// Use the local model for embedding generation.
+    pub fn use_local_for_embeddings(&self) -> bool {
+        self.runtime_enabled && self.usage.embeddings
+    }
+
+    /// Use the local model inside the heartbeat loop.
+    pub fn use_local_for_heartbeat(&self) -> bool {
+        self.runtime_enabled && self.usage.heartbeat
+    }
+
+    /// Use the local model for learning/reflection passes.
+    pub fn use_local_for_learning(&self) -> bool {
+        self.runtime_enabled && self.usage.learning_reflection
+    }
+
+    /// Use the local model for subconscious evaluation and execution.
+    pub fn use_local_for_subconscious(&self) -> bool {
+        self.runtime_enabled && self.usage.subconscious
+    }
+}
+
 impl Default for LocalAiConfig {
     fn default() -> Self {
         Self {
-            enabled: default_enabled(),
+            runtime_enabled: default_runtime_enabled(),
             provider: default_provider(),
             base_url: None,
             api_key: None,
@@ -183,6 +253,7 @@ impl Default for LocalAiConfig {
             ollama_binary_path: None,
             whisper_in_process: default_whisper_in_process(),
             voice_llm_cleanup_enabled: default_voice_llm_cleanup_enabled(),
+            usage: LocalAiUsage::default(),
         }
     }
 }
diff --git a/src/openhuman/config/schema/mod.rs b/src/openhuman/config/schema/mod.rs
index 337043db27d..44e5a749cb1 100644
--- a/src/openhuman/config/schema/mod.rs
+++ b/src/openhuman/config/schema/mod.rs
@@ -44,7 +44,7 @@ pub use dictation::{DictationActivationMode, DictationConfig};
 pub use heartbeat_cron::{CronConfig, HeartbeatConfig};
 pub use identity_cost::{CostConfig, ModelPricing};
 pub use learning::{LearningConfig, ReflectionSource};
-pub use local_ai::LocalAiConfig;
+pub use local_ai::{LocalAiConfig, LocalAiUsage};
 pub use node::NodeConfig;
 pub use observability::ObservabilityConfig;
 pub use proxy::{
diff --git a/src/openhuman/config/schemas.rs b/src/openhuman/config/schemas.rs
index e5d412288b5..252cab35cae 100644
--- a/src/openhuman/config/schemas.rs
+++ b/src/openhuman/config/schemas.rs
@@ -57,6 +57,15 @@ struct AnalyticsSettingsUpdate {
     enabled: Option<bool>,
 }
 
+#[derive(Debug, Deserialize)]
+struct LocalAiSettingsUpdate {
+    runtime_enabled: Option<bool>,
+    usage_embeddings: Option<bool>,
+    usage_heartbeat: Option<bool>,
+    usage_learning_reflection: Option<bool>,
+    usage_subconscious: Option<bool>,
+}
+
 #[derive(Debug, Deserialize)]
 struct SetBrowserAllowAllParams {
     enabled: bool,
@@ -108,6 +117,7 @@ pub fn all_controller_schemas() -> Vec<ControllerSchema> {
         schemas("update_screen_intelligence_settings"),
         schemas("update_runtime_settings"),
         schemas("update_browser_settings"),
+        schemas("update_local_ai_settings"),
         schemas("resolve_api_url"),
         schemas("get_runtime_flags"),
         schemas("set_browser_allow_all"),
@@ -156,6 +166,10 @@ pub fn all_registered_controllers() -> Vec<RegisteredController> {
             schema: schemas("update_browser_settings"),
             handler: handle_update_browser_settings,
         },
+        RegisteredController {
+            schema: schemas("update_local_ai_settings"),
+            handler: handle_update_local_ai_settings,
+        },
         RegisteredController {
             schema: schemas("resolve_api_url"),
             handler: handle_resolve_api_url,
@@ -359,6 +373,35 @@ pub fn schemas(function: &str) -> ControllerSchema {
             inputs: vec![optional_bool("enabled", "Enable browser integration.")],
             outputs: vec![json_output("snapshot", "Updated config snapshot.")],
         },
+        "update_local_ai_settings" => ControllerSchema {
+            namespace: "config",
+            function: "update_local_ai_settings",
+            description:
+                "Update the local AI runtime master switch and per-feature usage flags.",
+            inputs: vec![
+                optional_bool(
+                    "runtime_enabled",
+                    "Master switch — when false, no subsystem uses the local Ollama runtime.",
+                ),
+                optional_bool(
+                    "usage_embeddings",
+                    "Use the local model for embedding generation (when runtime_enabled).",
+                ),
+                optional_bool(
+                    "usage_heartbeat",
+                    "Use the local model inside the heartbeat loop (when runtime_enabled).",
+                ),
+                optional_bool(
+                    "usage_learning_reflection",
+                    "Use the local model for learning/reflection passes (when runtime_enabled).",
+                ),
+                optional_bool(
+                    "usage_subconscious",
+                    "Use the local model for subconscious evaluation (when runtime_enabled).",
+                ),
+            ],
+            outputs: vec![json_output("snapshot", "Updated config snapshot.")],
+        },
         "resolve_api_url" => ControllerSchema {
             namespace: "config",
             function: "resolve_api_url",
@@ -674,6 +717,20 @@ fn handle_update_browser_settings(params: Map<String, Value>) -> ControllerFutur
     })
 }
 
+fn handle_update_local_ai_settings(params: Map<String, Value>) -> ControllerFuture {
+    Box::pin(async move {
+        let update = deserialize_params::<LocalAiSettingsUpdate>(params)?;
+        let patch = config_rpc::LocalAiSettingsPatch {
+            runtime_enabled: update.runtime_enabled,
+            usage_embeddings: update.usage_embeddings,
+            usage_heartbeat: update.usage_heartbeat,
+            usage_learning_reflection: update.usage_learning_reflection,
+            usage_subconscious: update.usage_subconscious,
+        };
+        to_json(config_rpc::load_and_apply_local_ai_settings(patch).await?)
+    })
+}
+
 fn handle_get_runtime_flags(_params: Map<String, Value>) -> ControllerFuture {
     Box::pin(async { to_json(config_rpc::get_runtime_flags()) })
 }
diff --git a/src/openhuman/credentials/ops.rs b/src/openhuman/credentials/ops.rs
index b396127bfbf..b21e249b49d 100644
--- a/src/openhuman/credentials/ops.rs
+++ b/src/openhuman/credentials/ops.rs
@@ -25,7 +25,7 @@ use crate::openhuman::memory::conversations;
 /// fresh login.
 pub async fn start_login_gated_services(config: &Config) {
     // 1. Local AI (Ollama, whisper, embeddings)
-    if config.local_ai.enabled {
+    if config.local_ai.runtime_enabled {
         let service = crate::openhuman::local_ai::global(config);
         service.bootstrap(config).await;
         log::info!("[services] local AI bootstrapped after login");
@@ -77,7 +77,7 @@ pub async fn stop_login_gated_services(config: &Config) {
     // 4. Local AI — reset state to idle. We don't kill the Ollama process
     //    (it may be serving other clients or mid-download), but we clear
     //    the internal state so it re-bootstraps on next login.
-    if config.local_ai.enabled {
+    if config.local_ai.runtime_enabled {
         let service = crate::openhuman::local_ai::global(config);
         service.reset_to_idle(config);
         log::info!("[services] local AI reset to idle on logout");
diff --git a/src/openhuman/learning/reflection.rs b/src/openhuman/learning/reflection.rs
index e3bd8926111..790c044610a 100644
--- a/src/openhuman/learning/reflection.rs
+++ b/src/openhuman/learning/reflection.rs
@@ -155,6 +155,16 @@ impl ReflectionHook {
     async fn run_reflection(&self, prompt: &str) -> anyhow::Result<String> {
         match self.config.reflection_source {
             ReflectionSource::Local => {
+                // Gate: local reflection requires the per-feature flag.
+                // When off, no-op silently rather than erroring the turn.
+                // TODO: wire a cloud fallback here when use_local_for_learning is false.
+                if !self.full_config.local_ai.use_local_for_learning() {
+                    tracing::info!(
+                        "[learning::reflection] local_ai.usage.learning_reflection not enabled — \
+                         skipping local reflection (no cloud fallback configured for this subsystem)"
+                    );
+                    return Ok(String::new());
+                }
                 // Local reflection acquires the scheduler_gate LLM
                 // permit transitively through `service.prompt` →
                 // `inference_with_temperature_internal`. Cloud
@@ -434,6 +444,17 @@ impl PostTurnHook for ReflectionHook {
             }
         };
 
+        // Empty response is the sentinel `run_reflection` uses when the
+        // local-only `use_local_for_learning` gate is off. Don't burn quota
+        // on an empty parse — clean-skip without storing a blank record.
+        if raw.trim().is_empty() {
+            self.rollback_increment(&session_key);
+            log::debug!(
+                "[learning] reflection skipped (empty response — gate off or local AI unavailable)"
+            );
+            return Ok(());
+        }
+
         let output = Self::parse_reflection(&raw);
 
         log::info!(
diff --git a/src/openhuman/local_ai/ops_tests.rs b/src/openhuman/local_ai/ops_tests.rs
index 97c341a499d..b2f9d204e12 100644
--- a/src/openhuman/local_ai/ops_tests.rs
+++ b/src/openhuman/local_ai/ops_tests.rs
@@ -48,7 +48,7 @@ fn test_config(tmp: &tempfile::TempDir) -> Config {
     let mut c = Config::default();
     c.workspace_dir = tmp.path().join("workspace");
     c.config_path = tmp.path().join("config.toml");
-    c.local_ai.enabled = false; // disable so the local-ai-disabled error path fires.
+    c.local_ai.runtime_enabled = false; // disable so the local-ai-disabled error path fires.
     c
 }
 
diff --git a/src/openhuman/local_ai/presets.rs b/src/openhuman/local_ai/presets.rs
index b2cef192a71..092b867151f 100644
--- a/src/openhuman/local_ai/presets.rs
+++ b/src/openhuman/local_ai/presets.rs
@@ -248,6 +248,12 @@ pub fn apply_preset_to_config(config: &mut LocalAiConfig, tier: ModelTier) {
         config.preload_vision_model = matches!(preset.vision_mode, VisionMode::Bundled);
         config.preload_embedding_model = true;
         config.selected_tier = Some(tier.as_str().to_string());
+        // Applying a real preset enables the runtime — this is the authoritative
+        // activation path. bootstrap's config_with_recommended_tier_if_unselected
+        // also sets runtime_enabled = true when opt_in_confirmed is true, but
+        // setting it here ensures in-process callers (tests, RPC handlers) see
+        // the correct state without relying on bootstrap's post-processing.
+        config.runtime_enabled = true;
     } else {
         tracing::debug!("[local_ai] apply_preset_to_config called for custom tier; no-op");
     }
diff --git a/src/openhuman/local_ai/schemas.rs b/src/openhuman/local_ai/schemas.rs
index 1e759510fa5..19db1e65ba0 100644
--- a/src/openhuman/local_ai/schemas.rs
+++ b/src/openhuman/local_ai/schemas.rs
@@ -411,7 +411,7 @@ pub fn schemas(function: &str) -> ControllerSchema {
                  current_tier (string), selected_tier (string | null), device (DeviceProfile), \
                  recommend_disabled (boolean — true when the device is below the RAM floor and \
                  cloud fallback is the recommended default), local_ai_enabled (boolean — mirrors \
-                 config.local_ai.enabled so the UI can render the active state when disabled).",
+                 config.local_ai.runtime_enabled so the UI can render the active state when disabled).",
             )],
         },
         "local_ai_apply_preset" => ControllerSchema {
@@ -729,7 +729,7 @@ fn handle_local_ai_presets(_params: Map<String, Value>) -> ControllerFuture {
             "selected_tier": selected_tier,
             "device": device,
             "recommend_disabled": recommend_disabled,
-            "local_ai_enabled": config.local_ai.enabled,
+            "local_ai_enabled": config.local_ai.runtime_enabled,
         });
         Ok(value)
     })
@@ -744,7 +744,7 @@ fn handle_local_ai_apply_preset(params: Map<String, Value>) -> ControllerFuture
         // Special "disabled" tier: turn local_ai off and route AI to cloud.
         if tier_str == "disabled" {
             let mut config = config_rpc::load_config_with_timeout().await?;
-            config.local_ai.enabled = false;
+            config.local_ai.runtime_enabled = false;
             config.local_ai.selected_tier = Some("disabled".to_string());
             // Explicit opt-out also clears the MVP opt-in marker so bootstrap
             // keeps local AI off across restarts.
@@ -781,7 +781,7 @@ fn handle_local_ai_apply_preset(params: Map<String, Value>) -> ControllerFuture
         let mut config = config_rpc::load_config_with_timeout().await?;
         // Re-enable local AI in case it was previously disabled via the
         // "disabled" tier, so the user can switch back to local inference.
-        config.local_ai.enabled = true;
+        config.local_ai.runtime_enabled = true;
         // Explicit tier selection is the MVP opt-in — flip the marker so
         // `config_with_recommended_tier_if_unselected` stops hard-overriding
         // to disabled on subsequent boots.
diff --git a/src/openhuman/local_ai/service/assets.rs b/src/openhuman/local_ai/service/assets.rs
index 04a36ba8c18..c8ac03d870b 100644
--- a/src/openhuman/local_ai/service/assets.rs
+++ b/src/openhuman/local_ai/service/assets.rs
@@ -254,7 +254,7 @@ impl LocalAiService {
     }
 
     pub async fn download_all_models(&self, config: &Config) -> Result<(), String> {
-        if !config.local_ai.enabled {
+        if !config.local_ai.runtime_enabled {
             return Err("local ai is disabled".to_string());
         }
         let _guard = self.bootstrap_lock.lock().await;
@@ -334,7 +334,7 @@ impl LocalAiService {
         config: &Config,
         capability: &str,
     ) -> Result<LocalAiAssetsStatus, String> {
-        if !config.local_ai.enabled {
+        if !config.local_ai.runtime_enabled {
             return Err("local ai is disabled".to_string());
         }
         let _guard = self.bootstrap_lock.lock().await;
diff --git a/src/openhuman/local_ai/service/bootstrap.rs b/src/openhuman/local_ai/service/bootstrap.rs
index 5027bce78b6..edf251bd23e 100644
--- a/src/openhuman/local_ai/service/bootstrap.rs
+++ b/src/openhuman/local_ai/service/bootstrap.rs
@@ -108,7 +108,7 @@ impl LocalAiService {
         let device = crate::openhuman::local_ai::device::detect_device_profile();
         let effective_config = config_with_recommended_tier_if_unselected(config, &device);
 
-        if !effective_config.local_ai.enabled {
+        if !effective_config.local_ai.runtime_enabled {
             *self.status.lock() = LocalAiStatus::disabled(&effective_config);
             return;
         }
@@ -282,12 +282,17 @@ fn config_with_recommended_tier_if_unselected(config: &Config, device: &DevicePr
             "[local_ai] bootstrap: opt_in_confirmed=false, hard-overriding to disabled (cloud fallback)"
         );
         let mut effective_config = config.clone();
-        effective_config.local_ai.enabled = false;
+        effective_config.local_ai.runtime_enabled = false;
         return effective_config;
     }
 
-    // User has explicitly opted in via apply_preset. Honor the config as-is.
-    config.clone()
+    // User has explicitly opted in via apply_preset.
+    // Ensure runtime_enabled is true — the on-disk field may be stale (old
+    // installs that had `enabled = true` before the rename now serde-default to
+    // false, so we set it here based on the authoritative opt_in_confirmed flag).
+    let mut effective_config = config.clone();
+    effective_config.local_ai.runtime_enabled = true;
+    effective_config
 }
 
 fn format_degraded_warning(err: &str, config: &Config) -> String {
@@ -358,8 +363,8 @@ mod tests {
         let effective = config_with_recommended_tier_if_unselected(&config, &device);
 
         assert!(
-            !effective.local_ai.enabled,
-            "local_ai.enabled must default to false on <8 GB device"
+            !effective.local_ai.runtime_enabled,
+            "local_ai.runtime_enabled must default to false on <8 GB device"
         );
     }
 
@@ -373,8 +378,8 @@ mod tests {
         let effective = config_with_recommended_tier_if_unselected(&config, &device);
 
         assert!(
-            !effective.local_ai.enabled,
-            "local_ai.enabled must default to false when no tier selected, regardless of RAM"
+            !effective.local_ai.runtime_enabled,
+            "local_ai.runtime_enabled must default to false when no tier selected, regardless of RAM"
         );
     }
 
@@ -392,7 +397,7 @@ mod tests {
         let effective = config_with_recommended_tier_if_unselected(&config, &device);
 
         assert!(
-            effective.local_ai.enabled,
+            effective.local_ai.runtime_enabled,
             "explicit opt-in must be honored even on low-RAM device"
         );
     }
@@ -411,7 +416,7 @@ mod tests {
         let effective = config_with_recommended_tier_if_unselected(&config, &device);
 
         assert!(
-            effective.local_ai.enabled,
+            effective.local_ai.runtime_enabled,
             "explicit opt-in on sufficient-RAM device must stay enabled"
         );
         assert_eq!(
@@ -426,7 +431,7 @@ mod tests {
         // by old RAM-based bootstrap logic, but never went through an explicit MVP
         // opt-in. `opt_in_confirmed = false` must hard-override to disabled.
         let mut config = Config::default();
-        config.local_ai.enabled = true;
+        config.local_ai.runtime_enabled = true;
         config.local_ai.selected_tier = Some("ram_2_4gb".to_string());
         config.local_ai.opt_in_confirmed = false;
         let device = test_device(16);
@@ -434,7 +439,7 @@ mod tests {
         let effective = config_with_recommended_tier_if_unselected(&config, &device);
 
         assert!(
-            !effective.local_ai.enabled,
+            !effective.local_ai.runtime_enabled,
             "stale selected_tier without opt_in_confirmed must be hard-overridden to disabled"
         );
         assert_eq!(
diff --git a/src/openhuman/local_ai/service/public_infer.rs b/src/openhuman/local_ai/service/public_infer.rs
index 4a57f661ee7..dd865220ddf 100644
--- a/src/openhuman/local_ai/service/public_infer.rs
+++ b/src/openhuman/local_ai/service/public_infer.rs
@@ -14,7 +14,7 @@ impl LocalAiService {
         text: &str,
         max_tokens: Option<u32>,
     ) -> Result<String, String> {
-        if !config.local_ai.enabled {
+        if !config.local_ai.runtime_enabled {
             return Err("local ai is disabled".to_string());
         }
         let system = "You summarize internal assistant context. Keep concise bullet points.";
@@ -33,7 +33,7 @@ impl LocalAiService {
         max_tokens: Option<u32>,
         no_think: bool,
     ) -> Result<String, String> {
-        if !config.local_ai.enabled {
+        if !config.local_ai.runtime_enabled {
             return Err("local ai is disabled".to_string());
         }
         let system = if no_think {
@@ -113,7 +113,7 @@ impl LocalAiService {
         max_tokens: Option<u32>,
         gated: bool,
     ) -> Result<String, String> {
-        if !config.local_ai.enabled {
+        if !config.local_ai.runtime_enabled {
             return Ok(String::new());
         }
 
@@ -176,7 +176,7 @@ impl LocalAiService {
         messages: Vec<crate::openhuman::local_ai::ollama_api::OllamaChatMessage>,
         max_tokens: Option<u32>,
     ) -> Result<String, String> {
-        if !config.local_ai.enabled {
+        if !config.local_ai.runtime_enabled {
             return Err("local ai is disabled".to_string());
         }
 
diff --git a/src/openhuman/local_ai/service/public_infer_tests.rs b/src/openhuman/local_ai/service/public_infer_tests.rs
index 49a9d95751e..d60a749679f 100644
--- a/src/openhuman/local_ai/service/public_infer_tests.rs
+++ b/src/openhuman/local_ai/service/public_infer_tests.rs
@@ -11,7 +11,7 @@ async fn spawn_mock(app: Router) -> String {
 
 fn enabled_config() -> Config {
     let mut config = Config::default();
-    config.local_ai.enabled = true;
+    config.local_ai.runtime_enabled = true;
     config
 }
 
@@ -133,7 +133,7 @@ async fn inference_errors_on_empty_response_when_allow_empty_false() {
 async fn summarize_disabled_returns_error() {
     // When local_ai is disabled the summarize fn should short-circuit.
     let mut config = Config::default();
-    config.local_ai.enabled = false;
+    config.local_ai.runtime_enabled = false;
     let service = LocalAiService::new(&config);
     let err = service.summarize(&config, "text", None).await.unwrap_err();
     assert!(err.contains("local ai is disabled"));
@@ -142,7 +142,7 @@ async fn summarize_disabled_returns_error() {
 #[tokio::test]
 async fn prompt_disabled_returns_error() {
     let mut config = Config::default();
-    config.local_ai.enabled = false;
+    config.local_ai.runtime_enabled = false;
     let service = LocalAiService::new(&config);
     let err = service
         .prompt(&config, "text", None, false)
@@ -154,7 +154,7 @@ async fn prompt_disabled_returns_error() {
 #[tokio::test]
 async fn inline_complete_disabled_returns_empty_string() {
     let mut config = Config::default();
-    config.local_ai.enabled = false;
+    config.local_ai.runtime_enabled = false;
     let service = LocalAiService::new(&config);
     let out = service
         .inline_complete(&config, "ctx", "casual", None, &[], None)
@@ -168,7 +168,7 @@ async fn inline_complete_interactive_disabled_returns_empty_string() {
     // Interactive variant must match the gated variant on the
     // disabled short-circuit so the autocomplete UX is identical.
     let mut config = Config::default();
-    config.local_ai.enabled = false;
+    config.local_ai.runtime_enabled = false;
     let service = LocalAiService::new(&config);
     let out = service
         .inline_complete_interactive(&config, "ctx", "casual", None, &[], None)
diff --git a/src/openhuman/local_ai/service/speech.rs b/src/openhuman/local_ai/service/speech.rs
index 691ddbd6fb7..5cbf1a0c4e5 100644
--- a/src/openhuman/local_ai/service/speech.rs
+++ b/src/openhuman/local_ai/service/speech.rs
@@ -37,7 +37,7 @@ impl LocalAiService {
         initial_prompt: Option<&str>,
     ) -> Result<LocalAiSpeechResult, String> {
         let started = Instant::now();
-        if !config.local_ai.enabled {
+        if !config.local_ai.runtime_enabled {
             return Err("local ai is disabled".to_string());
         }
 
@@ -192,7 +192,7 @@ impl LocalAiService {
         text: &str,
         output_path: Option<&str>,
     ) -> Result<LocalAiTtsResult, String> {
-        if !config.local_ai.enabled {
+        if !config.local_ai.runtime_enabled {
             return Err("local ai is disabled".to_string());
         }
         let piper_bin = resolve_piper_binary()
diff --git a/src/openhuman/local_ai/service/vision_embed.rs b/src/openhuman/local_ai/service/vision_embed.rs
index de00c9fa33d..28d4650e036 100644
--- a/src/openhuman/local_ai/service/vision_embed.rs
+++ b/src/openhuman/local_ai/service/vision_embed.rs
@@ -18,7 +18,7 @@ impl LocalAiService {
         image_refs: &[String],
         max_tokens: Option<u32>,
     ) -> Result<String, String> {
-        if !config.local_ai.enabled {
+        if !config.local_ai.runtime_enabled {
             return Err("local ai is disabled".to_string());
         }
         if image_refs.is_empty() {
@@ -135,7 +135,7 @@ impl LocalAiService {
         config: &Config,
         inputs: &[String],
     ) -> Result<LocalAiEmbeddingResult, String> {
-        if !config.local_ai.enabled {
+        if !config.local_ai.runtime_enabled {
             return Err("local ai is disabled".to_string());
         }
         let items: Vec<String> = inputs
@@ -215,7 +215,7 @@ mod tests {
 
     fn enabled_config() -> Config {
         let mut c = Config::default();
-        c.local_ai.enabled = true;
+        c.local_ai.runtime_enabled = true;
         c
     }
 
@@ -301,7 +301,7 @@ mod tests {
     #[tokio::test]
     async fn embed_disabled_returns_error() {
         let mut config = Config::default();
-        config.local_ai.enabled = false;
+        config.local_ai.runtime_enabled = false;
         let service = LocalAiService::new(&config);
         let err = service.embed(&config, &["x".into()]).await.unwrap_err();
         assert!(err.contains("local ai is disabled"));
@@ -310,7 +310,7 @@ mod tests {
     #[tokio::test]
     async fn vision_prompt_disabled_returns_error() {
         let mut config = Config::default();
-        config.local_ai.enabled = false;
+        config.local_ai.runtime_enabled = false;
         let service = LocalAiService::new(&config);
         let err = service
             .vision_prompt(&config, "describe", &[], None)
diff --git a/src/openhuman/memory/ops/learn.rs b/src/openhuman/memory/ops/learn.rs
index a20a8258f0c..8103f6b9263 100644
--- a/src/openhuman/memory/ops/learn.rs
+++ b/src/openhuman/memory/ops/learn.rs
@@ -83,7 +83,7 @@ pub async fn memory_learn_all(
     };
 
     // Short-circuit when there are no namespaces to process — avoids loading
-    // config (and the local_ai.enabled guard) for an empty batch.
+    // config (and the local_ai.runtime_enabled guard) for an empty batch.
     if target_ns.is_empty() {
         tracing::info!(
             "[memory.learn] memory_learn_all: no namespaces to process, returning early"
@@ -101,8 +101,8 @@ pub async fn memory_learn_all(
         .await
         .map_err(|e| format!("load config: {e}"))?;
 
-    if !config.local_ai.enabled {
-        return Err("memory_learn_all requires local_ai.enabled=true".to_string());
+    if !config.local_ai.runtime_enabled {
+        return Err("memory_learn_all requires local_ai.runtime_enabled=true".to_string());
     }
 
     let mut results = Vec::with_capacity(target_ns.len());
diff --git a/src/openhuman/memory/tree/retrieval/drill_down.rs b/src/openhuman/memory/tree/retrieval/drill_down.rs
index 88e369d5832..a1e56f9edfb 100644
--- a/src/openhuman/memory/tree/retrieval/drill_down.rs
+++ b/src/openhuman/memory/tree/retrieval/drill_down.rs
@@ -94,6 +94,11 @@ pub async fn drill_down(
 /// Rerank hits by cosine similarity to the query embedding. Mirrors the
 /// pattern used by `query_source` / `query_topic`. Legacy rows without
 /// embeddings land at the end in BFS order.
+///
+/// On any error (embedder build failure or embedding inference failure) we log
+/// a warning and return hits in BFS order rather than bubbling the error up
+/// through the chat turn. This ensures local AI unavailability never surfaces
+/// as a visible error to the user.
 async fn rerank_by_semantic_similarity(
     config: &Config,
     query: &str,
@@ -101,8 +106,22 @@ async fn rerank_by_semantic_similarity(
     embeddings: Vec<Option<Vec<f32>>>,
 ) -> Result<Vec<RetrievalHit>> {
     debug_assert_eq!(hits.len(), embeddings.len());
-    let embedder = build_embedder_from_config(config)?;
-    let query_vec = embedder.embed(query).await?;
+    let embedder = match build_embedder_from_config(config) {
+        Ok(e) => e,
+        Err(err) => {
+            log::warn!(
+                "[retrieval::drill_down] embedder build failed — returning BFS order: {err}"
+            );
+            return Ok(hits);
+        }
+    };
+    let query_vec = match embedder.embed(query).await {
+        Ok(v) => v,
+        Err(err) => {
+            log::warn!("[retrieval::drill_down] embed query failed — returning BFS order: {err}");
+            return Ok(hits);
+        }
+    };
     log::debug!(
         "[retrieval::drill_down] query embedded provider={} hits_to_rerank={}",
         embedder.name(),
diff --git a/src/openhuman/providers/ops.rs b/src/openhuman/providers/ops.rs
index 74ffde22ccb..f22fcc11946 100644
--- a/src/openhuman/providers/ops.rs
+++ b/src/openhuman/providers/ops.rs
@@ -271,7 +271,7 @@ pub fn create_routed_provider_with_options(
 
 /// Create a provider with intelligent local/remote routing.
 ///
-/// When `config.local_ai.enabled` is `true` and Ollama is reachable,
+/// When `config.local_ai.runtime_enabled` is `true` and Ollama is reachable,
 /// lightweight and medium tasks (e.g. `hint:reaction`, `hint:summarize`) are
 /// served by the local model. Heavy tasks (`hint:reasoning`, `hint:agentic`,
 /// `hint:coding`) always go to the remote backend. A health-gated fallback
diff --git a/src/openhuman/routing/factory.rs b/src/openhuman/routing/factory.rs
index 049a90b5308..ddd3955551c 100644
--- a/src/openhuman/routing/factory.rs
+++ b/src/openhuman/routing/factory.rs
@@ -16,7 +16,7 @@ const LOCAL_HEALTH_TTL: Duration = Duration::from_secs(30);
 /// Construct an [`IntelligentRoutingProvider`] from a remote backend provider
 /// and the local AI configuration.
 ///
-/// When `local_ai_config.enabled` is `false` the returned provider behaves
+/// When `local_ai_config.runtime_enabled` is `false` the returned provider behaves
 /// identically to the remote provider (local health always returns `false`).
 ///
 /// `remote_fallback_model` is the model string sent to the remote backend when
@@ -86,7 +86,7 @@ pub fn new_provider(
         local,
         local_ai_config.chat_model_id.clone(),
         remote_fallback_model.to_string(),
-        local_ai_config.enabled,
+        local_ai_config.runtime_enabled,
         health,
     )
 }
diff --git a/src/openhuman/routing/provider.rs b/src/openhuman/routing/provider.rs
index 2cc359200e1..de52c0623f5 100644
--- a/src/openhuman/routing/provider.rs
+++ b/src/openhuman/routing/provider.rs
@@ -71,7 +71,7 @@ pub struct IntelligentRoutingProvider {
     local_model: String,
     /// Model string sent to remote on fallback (e.g. configured default model).
     remote_fallback_model: String,
-    /// Mirrors `config.local_ai.enabled`.
+    /// Mirrors `config.local_ai.runtime_enabled`.
     local_enabled: bool,
     health: Arc<LocalHealthChecker>,
     /// Global routing hints (privacy, latency, cost).
diff --git a/src/openhuman/screen_intelligence/cli/doctor.rs b/src/openhuman/screen_intelligence/cli/doctor.rs
index 4c220389800..733800b6d41 100644
--- a/src/openhuman/screen_intelligence/cli/doctor.rs
+++ b/src/openhuman/screen_intelligence/cli/doctor.rs
@@ -60,10 +60,10 @@ pub(super) fn run_doctor(args: &[String]) -> Result<()> {
             eprintln!("    use_vision_model:  {}", si.use_vision_model);
             eprintln!("    baseline_fps:      {}", si.baseline_fps);
             eprintln!("    keep_screenshots:  {}", si.keep_screenshots);
-            eprintln!("    local_ai.enabled:  {}", la.enabled);
+            eprintln!("    local_ai.runtime_enabled:  {}", la.runtime_enabled);
             eprintln!("    local_ai.provider: {}", la.provider);
-            if si.vision_enabled && !la.enabled {
-                eprintln!("    ⚠  Vision is enabled but local_ai.enabled=false — vision analysis will fail");
+            if si.vision_enabled && !la.runtime_enabled {
+                eprintln!("    ⚠  Vision is enabled but local_ai.runtime_enabled=false — vision analysis will fail");
             }
         }
 
@@ -96,7 +96,7 @@ pub(super) fn run_doctor(args: &[String]) -> Result<()> {
                     "use_vision_model": c.screen_intelligence.use_vision_model,
                     "baseline_fps": c.screen_intelligence.baseline_fps,
                     "keep_screenshots": c.screen_intelligence.keep_screenshots,
-                    "local_ai_enabled": c.local_ai.enabled,
+                    "local_ai_enabled": c.local_ai.runtime_enabled,
                     "local_ai_provider": c.local_ai.provider,
                 })),
             }))
diff --git a/src/openhuman/screen_intelligence/processing_worker.rs b/src/openhuman/screen_intelligence/processing_worker.rs
index bb1157cea2c..ef2784b6aea 100644
--- a/src/openhuman/screen_intelligence/processing_worker.rs
+++ b/src/openhuman/screen_intelligence/processing_worker.rs
@@ -211,9 +211,10 @@ pub(crate) async fn analyze_frame(
     let config = Config::load_or_init()
         .await
         .map_err(|e| format!("failed to load config: {e}"))?;
-    if !config.local_ai.enabled {
+    if !config.local_ai.runtime_enabled {
         return Err(
-            "screen intelligence vision requires local_ai.enabled=true in config".to_string(),
+            "screen intelligence vision requires local_ai.runtime_enabled=true in config"
+                .to_string(),
         );
     }
     let provider = config.local_ai.provider.trim().to_ascii_lowercase();
diff --git a/src/openhuman/screen_intelligence/tests.rs b/src/openhuman/screen_intelligence/tests.rs
index 6687b8ccbb7..701127ab7de 100644
--- a/src/openhuman/screen_intelligence/tests.rs
+++ b/src/openhuman/screen_intelligence/tests.rs
@@ -74,7 +74,7 @@ embedding_model = "none"
 embedding_dimensions = 0
 
 [local_ai]
-enabled = {local_ai_enabled}
+runtime_enabled = {local_ai_enabled}
 provider = "{local_ai_provider}"
 
 [secrets]
@@ -840,7 +840,7 @@ async fn analyze_and_persist_frame_rejects_disabled_local_ai() {
         .await
         .expect_err("disabled local ai should be rejected");
     assert!(
-        err.contains("local_ai.enabled=true"),
+        err.contains("local_ai.runtime_enabled=true"),
         "unexpected error when local ai is disabled: {err}"
     );
 }
diff --git a/src/openhuman/subconscious/engine.rs b/src/openhuman/subconscious/engine.rs
index 2d06bd72d56..74623bfd181 100644
--- a/src/openhuman/subconscious/engine.rs
+++ b/src/openhuman/subconscious/engine.rs
@@ -448,6 +448,31 @@ impl SubconsciousEngine {
             }
         };
 
+        // Gate: subconscious evaluation via local AI requires the per-feature flag.
+        // When off, all tasks resolve to Noop rather than erroring.
+        // TODO: wire a cloud fallback here when use_local_for_subconscious is false.
+        if !config.local_ai.use_local_for_subconscious() {
+            tracing::info!(
+                "[subconscious] local_ai.usage.subconscious not enabled — \
+                 skipping local evaluation, all tasks → Noop (no cloud fallback configured)"
+            );
+            // Use the `Evaluation failed:` prefix so the tick-level
+            // `evaluation_failed` detector treats this exactly like an LLM
+            // failure: don't advance `last_tick_at`, don't mark anything as
+            // executed. Silent success-shaped Noop here would otherwise let
+            // the tick clock advance past unevaluated tasks.
+            return tasks
+                .iter()
+                .map(|t| TaskEvaluation {
+                    task_id: t.id.clone(),
+                    decision: TickDecision::Noop,
+                    reason: "Evaluation failed: local_ai.usage.subconscious not enabled \
+                             (no cloud fallback configured)"
+                        .to_string(),
+                })
+                .collect();
+        }
+
         let messages = vec![
             crate::openhuman::local_ai::ops::LocalAiChatMessage {
                 role: "system".to_string(),
diff --git a/src/openhuman/subconscious/executor.rs b/src/openhuman/subconscious/executor.rs
index f79e3a193e5..ba6104ec045 100644
--- a/src/openhuman/subconscious/executor.rs
+++ b/src/openhuman/subconscious/executor.rs
@@ -110,6 +110,11 @@ pub async fn execute_approved_write(
 }
 
 /// Execute a text-only task using the local Ollama model.
+///
+/// Gated by `local_ai.usage.subconscious`. When the flag is off (or
+/// `runtime_enabled` is off), returns `Err` so callers don't mistake a
+/// disabled subsystem for a successfully-completed empty execution.
+/// TODO: wire a cloud fallback here when use_local_for_subconscious is false.
 async fn execute_with_local_model(
     task: &SubconsciousTask,
     situation_report: &str,
@@ -119,6 +124,22 @@ async fn execute_with_local_model(
         .await
         .map_err(|e| format!("config load: {e}"))?;
 
+    if !config.local_ai.use_local_for_subconscious() {
+        // Fail fast rather than returning Ok("") — upstream code uses an
+        // empty string as a normal "task ran but produced no output"
+        // signal, so a silent skip would mask a disabled subsystem as a
+        // completed action. Surface the gate state so callers can
+        // distinguish "skipped" from "succeeded with empty output".
+        tracing::info!(
+            "[subconscious:executor] local_ai.usage.subconscious not enabled — \
+             refusing to execute task '{}' (no cloud fallback configured)",
+            task.title
+        );
+        return Err(
+            "local_ai.usage.subconscious not enabled (no cloud fallback configured)".to_string(),
+        );
+    }
+
     let prompt_text = prompt::build_text_execution_prompt(task, situation_report, identity_context);
 
     let messages = vec![
diff --git a/src/openhuman/tools/impl/agent/onboarding_status.rs b/src/openhuman/tools/impl/agent/onboarding_status.rs
index ce0d5e88e8c..6ec2d3e2826 100644
--- a/src/openhuman/tools/impl/agent/onboarding_status.rs
+++ b/src/openhuman/tools/impl/agent/onboarding_status.rs
@@ -171,7 +171,7 @@ pub(crate) fn build_status_snapshot(
             "browser": config.browser.enabled,
             "web_search": true,
             "http_request": true,
-            "local_ai": config.local_ai.enabled,
+            "local_ai": config.local_ai.runtime_enabled,
         },
         "composio_connected_toolkits": composio_connected_toolkits,
         "webview_logins": webview_logins,
diff --git a/src/openhuman/tree_summarizer/ops.rs b/src/openhuman/tree_summarizer/ops.rs
index b9760ce603d..c88654bd608 100644
--- a/src/openhuman/tree_summarizer/ops.rs
+++ b/src/openhuman/tree_summarizer/ops.rs
@@ -149,7 +149,7 @@ fn create_provider(
 ) -> Result<Box<dyn crate::openhuman::providers::traits::Provider>, String> {
     // Tree summarization runs exclusively on local AI to keep memory
     // processing private and offline — no backend calls.
-    if !config.local_ai.enabled {
+    if !config.local_ai.runtime_enabled {
         return Err("tree summarizer requires local_ai to be enabled in config".to_string());
     }
     create_local_ai_provider(config)
diff --git a/src/openhuman/voice/ops.rs b/src/openhuman/voice/ops.rs
index 936f6ee4dd4..22a6fb3cba8 100644
--- a/src/openhuman/voice/ops.rs
+++ b/src/openhuman/voice/ops.rs
@@ -394,7 +394,7 @@ mod tests {
     #[tokio::test]
     async fn voice_transcribe_errors_when_local_ai_disabled() {
         let mut config = Config::default();
-        config.local_ai.enabled = false;
+        config.local_ai.runtime_enabled = false;
 
         let err = voice_transcribe(&config, " /tmp/input.wav ", None, true)
             .await
@@ -405,7 +405,7 @@ mod tests {
     #[tokio::test]
     async fn voice_transcribe_bytes_errors_when_local_ai_disabled() {
         let mut config = Config::default();
-        config.local_ai.enabled = false;
+        config.local_ai.runtime_enabled = false;
 
         let err = voice_transcribe_bytes(&config, b"abc", Some("wav".to_string()), None, true)
             .await
@@ -416,7 +416,7 @@ mod tests {
     #[tokio::test]
     async fn voice_tts_errors_when_local_ai_disabled() {
         let mut config = Config::default();
-        config.local_ai.enabled = false;
+        config.local_ai.runtime_enabled = false;
 
         let err = voice_tts(&config, "hello world", None)
             .await
diff --git a/tests/screen_intelligence_vision_e2e.rs b/tests/screen_intelligence_vision_e2e.rs
index bd4b6d3d766..e22921815c2 100644
--- a/tests/screen_intelligence_vision_e2e.rs
+++ b/tests/screen_intelligence_vision_e2e.rs
@@ -139,7 +139,7 @@ embedding_model = "none"
 embedding_dimensions = 0
 
 [local_ai]
-enabled = {local_ai_enabled}
+runtime_enabled = {local_ai_enabled}
 provider = "{local_ai_provider}"
 
 [screen_intelligence]
diff --git a/tests/subconscious_e2e.rs b/tests/subconscious_e2e.rs
index 5a24c525865..dc5e480e57b 100644
--- a/tests/subconscious_e2e.rs
+++ b/tests/subconscious_e2e.rs
@@ -138,7 +138,8 @@ Project: Q1 Budget Report
     config.heartbeat.inference_enabled = true;
     config.heartbeat.interval_minutes = 5;
     config.heartbeat.context_budget_tokens = 40_000;
-    config.local_ai.enabled = true;
+    config.local_ai.runtime_enabled = true;
+    config.local_ai.usage.subconscious = true;
 
     let engine = openhuman_core::openhuman::subconscious::SubconsciousEngine::new(
         &config,