fix: isolate concurrent browser agent instances

When two browser_agent calls run concurrently, they previously shared a
single BrowserManager singleton, causing one agent to navigate away from
the other's page.

Add acquire()/release() tracking to BrowserManager so getInstance()
creates a new parallel instance when the primary is already in-use.
Sequential calls still reuse the same browser (persistent session).

Changes:
- BrowserManager: add inUse field, acquire/release/isAcquired methods
- BrowserManager.getInstance: skip in-use instances, create parallel
  instances with suffixed keys (e.g. persistent:default:1)
- browserAgentFactory: call acquire() after getInstance()
- browserAgentInvocation: call release() in finally block
- Add 4 unit tests for concurrent isolation behavior
- Add integration test for concurrent browser agents with persistent
  session mode

Author: gsquared94

integration-tests/browser-agent.concurrent.responses

@@ -0,0 +1,8 @@
+{"method":"generateContentStream","response":[{"candidates":[{"content":{"parts":[{"text":"I'll launch two browser agents concurrently to check both repositories."},{"functionCall":{"name":"browser_agent","args":{"task":"Navigate to https://example.com and get the page title"}}},{"functionCall":{"name":"browser_agent","args":{"task":"Navigate to https://example.com and get the page title"}}}],"role":"model"},"finishReason":"STOP","index":0}],"usageMetadata":{"promptTokenCount":100,"candidatesTokenCount":50,"totalTokenCount":150}}]}
+{"method":"generateContentStream","response":[{"candidates":[{"content":{"parts":[{"functionCall":{"name":"navigate_page","args":{"url":"https://example.com"}}}],"role":"model"},"finishReason":"STOP","index":0}],"usageMetadata":{"promptTokenCount":100,"candidatesTokenCount":20,"totalTokenCount":120}}]}
+{"method":"generateContentStream","response":[{"candidates":[{"content":{"parts":[{"functionCall":{"name":"navigate_page","args":{"url":"https://example.com"}}}],"role":"model"},"finishReason":"STOP","index":0}],"usageMetadata":{"promptTokenCount":100,"candidatesTokenCount":20,"totalTokenCount":120}}]}
+{"method":"generateContentStream","response":[{"candidates":[{"content":{"parts":[{"functionCall":{"name":"take_snapshot","args":{}}}],"role":"model"},"finishReason":"STOP","index":0}],"usageMetadata":{"promptTokenCount":150,"candidatesTokenCount":15,"totalTokenCount":165}}]}
+{"method":"generateContentStream","response":[{"candidates":[{"content":{"parts":[{"functionCall":{"name":"take_snapshot","args":{}}}],"role":"model"},"finishReason":"STOP","index":0}],"usageMetadata":{"promptTokenCount":150,"candidatesTokenCount":15,"totalTokenCount":165}}]}
+{"method":"generateContentStream","response":[{"candidates":[{"content":{"parts":[{"functionCall":{"name":"complete_task","args":{"result":{"success":true,"summary":"Page title is Example Domain."}}}}],"role":"model"},"finishReason":"STOP","index":0}],"usageMetadata":{"promptTokenCount":200,"candidatesTokenCount":30,"totalTokenCount":230}}]}
+{"method":"generateContentStream","response":[{"candidates":[{"content":{"parts":[{"functionCall":{"name":"complete_task","args":{"result":{"success":true,"summary":"Page title is Example Domain."}}}}],"role":"model"},"finishReason":"STOP","index":0}],"usageMetadata":{"promptTokenCount":200,"candidatesTokenCount":30,"totalTokenCount":230}}]}
+{"method":"generateContentStream","response":[{"candidates":[{"content":{"parts":[{"text":"Both browser agents completed successfully. Agent 1 and Agent 2 both navigated to their respective pages and confirmed the page titles."}],"role":"model"},"finishReason":"STOP","index":0}],"usageMetadata":{"promptTokenCount":300,"candidatesTokenCount":40,"totalTokenCount":340}}]}

integration-tests/browser-agent.test.ts

@@ -307,4 +307,47 @@ describe.skipIf(!chromeAvailable)('browser-agent', () => {
 
     await run.expectText('successfully written', 15000);
   });
