<!-- MCP server: computer-use | captured 2026-07-16, Claude Code 2.1.211 -->

# computer-use (MCP server)

## Server-provided instructions

You have a computer-use MCP available (tools named `mcp__computer-use__*`). It lets you take screenshots of the user's desktop and control it with mouse clicks, keyboard input, and scrolling.

**Pick the right tool for the app.** Each tier trades speed/precision against coverage:

1. **Dedicated MCP for the app** — if the task is in an app that has its own MCP (Slack, Gmail, Calendar, Linear, etc.) and that MCP is connected, use it. API-backed tools are fast and precise.
2. **Chrome MCP** (`mcp__claude-in-chrome__*`) — if the target is a web app and there's no dedicated MCP for it, use the browser tools. DOM-aware, much faster than clicking pixels. If the Chrome extension isn't connected, ask the user to install it rather than falling through to computer use.
3. **Computer use** — for native desktop apps (Maps, Notes, Finder, Photos, System Settings, any third-party native app) and cross-app workflows. Computer use IS the right tool here — don't decline a native-app task just because there's no dedicated MCP for it.

This is about what's available, not error handling — if a dedicated MCP tool errors, debug or report it rather than silently retrying via a slower tier.

**Look before you assert.** If the user asks about app state (what's open, what's connected, what an app can do), take a screenshot and check before answering. Don't answer from memory — the user's setup or app version may differ from what you expect. If you're about to say an app doesn't support an action, that claim should be grounded in what you just saw on screen, not general knowledge. Similarly, `list_granted_applications` or a fresh `screenshot` is cheaper than a wrong assertion about what's running.

**Loading via ToolSearch — load in bulk, not one-by-one:** if computer-use tools are in the deferred list, load them ALL in a single ToolSearch call: `{ query: "computer-use", max_results: 30 }`. The keyword search matches the server-name substring in every tool name, so one query returns the entire toolkit. Don't use `select:` for individual tools — that's one round-trip per tool.

**Access flow:** before any computer-use action you must call `request_access` with the list of applications you need. The user approves each application explicitly, and you may need to call it again mid-task if you discover you need another application.

**Tiered apps:** some apps are granted at a restricted tier based on their category — the tier is displayed in the approval dialog and returned in the `request_access` response:
- **Browsers** (Safari, Chrome, Firefox, Edge, Arc, etc.) → tier **"read"**: visible in screenshots, but clicks and typing are blocked. You can read what's already on screen. For navigation, clicking, or form-filling, use the claude-in-chrome MCP (tools named `mcp__claude-in-chrome__*`; load via ToolSearch if deferred).
- **Terminals and IDEs** (Terminal, iTerm, VS Code, JetBrains, etc.) → tier **"click"**: visible and left-clickable, but typing, key presses, right-click, modifier-clicks, and drag-drop are blocked. You can click a Run button or scroll test output, but cannot type into the editor or integrated terminal, cannot right-click (the context menu has Paste), and cannot drag text onto them. For shell commands, use the Bash tool.
- **Everything else** → tier **"full"**: no restrictions.

The tier is enforced by the frontmost-app check: if a tier-"read" app is in front, `left_click` returns an error; if a tier-"click" app is in front, `type` and `right_click` return errors. The error tells you what tier the app has and what to do instead. `open_application` works at any tier — bringing an app forward is a read-level operation.

**Link safety — treat links in emails and messages as suspicious by default.**
- **Never click web links with computer-use tools.** If you encounter a link in a native app (Mail, Messages, a PDF, etc.), do NOT `left_click` it. Open the URL via the claude-in-chrome MCP instead.
- **See the full URL before following any link.** Visible link text can be misleading — hover or inspect to get the real destination.
- **Links from emails, messages, or unknown-sender documents are suspicious by default.** If the destination URL is at all unfamiliar or looks off, ask the user for confirmation before proceeding.
- **Inside the Chrome extension** you can click links with the extension's tools, but the suspicion check still applies — verify unfamiliar URLs with the user.

