A private Chrome in the cloud, for you and your agents

Set up the browser#

Deploy does this for you. By hand, it's one script that starts the browser and its helpers with Docker Compose.

ssh exe.dev new --name=my-browser
ssh my-browser.exe.xyz

curl -fsSL https://exe-staging.dev/deploy/cloud-browser/setup.sh | bash

Open it in a tab#

Open https://my-browser.exe.xyz:3000/ and sign in to exe.dev if asked. Chrome fills the tab and follows its size. Sign in to the sites you use; the browser keeps the cookies on the VM's disk, so you stay signed in across restarts and from any computer you open the tab on.

The tab is a video stream of the browser, encoded in software and sent over a WebSocket; your clicks and keys go back the same way. Reading, typing and scrolling feel close to local, and video plays with sound. The handle at the left edge opens Selkies' sidebar:

• Clipboard: text you copy on either side shows up on the other.
• Files: upload files to the browser's Downloads folder, and download what it saved. They're also in ~/browser/config/Downloads on the VM.
• Video settings: codec, frame rate and quality, if the stream is slow on your connection.
• Fullscreen, and buttons for sound, microphone and webcam.

To give a teammate the same browser, share the VM with them, on your computer: ssh exe.dev share add my-browser teammate@example.com. They sign in to exe.dev and open the same address, without getting a shell on the VM. Two people in the tab share one mouse and keyboard.

Warning

The browser has no password of its own; exe.dev login is the lock. Don't point port 8000 at it with share port and share set-public, or anyone could use it, signed in as you.

Drive it from code#

On the VM, Chrome's DevTools protocol is at http://localhost:9222. Playwright and Puppeteer attach to the running browser, its tabs, and its signed-in sessions, and you watch what they do in the tab:

# /// script
# dependencies = ["playwright"]
# ///
from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.connect_over_cdp("http://localhost:9222")
    context = browser.contexts[0]  # the browser's own profile
    page = context.new_page()
    page.goto("https://news.ycombinator.com/")
    print(page.locator(".titleline > a").first.inner_text())

Save it as top.py and run uv run top.py: a new tab opens in the browser and the script prints Hacker News' top story. uv installs Playwright the first time; it doesn't need to download a browser. In Puppeteer, puppeteer.connect({ browserURL: "http://localhost:9222" }) does the same. On a CDP connection, browser.close() only disconnects: the browser keeps running, and so do the tabs the script opened, so close those with page.close() if you don't want them piling up.

From your own computer, an SSH tunnel makes the VM's CDP port local:

ssh -N -L 9222:localhost:9222 my-browser.exe.xyz

While it runs, http://localhost:9222 on your computer is the VM's browser. Programs elsewhere, such as a CI job, can also go through exe.dev's proxy at https://my-browser.exe.xyz:9222/ with a VM token (ssh exe.dev ssh-key generate-api-key --vm=my-browser --label=cdp) in an X-Exedev-Authorization: Bearer ... header:

browser = p.chromium.connect_over_cdp(
    "https://my-browser.exe.xyz:9222/",
    headers={"X-Exedev-Authorization": "Bearer " + token},
)

The nginx in front of Chrome rewrites the WebSocket addresses Chrome hands out, so they point back through the proxy. Use the https:// address; Playwright finds the WebSocket from there.

Let an agent drive it#

The setup runs Playwright MCP next to the browser, on localhost:8931. It gives an agent tools such as browser_navigate, browser_click and browser_snapshot, which reads the page's structure rather than screenshots. Connect Claude Code on the VM to the LLM integration (if you haven't) and to Playwright MCP:

exeuntu configure claude
claude mcp add --transport http --scope user playwright http://localhost:8931/mcp
claude -p "Use the playwright tools to open https://news.ycombinator.com and tell me the title of the top story." --allowedTools=mcp__playwright

With the tab open, you watch the browser go to Hacker News, and Claude answers with the top story in about ten seconds. For Codex, codex mcp add playwright --url http://localhost:8931/mcp. The model comes through exe.dev's LLM integration, so there's no API key on the VM.

Shelley, the agent that comes with every VM, can write and run Playwright scripts like the one above against localhost:9222; ask it to use that browser so you can watch. An agent somewhere else, with the exe MCP, can run them over SSH.

The agent uses the browser you're signed in to. Only sign in to accounts you'd hand to the agent: a web page can carry instructions that steer it. For a browser the agent has to itself, use a second VM.

Headless and light: Lightpanda#

For scraping and tests that nobody watches, a full Chrome is more than you need. Lightpanda is a headless browser written from scratch for automation: it speaks CDP, runs JavaScript, and draws nothing. On the VM, next to Chrome or on its own:

docker run -d --name lightpanda --restart unless-stopped \
  -p 127.0.0.1:9333:9222 -e LIGHTPANDA_DISABLE_TELEMETRY=true \
  lightpanda/browser:latest

Then p.chromium.connect_over_cdp("ws://127.0.0.1:9333") and browser.new_context().new_page() in the script above. It loaded Hacker News and read the top story in 0.1 seconds, using 4 MB of memory. It sends usage telemetry unless LIGHTPANDA_DISABLE_TELEMETRY is set, and not every site works in it yet; when one doesn't, use Chrome.

What doesn't work#

• No GPU. The VM has none, so the stream is encoded on the CPU and WebGL is off (see the FAQ). Video calls and games are poor.
• Some streaming video. YouTube works; services that require hardware DRM may not.
• Sites that block data centers. Some sites show more CAPTCHAs or refuse to sign in from a cloud IP address. That's the address the browser has; there's no proxy or residential IP here.
• One user at a time. Two people in the tab share the mouse.

ssh exe.dev cp my-browser my-browser-backup

cd ~/browser && docker compose stop
tar -czf ~/browser-config.tgz config
docker compose start

cd ~/browser && docker compose pull && docker compose up -d