+
+  it('should handle concurrent browser agents with persistent session mode', async () => {
+    rig.setup('browser-concurrent', {
+      fakeResponsesPath: join(__dirname, 'browser-agent.concurrent.responses'),
+      settings: {
+        agents: {
+          overrides: {
+            browser_agent: {
+              enabled: true,
+            },
+          },
+          browser: {
+            headless: true,
+            // Persistent mode is the default — the regression scenario.
+            // Two concurrent calls should each get a separate browser.
+            sessionMode: 'persistent',
+          },
+        },
+      },
+    });
+
+    const result = await rig.run({
+      args: 'Launch two browser agents concurrently to check example.com',
+    });
+
+    assertModelHasOutput(result);
+
+    const toolLogs = rig.readToolLogs();
+    const browserCalls = toolLogs.filter(
+      (t) => t.toolRequest.name === 'browser_agent',
+    );
+
+    // Both browser_agent invocations should have been called
+    expect(browserCalls.length).toBe(2);
+
+    // Both should complete successfully (no errors)
+    for (const call of browserCalls) {
+      expect(
+        call.toolRequest.success,
+        `browser_agent call failed: ${JSON.stringify(call.toolRequest)}`,
+      ).toBe(true);
+    }
+  });
 });

packages/core/src/agents/browser/browserAgentFactory.test.ts

@@ -38,6 +38,8 @@ const mockBrowserManager = {
   ]),
   callTool: vi.fn().mockResolvedValue({ content: [] }),
   close: vi.fn().mockResolvedValue(undefined),
+  acquire: vi.fn(),
+  release: vi.fn(),
 };
 
 // Mock dependencies

packages/core/src/agents/browser/browserAgentFactory.ts

@@ -81,6 +81,7 @@ export async function createBrowserAgentDefinition(
 
   // Get or create browser manager singleton for this session mode/profile
   const browserManager = BrowserManager.getInstance(config);
+  browserManager.acquire();
   await browserManager.ensureConnection();
 
   debugLogger.log('Browser connected with isolated MCP client.');

packages/core/src/agents/browser/browserAgentInvocation.test.ts

@@ -192,7 +192,10 @@ describe('BrowserAgentInvocation', () => {
           promptConfig: { query: '', systemPrompt: '' },
           toolConfig: { tools: ['analyze_screenshot', 'click'] },
         },
-        browserManager: {} as never,
+        browserManager: {
+          release: vi.fn(),
+          callTool: vi.fn().mockResolvedValue({ content: [] }),
+        } as never,
         visionEnabled: true,
         sessionMode: 'persistent',
       });
@@ -766,6 +769,7 @@ describe('BrowserAgentInvocation', () => {
           }
           return { isError: false };
         }),
+        release: vi.fn(),
       };
 
       vi.mocked(createBrowserAgentDefinition).mockResolvedValue({

packages/core/src/agents/browser/browserAgentInvocation.ts

@@ -34,9 +34,13 @@ import {
   isToolActivityError,
 } from '../types.js';
 import type { MessageBus } from '../../confirmation-bus/message-bus.js';
-import { createBrowserAgentDefinition } from './browserAgentFactory.js';
+import {
+  createBrowserAgentDefinition,
+  cleanupBrowserAgent,
+} from './browserAgentFactory.js';
 import { removeInputBlocker } from './inputBlocker.js';
 import { logBrowserAgentTaskOutcome } from '../../telemetry/loggers.js';
+import { recordBrowserAgentTaskOutcome } from '../../telemetry/metrics.js';
 import {
   sanitizeThoughtContent,
   sanitizeToolArgs,
@@ -405,6 +409,14 @@ ${output.result}`;
         duration_ms: Date.now() - invocationStartMs,
       });
 
+      recordBrowserAgentTaskOutcome(this.config, {
+        success: taskSuccess,
+        session_mode: sessionMode,
+        vision_enabled: visionEnabled,
+        headless: !!this.config.getBrowserAgentConfig().customConfig.headless,
+        duration_ms: Date.now() - invocationStartMs,
+      });
+
       // Clean up input blocker, but keep browserManager alive for persistent sessions
       if (browserManager) {
         await removeInputBlocker(browserManager, signal);
@@ -441,6 +453,8 @@ ${output.result}`;
         } catch {
           // Ignore errors for removing the overlays.
         }
+        await cleanupBrowserAgent(browserManager, this.config, sessionMode);
+        browserManager.release();
       }
     }
   }

packages/core/src/agents/browser/browserManager.test.ts

@@ -873,6 +873,55 @@ describe('BrowserManager', () => {
 
       expect(instance1).not.toBe(instance2);
     });
