@@ -103,6 +103,14 @@ interface OccludablePanelFrame {
 }
 /** Geometry of the painted frame that is currently allowed to replace the view. */
 let occludableFrame: OccludablePanelFrame | null = null
+/**
+ * Each chat's agent tab, kept in a window even while no panel shows it. A view that is in no
+ * window has no compositor surface: CDP input on it never acknowledges and captures never
+ * complete. Parked invisibly, it renders exactly like the hidden panel view does.
+ */
+const agentViews = new Map<string, WebContentsView>()
+/** Agent views parked invisibly, with the window each one is parked in. */
+const parkedViews = new Map<WebContentsView, BrowserWindow>()
 /** The host window whose `resize` currently drives {@link layout}, if any. */
 let resizeBoundWindow: BrowserWindow | null = null
 /** Captures nothing, so one instance serves every window it is bound to. */
@@ -114,6 +122,8 @@ export function initPanel(panelHost: PanelHost): void {
   // by the next session: a stale owner window that rejects legitimate panel
   // updates, a lease timer polling for a panel that no longer exists, a
   // `lastApplied*` value that dedupes away the first layout of the new one.
+  agentViews.clear()
+  for (const view of [...parkedViews.keys()]) unparkView(view)
   detachAttachedView()
   resetOcclusion()
   if (leaseTimer !== null) {
@@ -299,6 +309,11 @@ function detachAttachedView(): void {
   if (!view || !win) return
   try {
     if (win.isDestroyed() || view.webContents.isDestroyed()) return
+    if (isAgentView(view)) {
+      view.setVisible(false)
+      parkedViews.set(view, win)
+      return
+    }
     win.contentView.removeChildView(view)
   } catch (error) {
     logger.warn('Could not detach embedded browser view', {
@@ -342,9 +357,67 @@ function hideAttachedView(): void {
  * tab must not pull the visible tab out of the window.
  */
 export function detachIfAttached(view: WebContentsView): void {
+  for (const [scopeId, agentView] of agentViews) {
+    if (agentView === view) agentViews.delete(scopeId)
+  }
   if (attachedView === view) {
     detachAttachedView()
   }
+  unparkView(view)
+}
+
+/**
+ * Registers the tab a chat's agent drives, so it stays composited while the panel shows
+ * another tab or no panel is open. Null releases the chat's previous agent tab.
+ */
+export function setAgentView(scopeId: string, view: WebContentsView | null): void {
+  const previous = agentViews.get(scopeId)
+  if (view) agentViews.set(scopeId, view)
+  else agentViews.delete(scopeId)
+  if (previous && previous !== view && !isAgentView(previous)) unparkView(previous)
+  parkAgentViews()
+}
+
+function isAgentView(view: WebContentsView): boolean {
+  for (const agentView of agentViews.values()) {
+    if (agentView === view) return true
+  }
+  return false
+}
+
+/** Parks every agent view that no window holds, keeping renderer focus where it was. */
+function parkAgentViews(): void {
+  const win = host.getMainWindow()
+  if (!win || win.isDestroyed()) return
+  for (const view of agentViews.values()) {
+    if (view === attachedView || view.webContents.isDestroyed()) continue
+    const parkedIn = parkedViews.get(view)
+    if (parkedIn && !parkedIn.isDestroyed()) continue
+    const rendererHadFocus = !win.webContents.isDestroyed() && win.webContents.isFocused()
+    try {
+      view.setVisible(false)
+      win.contentView.addChildView(view)
+      parkedViews.set(view, win)
+    } catch (error) {
+      logger.warn('Could not park the agent browser view', {
+        error: getErrorMessage(error, 'unknown'),
+      })
+    }
+    if (rendererHadFocus) win.webContents.focus()
+  }
+}
+
+function unparkView(view: WebContentsView): void {
+  const win = parkedViews.get(view)
+  if (!win) return
+  parkedViews.delete(view)
+  try {
+    if (!win.isDestroyed() && !view.webContents.isDestroyed()) win.contentView.removeChildView(view)
+  } catch (error) {
+    logger.warn('Could not unpark the agent browser view', {
+      error: getErrorMessage(error, 'unknown'),
+    })
+  }
 }
 
 /**
@@ -393,22 +466,31 @@ export function layout(): void {
   }
   if (!showing || !active || !win || panelBounds === null) {
     hideAttachedView()
+    parkAgentViews()
     return
   }
 
   if (attachedView !== active.view) {
-    // addChildView hands keyboard focus to the newly attached WebContentsView.
-    // Agent-driven attaches happen while the user may be typing in the chat
-    // composer, so if the renderer held focus before the attach, give it back —
-    // automation drives the page over CDP and never needs OS focus.
-    const rendererHadFocus = !win.webContents.isDestroyed() && win.webContents.isFocused()
-    win.contentView.addChildView(active.view)
+    // A parked agent view already sits in this window; adopting it in place avoids the
+    // blank repaint a remove-and-add costs.
+    const parkedIn = parkedViews.get(active.view)
+    parkedViews.delete(active.view)
+    if (parkedIn !== win) {
+      if (parkedIn && !parkedIn.isDestroyed()) parkedIn.contentView.removeChildView(active.view)
+      // addChildView hands keyboard focus to the newly attached WebContentsView.
+      // Agent-driven attaches happen while the user may be typing in the chat
+      // composer, so if the renderer held focus before the attach, give it back —
+      // automation drives the page over CDP and never needs OS focus.
+      const rendererHadFocus = !win.webContents.isDestroyed() && win.webContents.isFocused()
+      win.contentView.addChildView(active.view)
+      if (rendererHadFocus) {
+        win.webContents.focus()
+      }
+    }
     hostedWindow = win
     attachedView = active.view
-    if (rendererHadFocus) {
-      win.webContents.focus()
-    }
   }
+  parkAgentViews()
   bindHostResize(win)
   const zoom = win.webContents.getZoomFactor()
   const [contentWidth, contentHeight] = win.getContentSize()
 
@@ -2398,14 +2398,18 @@ describe('browser-agent session', () => {
 
   it('gives background automation a viewport without taking panel ownership', () => {
     const tab = session.withBrowserScope('background-chat', () => session.ensureTab())
+    const view = tab.view as unknown as MockView
 
     expect(tab.view.setBounds).toHaveBeenCalledWith({
       x: 0,
       y: 0,
       width: 1180,
       height: 850,
     })
-    expect(win.contentView.addChildView).not.toHaveBeenCalledWith(tab.view)
+    // Parked invisibly so input and captures on it complete; it never shows.
+    expect(win.contentView.addChildView).toHaveBeenCalledWith(tab.view)
+    expect(view.setVisible).toHaveBeenCalledWith(false)
+    expect(view.setVisible).not.toHaveBeenCalledWith(true)
     expect(session.getActiveBrowserScopeId()).toBe('chat-test')
   })
 
@@ -2422,11 +2426,16 @@ describe('browser-agent session', () => {
     const content = (win as unknown as { contentView: { addChildView: ReturnType<typeof vi.fn> } })
       .contentView
 
-    // No bounds yet: the view is not attached to the window.
-    expect(content.addChildView).not.toHaveBeenCalledWith(tab.view)
+    // No bounds yet: the agent's view is parked invisibly, never shown.
+    expect(content.addChildView).toHaveBeenCalledWith(tab.view)
+    expect(view.setVisible).toHaveBeenCalledWith(false)
+    expect(view.setVisible).not.toHaveBeenCalledWith(true)
 
+    // Bounds arrive: the parked view is adopted in place, not re-added.
+    content.addChildView.mockClear()
     panel.setPanelBounds({ x: 100, y: 50, width: 800, height: 600 })
-    expect(content.addChildView).toHaveBeenCalledWith(tab.view)
+    expect(content.addChildView).not.toHaveBeenCalled()
+    expect(view.setVisible).toHaveBeenLastCalledWith(true)
     expect(view.setBounds).toHaveBeenCalledWith({ x: 100, y: 50, width: 800, height: 600 })
 
     // Panel hidden: the view stops painting but stays attached. Detaching
@@ -2467,11 +2476,48 @@ describe('browser-agent session', () => {
 
     const second = session.addTab()
 
-    // Hiding keeps a view attached, but a tab switch still has to detach:
-    // two native views stacked in the window would composite over each other.
-    expect(content.removeChildView).toHaveBeenCalledWith(first.view)
+    // A tab switch hides the previous view so two native views never composite over
+    // each other; the agent still drives the first tab, so it stays parked, not removed.
+    expect(content.removeChildView).not.toHaveBeenCalledWith(first.view)
+    expect(first.view.setVisible).toHaveBeenLastCalledWith(false)
     expect(content.addChildView).toHaveBeenCalledWith(second.view)
     expect(second.view.webContents.invalidate).toHaveBeenCalledOnce()
+
+    // A tab the agent does not drive is removed when another tab takes over.
+    content.removeChildView.mockClear()
+    session.switchTab(first.id)
+    expect(content.removeChildView).toHaveBeenCalledWith(second.view)
+  })
+
+  it('keeps the agent tab composited while the user views another tab, and releases it on close', () => {
+    const agentTab = session.ensureTab()
+    panel.setPanelBounds({ x: 0, y: 0, width: 800, height: 600 })
+    const content = (
+      win as unknown as {
+        contentView: {
+          addChildView: ReturnType<typeof vi.fn>
+          removeChildView: ReturnType<typeof vi.fn>
+        }
+      }
+    ).contentView
+    const userTab = session.addTab()
+    const agentView = agentTab.view as unknown as MockView
+
+    // The user's tab is visible; the agent's tab is parked, still in the window.
+    expect(content.removeChildView).not.toHaveBeenCalledWith(agentTab.view)
+    expect(agentView.setVisible).toHaveBeenLastCalledWith(false)
+
+    // Switching back adopts the parked view in place.
+    content.addChildView.mockClear()
+    session.switchTab(agentTab.id)
+    expect(content.addChildView).not.toHaveBeenCalledWith(agentTab.view)
+    expect(agentView.setVisible).toHaveBeenLastCalledWith(true)
+
+    // Closing the agent tab while the user views another tab removes its parked view.
+    session.switchTab(userTab.id)
+    content.removeChildView.mockClear()
+    session.closeTab(agentTab.id)
+    expect(content.removeChildView).toHaveBeenCalledWith(agentTab.view)
   })
 
   // The measured report is the sole writer of bounds. A main-process
 
@@ -62,6 +62,7 @@ import {
   migratePanelScope,
   panelUpdateAllowed,
   panelWindow,
+  setAgentView,
 } from '@/main/browser-agent/panel'
 import {
   agentAppOrigin,
@@ -2155,7 +2156,7 @@ function createFreshTabView(appSession: BrowserAppSession | undefined): WebConte
       preload: join(__dirname, 'browser-preload.cjs'),
       // Throttled by default: a hidden tab should idle. The one exception is
       // the active tab while a tool waits on it, applied explicitly by
-      // applyActiveTabThrottling — never blanket across every tab.
+      // applyAutomationTabPolicy — never blanket across every tab.
       backgroundThrottling: true,
       spellcheck: false,
       // The default every origin this tab visits starts at; a per-origin zoom
@@ -2476,7 +2477,7 @@ export function hasSession(): boolean {
 export function setAutomationActive(active: boolean): void {
   if (currentScope.automationActive === active) return
   currentScope.automationActive = active
-  applyActiveTabThrottling()
+  applyAutomationTabPolicy()
   events?.onTabsChanged()
 }
 
@@ -2486,26 +2487,27 @@ export function setAutomationNeedsAttention(needsAttention: boolean): void {
   events?.onTabsChanged()
 }
 
-/**
- * Unthrottles the active tab while automation is active, and throttles every
- * other tab. Call after anything that changes which tab is active, so the
- * exemption follows the active tab rather than being stranded on the old one.
- */
 /**
  * Re-applies the tab throttling policy after a caller temporarily suspended it
  * (the panel's reveal pulse). Exempts the automation-active tab exactly as the
  * internal policy does.
  */
 export function reassertTabThrottling(): void {
-  applyActiveTabThrottling()
+  applyAutomationTabPolicy()
 }
 
-function applyActiveTabThrottling(): void {
+/**
+ * Unthrottles the automation tab while automation is active, throttles every other tab, and
+ * keeps the automation tab composited while no panel shows it. Call after anything that changes
+ * which tab the agent drives, so neither follows a stale tab.
+ */
+function applyAutomationTabPolicy(): void {
   for (const tab of tabs) {
     if (tab.view.webContents.isDestroyed()) continue
     const exempt = currentScope.automationActive && tab.id === currentScope.automationTabId
     tab.view.webContents.setBackgroundThrottling(!exempt)
   }
+  setAgentView(getBrowserScopeId(), automationTab()?.view ?? null)
 }
 
 /** A closed target must not transfer its activity marker to a replacement tab. */
@@ -2643,7 +2645,7 @@ function addTabInternal({
       revokeTabMediaPermissions(previousActiveTab, false)
     }
     currentScope.activeTabId = tab.id
-    applyActiveTabThrottling()
+    applyAutomationTabPolicy()
     if (!currentScope.restoring) layout()
     if (transferBrowserFocus) currentScope.focusedBrowserTabId = tab.id
     if (notify && !currentScope.restoring) events?.onActiveTabChanged(tab.view.webContents)
@@ -2923,7 +2925,7 @@ export function tabForNavigation(
     detachIfAttached(tab.view)
     tab.view = view
     contents.close()
-    applyActiveTabThrottling()
+    applyAutomationTabPolicy()
     layout()
     events?.onActiveTabChanged(view.webContents)
     return view.webContents
@@ -3058,13 +3060,13 @@ export function restoreBrowserSession(): void {
     state.lastPersistedSnapshot = previousState.lastPersistedSnapshot
     if (previousDownloads) browserDownloadsByScope.set(scopeId, previousDownloads)
     else browserDownloadsByScope.delete(scopeId)
-    applyActiveTabThrottling()
+    applyAutomationTabPolicy()
     throw error
   } finally {
     state.restoring = false
   }
 
-  applyActiveTabThrottling()
+  applyAutomationTabPolicy()
   const restoredActive = restoredLoads.find(({ tab }) => tab.id === state.activeTabId)
   if (restoredActive) {
     pendingForegroundTabRestores.push(
@@ -3099,7 +3101,7 @@ export function addAutomationTab(url?: string, popup?: PopupWindowOptions): Agen
   restoreBrowserSession()
   const tab = addTabInternal({ activate: false, notify: false, url, popup })
   currentScope.automationTabId = tab.id
-  applyActiveTabThrottling()
+  applyAutomationTabPolicy()
   persistBrowserSession()
   events?.onTabsChanged()
   return tab
@@ -3113,7 +3115,7 @@ export function ensureAutomationTab(): AgentTab {
   tab = activeTab()
   if (tab) {
     currentScope.automationTabId = tab.id
-    applyActiveTabThrottling()
+    applyAutomationTabPolicy()
     events?.onTabsChanged()
     return tab
   }
@@ -3174,7 +3176,7 @@ export function switchTab(tabId: string, { claim = true }: { claim?: boolean } =
   promotePendingTabRestore(tab)
   // Visible selection does not move the automation exemption; the user may
   // inspect another page while a tool continues in its background tab.
-  applyActiveTabThrottling()
+  applyAutomationTabPolicy()
   layout()
   if (transferBrowserFocus) currentScope.focusedBrowserTabId = tab.id
   persistBrowserSession()
@@ -3189,7 +3191,7 @@ export function switchAutomationTab(tabId: string): AgentTab {
   const tab = tabs.find((entry) => entry.id === tabId)
   if (!tab) throw new SessionError(`No tab with id ${tabId} — call browser_list_tabs.`)
   currentScope.automationTabId = tab.id
-  applyActiveTabThrottling()
+  applyAutomationTabPolicy()
   events?.onTabsChanged()
   return tab
 }
@@ -3271,7 +3273,7 @@ function removeTab(
     const opener = tabs.find((entry) => entry.id === tab.openerTabId)
     currentScope.automationTabId =
       opener?.id ?? (adoptNeighborForAgent ? ((tabs[index] ?? tabs[index - 1])?.id ?? null) : null)
-    applyActiveTabThrottling()
+    applyAutomationTabPolicy()
   }
   if (transferBrowserFocus) currentScope.focusedBrowserTabId = currentScope.activeTabId
   persistBrowserSession()