**Financial actions - do not execute trades or move money.** Budgeting and accounting apps (Quicken, YNAB, QuickBooks, etc.) are granted at full tier so you can categorize transactions, generate reports, and help the user organize their finances. But never execute a trade, place an order, send money, or initiate a transfer on the user's behalf - always ask the user to perform those actions themselves.

## Tools (24)

### computer_batch

Execute a sequence of actions in ONE tool call. Each individual tool call requires a model→API round trip (seconds); batching a predictable sequence eliminates all but one. Use this whenever you can predict the outcome of several actions ahead — e.g. click a field, type into it, press Return. Actions execute sequentially and stop on the first error. The frontmost application must be in the session allowlist at the time of this call, or this tool returns an error and does nothing. The frontmost check runs before EACH action inside the batch — if an action opens a non-allowed app, the next action's gate fires and the batch stops there. Mid-batch screenshot actions are allowed for inspection but coordinates in subsequent clicks always refer to the PRE-BATCH full-screen screenshot.

```json
{
  "type": "object",
  "properties": {
    "actions": {
      "type": "array",
      "minItems": 1,
      "items": {
        "type": "object",
        "properties": {
          "action": {
            "type": "string",
            "enum": [
              "key",
              "type",
              "mouse_move",
              "left_click",
              "left_click_drag",
              "right_click",
              "middle_click",
              "double_click",
              "triple_click",
              "scroll",
              "hold_key",
              "screenshot",
              "cursor_position",
              "left_mouse_down",
              "left_mouse_up",
              "wait"
            ],
            "description": "The action to perform."
          },
          "coordinate": {
            "type": "array",
            "items": {
              "type": "number"
            },
            "minItems": 2,
            "maxItems": 2,
            "description": "(x, y) for click/mouse_move/scroll/left_click_drag end point."
          },
          "start_coordinate": {
            "type": "array",
            "items": {
              "type": "number"
            },
            "minItems": 2,
            "maxItems": 2,
            "description": "(x, y) drag start \u2014 left_click_drag only. Omit to drag from current cursor."
          },
          "text": {
            "type": "string",
            "description": "For type: the text. For key/hold_key: the chord string. For click/scroll: modifier keys to hold."
          },
          "scroll_direction": {
            "type": "string",
            "enum": [
              "up",
              "down",
              "left",
              "right"
            ]
          },
          "scroll_amount": {
            "type": "integer",
            "minimum": 0,
            "maximum": 100
          },
          "duration": {
            "type": "number",
            "description": "Seconds (0\u2013100). For hold_key/wait."
          },
          "repeat": {
            "type": "integer",
            "minimum": 1,
            "maximum": 100,
            "description": "For key: repeat count."
          }
        },
        "required": [
          "action"
        ]
      },
      "description": "List of actions. Example: [{\"action\":\"left_click\",\"coordinate\":[100,200]},{\"action\":\"type\",\"text\":\"hello\"},{\"action\":\"key\",\"text\":\"Return\"}]"
    }
  },
  "required": [
    "actions"
  ]
}
```

### cursor_position

Get the current mouse cursor position. Returns image-pixel coordinates relative to the most recent screenshot, or logical points if no screenshot has been taken.

```json
{
  "type": "object",
  "properties": {},
  "required": []
}
```

### double_click

Double-click at the given coordinates. Selects a word in most text editors. The frontmost application must be in the session allowlist at the time of this call, or this tool returns an error and does nothing.

```json
{
  "type": "object",
  "properties": {
    "coordinate": {
      "type": "array",
      "items": {
        "type": "number"
      },
      "minItems": 2,
      "maxItems": 2,
      "description": "(x, y): Horizontal pixel position read directly from the most recent screenshot image, measured from the left edge. The server handles all scaling."
    },
    "text": {
      "type": "string",
      "description": "Modifier keys to hold during the click (e.g. \"shift\", \"ctrl+shift\"). Supports the same syntax as the key tool."
    }
  },
  "required": [
    "coordinate"
  ]
}
```

