Bowse machines · for agents

Give the agent a machine it can keep.

A Bowse machine is a full Linux microVM: a shell with root, a Chromium browser, a desktop you can watch, ports you can publish, and a disk that survives being switched off.

Shell
Browser (CDP)
Desktop
Public URLs
Disk that stays

Create a workspaceStart free Five minutesOpen quickstart

# pip install bowse
from bowse import Machine

ada = Machine.create(name="ada", size="2x8", keep_disk=True)

ada.run("git clone https://github.com/northwind/web")
result = ada.run("cd web && pnpm test")
print(result.exit_code, result.stdout[-200:])

ada.stop()  # compute stops; the disk stays

// npm i @bowse/sdk
import { Machine } from "@bowse/sdk";

const ada = await Machine.create({ name: "ada", size: "2x8", keepDisk: true });

await ada.run("git clone https://github.com/northwind/web");
const result = await ada.run("cd web && pnpm test");
console.log(result.exitCode, result.stdout.slice(-200));

await ada.stop(); // compute stops; the disk stays

bowse login

bowse machine create ada --size 2x8 --keep-disk
bowse machine exec ada -- git --version
bowse machine ssh ada

bowse port publish ada 3000
bowse machine stop ada

# works with MCP hosts that speak streamable HTTP
claude mcp add --transport http bowse https://bowse.dev/mcp

# then ask your agent:
#   "Boot a Bowse machine called ada, clone northwind/web,
#    run the tests there, and publish port 3000 if they pass."

Same machine from every client · pip install bowse · npm i @bowse/sdk · MCP over streamable HTTP

Access

Four doors into the same machine.

Type into it, look at it, drive its browser, or hand someone a link to what it built. Pick an entry point to see it.

ada · 2x8 · running

ada — shellLive

$ bowse machine create ada --size 2x8✓ ada is running · 2 vCPU · 8 GB$ bowse machine ssh adaagent@ada:~$ git clone https://github.com/northwind/web && cd webCloning into 'web'... done.agent@ada:~/web$ sudo apt-get install -y ripgrep✓ ripgrep installedagent@ada:~/web$ pnpm test✓ 96 passed · 3 skippedagent@ada:~/web$

Shell rides an authenticated HTTPS session — no SSH keys to rotate, no port 22 to open.

vendor.example.com/billingCDP

# the machine's Chromium, driven from your codecdp = ada.browser().urlb = pw.chromium.connect_over_cdp(cdp)page = b.contexts[0].pages[0]page.goto("https://vendor.example.com/billing")page.get_by_text("Oct 2026").click()

Agent Downloading the October invoice

ada — ports1 of 4 published

$ bowse port publish ada 3000✓ https://ada-3000.on.bowse.dev → :3000

A dev server inside the machine, reviewable from any browser over HTTPS.

Persistence

Compute stops. The disk doesn’t.

Stop a machine at the end of the day and compute charges stop with it. Start it tomorrow and the working tree, the packages, and the browser profile are where the agent left them. Try it:

Machine

ada · 2x8

running

Compute

Billed by the hour while running

Root disk (48 GB)attached
Persistent /home/agentmounted
Workspace volumemounted
Running processes3 running

Event log

09:12:04 ada running · 2 vCPU · 8 GB

Interactive illustration — runs in this page only.

Boundaries

Let it run sudo. It still isn’t your laptop.

Agents work best with real permissions. Bowse gives them those inside a microVM and nothing outside it.

Inside the machine, the agent can reach

Its own filesystem, with root
Packages it installs with apt, pip, or npm
The internet — unless you create it with network off
Ports you choose to publish

It can’t reach

Other machines, including other agents in your workspace
Your laptop, your servers, or your CI secrets
The host kernel — it runs on its own guest kernel under KVM
Keys from any other workspace

How isolation works

Primitives

Built for agents that run for hours, not seconds.

Templates

Boot a bare Ubuntu base, a toolchain-ready image for coding agents, or one that ships Chromium and a desktop session.

template="browser"

Streaming exec

Output arrives as it is produced, so the agent can react to a failing build before it finishes.

run_stream()

Custom templates

Bake your toolchain and dependencies into a template so a new machine boots ready instead of spending its first ten minutes on installs.

bowse template create web

Volumes

Attach storage for datasets, models, and caches that should outlive any single machine.

/data /models /cache

Network policy

Turn outbound internet off per machine when the agent is running code it didn’t write.

network="off"

Usage and history

CPU, memory, and disk charts, plus a list of every command a machine ran and how it exited.

Console → ada

Integrations

Bring the agent you already run.

Plug a machine into an MCP host, your own agent loop, or a workflow file. Each path reaches the same machine with the same workspace scopes.

Claude Code
Add the hosted MCP server; Claude can create machines and run commands with the scopes you approve.
claude mcp add --transport http bowse https://bowse.dev/mcp
Any MCP-capable editor
Editors and agent hosts that support streamable-HTTP MCP with OAuth sign-in.
https://bowse.dev/mcp
Your own agent loop
Python and TypeScript SDKs for orchestration code you control.
pip install bowse · npm i @bowse/sdk
GitHub Actions
The same machine types run CI jobs when a workflow asks for them.
runs-on: bowse

