@@ -761,6 +761,28 @@ test.describe('browser tools', () => {
     expect(await formState()).toMatchObject({ scrollLeft: 0 })
   })
 
+  test('batches an action with a fresh observation without replaying form fields', async () => {
+    const ref = await openForm()
+    const fill = await execute('browser_fill_form', {
+      fields: [{ elementId: ref('Name'), kind: 'text', text: 'Observed value' }],
+      observe: { query: 'Name' },
+    })
+    expect(fill.ok, fill.error).toBe(true)
+    expect(fill.result).toMatchObject({
+      completed: true,
+      completedCount: 1,
+      observation: { ok: true, result: { totalMatches: 1 } },
+    })
+    expect(await formState()).toMatchObject({ name: 'Observed value' })
+    const result = fill.result as { observation: { result: { matches: { elementId: number }[] } } }
+    const freshId = result.observation.result.matches[0].elementId
+    expect(freshId).not.toBe(ref('Name'))
+    const clear = await execute('browser_type', { elementId: freshId, text: '', observe: {} })
+    expect(clear.ok, clear.error).toBe(true)
+    expect(clear.result).toMatchObject({ observation: { ok: true } })
+    expect(await formState()).toMatchObject({ name: '' })
+  })
+
   test('stops after a route change without writing the next field', async () => {
     const ref = await openForm()
     const fill = await execute('browser_fill_form', {
 
@@ -69,6 +69,7 @@ import {
   setFocusedInputValue,
   typeIntoElement,
 } from '@/main/browser-agent/page-functions'
+import { withPostActionObservation } from '@/main/browser-agent/post-action-observation'
 import * as session from '@/main/browser-agent/session'
 import { checkAgentUrl } from '@/main/browser-agent/url-guard'
 import { clearCredentials, fillCoordinator, initFillCoordinator } from '@/main/browser-credentials'
@@ -4698,13 +4699,28 @@ export async function executeTool(
               throw new ToolError('This browser action expired before it could dispatch input.')
             }
           }
-          const execution = executeToolInner(
+          const execution = withPostActionObservation(
             tool,
             params,
-            assertCurrentExecution,
-            executionDeadline,
-            invocationEpoch,
-            executionController.signal
+            (actionParams) =>
+              executeToolInner(
+                tool,
+                actionParams,
+                assertCurrentExecution,
+                executionDeadline,
+                invocationEpoch,
+                executionController.signal
+              ),
+            (query) =>
+              executeToolInner(
+                query === undefined ? 'browser_snapshot' : 'browser_find',
+                query === undefined ? {} : { query },
+                assertCurrentExecution,
+                executionDeadline,
+                invocationEpoch,
+                executionController.signal
+              ),
+            assertCurrentExecution
           )
           const guardedExecution =
             watchdogMs === null
@@ -4715,7 +4731,8 @@ export async function executeTool(
                   if (
                     tool === 'browser_snapshot' ||
                     tool === 'browser_open_url' ||
-                    tool === 'browser_find'
+                    tool === 'browser_find' ||
+                    params.observe !== undefined
                   ) {
                     invalidateSnapshot(state)
                   }
@@ -4754,7 +4771,12 @@ export async function executeTool(
       // The watchdog cannot cancel an in-flight renderer promise. Invalidate its
       // capture token before releasing the queue so a late snapshot cannot
       // overwrite refs belonging to a newer tab or snapshot.
-      if (tool === 'browser_snapshot' || tool === 'browser_open_url' || tool === 'browser_find') {
+      if (
+        tool === 'browser_snapshot' ||
+        tool === 'browser_open_url' ||
+        tool === 'browser_find' ||
+        params.observe !== undefined
+      ) {
         invalidateSnapshot(state)
       }
       const message = String(sanitizeBrowserResult(getErrorMessage(error), undefined, 0, 'error'))
 
@@ -0,0 +1,102 @@
+import { describe, expect, it, vi } from 'vitest'
+import { withPostActionObservation } from './post-action-observation'
+
+describe('post-action observation', () => {
+  it('validates observation arguments before dispatching input', async () => {
+    for (const observe of [
+      null,
+      true,
+      [],
+      { query: '' },
+      { query: 'x'.repeat(4097) },
+      { extra: 1 },
+    ]) {
+      const action = vi.fn()
+      await expect(
+        withPostActionObservation('browser_click', { observe }, action, vi.fn(), vi.fn())
+      ).rejects.toThrow('observe must')
+      expect(action).not.toHaveBeenCalled()
+    }
+  })
+
+  it('keeps standalone actions unchanged and does not capture unrequested state', async () => {
+    const result = { dispatched: true, effectObserved: false }
+    const observe = vi.fn()
+    expect(
+      await withPostActionObservation('browser_click', {}, async () => result, observe, vi.fn())
+    ).toBe(result)
+    expect(observe).not.toHaveBeenCalled()
+  })
+
+  it('observes after the action, preserving partial form results and replacing refs', async () => {
+    const order: string[] = []
+    const result = await withPostActionObservation(
+      'browser_fill_form',
+      { observe: { query: 'Save' } },
+      async () => {
+        order.push('action')
+        return { completed: false, completedCount: 1, doNotRetry: true }
+      },
+      async (query) => {
+        order.push('observe')
+        expect(query).toBe('Save')
+        return { matches: [{ elementId: 24, line: 'button Save [ref=24]' }] }
+      },
+      vi.fn()
+    )
+    expect(order).toEqual(['action', 'observe'])
+    expect(result).toMatchObject({
+      completed: false,
+      completedCount: 1,
+      doNotRetry: true,
+      observation: { ok: true, result: { matches: [{ elementId: 24 }] } },
+    })
+  })
+
+  it('does not repeat or misreport a dispatched action when observation fails', async () => {
+    const action = vi.fn(async () => ({ dispatched: true, effectObserved: false }))
+    const result = await withPostActionObservation(
+      'browser_click',
+      { observe: {} },
+      action,
+      async () => {
+        throw new Error('Page changed')
+      },
+      vi.fn()
+    )
+    expect(action).toHaveBeenCalledTimes(1)
+    expect(action).toHaveBeenCalledWith({})
+    expect(result).toMatchObject({
+      dispatched: true,
+      effectObserved: false,
+      observation: { ok: false, error: 'Page changed' },
+    })
+  })
+
+  it('never observes after failed actions or expired executions', async () => {
+    const observe = vi.fn()
+    await expect(
+      withPostActionObservation(
+        'browser_type',
+        { observe: {} },
+        async () => {
+          throw new Error('Ref expired')
+        },
+        observe,
+        vi.fn()
+      )
+    ).rejects.toThrow('Ref expired')
+    await expect(
+      withPostActionObservation(
+        'browser_type',
+        { observe: {} },
+        async () => ({ typed: true }),
+        observe,
+        () => {
+          throw new Error('Cancelled')
+        }
+      )
+    ).rejects.toThrow('Cancelled')
+    expect(observe).not.toHaveBeenCalled()
+  })
+})
@@ -0,0 +1,53 @@
+import type { BrowserToolName } from '@sim/browser-protocol'
+import { getErrorMessage } from '@sim/utils/errors'
+import { isRecordLike } from '@sim/utils/object'
+import { ToolError } from '@/main/browser-agent/errors'
+
+const OBSERVABLE_ACTIONS: ReadonlySet<BrowserToolName> = new Set([
+  'browser_click',
+  'browser_type',
+  'browser_press_key',
+  'browser_fill_form',
+])
+
+/** Validate before dispatch; an observation failure must never invite replay of a completed action. */
+export async function withPostActionObservation(
+  tool: BrowserToolName,
+  params: Record<string, unknown>,
+  action: (params: Record<string, unknown>) => Promise<unknown>,
+  observe: (query: string | undefined) => Promise<unknown>,
+  assertCurrent: () => void
+): Promise<unknown> {
+  const request = params.observe
+  if (request === undefined) return action(params)
+  if (
+    !OBSERVABLE_ACTIONS.has(tool) ||
+    !isRecordLike(request) ||
+    Object.keys(request).some((key) => key !== 'query') ||
+    (request.query !== undefined &&
+      (typeof request.query !== 'string' ||
+        request.query.length === 0 ||
+        request.query.length > 4096))
+  ) {
+    throw new ToolError(
+      'observe must be {} or {query: nonempty text up to 4096 characters} on a supported action.'
+    )
+  }
+  const query = typeof request.query === 'string' ? request.query : undefined
+  const { observe: _observe, ...actionParams } = params
+  const result = await action(actionParams)
+  assertCurrent()
+  let observation: unknown
+  try {
+    observation = { ok: true, result: await observe(query) }
+  } catch (error) {
+    assertCurrent()
+    observation = {
+      ok: false,
+      error: getErrorMessage(error),
+      note: 'The action already ran. Inspect its result; do not repeat it just because observation failed.',
+    }
+  }
+  assertCurrent()
+  return isRecordLike(result) ? { ...result, observation } : { result, observation }
+}
@@ -6,6 +6,7 @@ export interface ToolCatalogEntry {
   capabilities?: unknown
   clientExecutable?: boolean
   description?:
+    | 'Create a workspace in the conversation’s organization under the current user’s workspace-creation policy. Returns its ID for subsequent explicitly workspace-scoped commands. Includes a starter workflow unless skipDefaultWorkflow is true.'
     | 'Discover and configure organization Search sources. list/get return accessible sources and indexing status; providers returns available integration approvals; approve changes a provider approval when authorized; setup returns the existing connection UI for the user to complete. Put the returned setupUrl in a clickable Markdown link at the end of the reply. Setup does not mean connected or indexed. Use search_workspace and read_document to retrieve source content.'
     | 'List currently accessible workspaces with roles and explicit capability restrictions. Bulk results report copilotAllowed and deniedCapabilities; exact workspaceId returns the full capability map. Omitted restrictions never authorize an operation.'
     | 'Read and manage account, organization, and workspace settings. list finds sections; get returns current values, updateSchema and operation names; describe returns one operation’s exact input schema; update changes narrow preferences; execute performs a listed operation; open returns the existing user setup flow. When user setup is needed, put the returned setupUrl in a clickable Markdown link at the end of the reply. Workspace resources retain their CLI commands. Account is the acting user; organization is the conversation’s organization. Every operation checks current permissions and entitlements.'
@@ -149,6 +150,7 @@ export interface ToolCatalogEntry {
     | 'web_scrape'
     | 'web_search'
     | 'workflow'
+    | 'workspaces'
   internal?: boolean
   mode?: 'async' | 'sync'
   name?:
@@ -400,6 +402,18 @@ export const BrowserClick: ToolCatalogEntry = {
         description:
           "The element id to act on (from the current tab's most recent browser_snapshot). Treat refs as invalid across tab switches or later snapshots.",
       },
+      observe: {
+        type: 'object',
+        description:
+          'Observe immediately after this action in the same call. Use {} for a fresh snapshot or {query: string} for matching element refs only. Returned refs replace prior refs. A failed observation does not mean the action failed; inspect its result before retrying.',
+        properties: {
+          query: {
+            type: 'string',
+            description:
+              'Case-insensitive text to find in the resulting page. Omit for the full snapshot. Maximum 4096 characters.',
+          },
+        },
+      },
     },
     required: ['elementId'],
   },
@@ -892,6 +906,18 @@ export const BrowserFillForm: ToolCatalogEntry = {
         minItems: 1,
         type: 'array',
       },
+      observe: {
+        type: 'object',
+        description:
+          'Observe immediately after this action in the same call. Use {} for a fresh snapshot or {query: string} for matching element refs only. Returned refs replace prior refs. A failed observation does not mean the action failed; inspect its result before retrying.',
+        properties: {
+          query: {
+            type: 'string',
+            description:
+              'Case-insensitive text to find in the resulting page. Omit for the full snapshot. Maximum 4096 characters.',
+          },
+        },
+      },
     },
     required: ['fields'],
     type: 'object',
@@ -1358,6 +1384,18 @@ export const BrowserPressKey: ToolCatalogEntry = {
         description:
           "Key or combination. Named keys (case-insensitive): Enter, Escape (Esc), Tab, Backspace, Delete, Space, ArrowUp/ArrowDown/ArrowLeft/ArrowRight (or Up/Down/Left/Right), Home, End, PageUp, PageDown. Any single character also works ('a', '5', '/', ','). Anything else — 'F5', 'Return', 'Insert' — is rejected. Join modifiers with '+'. Use Mod (aliases Primary, ControlOrMeta, CommandOrControl) for the platform primary modifier, e.g. Mod+K or Mod+,. Raw Control/Ctrl and Cmd/Command/Meta remain available; Control is not generally Cmd on macOS. Check effectObserved and primaryModifier in the result.",
       },
+      observe: {
+        type: 'object',
+        description:
+          'Observe immediately after this action in the same call. Use {} for a fresh snapshot or {query: string} for matching element refs only. Returned refs replace prior refs. A failed observation does not mean the action failed; inspect its result before retrying.',
+        properties: {
+          query: {
+            type: 'string',
+            description:
+              'Case-insensitive text to find in the resulting page. Omit for the full snapshot. Maximum 4096 characters.',
+          },
+        },
+      },
     },
     required: ['key'],
   },
@@ -1856,6 +1894,18 @@ export const BrowserType: ToolCatalogEntry = {
         description:
           "The element id to act on (from the current tab's most recent browser_snapshot). Treat refs as invalid across tab switches or later snapshots.",
       },
+      observe: {
+        type: 'object',
+        description:
+          'Observe immediately after this action in the same call. Use {} for a fresh snapshot or {query: string} for matching element refs only. Returned refs replace prior refs. A failed observation does not mean the action failed; inspect its result before retrying.',
+        properties: {
+          query: {
+            type: 'string',
+            description:
+              'Case-insensitive text to find in the resulting page. Omit for the full snapshot. Maximum 4096 characters.',
+          },
+        },
+      },
       submit: { type: 'boolean', description: 'Press Enter after typing. Default false.' },
       text: {
         type: 'string',
@@ -7250,6 +7300,24 @@ export const ListWorkspaces: ToolCatalogEntry = {
   },
 }
 
+export const Workspaces: ToolCatalogEntry = {
+  id: 'workspaces',
+  description:
+    'Create a workspace in the conversation’s organization under the current user’s workspace-creation policy. Returns its ID for subsequent explicitly workspace-scoped commands. Includes a starter workflow unless skipDefaultWorkflow is true.',
+  route: 'sim',
+  parameters: {
+    $schema: 'http://json-schema.org/draft-07/schema#',
+    type: 'object',
+    properties: {
+      name: { type: 'string', minLength: 1 },
+      skipDefaultWorkflow: { default: false, type: 'boolean' },
+      action: { type: 'string', const: 'create' },
+    },
+    required: ['name', 'action'],
+    additionalProperties: false,
+  },
+}
+
 export const Settings: ToolCatalogEntry = {
   id: 'settings',
   description:
@@ -7945,6 +8013,7 @@ export const TOOL_CATALOG: Record<string, ToolCatalogEntry> = {
   [WebSearch.id]: WebSearch,
   [Workflow.id]: Workflow,
   [ListWorkspaces.id]: ListWorkspaces,
+  [Workspaces.id]: Workspaces,
   [Settings.id]: Settings,
   [SearchSources.id]: SearchSources,
 }