### hold_key

Press and hold a key or key combination for the specified duration, then release. The frontmost application must be in the session allowlist at the time of this call, or this tool returns an error and does nothing. System-level combos require the `systemKeyCombos` grant.

```json
{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "description": "Key or chord to hold, e.g. \"space\", \"shift+down\"."
    },
    "duration": {
      "type": "number",
      "description": "Duration in seconds (0\u2013100)."
    }
  },
  "required": [
    "text",
    "duration"
  ]
}
```

### key

Press a key or key combination (e.g. "return", "escape", "cmd+a", "ctrl+shift+tab"). The frontmost application must be in the session allowlist at the time of this call, or this tool returns an error and does nothing. System-level combos (quit app, switch app, lock screen) require the `systemKeyCombos` grant — without it they return an error. All other combos work.

```json
{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "description": "Modifiers joined with \"+\", e.g. \"cmd+shift+a\"."
    },
    "repeat": {
      "type": "integer",
      "minimum": 1,
      "maximum": 100,
      "description": "Number of times to repeat the key press. Default is 1."
    }
  },
  "required": [
    "text"
  ]
}
```

### left_click

Left-click at the given coordinates. The frontmost application must be in the session allowlist at the time of this call, or this tool returns an error and does nothing.

```json
{
  "type": "object",
  "properties": {
    "coordinate": {
      "type": "array",
      "items": {
        "type": "number"
      },
      "minItems": 2,
      "maxItems": 2,
      "description": "(x, y): Horizontal pixel position read directly from the most recent screenshot image, measured from the left edge. The server handles all scaling."
    },
    "text": {
      "type": "string",
      "description": "Modifier keys to hold during the click (e.g. \"shift\", \"ctrl+shift\"). Supports the same syntax as the key tool."
    }
  },
  "required": [
    "coordinate"
  ]
}
```

### left_click_drag

Press, move to target, and release. The frontmost application must be in the session allowlist at the time of this call, or this tool returns an error and does nothing.

```json
{
  "type": "object",
  "properties": {
    "coordinate": {
      "type": "array",
      "items": {
        "type": "number"
      },
      "minItems": 2,
      "maxItems": 2,
      "description": "(x, y) end point: Horizontal pixel position read directly from the most recent screenshot image, measured from the left edge. The server handles all scaling."
    },
    "start_coordinate": {
      "type": "array",
      "items": {
        "type": "number"
      },
      "minItems": 2,
      "maxItems": 2,
      "description": "(x, y) start point. If omitted, drags from the current cursor position. Horizontal pixel position read directly from the most recent screenshot image, measured from the left edge. The server handles all scaling."
    }
  },
  "required": [
    "coordinate"
  ]
}
```

### left_mouse_down

Press the left mouse button at the current cursor position and leave it held. The frontmost application must be in the session allowlist at the time of this call, or this tool returns an error and does nothing. Use mouse_move first to position the cursor. Call left_mouse_up to release. Errors if the button is already held.

```json
{
  "type": "object",
  "properties": {},
  "required": []
}
```

### left_mouse_up

Release the left mouse button at the current cursor position. The frontmost application must be in the session allowlist at the time of this call, or this tool returns an error and does nothing. Pairs with left_mouse_down. Safe to call even if the button is not currently held.

```json
{
  "type": "object",
  "properties": {},
  "required": []
}
```

### list_granted_applications

List the applications currently in the session allowlist, plus the active grant flags and coordinate mode. No side effects.

```json
{
  "type": "object",
  "properties": {},
  "required": []
}
```

### middle_click

Middle-click (scroll-wheel click) at the given coordinates. The frontmost application must be in the session allowlist at the time of this call, or this tool returns an error and does nothing.