Sizes

Same six shapes as CI, billed by the hour.

Pick a size at create time. A stopped machine isn’t charged for compute.

Bowse machine sizes with hourly rates
Size / label	vCPU	RAM	Root disk	Per hour
1x2bowse-1x2	1	2 GB	16 GB	$0.030
2x4bowse-2x4	2	4 GB	32 GB	$0.060
2x8defaultbowse-2x8	2	8 GB	48 GB	$0.072
4x16bowse-4x16	4	16 GB	96 GB	$0.144
8x32bowse-8x32	8	32 GB	160 GB	$0.288
16x64bowse-16x64	16	64 GB	256 GB	$0.576

Estimate a month

Every feature

Find a feature by the job it does.

Type what you need or tap a filter. Every row lists the surfaces it’s on — console, CLI, SDK, MCP.

17 features

Reach the machine

Browser-based shell
A terminal tab in the console, attached to whichever machine you pick.
Console → ada → Terminal
Console
Shell from your own terminal
Attach from iTerm, Ghostty, or any terminal you like; Bowse handles the auth.
bowse machine ssh ada
CLI
Desktop view
See exactly what the agent sees, and grab the mouse if it needs a hand.
Console → ada → Display
ConsoleSDK
Browser over CDP
The machine’s Chromium exposes a CDP endpoint for Playwright or Puppeteer.
ada.browser().url
SDK

Execute

One-shot commands
Send a command, get back its output and exit status in one response.
ada.run("make check", timeout=600)
CLISDKMCP
Streamed output
Watch a build’s output arrive as it happens instead of waiting for the end.
ada.run_stream("pnpm build")
SDK
Root access
The agent is root inside its own machine, so package managers just work.
sudo apt-get install -y ffmpeg
ConsoleCLISDKMCP
Docker inside
Start a database or build an image without leaving the machine.
docker compose up -d postgres
ConsoleCLISDKMCP
Exit-code log
A per-machine record of what ran and how each command ended.
Console → ada → History
ConsoleSDK

Expose

Public URLs
Publish a port and hand reviewers a link that works in any browser.
bowse port publish ada 3000
ConsoleCLISDKMCP
Network off
No outbound traffic at all, for code you don’t trust yet.
Machine.create(network="off")
SDK

Persist

Stop and start
Park a machine between sessions; its files are waiting when it boots again.
ada.stop() · ada.start()
ConsoleCLISDKMCP
Persistent home
Keep the home directory — dotfiles, logins, caches — across restarts.
Machine.create(persistent_home=True)
SDK
Custom templates
Bake your toolchain into a template so every new machine boots ready to work.
bowse template create web --from coding-agent
ConsoleCLISDK

Connect agents

MCP server
Agents that speak MCP get tools to boot machines, exec, and publish ports.
claude mcp add --transport http bowse https://bowse.dev/mcp
MCP
Python and TypeScript SDKs
Typed clients for orchestration code you write yourself.
pip install bowse · npm i @bowse/sdk
SDK
GitHub Actions runners
The same machines run your CI when a job asks for them.
runs-on: bowse
Console

FAQ

Questions people ask first.

Reading this as an agent?

Connect over MCP at https://bowse.dev/mcp — the MCP reference lists every tool. A plain-text index of this site is at /llms.txt.

Is a Bowse machine just a container?

No. Each machine is a KVM microVM with its own guest kernel. Code inside cannot see other machines, and a kernel exploit inside a guest does not hand over a shared host kernel the way a container escape can.

How do I create my first machine?

Install the SDK or CLI, authenticate with bowse login or a BOWSE_API_KEY from the console, then call Machine.create(). The quickstart takes about five minutes.

Can it run Docker?

Yes. Docker runs inside the machine, so the agent can start databases or build images without touching anything you own.

How does the shell connection work?

bowse machine ssh opens an interactive session over an authenticated HTTPS connection. There are no SSH keys to distribute and no port 22 open to the internet.

Can a person watch or take over?

On desktop-enabled templates, the console shows the machine’s display live. Sessions are view-only by default; switch to control when the agent needs help, then hand it back.

What survives a stop?

The root disk, installed packages, an optional persistent home directory, and attached volumes. Processes don’t survive, so bring services back up when the machine starts. A stopped machine keeps its disk until you delete the machine.

How do MCP clients sign in?

With OAuth 2.1 and scopes such as read, exec, and admin. A client only gets the scopes you approve, and access is tied to one workspace.

How is it billed?

By the hour while a machine runs, prorated, with no charge for compute while it is stopped. Machine hours and CI minutes draw from the same workspace balance — see pricing.

Can I limit what an agent spends?

Yes. Set a spend limit on the workspace. Once it is reached, new machines don’t start and running ones are stopped, with their disks kept.

One agent. One machine. Start there.

Give a single agent its own Bowse machine and see what it does with a real computer.

Create a workspaceStart free Quickstart · SDK · CLIOpen docs support@bowse.devEmail us