# Live view and take-over (/docs/browser/live-view)

Watch what the agent does in an identity's browser, pause it and take the controls.

Off by default. Watch what the agent does in an identity's browser, and take the controls when it
needs you (a captcha, a confirmation, a page it does not understand):

```sh
turno-browser set school --live true     # from the next turno-browser-mcp for the identity
turno-browser live school                # status, and opens the view in your default browser
turno-browser pause school               # the agent's next call waits for you
turno-browser resume school              # it goes on, and is told what changed
```

`turno-browser-mcp --identity school --live` turns it on for one server, and `--live-wait 5m`
changes how long a paused call waits (identity.json `"live": { "enabled": true, "wait": "2m" }`;
from `"5s"` to `"30m"`, 2 minutes by default).

The view is a page with the agent's tab as a picture (a screencast over CDP, sent only while a view
is open), a list of tabs with "Follow the agent" (the tab of the latest call) as the default, and
Pause and Resume buttons. While the agent is paused, your clicks, keys and scrolls on the picture go
to that tab. In a headed Chrome you can also use the window itself: `turno-browser pause` brings the
agent's tab to the front.

What a pause does:

- A call that is running finishes. The next call of the agent (every session of the identity)
  waits, up to the live wait; then it fails with a message that says you still have the browser,
  and the next call waits again. A `browser_batch`, `browser_replay` or `browser_act` in progress
  stops at its next step. The natural language and captcha tools (`browser_act`, `browser_extract`,
  `browser_observe`, `browser_solve_captcha`) wait like any other call; tools that do not touch the
  browser (`browser_flows`) are not held.
- While you have the browser, the idle limit does not close it, the tab governor parks and closes
  nothing (a popup you open stays), and a trace (if `record.traces` is on) is saved, so what you do
  is not in it.
- On resume each waiting call starts with a note: how long the pause lasted and what changed (the
  current tab's URL and title, tabs opened and closed, your input in the view). When nothing
  changed the call runs. When something changed, a call that only reads (a snapshot, the tab list,
  `browser_extract`, `browser_observe`) runs; any other call does not, because the refs of the
  agent's last snapshot may point elsewhere, and the agent gets an error that says so, with a fresh
  snapshot.

How it is protected:

- The view is served on 127.0.0.1 only, on a random port. It answers only a browser that holds the
  server's cookie: a random token made at start, never written to disk or logged.
  `turno-browser live` gets a link from the server whose code works once, within two minutes,
  opens it, and never prints it. Requests must name the server by its loopback address (no DNS
  rebinding), and the buttons only work from the view's own page.
- `turno-browser live`, `pause` and `resume` talk to the server through a Unix socket in a private
  folder (mode 700). `~/.local/state/turno/browser/identities/<id>/live.json` says where it is, and
  holds no secret.
- A page that holds a vault value or a password is never shown: before `browser_login` fills a
  form (at once, or key by key with `humanize`), a value goes into a password field, or a replay types a sensitive parameter, the view stops
  sending that page and says it is hidden, until the page navigates. Your input is not sent to a
  hidden page either. With the live view on, the script tools are refused on such a page, as they
  are while recording.
- Your input in the view is not logged, traced or recorded in a flow; a flow being recorded does
  not have what you did, and the resume note says so.

With the other settings:

- Attach mode: you already see the agent's tabs in your own Chrome, and a view would stream your
  own tabs, so the view is off and `turno-browser live` says so. Pause and resume work; act in your
  Chrome, then resume.
- Read mode (`"engine": "lightpanda"`): Lightpanda renders no pixels, so there is no view. Pause
  and resume work.
- [Camoufox](/docs/browser/engines#camoufox): the view is a Chrome DevTools Protocol screencast, which Firefox does not
  have, so there is no view. Pause and resume work; with a headed Camoufox, act in its window.
- [A proxy](/docs/browser/network#a-proxy): the view's tab list hides the proxy's user name and password like vault
  values. The proxy signs in inside the browser, so no page holds them to show.
- `"sharing": "tabs"`: a pause holds every session. The view lists every tab with the session that
  holds it and follows the tab of the latest call from any session; pick a tab to stay on it. Each
  held call's note is about its own session's current tab.
- `humanize`: the view shows the humanized pointer moves, but not the sign-in form `browser_login`
  types key by key (the page is hidden first); your own input from the view is sent as is, and is
  never humanized.
- `turno-browser do`: each command is a call of a session like an agent's, so a pause holds it
  too. It prints the pause note as `note:` lines, and a command that the pause kept from running
  fails with exit code 1.
- Natural language actions and captcha solving: held like any call; a `browser_act` run that the
  pause meets stops before its next step and says which steps ran.
- Recordings: see above; screenshots are taken only after the agent's actions, never of yours.