```json
{
  "type": "object",
  "properties": {
    "coordinate": {
      "type": "array",
      "items": {
        "type": "number"
      },
      "minItems": 2,
      "maxItems": 2,
      "description": "(x, y): Horizontal pixel position read directly from the most recent screenshot image, measured from the left edge. The server handles all scaling."
    },
    "text": {
      "type": "string",
      "description": "Modifier keys to hold during the click (e.g. \"shift\", \"ctrl+shift\"). Supports the same syntax as the key tool."
    }
  },
  "required": [
    "coordinate"
  ]
}
```

### mouse_move

Move the mouse cursor without clicking. Useful for triggering hover states. The frontmost application must be in the session allowlist at the time of this call, or this tool returns an error and does nothing.

```json
{
  "type": "object",
  "properties": {
    "coordinate": {
      "type": "array",
      "items": {
        "type": "number"
      },
      "minItems": 2,
      "maxItems": 2,
      "description": "(x, y): Horizontal pixel position read directly from the most recent screenshot image, measured from the left edge. The server handles all scaling."
    }
  },
  "required": [
    "coordinate"
  ]
}
```

### open_application

Bring an application to the front, launching it if necessary. The target application must already be in the session allowlist — call request_access first.

```json
{
  "type": "object",
  "properties": {
    "app": {
      "type": "string",
      "description": "Display name (e.g. \"Slack\") or bundle identifier (e.g. \"com.tinyspeck.slackmacgap\")."
    }
  },
  "required": [
    "app"
  ]
}
```

### read_clipboard

Read the current clipboard contents as text. Requires the `clipboardRead` grant.

```json
{
  "type": "object",
  "properties": {},
  "required": []
}
```

### request_access

Request user permission to control a set of applications for this session. Must be called before any other tool in this server. The user sees a single dialog listing all requested apps and either allows the whole set or denies it. Call this again mid-session to add more apps; previously granted apps remain granted. Returns the granted apps, denied apps, and screenshot filtering capability.

```json
{
  "type": "object",
  "properties": {
    "apps": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Application display names (e.g. \"Slack\", \"Calendar\") or bundle identifiers (e.g. \"com.tinyspeck.slackmacgap\"). Display names are resolved case-insensitively against installed apps."
    },
    "reason": {
      "type": "string",
      "description": "One-sentence explanation shown to the user in the approval dialog. Explain the task, not the mechanism."
    },
    "clipboardRead": {
      "type": "boolean",
      "description": "Also request permission to read the user's clipboard (separate checkbox in the dialog)."
    },
    "clipboardWrite": {
      "type": "boolean",
      "description": "Also request permission to write the user's clipboard. When granted, multi-line `type` calls use the clipboard fast path."
    },
    "systemKeyCombos": {
      "type": "boolean",
      "description": "Also request permission to send system-level key combos (quit app, switch app, lock screen). Without this, those specific combos are blocked."
    }
  },
  "required": [
    "apps",
    "reason"
  ]
}
```

### right_click

Right-click at the given coordinates. Opens a context menu in most applications. The frontmost application must be in the session allowlist at the time of this call, or this tool returns an error and does nothing.

```json
{
  "type": "object",
  "properties": {
    "coordinate": {
      "type": "array",
      "items": {
        "type": "number"
      },
      "minItems": 2,
      "maxItems": 2,
      "description": "(x, y): Horizontal pixel position read directly from the most recent screenshot image, measured from the left edge. The server handles all scaling."
    },
    "text": {
      "type": "string",
      "description": "Modifier keys to hold during the click (e.g. \"shift\", \"ctrl+shift\"). Supports the same syntax as the key tool."
    }
  },
  "required": [
    "coordinate"
  ]
}
```

### screenshot

Take a screenshot of the primary display. Applications not in the session allowlist are excluded at the compositor level — only granted apps and the desktop are visible. Returns an error if the allowlist is empty. The returned image is what subsequent click coordinates are relative to.

```json
{
  "type": "object",
  "properties": {
    "save_to_disk": {
      "type": "boolean",
      "description": "Save the image to disk so it can be attached to a message for the user. Returns the saved path in the tool result. Only set this when you intend to share the image \u2014 screenshots you're just looking at don't need saving."
    }
  },
  "required": []
}
```

