Browser automation, at fleet scale.
Machineuse is distributed container management for browser automation. Create, schedule, and manage thousands of isolated browser instances across many nodes — with brokerless NNG messaging, load-aware scheduling, and snapshot dormancy. Self-hosted and open source.
git clone https://github.com/dotcommoners/machineuse && docker-compose up -dControl plane scheduling browsers across a worker mesh
A cluster that runs isolated browsers
Machineuse is an open-source, distributed container manager for browser automation at scale. A control plane schedules isolated browser instances onto worker nodes by capability and live load; workers coordinate over a brokerless NNG mesh; each browser runs in a dedicated systemd-nspawn container; and idle instances are snapshotted to dormancy and revived on demand. Built in Python, MIT-licensed, and fully self-hostable.
Running many browsers is a distributed-systems problem
A single headless browser is easy. A fleet of them inherits every hard problem in distributed systems.
Ad-hoc grids fall over at scale
- A central hub/broker becomes a bottleneck and single point of failure
- Work is placed round-robin, blind to real node load
- Weak isolation — sessions can leak state into each other
- Idle browsers keep burning CPU and memory
- A dead node takes its sessions down with it
Machineuse treats the fleet as a system
- Brokerless NNG mesh — no central hub to operate or bottleneck on
- Load-aware scheduling by node capability and live utilization
- A dedicated systemd-nspawn container per browser
- Snapshot dormancy reclaims resources from idle sessions
- Auto-healing detects failures and migrates instances
Built to run a fleet, not a browser
Everything you need to operate isolated browsers across a cluster — without a message broker or a SaaS bill.
Distributed control plane
A control plane schedules browser instances onto worker nodes by capability and live load. Add capacity by adding machines — scheduling adapts automatically.
Brokerless NNG mesh
Nodes coordinate over a brokerless NNG mesh. No external message broker to deploy, secure, or babysit — messaging is node-to-node.
Load-aware scheduling
Instances are placed by node capability and current utilization, so sessions land where there is real capacity instead of overloading one host.
systemd-nspawn isolation
Each browser runs in its own systemd-nspawn container with dedicated resources — clean, reproducible, and isolated from every other session.
Snapshot-based dormancy
Idle instances are snapshotted to dormancy and revived on demand, reclaiming node resources without discarding session state.
Real-time metrics & auto-healing
Per-node time-series metrics plus automatic failure detection and instance migration keep the fleet healthy without manual intervention.
Request a browser, drive it, release it
Stand up a single node, then ask the control plane for isolated browsers over its API or MCP tooling.
# Clone and start a single-node cluster
git clone https://github.com/dotcommoners/machineuse.git
cd machineuse && docker-compose up -d
# Scale out: workers join the control plane over NNG
python -m machineuse.nodes.agent \
worker-2 tcp://control-plane:5000from machineuse import Client
client = Client("tcp://control-plane:5000")
# control plane picks a worker by live load
browser = client.create(
image="ubuntu:22.04",
capabilities="gpu": False,
)
page = browser.connect() # drive with your tooling
page.goto("https://example.com")
browser.release() # idle → snapshot dormancyControl plane, workers, and a brokerless mesh
Two roles coordinate the whole fleet. A control plane schedules and tracks browser instances; worker nodes run them in isolated containers. They talk over a brokerless NNG mesh — there is no RabbitMQ, Kafka, or Redis to operate.
Control plane → workers → nspawn browsers → dormancy
Where teams run Machineuse
For scraping, testing, and automation teams and the platform engineers who support them.
AI agents & computer use
Give agents and MCP tools a scalable pool of isolated, disposable browsers.
Learn more →Web scraping at scale
Run large crawling and extraction workloads across nodes with per-session isolation.
Learn more →E2E test farms
Parallelize browser test suites across a fleet without a fragile central grid.
Learn more →Screenshot & render
Turn URLs and HTML into images or PDFs at volume, on isolated browsers.
Learn more →Questions
What is Machineuse?
Machineuse is an open-source, distributed container manager for browser automation at scale, built by dotcommoners in Python. It creates, schedules, and manages isolated browser instances across many worker nodes, with load-aware scheduling and snapshot-based dormancy. It is MIT-licensed and self-hostable.
How is it different from a Selenium/Playwright grid?
Machineuse is built for scale and isolation from the ground up: each browser runs in its own systemd-nspawn container, nodes talk over a brokerless NNG mesh (no central broker to operate), scheduling is load-aware, and idle instances can be snapshotted to dormancy. It is designed to run a fleet, not a single browser or a fragile grid.
Is Machineuse self-hostable and open source?
Yes. Machineuse is MIT-licensed and designed to be self-hosted on your own infrastructure — from a single node to a distributed cluster — with no SaaS dependency or lock-in.
What do I need to run it?
A Linux host with systemd-nspawn support. You can start with Docker Compose for a single-node setup, then scale out to a distributed control plane and multiple worker nodes.
Does it work with AI agents and MCP?
Yes. Machineuse targets browser-automation-at-scale use cases including AI agents and computer-use workloads, and the project includes MCP-oriented tooling for programmatic control.
Read the full FAQ → · Compare Machineuse to the alternatives →
Start automating at scale
Read the quickstart, browse the source, or reach out. Open source and self-hostable — no SaaS, no lock-in.