diff --git a/src/chatpanel/features/composer/input-toolbar.ts b/src/chatpanel/features/composer/input-toolbar.ts
index f84cd9a..5dd87d3 100644
--- a/src/chatpanel/features/composer/input-toolbar.ts
+++ b/src/chatpanel/features/composer/input-toolbar.ts
@@ -1,4 +1,10 @@
-import { GEMINI_SETTINGS_STORAGE_KEY, normalizeGeminiSettings } from '../../../shared/settings';
+import {
+  DEFAULT_GEMINI_MODEL,
+  GEMINI_SETTINGS_STORAGE_KEY,
+  getModelDisplayLabel,
+  getModelThinkingLevels,
+  normalizeGeminiSettings,
+} from '../../../shared/settings';
 import { queryRequiredElement } from '../../core/dom';
 import { createMenuController } from '../../core/menu-controller';
 
@@ -10,23 +16,6 @@ export interface InputToolbar {
   attachButton: HTMLButtonElement;
 }
 
-const MODEL_ALIASES: Record<string, string> = {
-  'gemini-3-flash-preview': 'Flash',
-  'gemini-3.1-pro-preview': 'Pro',
-};
-
-const BUILTIN_THINKING_LEVELS: Record<string, string[]> = {
-  'gemini-3-flash-preview': ['minimal', 'low', 'medium', 'high'],
-  'gemini-3.1-pro-preview': ['low', 'medium', 'high'],
-};
-
-const DEFAULT_THINKING_DEFAULTS: Record<string, string> = {
-  'gemini-3-flash-preview': 'minimal',
-  'gemini-3.1-pro-preview': 'high',
-};
-
-const DEFAULT_THINKING_LEVELS = ['low', 'medium', 'high'];
-
 const THINKING_LABELS: Record<string, string> = {
   high: 'High',
   medium: 'Med',
@@ -58,12 +47,17 @@ export function createInputToolbar(shadowRoot: ShadowRoot): InputToolbar {
   const attachButton = queryRequiredElement<HTMLButtonElement>(shadowRoot, '#speakeasy-attach');
   const modelMenuController = createMenuController({ container: modelDropup });
   const thinkingMenuController = createMenuController({ container: thinkingDropup });
+  let modelThinkingLevelMap = normalizeGeminiSettings(undefined).modelThinkingLevelMap;
 
   function closeAllDropups(): void {
     modelMenuController.setOpen(false);
     thinkingMenuController.setOpen(false);
   }
 
+  function selectedModelValue(): string {
+    return modelTrigger.dataset.value ?? DEFAULT_GEMINI_MODEL;
+  }
+
   function selectDropupItem(
     dropup: HTMLElement,
     trigger: HTMLButtonElement,
@@ -83,9 +77,21 @@ export function createInputToolbar(shadowRoot: ShadowRoot): InputToolbar {
     }
   }
 
-  function updateThinkingOptions(model: string): void {
-    const levels = BUILTIN_THINKING_LEVELS[model] ?? DEFAULT_THINKING_LEVELS;
-    const defaultLevel = DEFAULT_THINKING_DEFAULTS[model] ?? 'high';
+  function resolveThinkingLevel(model: string, preferred?: string): string {
+    const levels: readonly string[] = getModelThinkingLevels(model);
+    if (preferred && levels.includes(preferred)) {
+      return preferred;
+    }
+    const mapped = modelThinkingLevelMap[model];
+    if (mapped && levels.includes(mapped)) {
+      return mapped;
+    }
+    return levels[levels.length - 1] ?? 'high';
+  }
+
+  function updateThinkingOptions(model: string, preferredThinkingLevel?: string): void {
+    const levels = getModelThinkingLevels(model);
+    const selectedThinkingLevel = resolveThinkingLevel(model, preferredThinkingLevel);
     thinkingMenu.innerHTML = '';
     for (const level of [...levels].reverse()) {
       const btn = document.createElement('button');
@@ -93,14 +99,14 @@ export function createInputToolbar(shadowRoot: ShadowRoot): InputToolbar {
       btn.className = 'dropup-item';
       btn.dataset.value = level;
       btn.textContent = THINKING_LABELS[level] ?? level;
-      btn.setAttribute('aria-selected', level === defaultLevel ? 'true' : 'false');
+      btn.setAttribute('aria-selected', level === selectedThinkingLevel ? 'true' : 'false');
       thinkingMenu.appendChild(btn);
     }
     selectDropupItem(
       thinkingDropup,
       thinkingTrigger,
-      defaultLevel,
-      THINKING_LABELS[defaultLevel] ?? defaultLevel,
+      selectedThinkingLevel,
+      THINKING_LABELS[selectedThinkingLevel] ?? selectedThinkingLevel,
     );
   }
 
@@ -120,7 +126,7 @@ export function createInputToolbar(shadowRoot: ShadowRoot): InputToolbar {
         btn.className = 'dropup-item';
         btn.dataset.value = model;
         btn.dataset.custom = '1';
-        btn.textContent = MODEL_ALIASES[model] ?? model;
+        btn.textContent = getModelDisplayLabel(model);
         modelMenu.appendChild(btn);
       }
     }
@@ -171,9 +177,18 @@ export function createInputToolbar(shadowRoot: ShadowRoot): InputToolbar {
     closeAllDropups();
   });
 
-  void chrome.storage.local.get(GEMINI_SETTINGS_STORAGE_KEY).then((stored) => {
-    const settings = normalizeGeminiSettings(stored[GEMINI_SETTINGS_STORAGE_KEY]);
+  function applySettings(settingsValue: unknown, keepThinkingSelection = false): void {
+    const settings = normalizeGeminiSettings(settingsValue);
+    modelThinkingLevelMap = settings.modelThinkingLevelMap;
     applyCustomModels(settings.customModels);
+    const preferred = keepThinkingSelection ? thinkingTrigger.dataset.value : undefined;
+    updateThinkingOptions(selectedModelValue(), preferred);
+  }
+
+  applySettings(undefined);
+
+  void chrome.storage.local.get(GEMINI_SETTINGS_STORAGE_KEY).then((stored) => {
+    applySettings(stored[GEMINI_SETTINGS_STORAGE_KEY]);
   });
 
   chrome.storage.onChanged.addListener((changes) => {
@@ -181,16 +196,15 @@ export function createInputToolbar(shadowRoot: ShadowRoot): InputToolbar {
     if (!settingsChange) {
       return;
     }
-    const settings = normalizeGeminiSettings(settingsChange.newValue);
-    applyCustomModels(settings.customModels);
+    applySettings(settingsChange.newValue, true);
   });
 
   return {
     selectedModel(): string {
-      return modelTrigger.dataset.value ?? 'gemini-3-flash-preview';
+      return selectedModelValue();
     },
     selectedThinkingLevel(): string {
-      return thinkingTrigger.dataset.value ?? 'minimal';
+      return resolveThinkingLevel(selectedModelValue(), thinkingTrigger.dataset.value);
     },
     captureButton,
     extractTextButton,
diff --git a/src/chatpanel/template/composer-template.ts b/src/chatpanel/template/composer-template.ts
index 6da450b..855b54e 100644
--- a/src/chatpanel/template/composer-template.ts
+++ b/src/chatpanel/template/composer-template.ts
@@ -1,4 +1,39 @@
+import {
+  BUILTIN_GEMINI_MODEL_CATALOG,
+  type ThinkingLevel,
+  getBuiltinGeminiModelByKey,
+} from '../../shared/settings';
+
+const THINKING_LABELS: Record<ThinkingLevel, string> = {
+  high: 'High',
+  medium: 'Med',
+  low: 'Low',
+  minimal: 'Min',
+};
+
+function renderModelMenuItems(selectedModel: string): string {
+  return BUILTIN_GEMINI_MODEL_CATALOG.map((entry) => {
+    const selected = entry.model === selectedModel ? ' aria-selected="true"' : '';
+    return `<button type="button" class="dropup-item" data-value="${entry.model}"${selected}>${entry.label}</button>`;
+  }).join('');
+}
+
+function renderThinkingMenuItems(
+  levels: readonly ThinkingLevel[],
+  selectedLevel: ThinkingLevel,
+): string {
+  return [...levels]
+    .reverse()
+    .map((level) => {
+      const selected = level === selectedLevel ? ' aria-selected="true"' : '';
+      return `<button type="button" class="dropup-item" data-value="${level}"${selected}>${THINKING_LABELS[level] ?? level}</button>`;
+    })
+    .join('');
+}
+
 export function getComposerTemplate(): string {
+  const defaultModel = getBuiltinGeminiModelByKey('flash');
+  const defaultThinkingLevel = defaultModel.defaultThinkingLevel;
   return `
         <form id="speakeasy-form" class="composer" autocomplete="off">
           <div class="composer-inner">
@@ -20,21 +55,13 @@ export function getComposerTemplate(): string {
             </div>
             <div class="input-toolbar">
               <div class="dropup" id="speakeasy-model-dropup">
-                <button type="button" class="dropup-trigger" data-value="gemini-3-flash-preview" title="Select model">Flash</button>
-                <div class="dropup-menu">
-                  <button type="button" class="dropup-item" data-value="gemini-3-flash-preview" aria-selected="true">Flash</button>
-                  <button type="button" class="dropup-item" data-value="gemini-3.1-pro-preview">Pro</button>
-                </div>
+                <button type="button" class="dropup-trigger" data-value="${defaultModel.model}" title="Select model">${defaultModel.label}</button>
+                <div class="dropup-menu">${renderModelMenuItems(defaultModel.model)}</div>
               </div>
               <span class="input-toolbar-separator" aria-hidden="true">|</span>
               <div class="dropup" id="speakeasy-thinking-dropup">
-                <button type="button" class="dropup-trigger" data-value="minimal" title="Select effort level">Min</button>
-                <div class="dropup-menu">
-                  <button type="button" class="dropup-item" data-value="high">High</button>
-                  <button type="button" class="dropup-item" data-value="medium">Med</button>
-                  <button type="button" class="dropup-item" data-value="low">Low</button>
-                  <button type="button" class="dropup-item" data-value="minimal" aria-selected="true">Min</button>
-                </div>
+                <button type="button" class="dropup-trigger" data-value="${defaultThinkingLevel}" title="Select effort level">${THINKING_LABELS[defaultThinkingLevel] ?? defaultThinkingLevel}</button>
+                <div class="dropup-menu">${renderThinkingMenuItems(defaultModel.thinkingLevels, defaultThinkingLevel)}</div>
               </div>
               <div class="input-toolbar-actions">
                 <button
diff --git a/src/options/dom.ts b/src/options/dom.ts
index b9e9823..6ea12d4 100644
--- a/src/options/dom.ts
+++ b/src/options/dom.ts
@@ -3,7 +3,13 @@ export interface OptionsDom {
   versionNode: HTMLElement;
   statusNode: HTMLElement;
   apiKeyInput: HTMLInputElement;
-  modelInput: HTMLInputElement;
+  modelFlashNameInput: HTMLInputElement;
+  modelFlashThinkingLevelSelect: HTMLSelectElement;
+  modelProNameInput: HTMLInputElement;
+  modelProThinkingLevelSelect: HTMLSelectElement;
+  customModelRowsContainer: HTMLElement;
+  addCustomModelButton: HTMLButtonElement;
+  customModelRowTemplate: HTMLTemplateElement;
   systemInstructionInput: HTMLTextAreaElement;
   storeInteractionsInput: HTMLInputElement;
   maxToolRoundTripsInput: HTMLInputElement;
@@ -29,7 +35,17 @@ export function getOptionsDom(): OptionsDom {
     versionNode: queryRequiredElement<HTMLElement>('#version'),
     statusNode: queryRequiredElement<HTMLElement>('#save-status'),
     apiKeyInput: queryRequiredElement<HTMLInputElement>('#api-key'),
-    modelInput: queryRequiredElement<HTMLInputElement>('#model'),
+    modelFlashNameInput: queryRequiredElement<HTMLInputElement>('#model-name-flash'),
+    modelFlashThinkingLevelSelect: queryRequiredElement<HTMLSelectElement>(
+      '#model-thinking-level-flash',
+    ),
+    modelProNameInput: queryRequiredElement<HTMLInputElement>('#model-name-pro'),
+    modelProThinkingLevelSelect: queryRequiredElement<HTMLSelectElement>(
+      '#model-thinking-level-pro',
+    ),
+    customModelRowsContainer: queryRequiredElement<HTMLElement>('#custom-model-rows'),
+    addCustomModelButton: queryRequiredElement<HTMLButtonElement>('#add-custom-model'),
+    customModelRowTemplate: queryRequiredElement<HTMLTemplateElement>('#custom-model-row-template'),
     systemInstructionInput: queryRequiredElement<HTMLTextAreaElement>('#system-instruction'),
     storeInteractionsInput: queryRequiredElement<HTMLInputElement>('#store-interactions'),
     maxToolRoundTripsInput: queryRequiredElement<HTMLInputElement>('#max-tool-round-trips'),
diff --git a/src/options/form-state.ts b/src/options/form-state.ts
index 220d036..1b9bf94 100644
--- a/src/options/form-state.ts
+++ b/src/options/form-state.ts
@@ -1,9 +1,54 @@
-import { type GeminiSettings, parseCommaSeparatedList } from '../shared/settings';
+import {
+  CUSTOM_MODEL_THINKING_LEVELS,
+  DEFAULT_CUSTOM_MODEL_THINKING_LEVEL,
+  type GeminiSettings,
+  type ThinkingLevel,
+  getBuiltinGeminiModelByKey,
+  parseCommaSeparatedList,
+} from '../shared/settings';
 import type { OptionsDom } from './dom';
 
+const FLASH_MODEL = getBuiltinGeminiModelByKey('flash');
+const PRO_MODEL = getBuiltinGeminiModelByKey('pro');
+const CUSTOM_MODEL_ROW_SELECTOR = '[data-custom-model-row]';
+const CUSTOM_MODEL_INPUT_SELECTOR = '[data-custom-model-input]';
+const CUSTOM_MODEL_THINKING_LEVEL_SELECTOR = '[data-custom-model-thinking-level]';
+const THINKING_LEVEL_LABELS: Record<ThinkingLevel, string> = {
+  minimal: 'Minimal (fastest)',
+  low: 'Low',
+  medium: 'Medium',
+  high: 'High (deepest)',
+};
+
+export function initializeModelThinkingControls(dom: OptionsDom): void {
+  dom.modelFlashNameInput.value = FLASH_MODEL.model;
+  dom.modelProNameInput.value = PRO_MODEL.model;
+  replaceThinkingLevelOptions(dom.modelFlashThinkingLevelSelect, FLASH_MODEL.thinkingLevels);
+  replaceThinkingLevelOptions(dom.modelProThinkingLevelSelect, PRO_MODEL.thinkingLevels);
+
+  const templateThinkingLevelSelect = queryRequiredInTemplate<HTMLSelectElement>(
+    dom.customModelRowTemplate,
+    CUSTOM_MODEL_THINKING_LEVEL_SELECTOR,
+  );
+  replaceThinkingLevelOptions(templateThinkingLevelSelect, CUSTOM_MODEL_THINKING_LEVELS);
+}
+
 export function applySettingsToForm(dom: OptionsDom, settings: GeminiSettings): void {
+  initializeModelThinkingControls(dom);
+
   dom.apiKeyInput.value = settings.apiKey;
-  dom.modelInput.value = settings.customModels[0] ?? '';
+  dom.modelFlashThinkingLevelSelect.value = normalizeThinkingLevelForAllowed(
+    settings.modelThinkingLevelMap[FLASH_MODEL.model],
+    FLASH_MODEL.thinkingLevels,
+    FLASH_MODEL.defaultThinkingLevel,
+  );
+  dom.modelProThinkingLevelSelect.value = normalizeThinkingLevelForAllowed(
+    settings.modelThinkingLevelMap[PRO_MODEL.model],
+    PRO_MODEL.thinkingLevels,
+    PRO_MODEL.defaultThinkingLevel,
+  );
+  replaceCustomModelRows(dom, settings.customModels, settings.modelThinkingLevelMap);
+
   dom.systemInstructionInput.value = settings.systemInstruction;
   dom.storeInteractionsInput.checked = settings.storeInteractions;
   dom.maxToolRoundTripsInput.value = String(settings.maxToolRoundTrips);
@@ -27,11 +72,45 @@ export function applySettingsToForm(dom: OptionsDom, settings: GeminiSettings):
 }
 
 export function readFormState(dom: OptionsDom): Partial<GeminiSettings> {
-  const customModel = dom.modelInput.value.trim();
+  const modelThinkingLevelMap: Record<string, string> = {
+    [FLASH_MODEL.model]: normalizeThinkingLevelForAllowed(
+      dom.modelFlashThinkingLevelSelect.value,
+      FLASH_MODEL.thinkingLevels,
+      FLASH_MODEL.defaultThinkingLevel,
+    ),
+    [PRO_MODEL.model]: normalizeThinkingLevelForAllowed(
+      dom.modelProThinkingLevelSelect.value,
+      PRO_MODEL.thinkingLevels,
+      PRO_MODEL.defaultThinkingLevel,
+    ),
+  };
+  const customModels: string[] = [];
+  const seenModels = new Set<string>();
+
+  for (const row of listCustomModelRows(dom)) {
+    const modelInput = queryRequiredInRow<HTMLInputElement>(row, CUSTOM_MODEL_INPUT_SELECTOR);
+    const thinkingLevelInput = queryRequiredInRow<HTMLSelectElement>(
+      row,
+      CUSTOM_MODEL_THINKING_LEVEL_SELECTOR,
+    );
+    const model = modelInput.value.trim();
+    if (!model || seenModels.has(model)) {
+      continue;
+    }
+
+    seenModels.add(model);
+    customModels.push(model);
+    modelThinkingLevelMap[model] = normalizeThinkingLevelForAllowed(
+      thinkingLevelInput.value,
+      CUSTOM_MODEL_THINKING_LEVELS,
+      DEFAULT_CUSTOM_MODEL_THINKING_LEVEL,
+    );
+  }
+
   return {
     apiKey: dom.apiKeyInput.value.trim(),
-    model: customModel || 'gemini-3-flash-preview',
-    customModels: customModel ? [customModel] : [],
+    customModels,
+    modelThinkingLevelMap,
     systemInstruction: dom.systemInstructionInput.value.trim(),
     storeInteractions: dom.storeInteractionsInput.checked,
     maxToolRoundTrips: Number(dom.maxToolRoundTripsInput.value),
@@ -55,6 +134,93 @@ export function readFormState(dom: OptionsDom): Partial<GeminiSettings> {
   };
 }
 
+export function addCustomModelRow(
+  dom: OptionsDom,
+  model = '',
+  thinkingLevel: string | undefined = DEFAULT_CUSTOM_MODEL_THINKING_LEVEL,
+): HTMLElement {
+  const templateRoot = dom.customModelRowTemplate.content.firstElementChild as HTMLElement | null;
+  if (!templateRoot) {
+    throw new Error('Custom model row template must have a root element.');
+  }
+
+  const row = templateRoot.cloneNode(true) as HTMLElement;
+  const thinkingLevelInput = queryRequiredInRow<HTMLSelectElement>(
+    row,
+    CUSTOM_MODEL_THINKING_LEVEL_SELECTOR,
+  );
+  if (thinkingLevelInput.options.length === 0) {
+    replaceThinkingLevelOptions(thinkingLevelInput, CUSTOM_MODEL_THINKING_LEVELS);
+  }
+
+  queryRequiredInRow<HTMLInputElement>(row, CUSTOM_MODEL_INPUT_SELECTOR).value = model;
+  thinkingLevelInput.value = normalizeThinkingLevelForAllowed(
+    thinkingLevel,
+    CUSTOM_MODEL_THINKING_LEVELS,
+    DEFAULT_CUSTOM_MODEL_THINKING_LEVEL,
+  );
+
+  dom.customModelRowsContainer.appendChild(row);
+  return row;
+}
+
+export function removeCustomModelRow(row: HTMLElement): void {
+  row.remove();
+}
+
+function replaceCustomModelRows(
+  dom: OptionsDom,
+  customModels: readonly string[],
+  modelThinkingLevelMap: Record<string, string>,
+): void {
+  dom.customModelRowsContainer.replaceChildren();
+  for (const model of customModels) {
+    addCustomModelRow(dom, model, modelThinkingLevelMap[model]);
+  }
+}
+
+function listCustomModelRows(dom: OptionsDom): HTMLElement[] {
+  return Array.from(
+    dom.customModelRowsContainer.querySelectorAll<HTMLElement>(CUSTOM_MODEL_ROW_SELECTOR),
+  );
+}
+
+function queryRequiredInRow<TElement extends Element>(
+  row: HTMLElement,
+  selector: string,
+): TElement {
+  const element = row.querySelector<TElement>(selector);
+  if (!element) {
+    throw new Error(`Custom model row is missing required node: ${selector}`);
+  }
+  return element;
+}
+
+function queryRequiredInTemplate<TElement extends Element>(
+  template: HTMLTemplateElement,
+  selector: string,
+): TElement {
+  const element = template.content.querySelector<TElement>(selector);
+  if (!element) {
+    throw new Error(`Custom model template is missing required node: ${selector}`);
+  }
+  return element;
+}
+
+function replaceThinkingLevelOptions(
+  select: HTMLSelectElement,
+  levels: readonly ThinkingLevel[],
+): void {
+  select.replaceChildren(...levels.map((level) => createThinkingOption(level)));
+}
+
+function createThinkingOption(level: ThinkingLevel): HTMLOptionElement {
+  const option = document.createElement('option');
+  option.value = level;
+  option.textContent = THINKING_LEVEL_LABELS[level] ?? level;
+  return option;
+}
+
 function parseNullableNumber(raw: string): number | null {
   const normalized = raw.trim();
   if (!normalized) {
@@ -64,3 +230,12 @@ function parseNullableNumber(raw: string): number | null {
   const parsed = Number(normalized);
   return Number.isFinite(parsed) ? parsed : null;
 }
+
+function normalizeThinkingLevelForAllowed(
+  raw: string | undefined,
+  allowedLevels: readonly ThinkingLevel[],
+  fallback: ThinkingLevel,
+): ThinkingLevel {
+  const normalized = raw?.trim().toLowerCase() as ThinkingLevel;
+  return allowedLevels.includes(normalized) ? normalized : fallback;
+}
diff --git a/src/options/options.html b/src/options/options.html
index 7a1649d..2c30881 100644
--- a/src/options/options.html
+++ b/src/options/options.html
@@ -28,13 +28,48 @@ <h2 class="settings-section-heading">Provider
             placeholder="AI... or your Gemini API key" required />
         </label>
 
-        <label class="settings-field">
-          <span class="settings-label">Custom model <span
-              class="settings-optional">(optional)</span></span>
-          <input id="model" name="model" type="text"
-            class="settings-input"
-            placeholder="gemini-3-pro-preview (appears in chat selector)" />
-        </label>
+        <section class="settings-field">
+          <span class="settings-label">Model thinking defaults</span>
+          <div class="settings-grid-two">
+            <input id="model-name-flash" type="text"
+              class="settings-input"
+              readonly />
+            <select id="model-thinking-level-flash" name="modelThinkingLevelFlash"
+              class="settings-input">
+            </select>
+          </div>
+          <div class="settings-grid-two mt-3">
+            <input id="model-name-pro" type="text"
+              class="settings-input"
+              readonly />
+            <select id="model-thinking-level-pro" name="modelThinkingLevelPro"
+              class="settings-input">
+            </select>
+          </div>
+          <span class="settings-label mt-4">Custom models</span>
+          <div id="custom-model-rows" class="space-y-3"></div>
+          <button id="add-custom-model" type="button" class="settings-inline-button mt-3">
+            Add custom model
+          </button>
+          <template id="custom-model-row-template">
+            <div class="settings-grid-two" data-custom-model-row>
+              <input type="text"
+                class="settings-input"
+                data-custom-model-input
+                placeholder="gemini-3.2-custom" />
+              <div class="flex gap-3">
+                <select data-custom-model-thinking-level
+                  class="settings-input">
+                </select>
+                <button type="button"
+                  class="settings-inline-button"
+                  data-remove-custom-model>
+                  Remove
+                </button>
+              </div>
+            </div>
+          </template>
+        </section>
 
         <label class="settings-field">
           <span class="settings-label">System instruction <span
diff --git a/src/options/options.ts b/src/options/options.ts
index 699de72..01562f1 100644
--- a/src/options/options.ts
+++ b/src/options/options.ts
@@ -1,17 +1,42 @@
 import { GEMINI_SETTINGS_STORAGE_KEY, normalizeGeminiSettings } from '../shared/settings';
 import { getOptionsDom, setStatus } from './dom';
-import { applySettingsToForm, readFormState } from './form-state';
+import {
+  addCustomModelRow,
+  applySettingsToForm,
+  readFormState,
+  removeCustomModelRow,
+} from './form-state';
 import { validateSettings } from './validation';
 
 const dom = getOptionsDom();
+let currentSettings = normalizeGeminiSettings(undefined);
 
 dom.versionNode.textContent = chrome.runtime.getManifest().version;
 void initializeForm();
 
+dom.addCustomModelButton.addEventListener('click', () => {
+  addCustomModelRow(dom);
+});
+
+dom.customModelRowsContainer.addEventListener('click', (event) => {
+  const removeButton = (event.target as Element).closest<HTMLElement>('[data-remove-custom-model]');
+  if (!removeButton) {
+    return;
+  }
+
+  const row = removeButton.closest<HTMLElement>('[data-custom-model-row]');
+  if (row) {
+    removeCustomModelRow(row);
+  }
+});
+
 dom.form.addEventListener('submit', async (event) => {
   event.preventDefault();
 
-  const nextSettings = normalizeGeminiSettings(readFormState(dom));
+  const nextSettings = normalizeGeminiSettings({
+    ...currentSettings,
+    ...readFormState(dom),
+  });
   const validationError = validateSettings(nextSettings);
   if (validationError) {
     setStatus(dom.statusNode, validationError, 'error');
@@ -21,6 +46,7 @@ dom.form.addEventListener('submit', async (event) => {
   await chrome.storage.local.set({
     [GEMINI_SETTINGS_STORAGE_KEY]: nextSettings,
   });
+  currentSettings = nextSettings;
 
   setStatus(dom.statusNode, 'Saved Gemini settings.', 'success');
 });
@@ -28,6 +54,7 @@ dom.form.addEventListener('submit', async (event) => {
 async function initializeForm(): Promise<void> {
   const stored = await chrome.storage.local.get(GEMINI_SETTINGS_STORAGE_KEY);
   const settings = normalizeGeminiSettings(stored[GEMINI_SETTINGS_STORAGE_KEY]);
+  currentSettings = settings;
   applySettingsToForm(dom, settings);
   setStatus(dom.statusNode, 'Ready.', 'info');
 }
diff --git a/src/options/validation.ts b/src/options/validation.ts
index 8a6c0cb..61827f4 100644
--- a/src/options/validation.ts
+++ b/src/options/validation.ts
@@ -14,7 +14,9 @@ export function validateSettings(settings: GeminiSettings): string | null {
     return 'Provide both maps latitude and longitude, or leave both empty.';
   }
 
-  const toolConfigurationError = validateGeminiToolConfiguration(settings);
+  const toolConfigurationError = validateGeminiToolConfiguration(settings, {
+    mcpModelValidationScope: 'available-models',
+  });
   if (toolConfigurationError) {
     return toolConfigurationError;
   }
diff --git a/src/shared/settings.ts b/src/shared/settings.ts
index 8d3fae6..d12f695 100644
--- a/src/shared/settings.ts
+++ b/src/shared/settings.ts
@@ -13,9 +13,75 @@ export const PAGE_TEXT_EXTRACTION_ENGINES = ['defuddle', 'readability'] as const
 export type PageTextExtractionEngine = (typeof PAGE_TEXT_EXTRACTION_ENGINES)[number];
 export const DEFAULT_PAGE_TEXT_EXTRACTION_ENGINE: PageTextExtractionEngine = 'defuddle';
 
+export const THINKING_LEVELS = ['minimal', 'low', 'medium', 'high'] as const;
+export type ThinkingLevel = (typeof THINKING_LEVELS)[number];
+export const CUSTOM_MODEL_THINKING_LEVELS = [
+  'low',
+  'medium',
+  'high',
+] as const satisfies readonly ThinkingLevel[];
+export const DEFAULT_CUSTOM_MODEL_THINKING_LEVEL: ThinkingLevel = 'high';
+
+export type BuiltinGeminiModelKey = 'flash' | 'pro';
+
+export interface BuiltinGeminiModelCatalogEntry {
+  key: BuiltinGeminiModelKey;
+  model: string;
+  label: string;
+  thinkingLevels: readonly ThinkingLevel[];
+  defaultThinkingLevel: ThinkingLevel;
+}
+
+export const BUILTIN_GEMINI_MODEL_CATALOG: readonly BuiltinGeminiModelCatalogEntry[] = [
+  {
+    key: 'flash',
+    model: 'gemini-3-flash-preview',
+    label: 'Flash',
+    thinkingLevels: ['minimal', 'low', 'medium', 'high'],
+    defaultThinkingLevel: 'minimal',
+  },
+  {
+    key: 'pro',
+    model: 'gemini-3.1-pro-preview',
+    label: 'Pro',
+    thinkingLevels: ['low', 'medium', 'high'],
+    defaultThinkingLevel: 'high',
+  },
+];
+
+export const DEFAULT_GEMINI_MODEL =
+  BUILTIN_GEMINI_MODEL_CATALOG[0]?.model ?? 'gemini-3-flash-preview';
+
+const DEFAULT_MODEL_THINKING_LEVEL_MAP: Record<string, string> = Object.fromEntries(
+  BUILTIN_GEMINI_MODEL_CATALOG.map((entry) => [entry.model, entry.defaultThinkingLevel]),
+) as Record<string, string>;
+
+export function getBuiltinGeminiModelByKey(
+  key: BuiltinGeminiModelKey,
+): BuiltinGeminiModelCatalogEntry {
+  const entry = BUILTIN_GEMINI_MODEL_CATALOG.find((e) => e.key === key);
+  if (!entry) {
+    throw new Error(`Built-in Gemini model config is missing for key "${key}".`);
+  }
+  return entry;
+}
+
+function findBuiltinGeminiModel(model: string): BuiltinGeminiModelCatalogEntry | undefined {
+  return BUILTIN_GEMINI_MODEL_CATALOG.find((entry) => entry.model === model);
+}
+
+export function getModelDisplayLabel(model: string): string {
+  return findBuiltinGeminiModel(model)?.label ?? model;
+}
+
+export function getModelThinkingLevels(model: string): readonly ThinkingLevel[] {
+  return findBuiltinGeminiModel(model)?.thinkingLevels ?? CUSTOM_MODEL_THINKING_LEVELS;
+}
+
 export interface GeminiSettings {
   apiKey: string;
   model: string;
+  modelThinkingLevelMap: Record<string, string>;
   systemInstruction: string;
   storeInteractions: boolean;
   maxToolRoundTrips: number;
@@ -36,7 +102,8 @@ export const CHAT_STORAGE_SCHEMA_VERSION_STORAGE_KEY = 'chatStorageSchemaVersion
 
 const DEFAULT_SETTINGS: GeminiSettings = {
   apiKey: '',
-  model: 'gemini-3-flash-preview',
+  model: DEFAULT_GEMINI_MODEL,
+  modelThinkingLevelMap: { ...DEFAULT_MODEL_THINKING_LEVEL_MAP },
   systemInstruction: '',
   storeInteractions: true,
   maxToolRoundTrips: 6,
@@ -113,6 +180,29 @@ function sanitizeStringList(value: unknown): string[] {
   return [...unique];
 }
 
+function sanitizeModelThinkingLevelMap(value: unknown): Record<string, string> {
+  if (!value || typeof value !== 'object') {
+    return {};
+  }
+
+  const normalized: Record<string, string> = {};
+  for (const [rawModel, rawLevel] of Object.entries(value as Record<string, unknown>)) {
+    if (typeof rawLevel !== 'string') {
+      continue;
+    }
+
+    const model = rawModel.trim();
+    const thinkingLevel = rawLevel.trim();
+    if (!model || !thinkingLevel) {
+      continue;
+    }
+
+    normalized[model] = thinkingLevel;
+  }
+
+  return normalized;
+}
+
 function toPageTextExtractionEngineOrDefault(
   value: unknown,
   fallback: PageTextExtractionEngine,
@@ -140,16 +230,21 @@ export function parseCommaSeparatedList(raw: string): string[] {
 
 export function normalizeGeminiSettings(value: unknown): GeminiSettings {
   if (!value || typeof value !== 'object') {
-    return { ...DEFAULT_SETTINGS };
+    return defaultGeminiSettings();
   }
 
   const settings = value as Partial<GeminiSettings> & { tools?: Partial<GeminiToolSettings> };
   const tools: Partial<GeminiToolSettings> =
     settings.tools && typeof settings.tools === 'object' ? settings.tools : {};
+  const modelThinkingLevelMap = sanitizeModelThinkingLevelMap(settings.modelThinkingLevelMap);
 
   return {
     apiKey: toStringOrEmpty(settings.apiKey).trim(),
     model: toStringOrEmpty(settings.model).trim() || DEFAULT_SETTINGS.model,
+    modelThinkingLevelMap: {
+      ...DEFAULT_SETTINGS.modelThinkingLevelMap,
+      ...modelThinkingLevelMap,
+    },
     systemInstruction: toStringOrEmpty(settings.systemInstruction).trim(),
     storeInteractions: toBooleanOrDefault(
       settings.storeInteractions,
@@ -188,5 +283,9 @@ export function normalizeGeminiSettings(value: unknown): GeminiSettings {
 }
 
 export function defaultGeminiSettings(): GeminiSettings {
-  return { ...DEFAULT_SETTINGS, tools: { ...DEFAULT_SETTINGS.tools } };
+  return {
+    ...DEFAULT_SETTINGS,
+    modelThinkingLevelMap: { ...DEFAULT_SETTINGS.modelThinkingLevelMap },
+    tools: { ...DEFAULT_SETTINGS.tools },
+  };
 }
diff --git a/src/shared/tool-validation.ts b/src/shared/tool-validation.ts
index 52cb13c..9906de1 100644
--- a/src/shared/tool-validation.ts
+++ b/src/shared/tool-validation.ts
@@ -1,6 +1,13 @@
 import type { GeminiSettings } from './settings';
 
-export function validateGeminiToolConfiguration(settings: GeminiSettings): string | null {
+export interface GeminiToolValidationOptions {
+  mcpModelValidationScope?: 'selected-model' | 'available-models';
+}
+
+export function validateGeminiToolConfiguration(
+  settings: GeminiSettings,
+  options?: GeminiToolValidationOptions,
+): string | null {
   if (settings.tools.fileSearch && settings.fileSearchStoreNames.length === 0) {
     return 'File Search is enabled but no file store names are configured.';
   }
@@ -27,13 +34,39 @@ export function validateGeminiToolConfiguration(settings: GeminiSettings): strin
     return 'MCP servers cannot be combined with built-in tools or local function calling in the Interactions API yet. Choose one mode.';
   }
 
-  if (settings.tools.mcpServers && isGemini3Model(settings.model)) {
+  if (settings.tools.mcpServers && !hasMcpCompatibleModel(settings, options)) {
     return 'Remote MCP is not supported on Gemini 3 models yet. Use a Gemini 2.5 model for MCP server tools.';
   }
 
   return null;
 }
 
+function hasMcpCompatibleModel(
+  settings: GeminiSettings,
+  options: GeminiToolValidationOptions | undefined,
+): boolean {
+  const scope = options?.mcpModelValidationScope ?? 'selected-model';
+  const candidateModels = listMcpCandidateModels(settings, scope);
+  return candidateModels.some((model) => !isGemini3Model(model));
+}
+
+function listMcpCandidateModels(
+  settings: GeminiSettings,
+  scope: NonNullable<GeminiToolValidationOptions['mcpModelValidationScope']>,
+): string[] {
+  const candidates =
+    scope === 'available-models' ? [settings.model, ...settings.customModels] : [settings.model];
+  const unique = new Set<string>();
+  for (const candidate of candidates) {
+    const normalized = candidate.trim();
+    if (!normalized) {
+      continue;
+    }
+    unique.add(normalized);
+  }
+  return [...unique];
+}
+
 function isGemini3Model(model: string): boolean {
   return /^gemini-3(?:[.-]|$)/i.test(model.trim());
 }
diff --git a/src/styles/tailwind.css b/src/styles/tailwind.css
index c26c8c2..9347a33 100644
--- a/src/styles/tailwind.css
+++ b/src/styles/tailwind.css
@@ -112,6 +112,10 @@
     @apply bg-white/90 px-6 py-2.5 text-xs font-bold uppercase tracking-widest text-black transition-colors hover:bg-white focus:outline-none;
   }
 
+  .settings-inline-button {
+    @apply border border-white/20 bg-black/30 px-3 py-2 text-xs uppercase tracking-widest text-white/80 transition-colors hover:border-white/40 hover:text-white focus:outline-none;
+  }
+
   .settings-status {
     @apply text-xs tracking-wider text-white/50;
   }
diff --git a/tests/unit/background/features/gemini/gemini.test.ts b/tests/unit/background/features/gemini/gemini.test.ts
index 4479322..f81017d 100644
--- a/tests/unit/background/features/gemini/gemini.test.ts
+++ b/tests/unit/background/features/gemini/gemini.test.ts
@@ -207,6 +207,18 @@ describe('buildGeminiRequestToolSelection', () => {
     );
   });
 
+  it('rejects mcp server usage on selected gemini 3 models even with gemini 2.5 custom models', () => {
+    const settings = createSettingsForToolTests();
+    settings.model = 'gemini-3-flash-preview';
+    settings.customModels = ['gemini-2.5-flash'];
+    settings.tools.mcpServers = true;
+    settings.mcpServerUrls = ['https://mcp.example.com/stream'];
+
+    expect(() => buildGeminiRequestToolSelection(settings, FUNCTION_DECLARATIONS)).toThrow(
+      /remote mcp is not supported on gemini 3/i,
+    );
+  });
+
   it('builds a computer_use tool payload with excluded actions', () => {
     const settings = createSettingsForToolTests();
     settings.model = 'gemini-2.5-computer-use-preview-10-2025';
diff --git a/tests/unit/chatpanel/features/composer/input-toolbar.test.ts b/tests/unit/chatpanel/features/composer/input-toolbar.test.ts
index c48458e..8075857 100644
--- a/tests/unit/chatpanel/features/composer/input-toolbar.test.ts
+++ b/tests/unit/chatpanel/features/composer/input-toolbar.test.ts
@@ -173,6 +173,45 @@ describe('chatpanel input toolbar', () => {
     ).toBe('false');
   });
 
+  it('uses mapped thinking defaults from settings', async () => {
+    const testWindow = dom?.window;
+    if (!testWindow) {
+      throw new Error('DOM test environment is not installed.');
+    }
+
+    installChromeStorageMock({
+      [GEMINI_SETTINGS_STORAGE_KEY]: {
+        customModels: [],
+        modelThinkingLevelMap: {
+          'gemini-3.1-pro-preview': 'medium',
+        },
+      },
+    });
+
+    const shadowRoot = createToolbarShadowRoot();
+    const toolbar = createInputToolbar(shadowRoot);
+    await Promise.resolve();
+
+    const proModelButton = queryRequiredElement<HTMLElement>(
+      shadowRoot,
+      '#speakeasy-model-dropup .dropup-item[data-value="gemini-3.1-pro-preview"]',
+    );
+    proModelButton.dispatchEvent(new testWindow.MouseEvent('click', { bubbles: true }));
+
+    const thinkingTrigger = queryRequiredElement<HTMLElement>(
+      shadowRoot,
+      '#speakeasy-thinking-dropup .dropup-trigger',
+    );
+    expect(toolbar.selectedThinkingLevel()).toBe('medium');
+    expect(thinkingTrigger.dataset.value).toBe('medium');
+    expect(thinkingTrigger.textContent?.trim()).toBe('Med');
+    expect(
+      shadowRoot
+        .querySelector<HTMLElement>('#speakeasy-thinking-dropup .dropup-item[data-value="medium"]')
+        ?.getAttribute('aria-selected'),
+    ).toBe('true');
+  });
+
   it('updates selected thinking level when a menu item is clicked', async () => {
     const testWindow = dom?.window;
     if (!testWindow) {
@@ -218,6 +257,84 @@ describe('chatpanel input toolbar', () => {
     ).toBe('false');
   });
 
+  it('resolves thinking level from model defaults when trigger state is empty', async () => {
+    const testWindow = dom?.window;
+    if (!testWindow) {
+      throw new Error('DOM test environment is not installed.');
+    }
+
+    installChromeStorageMock({
+      [GEMINI_SETTINGS_STORAGE_KEY]: {
+        customModels: [],
+        modelThinkingLevelMap: {
+          'gemini-3.1-pro-preview': 'medium',
+        },
+      },
+    });
+
+    const shadowRoot = createToolbarShadowRoot();
+    const toolbar = createInputToolbar(shadowRoot);
+    await Promise.resolve();
+
+    const proModelButton = queryRequiredElement<HTMLElement>(
+      shadowRoot,
+      '#speakeasy-model-dropup .dropup-item[data-value="gemini-3.1-pro-preview"]',
+    );
+    proModelButton.dispatchEvent(new testWindow.MouseEvent('click', { bubbles: true }));
+
+    const thinkingTrigger = queryRequiredElement<HTMLElement>(
+      shadowRoot,
+      '#speakeasy-thinking-dropup .dropup-trigger',
+    );
+    thinkingTrigger.removeAttribute('data-value');
+
+    expect(toolbar.selectedThinkingLevel()).toBe('medium');
+  });
+
+  it('keeps selected thinking level after live settings updates', async () => {
+    const testWindow = dom?.window;
+    if (!testWindow) {
+      throw new Error('DOM test environment is not installed.');
+    }
+
+    installChromeStorageMock({
+      [GEMINI_SETTINGS_STORAGE_KEY]: {
+        customModels: [],
+      },
+    });
+
+    const shadowRoot = createToolbarShadowRoot();
+    const toolbar = createInputToolbar(shadowRoot);
+    await Promise.resolve();
+
+    const proModelButton = queryRequiredElement<HTMLElement>(
+      shadowRoot,
+      '#speakeasy-model-dropup .dropup-item[data-value="gemini-3.1-pro-preview"]',
+    );
+    proModelButton.dispatchEvent(new testWindow.MouseEvent('click', { bubbles: true }));
+
+    const lowThinkingButton = queryRequiredElement<HTMLElement>(
+      shadowRoot,
+      '#speakeasy-thinking-dropup .dropup-item[data-value="low"]',
+    );
+    lowThinkingButton.dispatchEvent(new testWindow.MouseEvent('click', { bubbles: true }));
+    expect(toolbar.selectedThinkingLevel()).toBe('low');
+
+    emitChanged?.({
+      [GEMINI_SETTINGS_STORAGE_KEY]: {
+        newValue: {
+          customModels: [],
+          modelThinkingLevelMap: {
+            'gemini-3.1-pro-preview': 'medium',
+          },
+        },
+      },
+    });
+    await Promise.resolve();
+
+    expect(toolbar.selectedThinkingLevel()).toBe('low');
+  });
+
   it('ignores unrelated storage change events', async () => {
     installChromeStorageMock({
       [GEMINI_SETTINGS_STORAGE_KEY]: {
diff --git a/tests/unit/options/dom.test.ts b/tests/unit/options/dom.test.ts
index 5130f47..c6dac17 100644
--- a/tests/unit/options/dom.test.ts
+++ b/tests/unit/options/dom.test.ts
@@ -19,14 +19,20 @@ describe('options dom helpers', () => {
 
     expect(optionsDom.form.id).toBe('settings-form');
     expect(optionsDom.apiKeyInput.id).toBe('api-key');
-    expect(optionsDom.modelInput.id).toBe('model');
+    expect(optionsDom.modelFlashNameInput.id).toBe('model-name-flash');
+    expect(optionsDom.modelFlashThinkingLevelSelect.id).toBe('model-thinking-level-flash');
+    expect(optionsDom.modelProNameInput.id).toBe('model-name-pro');
+    expect(optionsDom.modelProThinkingLevelSelect.id).toBe('model-thinking-level-pro');
+    expect(optionsDom.customModelRowsContainer.id).toBe('custom-model-rows');
+    expect(optionsDom.addCustomModelButton.id).toBe('add-custom-model');
+    expect(optionsDom.customModelRowTemplate.id).toBe('custom-model-row-template');
     expect(optionsDom.pageTextExtractionEngineInput.id).toBe('page-text-extraction-engine');
     expect(optionsDom.statusNode.id).toBe('save-status');
   });
 
   it('throws when a required node is missing', () => {
-    document.getElementById('model')?.remove();
-    expect(() => getOptionsDom()).toThrow(/missing required node: #model/i);
+    document.getElementById('add-custom-model')?.remove();
+    expect(() => getOptionsDom()).toThrow(/missing required node: #add-custom-model/i);
   });
 
   it('updates status text and tone classes', () => {
@@ -51,7 +57,13 @@ function buildOptionsFixtureHtml(): string {
         <span id="version"></span>
         <p id="save-status"></p>
         <input id="api-key" />
-        <input id="model" />
+        <input id="model-name-flash" />
+        <select id="model-thinking-level-flash"></select>
+        <input id="model-name-pro" />
+        <select id="model-thinking-level-pro"></select>
+        <div id="custom-model-rows"></div>
+        <button id="add-custom-model" type="button">Add</button>
+        <template id="custom-model-row-template"></template>
         <textarea id="system-instruction"></textarea>
         <input id="store-interactions" type="checkbox" />
         <input id="max-tool-round-trips" />
diff --git a/tests/unit/options/form-state.test.ts b/tests/unit/options/form-state.test.ts
index 59bac1e..991cd83 100644
--- a/tests/unit/options/form-state.test.ts
+++ b/tests/unit/options/form-state.test.ts
@@ -1,54 +1,36 @@
-import { describe, expect, it } from 'bun:test';
-import type { OptionsDom } from '../../../src/options/dom';
-import { applySettingsToForm, readFormState } from '../../../src/options/form-state';
+import { afterEach, beforeEach, describe, expect, it } from 'bun:test';
+import { getOptionsDom } from '../../../src/options/dom';
+import {
+  applySettingsToForm,
+  initializeModelThinkingControls,
+  readFormState,
+} from '../../../src/options/form-state';
 import { defaultGeminiSettings } from '../../../src/shared/settings';
+import { type InstalledDomEnvironment, installDomTestEnvironment } from '../helpers/dom-test-env';
 
-function createInput(value = '', checked = false): HTMLInputElement {
-  return { value, checked } as HTMLInputElement;
-}
-
-function createTextArea(value = ''): HTMLTextAreaElement {
-  return { value } as HTMLTextAreaElement;
-}
+describe('options form state', () => {
+  let installedDom: InstalledDomEnvironment | null = null;
 
-function createSelect(value = 'defuddle'): HTMLSelectElement {
-  return { value } as HTMLSelectElement;
-}
+  beforeEach(() => {
+    installedDom = installDomTestEnvironment(buildOptionsFixtureHtml());
+  });
 
-function createOptionsDomStub(): OptionsDom {
-  return {
-    form: {} as HTMLFormElement,
-    versionNode: {} as HTMLElement,
-    statusNode: {} as HTMLElement,
-    apiKeyInput: createInput(),
-    modelInput: createInput(),
-    systemInstructionInput: createTextArea(),
-    storeInteractionsInput: createInput('', false),
-    maxToolRoundTripsInput: createInput(),
-    pageTextExtractionEngineInput: createSelect(),
-    toolGoogleSearch: createInput('', false),
-    toolGoogleMaps: createInput('', false),
-    toolCodeExecution: createInput('', false),
-    toolUrlContext: createInput('', false),
-    toolFileSearch: createInput('', false),
-    toolMcpServers: createInput('', false),
-    toolFunctionCalling: createInput('', false),
-    toolComputerUse: createInput('', false),
-    fileSearchStoreNamesInput: createInput(),
-    mcpServerUrlsInput: createInput(),
-    mapsLatitudeInput: createInput(),
-    mapsLongitudeInput: createInput(),
-    computerUseExcludedActionsInput: createInput(),
-  };
-}
+  afterEach(() => {
+    installedDom?.restore();
+    installedDom = null;
+  });
 
-describe('options form state', () => {
-  it('applies settings into form fields', () => {
-    const dom = createOptionsDomStub();
+  it('applies settings into form fields including multiple custom models', () => {
+    const dom = getOptionsDom();
     const settings = defaultGeminiSettings();
     settings.apiKey = 'api-key';
-    settings.model = 'gemini-2.5-pro';
-    settings.customModels = ['gemini-2.5-pro'];
+    settings.customModels = ['gemini-3.2-custom', 'gemini-3.2-beta'];
+    settings.modelThinkingLevelMap = {
+      'gemini-3-flash-preview': 'medium',
+      'gemini-3.1-pro-preview': 'low',
+      'gemini-3.2-custom': 'high',
+      'gemini-3.2-beta': 'low',
+    };
     settings.systemInstruction = 'Be direct.';
     settings.storeInteractions = false;
     settings.maxToolRoundTrips = 9;
@@ -70,7 +52,18 @@ describe('options form state', () => {
     applySettingsToForm(dom, settings);
 
     expect(dom.apiKeyInput.value).toBe('api-key');
-    expect(dom.modelInput.value).toBe('gemini-2.5-pro');
+    expect(dom.modelFlashNameInput.value).toBe('gemini-3-flash-preview');
+    expect(dom.modelFlashThinkingLevelSelect.value).toBe('medium');
+    expect(dom.modelProNameInput.value).toBe('gemini-3.1-pro-preview');
+    expect(dom.modelProThinkingLevelSelect.value).toBe('low');
+
+    const customRows = getCustomRows(dom);
+    expect(customRows).toHaveLength(2);
+    expect(customRows[0]?.modelInput.value).toBe('gemini-3.2-custom');
+    expect(customRows[0]?.thinkingLevelInput.value).toBe('high');
+    expect(customRows[1]?.modelInput.value).toBe('gemini-3.2-beta');
+    expect(customRows[1]?.thinkingLevelInput.value).toBe('low');
+
     expect(dom.systemInstructionInput.value).toBe('Be direct.');
     expect(dom.storeInteractionsInput.checked).toBe(false);
     expect(dom.maxToolRoundTripsInput.value).toBe('9');
@@ -91,7 +84,7 @@ describe('options form state', () => {
   });
 
   it('writes empty map coordinate fields when settings hold null coordinates', () => {
-    const dom = createOptionsDomStub();
+    const dom = getOptionsDom();
     const settings = defaultGeminiSettings();
     settings.mapsLatitude = null;
     settings.mapsLongitude = null;
@@ -102,10 +95,16 @@ describe('options form state', () => {
     expect(dom.mapsLongitudeInput.value).toBe('');
   });
 
-  it('reads and normalizes form values into partial settings', () => {
-    const dom = createOptionsDomStub();
+  it('reads and normalizes multiple custom model rows into partial settings', () => {
+    const dom = getOptionsDom();
+    initializeModelThinkingControls(dom);
     dom.apiKeyInput.value = '  key-123  ';
-    dom.modelInput.value = '  gemini-2.5-flash  ';
+    dom.modelFlashThinkingLevelSelect.value = 'low';
+    dom.modelProThinkingLevelSelect.value = 'high';
+    appendCustomModelRow(dom, '  gemini-3.2-custom  ', 'medium');
+    appendCustomModelRow(dom, 'gemini-3.2-beta', 'low');
+    appendCustomModelRow(dom, 'gemini-3.2-custom', 'high');
+    appendCustomModelRow(dom, '   ', 'high');
     dom.systemInstructionInput.value = '  Use tools when needed. ';
     dom.storeInteractionsInput.checked = true;
     dom.maxToolRoundTripsInput.value = '7';
@@ -128,8 +127,13 @@ describe('options form state', () => {
 
     expect(state).toEqual({
       apiKey: 'key-123',
-      model: 'gemini-2.5-flash',
-      customModels: ['gemini-2.5-flash'],
+      customModels: ['gemini-3.2-custom', 'gemini-3.2-beta'],
+      modelThinkingLevelMap: {
+        'gemini-3-flash-preview': 'low',
+        'gemini-3.1-pro-preview': 'high',
+        'gemini-3.2-custom': 'medium',
+        'gemini-3.2-beta': 'low',
+      },
       systemInstruction: 'Use tools when needed.',
       storeInteractions: true,
       maxToolRoundTrips: 7,
@@ -153,7 +157,8 @@ describe('options form state', () => {
   });
 
   it('parses empty or invalid coordinates as null', () => {
-    const dom = createOptionsDomStub();
+    const dom = getOptionsDom();
+    initializeModelThinkingControls(dom);
     dom.mapsLatitudeInput.value = ' ';
     dom.mapsLongitudeInput.value = 'Infinity';
 
@@ -162,4 +167,132 @@ describe('options form state', () => {
     expect(state.mapsLatitude).toBeNull();
     expect(state.mapsLongitude).toBeNull();
   });
+
+  it('falls back to model defaults when select values are unsupported', () => {
+    const dom = getOptionsDom();
+    initializeModelThinkingControls(dom);
+    dom.modelFlashThinkingLevelSelect.value = 'ultra';
+    dom.modelProThinkingLevelSelect.value = 'ultra';
+    appendCustomModelRow(dom, 'gemini-3.2-custom', 'ultra');
+    const customRows = getCustomRows(dom);
+    const firstCustomRow = customRows[0];
+    if (!firstCustomRow) {
+      throw new Error('Expected one custom model row.');
+    }
+    firstCustomRow.thinkingLevelInput.replaceChildren(
+      createOption('ultra', 'Ultra'),
+      createOption('high', 'High'),
+    );
+    firstCustomRow.thinkingLevelInput.value = 'ultra';
+
+    const state = readFormState(dom);
+
+    expect(state.modelThinkingLevelMap).toEqual({
+      'gemini-3-flash-preview': 'minimal',
+      'gemini-3.1-pro-preview': 'high',
+      'gemini-3.2-custom': 'high',
+    });
+  });
 });
+
+function getCustomRows(dom: ReturnType<typeof getOptionsDom>): CustomModelRow[] {
+  return Array.from(
+    dom.customModelRowsContainer.querySelectorAll<HTMLElement>('[data-custom-model-row]'),
+  ).map(
+    (row): CustomModelRow => ({
+      row,
+      modelInput: requireInRow<HTMLInputElement>(row, '[data-custom-model-input]'),
+      thinkingLevelInput: requireInRow<HTMLSelectElement>(
+        row,
+        '[data-custom-model-thinking-level]',
+      ),
+    }),
+  );
+}
+
+function appendCustomModelRow(
+  dom: ReturnType<typeof getOptionsDom>,
+  model: string,
+  thinkingLevel: string,
+): void {
+  const templateRoot = dom.customModelRowTemplate.content.firstElementChild as HTMLElement | null;
+  if (!templateRoot) {
+    throw new Error('custom model row template is missing root element');
+  }
+
+  const row = templateRoot.cloneNode(true) as HTMLElement;
+  const modelInput = requireInRow<HTMLInputElement>(row, '[data-custom-model-input]');
+  const thinkingLevelInput = requireInRow<HTMLSelectElement>(
+    row,
+    '[data-custom-model-thinking-level]',
+  );
+  modelInput.value = model;
+  thinkingLevelInput.value = thinkingLevel;
+  dom.customModelRowsContainer.appendChild(row);
+}
+
+function requireInRow<TElement extends Element>(row: HTMLElement, selector: string): TElement {
+  const element = row.querySelector<TElement>(selector);
+  if (!element) {
+    throw new Error(`custom model row is missing ${selector}`);
+  }
+  return element;
+}
+
+function createOption(value: string, label: string): HTMLOptionElement {
+  const option = document.createElement('option');
+  option.value = value;
+  option.textContent = label;
+  return option;
+}
+
+interface CustomModelRow {
+  row: HTMLElement;
+  modelInput: HTMLInputElement;
+  thinkingLevelInput: HTMLSelectElement;
+}
+
+function buildOptionsFixtureHtml(): string {
+  return `
+    <!doctype html>
+    <html>
+      <body>
+        <form id="settings-form">
+          <input id="api-key" />
+          <input id="model-name-flash" />
+          <select id="model-thinking-level-flash"></select>
+          <input id="model-name-pro" />
+          <select id="model-thinking-level-pro"></select>
+          <div id="custom-model-rows"></div>
+          <button id="add-custom-model" type="button">Add custom model</button>
+          <template id="custom-model-row-template">
+            <div data-custom-model-row>
+              <input data-custom-model-input />
+              <select data-custom-model-thinking-level></select>
+              <button type="button" data-remove-custom-model>Remove</button>
+            </div>
+          </template>
+          <textarea id="system-instruction"></textarea>
+          <input id="store-interactions" type="checkbox" />
+          <input id="max-tool-round-trips" />
+          <input id="page-text-extraction-engine" />
+          <input id="tool-google-search" type="checkbox" />
+          <input id="tool-google-maps" type="checkbox" />
+          <input id="tool-code-execution" type="checkbox" />
+          <input id="tool-url-context" type="checkbox" />
+          <input id="tool-file-search" type="checkbox" />
+          <input id="tool-mcp-servers" type="checkbox" />
+          <input id="tool-function-calling" type="checkbox" />
+          <input id="tool-computer-use" type="checkbox" />
+          <input id="file-search-store-names" />
+          <input id="mcp-server-urls" />
+          <input id="maps-latitude" />
+          <input id="maps-longitude" />
+          <input id="computer-use-excluded-actions" />
+          <span id="version"></span>
+          <p id="save-status"></p>
+        </form>
+      </body>
+    </html>
+  `;
+}
diff --git a/tests/unit/options/options.test.ts b/tests/unit/options/options.test.ts
index 2bac7e2..1dfb04b 100644
--- a/tests/unit/options/options.test.ts
+++ b/tests/unit/options/options.test.ts
@@ -23,7 +23,13 @@ describe('options page bootstrap', () => {
   it('initializes form state and page metadata from storage', async () => {
     storedSettings = {
       apiKey: 'init-key',
-      customModels: ['gemini-3.2-custom'],
+      model: 'gemini-3.1-pro-preview',
+      customModels: ['gemini-3.2-custom', 'gemini-3.2-beta'],
+      modelThinkingLevelMap: {
+        'gemini-3-flash-preview': 'high',
+        'gemini-3.2-custom': 'medium',
+        'gemini-3.2-beta': 'low',
+      },
       maxToolRoundTrips: 7,
       pageTextExtractionEngine: 'readability',
     };
@@ -34,7 +40,24 @@ describe('options page bootstrap', () => {
 
     expect(document.getElementById('version')?.textContent).toBe('9.9.9');
     expect((document.getElementById('api-key') as HTMLInputElement).value).toBe('init-key');
-    expect((document.getElementById('model') as HTMLInputElement).value).toBe('gemini-3.2-custom');
+    expect((document.getElementById('model-name-flash') as HTMLInputElement).value).toBe(
+      'gemini-3-flash-preview',
+    );
+    expect((document.getElementById('model-thinking-level-flash') as HTMLSelectElement).value).toBe(
+      'high',
+    );
+    expect((document.getElementById('model-name-pro') as HTMLInputElement).value).toBe(
+      'gemini-3.1-pro-preview',
+    );
+    expect((document.getElementById('model-thinking-level-pro') as HTMLSelectElement).value).toBe(
+      'high',
+    );
+    const customRows = getCustomModelRows();
+    expect(customRows).toHaveLength(2);
+    expect(customRows[0]?.modelInput.value).toBe('gemini-3.2-custom');
+    expect(customRows[0]?.thinkingLevelInput.value).toBe('medium');
+    expect(customRows[1]?.modelInput.value).toBe('gemini-3.2-beta');
+    expect(customRows[1]?.thinkingLevelInput.value).toBe('low');
     expect(
       (document.getElementById('page-text-extraction-engine') as HTMLSelectElement).value,
     ).toBe('readability');
@@ -73,7 +96,23 @@ describe('options page bootstrap', () => {
     await flushTasks();
 
     (document.getElementById('api-key') as HTMLInputElement).value = 'live-key';
-    (document.getElementById('model') as HTMLInputElement).value = 'gemini-3.2-custom';
+    (document.getElementById('model-thinking-level-flash') as HTMLSelectElement).value = 'low';
+    (document.getElementById('model-thinking-level-pro') as HTMLSelectElement).value = 'medium';
+    const addButton = document.getElementById('add-custom-model') as HTMLButtonElement;
+    addButton.dispatchEvent(new testWindow.MouseEvent('click', { bubbles: true }));
+    addButton.dispatchEvent(new testWindow.MouseEvent('click', { bubbles: true }));
+    const customRows = getCustomModelRows();
+    expect(customRows).toHaveLength(2);
+    const firstCustomRow = customRows[0];
+    const secondCustomRow = customRows[1];
+    if (!firstCustomRow || !secondCustomRow) {
+      throw new Error('Expected two custom model rows.');
+    }
+
+    firstCustomRow.modelInput.value = 'gemini-3.2-custom';
+    firstCustomRow.thinkingLevelInput.value = 'high';
+    secondCustomRow.modelInput.value = 'gemini-3.2-beta';
+    secondCustomRow.thinkingLevelInput.value = 'low';
     (document.getElementById('max-tool-round-trips') as HTMLInputElement).value = '4';
     (document.getElementById('page-text-extraction-engine') as HTMLSelectElement).value =
       'readability';
@@ -85,18 +124,132 @@ describe('options page bootstrap', () => {
     const persisted = savedItems[0]?.[GEMINI_SETTINGS_STORAGE_KEY] as
       | {
           apiKey?: string;
+          model?: string;
           customModels?: string[];
+          modelThinkingLevelMap?: Record<string, string>;
           maxToolRoundTrips?: number;
           pageTextExtractionEngine?: string;
         }
       | undefined;
     expect(persisted?.apiKey).toBe('live-key');
-    expect(persisted?.customModels).toEqual(['gemini-3.2-custom']);
+    expect(persisted?.model).toBe('gemini-3-flash-preview');
+    expect(persisted?.customModels).toEqual(['gemini-3.2-custom', 'gemini-3.2-beta']);
+    expect(persisted?.modelThinkingLevelMap).toEqual({
+      'gemini-3-flash-preview': 'low',
+      'gemini-3.1-pro-preview': 'medium',
+      'gemini-3.2-custom': 'high',
+      'gemini-3.2-beta': 'low',
+    });
     expect(persisted?.maxToolRoundTrips).toBe(4);
     expect(persisted?.pageTextExtractionEngine).toBe('readability');
     expect(document.getElementById('save-status')?.textContent).toBe('Saved Gemini settings.');
   });
 
+  it('persists MCP settings when a Gemini 2.5 custom model is configured', async () => {
+    const testWindow = dom?.window;
+    if (!testWindow) {
+      throw new Error('DOM test environment is not installed.');
+    }
+
+    installChromeOptionsMock();
+    await importFreshOptionsModule();
+    await flushTasks();
+
+    (document.getElementById('api-key') as HTMLInputElement).value = 'live-key';
+    (document.getElementById('tool-google-search') as HTMLInputElement).checked = false;
+    (document.getElementById('tool-code-execution') as HTMLInputElement).checked = false;
+    (document.getElementById('tool-url-context') as HTMLInputElement).checked = false;
+    (document.getElementById('tool-mcp-servers') as HTMLInputElement).checked = true;
+    (document.getElementById('mcp-server-urls') as HTMLInputElement).value =
+      'https://mcp.example.com/stream';
+
+    const addButton = document.getElementById('add-custom-model') as HTMLButtonElement;
+    addButton.dispatchEvent(new testWindow.MouseEvent('click', { bubbles: true }));
+    const customRows = getCustomModelRows();
+    const firstCustomRow = customRows[0];
+    if (!firstCustomRow) {
+      throw new Error('Expected one custom model row.');
+    }
+    firstCustomRow.modelInput.value = 'gemini-2.5-flash';
+    firstCustomRow.thinkingLevelInput.value = 'high';
+
+    const form = document.getElementById('settings-form') as HTMLFormElement;
+    form.dispatchEvent(new testWindow.Event('submit', { bubbles: true, cancelable: true }));
+    await flushTasks();
+
+    expect(savedItems).toHaveLength(1);
+    const persisted = savedItems[0]?.[GEMINI_SETTINGS_STORAGE_KEY] as
+      | {
+          customModels?: string[];
+          tools?: { mcpServers?: boolean };
+          mcpServerUrls?: string[];
+        }
+      | undefined;
+    expect(persisted?.customModels).toEqual(['gemini-2.5-flash']);
+    expect(persisted?.tools?.mcpServers).toBe(true);
+    expect(persisted?.mcpServerUrls).toEqual(['https://mcp.example.com/stream']);
+    expect(document.getElementById('save-status')?.textContent).toBe('Saved Gemini settings.');
+  });
+
+  it('preserves the stored active model because options form does not edit it directly', async () => {
+    const testWindow = dom?.window;
+    if (!testWindow) {
+      throw new Error('DOM test environment is not installed.');
+    }
+
+    storedSettings = {
+      apiKey: 'init-key',
+      model: 'gemini-2.5-flash',
+      customModels: ['gemini-2.5-flash'],
+      modelThinkingLevelMap: {
+        'gemini-3-flash-preview': 'minimal',
+        'gemini-3.1-pro-preview': 'high',
+        'gemini-2.5-flash': 'medium',
+      },
+    };
+    installChromeOptionsMock();
+    await importFreshOptionsModule();
+    await flushTasks();
+
+    (document.getElementById('api-key') as HTMLInputElement).value = 'updated-key';
+    const form = document.getElementById('settings-form') as HTMLFormElement;
+    form.dispatchEvent(new testWindow.Event('submit', { bubbles: true, cancelable: true }));
+    await flushTasks();
+
+    const persisted = savedItems[0]?.[GEMINI_SETTINGS_STORAGE_KEY] as
+      | {
+          model?: string;
+          apiKey?: string;
+        }
+      | undefined;
+    expect(persisted?.apiKey).toBe('updated-key');
+    expect(persisted?.model).toBe('gemini-2.5-flash');
+  });
+
+  it('removes a custom model row when remove is clicked', async () => {
+    const testWindow = dom?.window;
+    if (!testWindow) {
+      throw new Error('DOM test environment is not installed.');
+    }
+
+    installChromeOptionsMock();
+    await importFreshOptionsModule();
+    await flushTasks();
+
+    const addButton = document.getElementById('add-custom-model') as HTMLButtonElement;
+    addButton.dispatchEvent(new testWindow.MouseEvent('click', { bubbles: true }));
+    addButton.dispatchEvent(new testWindow.MouseEvent('click', { bubbles: true }));
+    expect(getCustomModelRows()).toHaveLength(2);
+
+    const firstRemoveButton = document.querySelector<HTMLElement>('[data-remove-custom-model]');
+    if (!firstRemoveButton) {
+      throw new Error('First remove button is missing.');
+    }
+    firstRemoveButton.dispatchEvent(new testWindow.MouseEvent('click', { bubbles: true }));
+
+    expect(getCustomModelRows()).toHaveLength(1);
+  });
+
   function installChromeOptionsMock(): void {
     const storageState: Record<string, unknown> = {
       [GEMINI_SETTINGS_STORAGE_KEY]: storedSettings,
@@ -133,7 +286,19 @@ function buildOptionsPageFixtureHtml(): string {
       <body>
         <form id="settings-form">
           <input id="api-key" />
-          <input id="model" />
+          <input id="model-name-flash" />
+          <select id="model-thinking-level-flash"></select>
+          <input id="model-name-pro" />
+          <select id="model-thinking-level-pro"></select>
+          <div id="custom-model-rows"></div>
+          <button id="add-custom-model" type="button">Add custom model</button>
+          <template id="custom-model-row-template">
+            <div data-custom-model-row>
+              <input data-custom-model-input />
+              <select data-custom-model-thinking-level></select>
+              <button type="button" data-remove-custom-model>Remove</button>
+            </div>
+          </template>
           <textarea id="system-instruction"></textarea>
           <input id="store-interactions" type="checkbox" />
           <input id="max-tool-round-trips" value="8" />
@@ -158,3 +323,22 @@ function buildOptionsPageFixtureHtml(): string {
     </html>
   `;
 }
+
+function getCustomModelRows(): Array<{
+  modelInput: HTMLInputElement;
+  thinkingLevelInput: HTMLSelectElement;
+}> {
+  return Array.from(document.querySelectorAll<HTMLElement>('[data-custom-model-row]')).map(
+    (row) => {
+      const modelInput = row.querySelector<HTMLInputElement>('[data-custom-model-input]');
+      const thinkingLevelInput = row.querySelector<HTMLSelectElement>(
+        '[data-custom-model-thinking-level]',
+      );
+      if (!modelInput || !thinkingLevelInput) {
+        throw new Error('Custom model row is missing required inputs.');
+      }
+
+      return { modelInput, thinkingLevelInput };
+    },
+  );
+}
diff --git a/tests/unit/options/validation.test.ts b/tests/unit/options/validation.test.ts
index 5c82320..33398c8 100644
--- a/tests/unit/options/validation.test.ts
+++ b/tests/unit/options/validation.test.ts
@@ -90,6 +90,16 @@ describe('validateSettings', () => {
     );
   });
 
+  it('allows MCP when a non-Gemini 3 custom model is configured', () => {
+    const settings = createValidSettings();
+    settings.model = 'gemini-3-flash-preview';
+    settings.customModels = ['gemini-2.5-flash'];
+    settings.tools.mcpServers = true;
+    settings.mcpServerUrls = ['https://mcp.example.com/stream'];
+
+    expect(validateSettings(settings)).toBeNull();
+  });
+
   it('requires both or neither map coordinates', () => {
     const onlyLatitude = createValidSettings();
     onlyLatitude.mapsLatitude = 37.422;
diff --git a/tests/unit/shared/settings.test.ts b/tests/unit/shared/settings.test.ts
index 7d52ee7..d1719b5 100644
--- a/tests/unit/shared/settings.test.ts
+++ b/tests/unit/shared/settings.test.ts
@@ -1,6 +1,11 @@
 import { describe, expect, it } from 'bun:test';
 import {
+  BUILTIN_GEMINI_MODEL_CATALOG,
+  DEFAULT_GEMINI_MODEL,
   defaultGeminiSettings,
+  getBuiltinGeminiModelByKey,
+  getModelDisplayLabel,
+  getModelThinkingLevels,
   normalizeGeminiSettings,
   parseCommaSeparatedList,
 } from '../../../src/shared/settings';
@@ -13,6 +18,10 @@ describe('defaultGeminiSettings', () => {
     expect(first).toEqual({
       apiKey: '',
       model: 'gemini-3-flash-preview',
+      modelThinkingLevelMap: {
+        'gemini-3-flash-preview': 'minimal',
+        'gemini-3.1-pro-preview': 'high',
+      },
       systemInstruction: '',
       storeInteractions: true,
       maxToolRoundTrips: 6,
@@ -40,6 +49,33 @@ describe('defaultGeminiSettings', () => {
   });
 });
 
+describe('model catalog', () => {
+  it('provides a single source for built-in models and thinking defaults', () => {
+    expect(BUILTIN_GEMINI_MODEL_CATALOG).toEqual([
+      {
+        key: 'flash',
+        model: 'gemini-3-flash-preview',
+        label: 'Flash',
+        thinkingLevels: ['minimal', 'low', 'medium', 'high'],
+        defaultThinkingLevel: 'minimal',
+      },
+      {
+        key: 'pro',
+        model: 'gemini-3.1-pro-preview',
+        label: 'Pro',
+        thinkingLevels: ['low', 'medium', 'high'],
+        defaultThinkingLevel: 'high',
+      },
+    ]);
+
+    expect(getBuiltinGeminiModelByKey('flash').model).toBe(DEFAULT_GEMINI_MODEL);
+    expect(getModelDisplayLabel('gemini-3.1-pro-preview')).toBe('Pro');
+    expect(getModelDisplayLabel('gemini-3.2-custom')).toBe('gemini-3.2-custom');
+    expect(getModelThinkingLevels('gemini-3.1-pro-preview')).toEqual(['low', 'medium', 'high']);
+    expect(getModelThinkingLevels('gemini-3.2-custom')).toEqual(['low', 'medium', 'high']);
+  });
+});
+
 describe('normalizeGeminiSettings', () => {
   it('normalizes malformed input into safe defaults', () => {
     const normalized = normalizeGeminiSettings({
@@ -64,6 +100,11 @@ describe('normalizeGeminiSettings', () => {
       mapsLatitude: ' 41.5 ',
       mapsLongitude: 'not-a-number',
       computerUseExcludedActions: [' click ', 'drag', '', 'click'],
+      modelThinkingLevelMap: {
+        ' custom-model ': ' low ',
+        '': 'high',
+        'gemini-3.1-pro-preview': 9,
+      },
     });
 
     expect(normalized.apiKey).toBe('');
@@ -87,6 +128,11 @@ describe('normalizeGeminiSettings', () => {
     expect(normalized.mapsLatitude).toBe(41.5);
     expect(normalized.mapsLongitude).toBeNull();
     expect(normalized.computerUseExcludedActions).toEqual(['click', 'drag']);
+    expect(normalized.modelThinkingLevelMap).toEqual({
+      'gemini-3-flash-preview': 'minimal',
+      'gemini-3.1-pro-preview': 'high',
+      'custom-model': 'low',
+    });
   });
 
   it('clamps and coerces numeric boundaries', () => {