+
+    it('should return a different instance when the primary is acquired', () => {
+      const instance1 = BrowserManager.getInstance(mockConfig);
+      instance1.acquire();
+
+      const instance2 = BrowserManager.getInstance(mockConfig);
+
+      expect(instance2).not.toBe(instance1);
+      expect(instance1.isAcquired()).toBe(true);
+      expect(instance2.isAcquired()).toBe(false);
+    });
+
+    it('should reuse the primary when it has been released', () => {
+      const instance1 = BrowserManager.getInstance(mockConfig);
+      instance1.acquire();
+      instance1.release();
+
+      const instance2 = BrowserManager.getInstance(mockConfig);
+
+      expect(instance2).toBe(instance1);
+      expect(instance1.isAcquired()).toBe(false);
+    });
+
+    it('should reuse a released parallel instance', () => {
+      const instance1 = BrowserManager.getInstance(mockConfig);
+      instance1.acquire();
+
+      const instance2 = BrowserManager.getInstance(mockConfig);
+      instance2.acquire();
+      instance2.release();
+
+      // Primary is still acquired, parallel is released — should reuse parallel
+      const instance3 = BrowserManager.getInstance(mockConfig);
+      expect(instance3).toBe(instance2);
+    });
+
+    it('should create multiple parallel instances for multiple concurrent calls', () => {
+      const instance1 = BrowserManager.getInstance(mockConfig);
+      instance1.acquire();
+
+      const instance2 = BrowserManager.getInstance(mockConfig);
+      instance2.acquire();
+
+      const instance3 = BrowserManager.getInstance(mockConfig);
+
+      expect(instance1).not.toBe(instance2);
+      expect(instance2).not.toBe(instance3);
+      expect(instance1).not.toBe(instance3);
+    });
   });
 
   describe('resetAll', () => {

packages/core/src/agents/browser/browserManager.ts

@@ -128,6 +128,10 @@ export class BrowserManager {
   /**
    * Returns an existing BrowserManager for the current config's session mode
    * and profile, or creates a new one.
+   *
+   * When an instance is currently acquired (in-use by an active invocation),
+   * a new instance is created with a suffixed key so concurrent browser_agent
+   * calls each get their own browser.
    */
   static getInstance(config: Config): BrowserManager {
     const key = BrowserManager.getInstanceKey(config);
@@ -136,6 +140,29 @@ export class BrowserManager {
       instance = new BrowserManager(config);
       BrowserManager.instances.set(key, instance);
       debugLogger.log(`Created new BrowserManager singleton (key: ${key})`);
+    } else if (instance.inUse) {
+      // The primary instance is in-use by another concurrent invocation.
+      // Find or create a parallel instance with a suffixed key.
+      let suffix = 1;
+      let parallelKey = `${key}:${suffix}`;
+      let parallel = BrowserManager.instances.get(parallelKey);
+      while (parallel?.inUse) {
+        suffix++;
+        parallelKey = `${key}:${suffix}`;
+        parallel = BrowserManager.instances.get(parallelKey);
+      }
+      if (!parallel) {
+        parallel = new BrowserManager(config);
+        BrowserManager.instances.set(parallelKey, parallel);
+        debugLogger.log(
+          `Created parallel BrowserManager (key: ${parallelKey})`,
+        );
+      } else {
+        debugLogger.log(
+          `Reusing released parallel BrowserManager (key: ${parallelKey})`,
+        );
+      }
+      instance = parallel;
     } else {
       debugLogger.log(
         `Reusing existing BrowserManager singleton (key: ${key})`,
@@ -180,6 +207,36 @@ export class BrowserManager {
   private isClosing = false;
   private connectionPromise: Promise<void> | undefined;
 
+  /**
+   * Whether this instance is currently acquired by an active invocation.
+   * Used by getInstance() to avoid handing the same browser to concurrent
+   * browser_agent calls.
+   */
+  private inUse = false;
+
+  /**
+   * Marks this instance as in-use. Call this when starting a browser agent
+   * invocation so concurrent calls get a separate instance.
+   */
+  acquire(): void {
+    this.inUse = true;
+  }
+
+  /**
+   * Marks this instance as available for reuse. Call this in the finally
+   * block of a browser agent invocation.
+   */
+  release(): void {
+    this.inUse = false;
+  }
+
+  /**
+   * Returns whether this instance is currently acquired by an active invocation.
+   */
+  isAcquired(): boolean {
+    return this.inUse;
+  }
+
   /** State for action rate limiting */
   private actionCounter = 0;
   private readonly maxActionsPerTask: number;