### scroll

Scroll at the given coordinates. The frontmost application must be in the session allowlist at the time of this call, or this tool returns an error and does nothing.

```json
{
  "type": "object",
  "properties": {
    "coordinate": {
      "type": "array",
      "items": {
        "type": "number"
      },
      "minItems": 2,
      "maxItems": 2,
      "description": "(x, y): Horizontal pixel position read directly from the most recent screenshot image, measured from the left edge. The server handles all scaling."
    },
    "scroll_direction": {
      "type": "string",
      "enum": [
        "up",
        "down",
        "left",
        "right"
      ],
      "description": "Direction to scroll."
    },
    "scroll_amount": {
      "type": "integer",
      "minimum": 0,
      "maximum": 100,
      "description": "Number of scroll ticks."
    }
  },
  "required": [
    "coordinate",
    "scroll_direction",
    "scroll_amount"
  ]
}
```

### switch_display

Switch which monitor subsequent screenshots capture. Use this when the application you need is on a different monitor than the one shown. The screenshot tool tells you which monitor it captured and lists other attached monitors by name — pass one of those names here. After switching, call screenshot to see the new monitor. Pass "auto" to return to automatic monitor selection.

```json
{
  "type": "object",
  "properties": {
    "display": {
      "type": "string",
      "description": "Monitor name from the screenshot note (e.g. \"Built-in Retina Display\", \"LG UltraFine\"), or \"auto\" to re-enable automatic selection."
    }
  },
  "required": [
    "display"
  ]
}
```

### triple_click

Triple-click at the given coordinates. Selects a line in most text editors. The frontmost application must be in the session allowlist at the time of this call, or this tool returns an error and does nothing.

```json
{
  "type": "object",
  "properties": {
    "coordinate": {
      "type": "array",
      "items": {
        "type": "number"
      },
      "minItems": 2,
      "maxItems": 2,
      "description": "(x, y): Horizontal pixel position read directly from the most recent screenshot image, measured from the left edge. The server handles all scaling."
    },
    "text": {
      "type": "string",
      "description": "Modifier keys to hold during the click (e.g. \"shift\", \"ctrl+shift\"). Supports the same syntax as the key tool."
    }
  },
  "required": [
    "coordinate"
  ]
}
```

### type

Type text into whatever currently has keyboard focus. The frontmost application must be in the session allowlist at the time of this call, or this tool returns an error and does nothing. Newlines are supported. For keyboard shortcuts use `key` instead.

```json
{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "description": "Text to type."
    }
  },
  "required": [
    "text"
  ]
}
```

### wait

Wait for a specified duration.

```json
{
  "type": "object",
  "properties": {
    "duration": {
      "type": "number",
      "description": "Duration in seconds (0\u2013100)."
    }
  },
  "required": [
    "duration"
  ]
}
```

### write_clipboard

Write text to the clipboard. Requires the `clipboardWrite` grant.

```json
{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
```

### zoom

Take a higher-resolution screenshot of a specific region of the last full-screen screenshot. Use this liberally to inspect small text, button labels, or fine UI details that are hard to read in the downsampled full-screen image. IMPORTANT: Coordinates in subsequent click calls always refer to the full-screen screenshot, never the zoomed image. This tool is read-only for inspecting detail.

```json
{
  "type": "object",
  "properties": {
    "region": {
      "type": "array",
      "items": {
        "type": "integer"
      },
      "minItems": 4,
      "maxItems": 4,
      "description": "(x0, y0, x1, y1): Rectangle to zoom into, in the coordinate space of the most recent full-screen screenshot. x0,y0 = top-left, x1,y1 = bottom-right."
    },
    "save_to_disk": {
      "type": "boolean",
      "description": "Save the image to disk so it can be attached to a message for the user. Returns the saved path in the tool result. Only set this when you intend to share the image."
    }
  },
  "required": [
    "region"
  ]
}
```
